Changeset 708


Ignore:
Timestamp:
Jul 12, 2016 4:18:44 AM (3 years ago)
Author:
kulshres
Message:

Merge branch 'master' of 'gitclone' into 'svn'

The following changes have been merged:

commit e2291bde44a282a133894b0db350aeb0b92a87db
Author: Mladen Banovic <mladenbanovic2705@…>
Date: Fri Jul 8 10:15:51 2016 +0200

Add methods getNumLiveVar and getNumDir in adtl.h, change counter type in FOR_I_EQ_0_LT_NUMDIR macro to size_t (instead of int). Update chunk size of BOOST pool in adouble_tl.cpp according to adouble::numDir.

commit 2ffb294465b973bfd4bf1f73d84478f8233c0d2f
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 23 12:32:14 2016 +0200

implement missing ref_eq_mult_p und ref_eq_min_p in ho_rev.c

somehow these were left out when parameters were being implemented.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 8cf0e5c1bd36f1dcf3be72cd67de631b2e1d0ee6
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 23 12:31:04 2016 +0200

make sure the result is the last locint written in trace for each operation

since we're trying to generate ascii traces in the future, we'll need this
convention that the last location is the result, and previous locations
are arguments. This has been the case for almost all operations anyway
except for a few new one's that I wrote without keeping this in mind.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 9ae0ff220f37463f2ed85cafc8a626c24e472f2f
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Jun 21 14:16:27 2016 +0200

on some compilers newer boost interferes with AC_FUNC_MALLOC test

so do AC_FUNC_MALLOC and AC_FUNC_REALLOC as usual and check for boost
library later.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit b746f620772cc8cce53e8f350adc6281279caf72
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Jun 20 15:32:22 2016 +0200

make Klaus Röbenack's name UTF-8 instead of ISO-8859-1

These are the only places where we're not simple ASCII or UTF-8 already

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 1171aa3961b5eb46a5d2ee64751c02a393a8a6f5
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jun 17 10:42:39 2016 +0200

correct short_ref document about include file

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 2c6b2aac2ef04431ece2c6ff80e574aa2e58814b
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jun 17 10:40:34 2016 +0200

correct error message to new semantics

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 506cde73451740bf0a15eff7d4abb158ee719ab0
Author: mflehmig <martin.flehmig@…>
Date: Fri Jun 17 10:14:26 2016 +0200

Fixed include of ADOL-C header.

ADOL-C header was included in old fashion (without adolc directory) for this example.

commit 2a023d3281d3d6d9824bad724a5768e3ee2fff94
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 16 13:50:39 2016 +0200

Try to use boost::pool for allocating advals in traceless vector mode

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 80f1e2019ac1faab96fe06f3e9da47efcc1bcd23
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon May 23 15:13:22 2016 +0200

correct a reference in doc and rebuild

commit d7ab5283afe58bacb2e8739d72ede4e17f4c8081
Author: Mladen Banovic <mladenbanovic2705@…>
Date: Fri May 20 16:42:13 2016 +0200

Update section 7 of adolc-manual related to the Traceless forward differentiation.

commit bedb8e36f959c5272e4610fe504acc83208e5e9d
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue May 17 16:09:36 2016 +0200

macro name correction

commit 92ff596a0331776901df7f172ca347572e3daafd
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue May 17 15:56:17 2016 +0200

Add a warning about using static build of ADOL-C

static build of ADOL-C does not call constructors
for internal global objects, thereby causing
segmentation faults.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

Location:
trunk
Files:
59 edited

Legend:

Unmodified
Added
Removed
  • trunk/ADOL-C/Makefile.in

    r611 r708  
    330330STRIP = @STRIP@
    331331UINT_TYPE = @UINT_TYPE@
     332USE_BOOST_POOL = @USE_BOOST_POOL@
    332333VERSION = @VERSION@
    333334_lib = @_lib@
  • trunk/ADOL-C/doc/adolc-manual.tex

    r689 r708  
    32853285%++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    32863286%
    3287 \section{Tapeless forward differentiation in ADOL-C}
     3287\section{Traceless forward differentiation in ADOL-C}
    32883288\label{tapeless}
    32893289%
    32903290Up to version 1.9.0, the development of the ADOL-C software package
    32913291was based on the decision to store all data necessary for derivative
    3292 computation on tapes, where large applications require the tapes to be
     3292computation on traces (tapes), where large applications require the traces to be
    32933293written out to corresponding files. In almost all cases this means
    32943294a considerable drawback in terms of run time due to the excessive
    3295 memory accesses. Using these tapes enables ADOL-C to offer multiple
     3295memory accesses. Using these traces enables ADOL-C to offer multiple
    32963296functions. However, it is not necessary for all tasks of derivative
    32973297computation to do that.
    32983298
    3299 Starting with version 1.10.0, ADOL-C now features a tapeless forward
     3299Starting with version 1.10.0, ADOL-C now features a traceless forward
    33003300mode for computing first order derivatives in scalar mode, i.e.,
    33013301$\dot{y} = F'(x)\dot{x}$, and in vector mode, i.e., $\dot{Y} = F'(x)\dot{X}$.
    3302 This tapeless variant coexists with the more universal
    3303 tape based mode in the package. The following subsections describe
    3304 the source code modifications required to use the tapeless forward mode of
     3302This traceless variant coexists with the more universal
     3303trace based mode in the package. The following subsections describe
     3304the source code modifications required to use the traceless forward mode of
    33053305ADOL-C. 
    33063306%
     
    33153315y_3  =  \arctan(x_2/x_1),
    33163316\end{eqnarray*}
    3317 as an example. The corresponding source code is shown in \autoref{fig:tapeless}.
     3317as an example. The corresponding source code is shown in \autoref{fig:traceless}.
    33183318\begin{figure}[htb]
    33193319\framebox[\textwidth]{\parbox{\textwidth}{
     
    33433343%\end{center}
    33443344}}
    3345 \caption{Example for tapeless forward mode}
    3346 \label{fig:tapeless}
     3345\caption{Example for traceless forward mode}
     3346\label{fig:traceless}
    33473347\end{figure}
    33483348%
    33493349Changes to the source code that are necessary for applying the
    3350 tapeless forward ADOL-C are described in the following two
     3350traceless forward mode of ADOL-C are described in the following two
    33513351subsections, where the vector mode version is described
    33523352as extension of the scalar mode.
     
    33543354\subsubsection*{The scalar mode}
    33553355%
    3356 To use the tapeless forward mode, one has to include only
     3356To use the traceless forward mode, one has to include only
    33573357the header file \verb#adtl.h# since it does not include the
    3358 tape based functions defined in other header files.
    3359 
    3360 As in the tape based forward version of ADOL-C all derivative
     3358trace based functions defined in other header files.
     3359
     3360As in the trace based forward version of ADOL-C all derivative
    33613361calculations are introduced by calls to overloaded
    3362 operators. Therefore, similar to the tape-based version all
     3362operators. Therefore, similar to the trace-based version all
    33633363independent, intermediate and dependent variables must be declared
    3364 with type {\sf adouble}. The whole tapeless functionality provided by
     3364with type {\sf adouble}. The whole traceless functionality provided by
    33653365\verb#adtl.h# was written as complete inline intended code
    33663366due to run time aspects, where the real portion of inlined code can
    33673367be influenced by switches for many compilers. Likely, the whole
    33683368derivative code is inlined by default. Our experiments
    3369 with the tapeless mode have produced complete inlined code by using
     3369with the traceless mode have produced complete inlined code by using
    33703370standard switches (optimization) for GNU and Intel C++
    33713371compiler.
    33723372
    33733373To avoid name conflicts
    3374 resulting from the inlining the tapeless version has its own namespace
     3374resulting from the inlining the traceless version has its own namespace
    33753375\verb#adtl#. As a result four possibilities of using the {\sf adouble}
    3376 type are available for the tapeless version:
     3376type are available for the traceless version:
    33773377\begin{itemize}
    33783378\item Defining a new type
     
    34073407        \begin{center}
    34083408          \begin{tabular}{l}
    3409             {\sf \#using namespace adtl;}\\
     3409            {\sf using namespace adtl;}\\
    34103410            ...\\
    34113411            {\sf adouble tmp;}
     
    34183418function evaluation. This can be done by assigning the variables a {\sf
    34193419double} value. The {\sf ad}-value is set to zero in this case.
    3420 Additionally, the tapeless forward mode variant of ADOL-C
     3420Additionally, the traceless forward mode variant of ADOL-C
    34213421offers a function named {\sf setValue} for setting the value without
    34223422changing the {\sf ad}-value. To set the {\sf ad}-values of the independent
    3423 variables ADOL-C offers two possibilities: 
     3423variables ADOL-C offers two possibilities:
    34243424\begin{itemize}
    34253425  \item Using the constructor
    34263426        \begin{center}
    34273427          \begin{tabular}{l}
    3428             {\sf adouble x1(2,1), x2(4,0), y;}
     3428        {\sf double seedOne = 1., seedZero = 0.;}\\
     3429            {\sf adouble x1(2,\&seedOne), x2(4,\&seedZero), y;}
    34293430          \end{tabular}
    34303431        \end{center}
     
    34363437         \begin{center}
    34373438           \begin{tabular}{l}
     3439         {\sf double seedOne = 1., seedZero = 0.;}\\
    34383440             {\sf adouble x1=2, x2=4, y;}\\
    34393441             ...\\
    3440              {\sf x1.setADValue(1);}\\
    3441              {\sf x2.setADValue(0);}
     3442             {\sf x1.setADValue(\&seedOne);}\\
     3443             {\sf x2.setADValue(\&seedZero);}
    34423444           \end{tabular}
    34433445         \end{center}
    3444          The same example as above but now using {\sf setADValue}-method for initializing the derivative values.
     3446         The same example as above but now using {\sf setADValue}-method for initializing the derivative values. It is important to note that in both cases the derivative values have to be set by passing an address of a variable or a pointer of the {\sf double} type (instead of passing the value directly). The reason for doing this will become clear in the next subsection.
    34453447\end{itemize}
    34463448%
    34473449The derivatives can be obtained at any time during the evaluation
    3448 process by calling the {\sf getADValue}-method
     3450process by calling the {\sf getADValue}-method which returns a pointer (instead of a value), and therefore, it can be assigned to another pointer or it can be dereferenced immediately in order to read the value:
    34493451\begin{center}
    34503452  \begin{tabular}{l}
    34513453    {\sf adouble y;}\\
    34523454    ...\\
    3453     {\sf cout $<<$ y.getADValue();}
     3455    {\sf cout $<<$ *(y.getADValue());}
    34543456  \end{tabular}
    34553457\end{center}
     
    34753477\> {\sf \rule{1cm}{0pt}...}\\
    34763478\\
    3477 \> {\sf \rule{0.5cm}{0pt}x[0].setADValue(1);\hspace*{3cm}// derivative of f with respect to $x_1$}\\
     3479\> {\sf \rule{0.5cm}{0pt}double seed = 1.;}\\
     3480\> {\sf \rule{0.5cm}{0pt}x[0].setADValue(\&seed);\hspace*{3cm}// derivative of f with respect to $x_1$}\\
    34783481\> {\sf \rule{0.5cm}{0pt}y[0] = sqrt(x[0]*x[0]+x[1]*x[1]+x[2]*x[2]);}\\
    34793482\> {\sf \rule{0.5cm}{0pt}y[1] = atan(sqrt(x[0]*x[0]+x[1]*x[1])/x[2]);}\\
     
    34813484\\
    34823485\> {\sf \rule{0.5cm}{0pt}cout $<<$ "y1=" $<<$ y[0].getValue() $<<$ " , y2=" $<<$ y[1].getValue ... ;}\\
    3483 \> {\sf \rule{0.5cm}{0pt}cout $<<$ "dy2/dx1 = " $<<$ y[1].getADValue() $<<$ endl;}\\
     3486\> {\sf \rule{0.5cm}{0pt}cout $<<$ "dy2/dx1 = " $<<$ *(y[1].getADValue()) $<<$ endl;}\\
    34843487\> {\sf \rule{0.5cm}{0pt}return 0;}\\
    34853488\> {\sf \}}
     
    34873490%\end{center}
    34883491}}
    3489 \caption{Example for tapeless scalar forward mode}
     3492\caption{Example for traceless scalar forward mode}
    34903493\label{fig:modcode}
    34913494\end{figure}
     
    35063509error. \verb#adtl::setNumDir(N)# must therefore be called before
    35073510declaring any \verb#adtl::adouble# objects.
    3508  
    3509 Compared to the scalar case setting and getting the derivative
    3510 values, i.e. the directions, is more involved. Instead of
    3511 working with single {\sf double} values, pointer to fields of {\sf
    3512 double}s are used as illustrated by the following example:
     3511
     3512Setting and getting the derivative values is done in the same manner as in the scalar case, by passing and retrieving the pointers, as illustrated in the following example:
    35133513\begin{center}
    35143514  \begin{tabular}{l}
     
    35243524  \end{tabular}
    35253525\end{center}
    3526 Additionally, the tapeless vector forward mode of ADOL-C offers two
    3527 new methods for setting/getting the derivative values. Similar
    3528 to the scalar case, {\sf double} values are used but due to the vector
    3529 mode the position of the desired vector element must be supplied in
    3530 the argument list:
     3526Now using the pointers in the methods {\sf setADValue} and {\sf getADValue} makes more sense since the vector mode requires the field of $p$ elements per {\sf adouble} which holds the derivative values.
     3527Additionally, the traceless vector forward mode of ADOL-C offers two
     3528new methods for setting/getting the derivative values. Setting a derivative value of the desired vector element is possible by passing a {\sf double} value and its position in the vector ({\sf integer}). Getting a derivative value of the desired vector element requires as argument only its position in the vector. One can note that the pointers are not used in these cases, as illustrated in the following example:
    35313529\begin{center}
    35323530  \begin{tabular}{l}
     
    35783576\end{tabbing}
    35793577}}
    3580 \caption{Example for tapeless vector forward mode}
     3578\caption{Example for traceless vector forward mode}
    35813579\label{fig:modcode2}
    35823580\end{figure}
     
    35903588\begin{center}
    35913589  \begin{tabular}{l}
    3592     {\sf g++ -I/home/username/adolc\_base/include -c tapeless\_scalar.cpp}
     3590    {\sf g++ -I/home/username/adolc\_base/include -c traceless\_scalar.cpp}
    35933591  \end{tabular}
    35943592\end{center}
     
    36043602\begin{center}
    36053603  \begin{tabular}{l}
    3606     {\sf g++ -o tapeless\_scalar tapeless\_scalar.o -ladolc -L/home/username/adolc\_base/lib}
     3604    {\sf g++ -o traceless\_scalar traceless\_scalar.o}\\
     3605    {\sf -Wl,-{}-rpath -Wl,/home/username/adolc\_base/lib -L/home/username/adolc\_base/lib -ladolc}
    36073606  \end{tabular}
    36083607\end{center}
    3609 The mentioned source codes {\sf tapeless\_scalar.c} and {\sf tapeless\_vector.c}
    3610 illustrating the use of the for tapeless scalar and vector mode can be found in
     3608The mentioned source codes {\sf traceless\_scalar.c} and {\sf traceless\_vector.c}
     3609illustrating the use of the for traceless scalar and vector mode can be found in
    36113610the directory {\sf examples}.
    36123611%
    3613 \subsection{Concluding Remarks for the Tapeless Forward Mode Variant}
    3614 %
    3615 As many other AD methods the tapeless forward mode provided by the
     3612\subsection{Concluding Remarks for the Traceless Forward Mode Variant}
     3613%
     3614As many other AD methods the traceless forward mode provided by the
    36163615ADOL-C package has its own strengths and drawbacks. Please read the
    36173616following section carefully to become familiar with the things that
     
    36223621      \item Code speed\\
    36233622        Increasing computation speed was one of the main aspects in writing
    3624         the tapeless code. In many cases higher performance can be
     3623        the traceless code. In many cases higher performance can be
    36253624        expected this way. However this is not guarenteed for repeated
    36263625        evaluations.
    36273626      \item Smaller overall memory requirements\\
    3628         Tapeless ADOL-C does not write tapes anymore, as the name
     3627        Traceless ADOL-C does not write traces anymore, as the name
    36293628        implies. Loop ''unrolling'' can be avoided this
    36303629        way. Considered main memory plus disk space as overall memory
    3631         requirements the tapeless version can be
     3630        requirements the traceless version can be
    36323631        executed in a more efficient way.
    36333632    \end{itemize}
     
    36373636      The ability to compute derivatives to a given function is
    36383637      bounded by the main memory plus swap size  when using
    3639       tapeless ADOL-C. Computation from swap should be avoided anyway
     3638      traceless ADOL-C. Computation from swap should be avoided anyway
    36403639      as far as possible since it slows down the computing time
    36413640      drastically. Therefore, if the program execution is 
     
    36503649      where the storage size of all non {\sf adouble} based variables is described by $M_p$.
    36513650    \item Compile time\\
    3652       As discussed in the previous sections, the tapeless forward mode of
     3651      As discussed in the previous sections, the traceless forward mode of
    36533652      the ADOL-C package is implemented as inline intended version. Using
    36543653      this approach results in a higher source code size, since every
     
    36563655      operation itself as well as for the corresponding derivative
    36573656      code after the inlining process. Therefore, the compilation time
    3658       needed for the tapeless version may be higher than that of the tape based code.
     3657      needed for the traceless version may be higher than that of the trace based code.
    36593658    \item Code Size\\
    36603659      A second drawback and result of the code inlining is the
    36613660      increase of code sizes for the binaries. The increase
    3662       factor compared to the corresponding tape based program is
     3661      factor compared to the corresponding trace based program is
    36633662      difficult to quantify as it is task dependent. Practical results
    36643663      have shown that values between 1.0 and 2.0 can be
     
    37123711\end{eqnarray*}
    37133712as an example. We now calculate the Jacobian at $M=1024$ different points.
    3714 The source code for one point is shown in \autoref{fig:tapeless}. This example
     3713The source code for one point is shown in \autoref{fig:traceless}. This example
    37153714has no real application but can still be used to show the combination of the traceless version
    37163715of ADOL-C and Cuda.
  • trunk/ADOL-C/doc/short_ref.tex

    r109 r708  
    125125\underline{Example:}
    126126\begin{verbatim}
    127 #include "adolc.h"                      // inlusion of ADOL-C headers
     127#include <adolc/adolc.h>                      // inlusion of ADOL-C headers
    128128...
    129129adouble foo ( adouble x )               // some activated function
  • trunk/ADOL-C/examples/Makefile.in

    r624 r708  
    318318STRIP = @STRIP@
    319319UINT_TYPE = @UINT_TYPE@
     320USE_BOOST_POOL = @USE_BOOST_POOL@
    320321VERSION = @VERSION@
    321322_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/Makefile.in

    r611 r708  
    263263STRIP = @STRIP@
    264264UINT_TYPE = @UINT_TYPE@
     265USE_BOOST_POOL = @USE_BOOST_POOL@
    265266VERSION = @VERSION@
    266267_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/checkpointing/Makefile.in

    r624 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/clock/Makefile.in

    r624 r708  
    269269STRIP = @STRIP@
    270270UINT_TYPE = @UINT_TYPE@
     271USE_BOOST_POOL = @USE_BOOST_POOL@
    271272VERSION = @VERSION@
    272273_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/cuda/Makefile.in

    r596 r708  
    201201STRIP = @STRIP@
    202202UINT_TYPE = @UINT_TYPE@
     203USE_BOOST_POOL = @USE_BOOST_POOL@
    203204VERSION = @VERSION@
    204205_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/detexam/Makefile.in

    r624 r708  
    255255STRIP = @STRIP@
    256256UINT_TYPE = @UINT_TYPE@
     257USE_BOOST_POOL = @USE_BOOST_POOL@
    257258VERSION = @VERSION@
    258259_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/ext_diff_func/Makefile.in

    r624 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/fixpoint_exam/Makefile.in

    r624 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/helm/Makefile.in

    r624 r708  
    255255STRIP = @STRIP@
    256256UINT_TYPE = @UINT_TYPE@
     257USE_BOOST_POOL = @USE_BOOST_POOL@
    257258VERSION = @VERSION@
    258259_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/hessmat/Makefile.in

    r624 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/lie/Makefile.in

    r624 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/lighthouse/Makefile.in

    r624 r708  
    264264STRIP = @STRIP@
    265265UINT_TYPE = @UINT_TYPE@
     266USE_BOOST_POOL = @USE_BOOST_POOL@
    266267VERSION = @VERSION@
    267268_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/lufact/Makefile.in

    r624 r708  
    255255STRIP = @STRIP@
    256256UINT_TYPE = @UINT_TYPE@
     257USE_BOOST_POOL = @USE_BOOST_POOL@
    257258VERSION = @VERSION@
    258259_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/ode/Makefile.in

    r624 r708  
    274274STRIP = @STRIP@
    275275UINT_TYPE = @UINT_TYPE@
     276USE_BOOST_POOL = @USE_BOOST_POOL@
    276277VERSION = @VERSION@
    277278_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/openmp_exam/Makefile.in

    r624 r708  
    255255STRIP = @STRIP@
    256256UINT_TYPE = @UINT_TYPE@
     257USE_BOOST_POOL = @USE_BOOST_POOL@
    257258VERSION = @VERSION@
    258259_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/openmp_exam/liborpar.cpp

    r503 r708  
    2828#include <cmath>
    2929
    30 #include "adolc.h"
     30#include "adolc/adolc.h"
    3131
    3232#ifdef _OPENMP
  • trunk/ADOL-C/examples/additional_examples/param/Makefile.in

    r624 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/pow/Makefile.in

    r624 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/scal/Makefile.in

    r624 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/sparse/Makefile.in

    r624 r708  
    267267STRIP = @STRIP@
    268268UINT_TYPE = @UINT_TYPE@
     269USE_BOOST_POOL = @USE_BOOST_POOL@
    269270VERSION = @VERSION@
    270271_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/speelpenning/Makefile.in

    r624 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/tapesave/Makefile.in

    r624 r708  
    255255STRIP = @STRIP@
    256256UINT_TYPE = @UINT_TYPE@
     257USE_BOOST_POOL = @USE_BOOST_POOL@
    257258VERSION = @VERSION@
    258259_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/taylor/Makefile.in

    r624 r708  
    268268STRIP = @STRIP@
    269269UINT_TYPE = @UINT_TYPE@
     270USE_BOOST_POOL = @USE_BOOST_POOL@
    270271VERSION = @VERSION@
    271272_lib = @_lib@
  • trunk/ADOL-C/examples/additional_examples/timing/Makefile.in

    r624 r708  
    319319STRIP = @STRIP@
    320320UINT_TYPE = @UINT_TYPE@
     321USE_BOOST_POOL = @USE_BOOST_POOL@
    321322VERSION = @VERSION@
    322323_lib = @_lib@
  • trunk/ADOL-C/include/Makefile.in

    r596 r708  
    261261STRIP = @STRIP@
    262262UINT_TYPE = @UINT_TYPE@
     263USE_BOOST_POOL = @USE_BOOST_POOL@
    263264VERSION = @VERSION@
    264265_lib = @_lib@
  • trunk/ADOL-C/include/adolc/Makefile.in

    r611 r708  
    293293STRIP = @STRIP@
    294294UINT_TYPE = @UINT_TYPE@
     295USE_BOOST_POOL = @USE_BOOST_POOL@
    295296VERSION = @VERSION@
    296297_lib = @_lib@
  • trunk/ADOL-C/include/adolc/adtl.h

    r704 r708  
    2727#else
    2828#error "please use -std=c++11 compiler flag with a C++11 compliant compiler"
     29#endif
     30
     31#if USE_BOOST_POOL
     32#include <boost/pool/pool_alloc.hpp>
    2933#endif
    3034
     
    5761    refcounter() { ++refcnt; }
    5862    ~refcounter() { --refcnt; }
     63    inline static size_t getNumLiveVar() {return refcnt;}
    5964};
    6065
     
    236241
    237242private:
     243#if USE_BOOST_POOL
     244    static boost::pool<boost::default_user_allocator_new_delete>* advalpool;
     245#endif
    238246    double val;
    239247    double *adval;
     
    246254    ADOLC_DLL_EXPIMP static enum Mode forward_mode;
    247255    inline friend void setNumDir(const size_t p);
     256    inline friend size_t getNumDir();
    248257    inline friend void setMode(enum Mode newmode);
    249258};
     
    295304inline void setNumDir(const size_t p) {
    296305    if (refcounter::refcnt > 0) {
    297         fprintf(DIAG_OUT, "ADOL-C Warning: Tapeless: Setting numDir will not change the number of\n directional derivative in existing adoubles and may lead to erronious results\n or memory corruption\n Number of currently existing adoubles = %zu\n", refcounter::refcnt);
     306        fprintf(DIAG_OUT, "ADOL-C Warning: Tapeless: Setting numDir could change memory allocation of\n derivatives in existing adoubles and may lead to erronious results\n or memory corruption\n Number of currently existing adoubles = %zu\n", refcounter::refcnt);
    298307    }
    299308    if (p < 1) {
     
    302311    }
    303312    adouble::numDir = p;
    304 }
     313#if USE_BOOST_POOL
     314    if (adouble::advalpool != NULL) {
     315        delete adouble::advalpool;
     316        adouble::advalpool = NULL;
     317    }
     318    adouble::advalpool = new boost::pool<boost::default_user_allocator_new_delete>(adouble::numDir*sizeof(double));
     319#endif
     320}
     321
     322inline size_t getNumDir() {return adouble::numDir;}
    305323
    306324inline void setMode(enum Mode newmode) {
     
    319337}
    320338
    321 #define FOR_I_EQ_0_LT_NUMDIR for (int _i=0; _i < adouble::numDir; ++_i)
     339#define FOR_I_EQ_0_LT_NUMDIR for (size_t _i=0; _i < adouble::numDir; ++_i)
    322340#define ADVAL_I              adval[_i]
    323341#define ADV_I                adv[_i]
     
    327345inline adouble::adouble() : val(0), adval(NULL) {
    328346    if (do_adval())
     347#if USE_BOOST_POOL
     348        adval = reinterpret_cast<double*>(advalpool->malloc());
     349#else
    329350        adval = new double[adouble::numDir];
     351#endif
    330352    if (do_indo()) {
    331353     if (!pattern.empty())
     
    336358inline adouble::adouble(const double v) : val(v), adval(NULL) {
    337359    if (do_adval()) {
     360#if USE_BOOST_POOL
     361        adval = reinterpret_cast<double*>(advalpool->malloc());
     362#else
    338363        adval = new double[adouble::numDir];
     364#endif
    339365        FOR_I_EQ_0_LT_NUMDIR
    340366            ADVAL_I = 0.0;
     
    348374inline adouble::adouble(const double v, const double* adv) : val(v), adval(NULL) {
    349375    if (do_adval()) {
     376#if USE_BOOST_POOL
     377        adval = reinterpret_cast<double*>(advalpool->malloc());
     378#else
    350379        adval = new double[adouble::numDir];
     380#endif
    351381        FOR_I_EQ_0_LT_NUMDIR
    352382            ADVAL_I=ADV_I;
     
    360390inline adouble::adouble(const adouble& a) : val(a.val), adval(NULL) {
    361391    if (do_adval()) {
     392#if USE_BOOST_POOL
     393        adval = reinterpret_cast<double*>(advalpool->malloc());
     394#else
    362395        adval = new double[adouble::numDir];
     396#endif
    363397        FOR_I_EQ_0_LT_NUMDIR
    364398            ADVAL_I=a.ADVAL_I;
     
    375409inline adouble::~adouble() {
    376410    if (adval != NULL)
     411#if USE_BOOST_POOL
     412        advalpool->free(adval);
     413#else
    377414        delete[] adval;
     415#endif
    378416#if 0
    379417    if ( !pattern.empty() )
  • trunk/ADOL-C/include/adolc/drivers/Makefile.in

    r640 r708  
    250250STRIP = @STRIP@
    251251UINT_TYPE = @UINT_TYPE@
     252USE_BOOST_POOL = @USE_BOOST_POOL@
    252253VERSION = @VERSION@
    253254_lib = @_lib@
  • trunk/ADOL-C/include/adolc/internal/Makefile.in

    r596 r708  
    250250STRIP = @STRIP@
    251251UINT_TYPE = @UINT_TYPE@
     252USE_BOOST_POOL = @USE_BOOST_POOL@
    252253VERSION = @VERSION@
    253254_lib = @_lib@
  • trunk/ADOL-C/include/adolc/internal/adolc_settings.h

    r707 r708  
    22 ADOL-C -- Automatic Differentiation by Overloading in C++
    33 File:     adolc_settings.h
    4  Revision: $Id: adolc_settings.h.in 537 2014-08-15 14:10:48Z kulshres $
     4 Revision: $Id$
    55 Contents: ADOL-C Settings:
    66           These parameters might affect the performance of the ADOL-C
     
    1818#if !defined(ADOLC_ADOLC_SETTINGS_H)
    1919#define ADOLC_ADOLC_SETTINGS_H 1
     20
     21#include <stdint.h>
    2022/*--------------------------------------------------------------------------*/
    2123/* ADOL-C data types */
     
    3133#undef ADOLC_ADVANCED_BRANCHING
    3234
     35/*--------------------------------------------------------------------------*/
     36/* Use Boost Library Pool allocator */
     37#define USE_BOOST_POOL 1
     38
    3339#endif
  • trunk/ADOL-C/include/adolc/internal/adolc_settings.h.in

    r537 r708  
    1818#if !defined(ADOLC_ADOLC_SETTINGS_H)
    1919#define ADOLC_ADOLC_SETTINGS_H 1
     20
     21#include <stdint.h>
    2022/*--------------------------------------------------------------------------*/
    2123/* ADOL-C data types */
     
    3133@ADVBRANCH@
    3234
     35/*--------------------------------------------------------------------------*/
     36/* Use Boost Library Pool allocator */
     37@USE_BOOST_POOL@
     38
    3339#endif
  • trunk/ADOL-C/include/adolc/lie/Makefile.in

    r611 r708  
    250250STRIP = @STRIP@
    251251UINT_TYPE = @UINT_TYPE@
     252USE_BOOST_POOL = @USE_BOOST_POOL@
    252253VERSION = @VERSION@
    253254_lib = @_lib@
  • trunk/ADOL-C/include/adolc/lie/drivers.h

    r609 r708  
    66 
    77
    8  Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
     8 Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
    99
    1010 This file is part of ADOL-C. This software is provided as open source.
  • trunk/ADOL-C/include/adolc/sparse/Makefile.in

    r596 r708  
    250250STRIP = @STRIP@
    251251UINT_TYPE = @UINT_TYPE@
     252USE_BOOST_POOL = @USE_BOOST_POOL@
    252253VERSION = @VERSION@
    253254_lib = @_lib@
  • trunk/ADOL-C/include/adolc/tapedoc/Makefile.in

    r596 r708  
    250250STRIP = @STRIP@
    251251UINT_TYPE = @UINT_TYPE@
     252USE_BOOST_POOL = @USE_BOOST_POOL@
    252253VERSION = @VERSION@
    253254_lib = @_lib@
  • trunk/ADOL-C/src/Makefile.in

    r640 r708  
    365365STRIP = @STRIP@
    366366UINT_TYPE = @UINT_TYPE@
     367USE_BOOST_POOL = @USE_BOOST_POOL@
    367368VERSION = @VERSION@
    368369_lib = @_lib@
  • trunk/ADOL-C/src/adouble_tl.cpp

    r630 r708  
    3939
    4040size_t refcounter::refcnt = 0;
    41 
     41#if USE_BOOST_POOL
     42boost::pool<boost::default_user_allocator_new_delete>* adouble::advalpool = new
     43boost::pool<boost::default_user_allocator_new_delete>(adouble::numDir * sizeof(double));
     44#endif
    4245
    4346/*******************  i/o operations  ***************************************/
  • trunk/ADOL-C/src/advector.cpp

    r676 r708  
    464464        put_op(subscript);
    465465        ADOLC_PUT_LOCINT(index.loc());
    466         ADOLC_PUT_LOCINT(locat);
    467466        ADOLC_PUT_VAL(n);
    468467        ADOLC_PUT_LOCINT(data[0].loc());
     468        ADOLC_PUT_LOCINT(locat);
    469469
    470470        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    489489        put_op(subscript_ref);
    490490        ADOLC_PUT_LOCINT(index.loc());
    491         ADOLC_PUT_LOCINT(locat);
    492491        ADOLC_PUT_VAL(n);
    493492        ADOLC_PUT_LOCINT(data[0].loc());
     493        ADOLC_PUT_LOCINT(locat);
    494494
    495495        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    527527  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    528528      put_op(vec_copy);
    529       ADOLC_PUT_LOCINT(dest[0].loc());
    530529      ADOLC_PUT_LOCINT(src[0].loc());
    531530      ADOLC_PUT_LOCINT(n);
     531      ADOLC_PUT_LOCINT(dest[0].loc());
    532532      for (locint i=0; i<n; i++) {
    533533          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    548548  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    549549      put_op(vec_dot);
    550       ADOLC_PUT_LOCINT(res);
    551550      ADOLC_PUT_LOCINT(x[0].loc());
    552551      ADOLC_PUT_LOCINT(y[0].loc());
    553552      ADOLC_PUT_LOCINT(n);
     553      ADOLC_PUT_LOCINT(res);
    554554      ADOLC_CURRENT_TAPE_INFOS.num_eq_prod += 2*n;
    555555      ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    572572  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    573573      put_op(vec_axpy);
    574       ADOLC_PUT_LOCINT(res[0].loc());
    575574      ADOLC_PUT_LOCINT(a_loc);
    576575      ADOLC_PUT_LOCINT(x[0].loc());
    577576      ADOLC_PUT_LOCINT(y[0].loc());
    578577      ADOLC_PUT_LOCINT(n);
     578      ADOLC_PUT_LOCINT(res[0].loc());
    579579      ADOLC_CURRENT_TAPE_INFOS.num_eq_prod += 2*n -1;
    580580      for (locint i=0; i<n; i++) {
  • trunk/ADOL-C/src/drivers/Makefile.in

    r640 r708  
    252252STRIP = @STRIP@
    253253UINT_TYPE = @UINT_TYPE@
     254USE_BOOST_POOL = @USE_BOOST_POOL@
    254255VERSION = @VERSION@
    255256_lib = @_lib@
  • trunk/ADOL-C/src/fo_rev.c

    r676 r708  
    693693            case assign_p:            /* assign an adouble variable a    assign_d */
    694694                /* double value. (=) */
     695                res   = get_locint_r();
    695696                arg   = get_locint_r();
    696                 res   = get_locint_r();
    697697#if !defined(_NTIGHT_)
    698698                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    795795            case eq_plus_p:            /* Add a floating point to an    eq_plus_d */
    796796                /* adouble. (+=) */
     797                res   = get_locint_r();
    797798                arg   = get_locint_r();
    798                 res   = get_locint_r();
    799799#if !defined(_NTIGHT_)
    800800                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    839839            case eq_min_p:       /* Subtract a floating point from an    eq_min_d */
    840840                /* adouble. (-=) */
     841                res   = get_locint_r();
    841842                arg   = get_locint_r();
    842                 res   = get_locint_r();
    843843#if !defined(_NTIGHT_)
    844844                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    892892            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    893893                /* flaoting point. (*=) */
     894                res   = get_locint_r();
    894895                arg   = get_locint_r();
    895                 res   = get_locint_r();
    896896#if !defined(_NTIGHT_)
    897897                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    10091009            case min_a_p:                /* Subtract an adouble from a    min_d_a */
    10101010                /* (+) */
     1011                res   = get_locint_r();
    10111012                arg1  = get_locint_r();
    1012                 res   = get_locint_r();
    10131013                arg   = get_locint_r();
    10141014#if !defined(_NTIGHT_)
     
    12091209            case mult_a_p:         /* Multiply an adouble by a double    mult_a_p */
    12101210                /* (*) */
     1211                res   = get_locint_r();
    12111212                arg1  = get_locint_r();
    1212                 res   = get_locint_r();
    12131213                arg   = get_locint_r();
    12141214#if !defined(_NTIGHT_)
     
    13091309                /****************************************************************************/
    13101310            case div_p_a:             /* Division double - adouble (/)    div_p_a */
     1311                res   = get_locint_r();
    13111312                arg1  = get_locint_r();
    1312                 res   = get_locint_r();
    13131313                arg   = get_locint_r();
    13141314
     
    15781578                /*--------------------------------------------------------------------------*/
    15791579            case pow_op_p:                                                /* pow_op_p */
     1580                res   = get_locint_r();
    15801581                arg1  = get_locint_r();
    1581                 res   = get_locint_r();
    15821582                arg   = get_locint_r();
    15831583#if !defined(_NTIGHT_)
     
    21622162#endif
    21632163                    get_val_r();
     2164                    res = get_locint_r();
    21642165#if !defined(_NTIGHT_)
    21652166                    size_t idx, numval = (size_t)trunc(fabs(val));
     
    21682169#endif
    21692170                    get_locint_r();
    2170                     res = get_locint_r();
    21712171                    arg = get_locint_r();
    21722172#if !defined(_NTIGHT_)
     
    22012201#endif
    22022202                    get_val_r();
     2203                    res = get_locint_r();
    22032204#if !defined(_NTIGHT_)
    22042205                    size_t idx, numval = (size_t)trunc(fabs(val));
     
    22072208#endif
    22082209                    get_locint_r();
    2209                     res = get_locint_r();
    22102210                    arg = get_locint_r();
    22112211#if !defined(_NTIGHT_)
     
    24032403            case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_d */
    24042404                /* adouble. (+=) */
     2405                arg1   = get_locint_r();
    24052406                arg    = get_locint_r();
    2406                 arg1   = get_locint_r();
    24072407#if !defined(_NTIGHT_)
    24082408                res = (size_t)trunc(fabs(TARG1));
     
    24572457            case ref_eq_min_p:       /* Subtract a floating point from an    eq_min_p */
    24582458                /* adouble. (-=) */
     2459                arg1   = get_locint_r();
    24592460                arg    = get_locint_r();
    2460                 arg1   = get_locint_r();
    24612461#if !defined(_NTIGHT_)
    24622462                res = (size_t)trunc(fabs(TARG1));
     
    25172517            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    25182518                /* flaoting point. (*=) */
     2519                arg1   = get_locint_r();
    25192520                arg    = get_locint_r();
    2520                 arg1   = get_locint_r();
    25212521#if !defined(_NTIGHT_)
    25222522                res = (size_t)trunc(fabs(TARG1));
     
    25662566
    25672567        case vec_copy:
     2568                res = get_locint_r();
    25682569                size = get_locint_r();
    25692570                arg = get_locint_r();
    2570                 res = get_locint_r();
    25712571                for (qq=0;qq<size;qq++) {
    25722572
     
    25932593
    25942594        case vec_dot:
     2595                res = get_locint_r();
    25952596                size = get_locint_r();
    25962597                arg2 = get_locint_r();
    25972598                arg1 = get_locint_r();
    2598                 res = get_locint_r();
    25992599                for (qq=0;qq<size;qq++) {
    26002600                    ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     
    26202620
    26212621        case vec_axpy:
     2622                res = get_locint_r();
    26222623                size = get_locint_r();
    26232624                arg2 = get_locint_r();
    26242625                arg1 = get_locint_r();
    26252626                arg = get_locint_r();
    2626                 res = get_locint_r();
    26272627                for (qq=0;qq<size;qq++) {
    26282628                    ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
  • trunk/ADOL-C/src/ho_rev.c

    r676 r708  
    699699            case assign_p:      /* assign an adouble variable a    assign_d */
    700700                /* double value. (=) */
     701                res   = get_locint_r();
    701702                arg   = get_locint_r();
    702                 res   = get_locint_r();
    703703                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    704704
     
    783783        case eq_plus_p:            /* Add a floating point to an    eq_plus_p */
    784784            /* adouble. (+=) */
     785           res   = get_locint_r();
    785786           arg   = get_locint_r();
    786            res   = get_locint_r();
    787787                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    788788
     
    826826            case eq_min_p:       /* Subtract a floating point from an    eq_min_p */
    827827                /* adouble. (-=) */
     828                res   = get_locint_r();
    828829                arg   = get_locint_r();
    829                 res   = get_locint_r();
    830830                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    831831
     
    878878            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    879879                /* flaoting point. (*=) */
     880                res   = get_locint_r();
    880881                arg   = get_locint_r();
    881                 res   = get_locint_r();
    882882                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    883883
     
    982982            case min_a_p:                /* Subtract an adouble from a    min_a_p */
    983983                /* (+) */
     984                res   = get_locint_r();
    984985                arg1  = get_locint_r();
    985                 res   = get_locint_r();
    986986                arg   = get_locint_r();
    987987                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    12721272            case mult_a_p:         /* Multiply an adouble by a double    mult_a_p */
    12731273                /* (*) */
     1274                res   = get_locint_r();
    12741275                arg1  = get_locint_r();
    1275                 res   = get_locint_r();
    12761276                arg   = get_locint_r();
    12771277                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    14111411                /****************************************************************************/
    14121412            case div_p_a:             /* Division double - adouble (/)    div_p_a */
     1413                res   = get_locint_r();
    14131414                arg1  = get_locint_r();
    1414                 res   = get_locint_r();
    14151415                arg   = get_locint_r();
    14161416                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    17961796                /*--------------------------------------------------------------------------*/
    17971797            case pow_op_p:                                                /* pow_op_p */
     1798                res   = get_locint_r();
    17981799                arg1  = get_locint_r();
    1799                 res   = get_locint_r();
    18001800                arg   = get_locint_r();
    18011801                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    24762476                    size_t idx, numval = (size_t)trunc(fabs(coval));
    24772477                    locint vectorloc;
     2478                    res = get_locint_r();
    24782479                    vectorloc = get_locint_r();
    2479                     res = get_locint_r();
    24802480                    arg = get_locint_r();
    24812481                    ASSIGN_T(Targ, rpp_T[arg])
     
    25102510                    size_t idx, numval = (size_t)trunc(fabs(coval));
    25112511                    locint vectorloc;
     2512                    res = get_locint_r();
    25122513                    vectorloc = get_locint_r();
    2513                     res = get_locint_r();
    25142514                    arg = get_locint_r();
    25152515                    ASSIGN_T(Targ, rpp_T[arg])
     
    26672667        case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_d */
    26682668            /* adouble. (+=) */
     2669                arg1   = get_locint_r();
    26692670                arg    = get_locint_r();
    2670                 arg1   = get_locint_r();
    26712671                ASSIGN_T(Targ1, rpp_T[arg1])
    26722672                res = (size_t)trunc(fabs(TARG1));
     
    27112711                break;
    27122712
     2713           case ref_eq_min_p:            /* Add a floating point to an    eq_min_d */
     2714            /* adouble. (-=) */
     2715                arg1   = get_locint_r();
     2716                arg    = get_locint_r();
     2717                ASSIGN_T(Targ1, rpp_T[arg1])
     2718                res = (size_t)trunc(fabs(TARG1));
     2719                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     2720
     2721                GET_TAYL(res,k,p)
     2722                break;
     2723
    27132724            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
    27142725                /* adouble. (-=) */
     
    27422753                res = (size_t)trunc(fabs(TARG1));
    27432754                coval = get_val_r();
     2755
     2756                ASSIGN_A(Ares, rpp_A[res])
     2757
     2758                FOR_0_LE_l_LT_p
     2759                if ( 0 == ARES_INC )
     2760                    HOV_INC(Ares, k)
     2761                    else
     2762                        FOR_0_LE_i_LT_k
     2763                        ARES_INC *= coval;
     2764
     2765                GET_TAYL(res,k,p)
     2766                break;
     2767
     2768            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
     2769                /* flaoting point. (*=) */
     2770                arg1   = get_locint_r();
     2771                arg    = get_locint_r();
     2772                ASSIGN_T(Targ1, rpp_T[arg1])
     2773                res = (size_t)trunc(fabs(TARG1));
     2774                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
    27442775
    27452776                ASSIGN_A(Ares, rpp_A[res])
     
    27972828            case vec_copy:
    27982829
     2830                res = get_locint_r();
    27992831                size = get_locint_r();
    28002832                arg = get_locint_r();
    2801                 res = get_locint_r();
    28022833
    28032834                for(qq=0;qq<size;qq++) {
     
    28282859
    28292860        case vec_dot:
     2861                res = get_locint_r();
    28302862                size = get_locint_r();
    28312863                arg2 = get_locint_r();
    28322864                arg1 = get_locint_r();
    2833                 res = get_locint_r();
    28342865                for (qq=0;qq<size;qq++) {
    28352866                ASSIGN_A(Ares,  rpp_A[res])
     
    28672898
    28682899        case vec_axpy:
     2900                res = get_locint_r();
    28692901                size = get_locint_r();
    28702902                arg2 = get_locint_r();
    28712903                arg1 = get_locint_r();
    28722904                arg = get_locint_r();
    2873                 res = get_locint_r();
    28742905                for (qq=0;qq<size;qq++) {
    28752906                ASSIGN_A(Ares,  rpp_A[res+qq])
  • trunk/ADOL-C/src/lie/Makefile.in

    r611 r708  
    269269STRIP = @STRIP@
    270270UINT_TYPE = @UINT_TYPE@
     271USE_BOOST_POOL = @USE_BOOST_POOL@
    271272VERSION = @VERSION@
    272273_lib = @_lib@
  • trunk/ADOL-C/src/lie/adolc_lie.cpp

    r609 r708  
    66 
    77
    8  Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
     8 Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
    99
    1010 This file is part of ADOL-C. This software is provided as open source.
  • trunk/ADOL-C/src/lie/adolc_lie_c.c

    r643 r708  
    66 
    77
    8  Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
     8 Copyright (c) Siquian Wang, Klaus Röbenack, Jan Winkler, Mirko Franke
    99
    1010 This file is part of ADOL-C. This software is provided as open source.
  • trunk/ADOL-C/src/param.cpp

    r605 r708  
    9090    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    9191        put_op(assign_p);
    92         ADOLC_PUT_LOCINT(location);
    9392        ADOLC_PUT_LOCINT(_idx);
     93        ADOLC_PUT_LOCINT(location);
    9494
    9595        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    150150    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    151151        put_op(eq_plus_p);
     152        ADOLC_PUT_LOCINT(p._idx);
    152153        ADOLC_PUT_LOCINT(loc);
    153         ADOLC_PUT_LOCINT(p._idx);
    154154       
    155155        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    168168    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
    169169        put_op(ref_eq_plus_p);
    170         ADOLC_PUT_LOCINT(location);
    171         ADOLC_PUT_LOCINT(p._idx);
     170        ADOLC_PUT_LOCINT(p._idx);
     171        ADOLC_PUT_LOCINT(location);
    172172
    173173        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    185185    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_min_d,loc(),coval);
    186186        put_op(eq_min_p);
     187        ADOLC_PUT_LOCINT(p._idx);
    187188        ADOLC_PUT_LOCINT(loc());
    188         ADOLC_PUT_LOCINT(p._idx);
    189189
    190190        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    202202    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_min_d,location,coval);
    203203        put_op(ref_eq_min_p);
    204         ADOLC_PUT_LOCINT(location);
    205         ADOLC_PUT_LOCINT(p._idx);
     204        ADOLC_PUT_LOCINT(p._idx);
     205        ADOLC_PUT_LOCINT(location);
    206206
    207207        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    219219    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_mult_d,loc(),coval);
    220220        put_op(eq_mult_p);
     221        ADOLC_PUT_LOCINT(p._idx);       // = coval
    221222        ADOLC_PUT_LOCINT(loc()); // = res
    222         ADOLC_PUT_LOCINT(p._idx);       // = coval
    223223
    224224        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    236236    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_mult_d,location,coval);
    237237        put_op(ref_eq_mult_p);
    238         ADOLC_PUT_LOCINT(location);
    239         ADOLC_PUT_LOCINT(p._idx);
     238        ADOLC_PUT_LOCINT(p._idx);
     239        ADOLC_PUT_LOCINT(location);
    240240
    241241        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    278278        put_op(min_a_p);
    279279        ADOLC_PUT_LOCINT(a.loc());
     280        ADOLC_PUT_LOCINT(p._idx);
    280281        ADOLC_PUT_LOCINT(locat);
    281         ADOLC_PUT_LOCINT(p._idx);
    282282
    283283        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    299299        put_op(mult_a_p);
    300300        ADOLC_PUT_LOCINT(a.loc());
     301        ADOLC_PUT_LOCINT(p._idx);
    301302        ADOLC_PUT_LOCINT(locat);
    302         ADOLC_PUT_LOCINT(p._idx);
    303303
    304304        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    320320        put_op(div_p_a);
    321321        ADOLC_PUT_LOCINT(a.loc());
     322        ADOLC_PUT_LOCINT(p._idx);
    322323        ADOLC_PUT_LOCINT(locat);
    323         ADOLC_PUT_LOCINT(p._idx);
    324324
    325325        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     
    340340        put_op(pow_op_p);
    341341        ADOLC_PUT_LOCINT(x.loc()); // = arg
     342        ADOLC_PUT_LOCINT(p._idx);         // = coval
    342343        ADOLC_PUT_LOCINT(locat);      // = res
    343         ADOLC_PUT_LOCINT(p._idx);         // = coval
    344344
    345345        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
  • trunk/ADOL-C/src/sparse/Makefile.in

    r678 r708  
    251251STRIP = @STRIP@
    252252UINT_TYPE = @UINT_TYPE@
     253USE_BOOST_POOL = @USE_BOOST_POOL@
    253254VERSION = @VERSION@
    254255_lib = @_lib@
  • trunk/ADOL-C/src/storemanager.h

    r671 r708  
    7070#    endif
    7171#endif
     72#include <adolc/internal/adolc_settings.h>
    7273#include <forward_list>
    73 #if defined(HAVE_BOOST_POOL_POOL_ALLOC_HPP) && defined(HAVE_BOOST_SYSTEM)
     74
     75#if USE_BOOST_POOL
    7476#include <boost/pool/pool_alloc.hpp>
    75 #define USE_BOOST_POOL 1
    76 #else
    77 #define USE_BOOST_POOL 0
    7877#endif
     78
    7979#include <adolc/internal/common.h>
    8080
  • trunk/ADOL-C/src/tapedoc/Makefile.in

    r611 r708  
    251251STRIP = @STRIP@
    252252UINT_TYPE = @UINT_TYPE@
     253USE_BOOST_POOL = @USE_BOOST_POOL@
    253254VERSION = @VERSION@
    254255_lib = @_lib@
  • trunk/ADOL-C/src/uni5_for.c

    r707 r708  
    15781578            case assign_p:            /* assign an adouble variable a    assign_d */
    15791579                /* double value. (=) */
     1580                arg   = get_locint_f();
    15801581                res   = get_locint_f();
    1581                 arg   = get_locint_f();
    15821582#if !defined(_NTIGHT_)
    15831583                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    17841784            case eq_plus_p:            /* Add a floating point to an    eq_plus_p */
    17851785                /* adouble. (+=) */
     1786                arg   = get_locint_f();
    17861787                res   = get_locint_f();
    1787                 arg   = get_locint_f();
    17881788#if !defined(_NTIGHT_)
    17891789                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    18531853            case eq_min_p:       /* Subtract a floating point from an    eq_min_p */
    18541854                /* adouble. (-=) */
     1855                arg = get_locint_f();
    18551856                res = get_locint_f();
    1856                 arg = get_locint_f();
    18571857#if !defined(_NTIGHT_)
    18581858                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    19361936            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    19371937                /* flaoting point. (*=) */
     1938                arg   = get_locint_f();
    19381939                res   = get_locint_f();
    1939                 arg   = get_locint_f();
    19401940#if !defined(_NTIGHT_)
    19411941                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
     
    21242124                /* (+) */
    21252125                arg   = get_locint_f();
     2126                arg1  = get_locint_f();
    21262127                res   = get_locint_f();
    2127                 arg1  = get_locint_f();
    21282128#if !defined(_NTIGHT_)
    21292129                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    24842484                /* (*) */
    24852485                arg   = get_locint_f();
     2486                arg1  = get_locint_f();
    24862487                res   = get_locint_f();
    2487                 arg1  = get_locint_f();
    24882488#if !defined(_NTIGHT_)
    24892489                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    26632663        case div_p_a:             /* Division double - adouble (/)    div_p_a */
    26642664                arg   = get_locint_f();
     2665                arg1  = get_locint_f();
    26652666                res   = get_locint_f();
    2666                 arg1  = get_locint_f();
    26672667#if !defined(_NTIGHT_)
    26682668                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    38353835            case pow_op_p:                                                /* pow_op_p */
    38363836                arg   = get_locint_f();
     3837                arg1  = get_locint_f();
    38373838                res   = get_locint_f();
    3838                 arg1  = get_locint_f();
    38393839#if !defined(_NTIGHT_)
    38403840                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    49964996                get_val_f();
    49974997                arg = get_locint_f();
    4998                 res = get_locint_f();
    49994998                {
    50004999#if !defined(_NTIGHT_)
     
    50045003#endif
    50055004                    get_locint_f();
     5005                    res = get_locint_f();
    50065006#if !defined(_NTIGHT_)
    50075007                    idx = (size_t)trunc(fabs(dp_T0[arg]));
     
    50405040                get_val_f();
    50415041                arg = get_locint_f();
    5042                 res = get_locint_f();
    50435042                {
    50445043#if !defined(_NTIGHT_)
     
    50485047#endif
    50495048                    get_locint_f();
     5049                    res = get_locint_f();
    50505050#if !defined(_NTIGHT_)
    50515051                    idx = (size_t)trunc(fabs(dp_T0[arg]));
     
    53415341            case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_p */
    53425342                /* adouble. (+=) */
     5343                arg1  = get_locint_f();
    53435344                arg  = get_locint_f();
    5344                 arg1  = get_locint_f();
    53455345#if !defined(_NTIGHT_)
    53465346                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    54175417            case ref_eq_min_p:       /* Subtract a floating point from an    eq_min_p */
    54185418                /* adouble. (-=) */
     5419                arg1 = get_locint_f();
    54195420                arg = get_locint_f();
    5420                 arg1 = get_locint_f();
    54215421#if !defined(_NTIGHT_)
    54225422                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    55055505            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
    55065506                /* flaoting point. (*=) */
     5507                arg1 = get_locint_f();
    55075508                arg = get_locint_f();
    5508                 arg1 = get_locint_f();
    55095509#if !defined(_NTIGHT_)
    55105510                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
     
    55935593
    55945594            case vec_copy:
    5595                 res = get_locint_f();
    55965595                arg = get_locint_f();
    55975596                size = get_locint_f();
     5597                res = get_locint_f();
    55985598
    55995599                for(qq=0;qq<size;qq++) {
     
    56245624
    56255625            case vec_dot:
    5626                 res = get_locint_f();
    56275626                arg1 = get_locint_f();
    56285627                arg2 = get_locint_f();
    56295628                size = get_locint_f();
     5629                res = get_locint_f();
    56305630                IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
    56315631#if !defined(_NTIGHT_)
     
    57145714
    57155715            case vec_axpy:
    5716                 res = get_locint_f();
    57175716                arg = get_locint_f();
    57185717                arg1 = get_locint_f();
    57195718                arg2 = get_locint_f();
    57205719                size = get_locint_f();
     5720                res = get_locint_f();
    57215721               
    57225722                for(qq=0;qq<size;qq++) {
  • trunk/ADOL-C/test/Makefile.in

    r611 r708  
    260260STRIP = @STRIP@
    261261UINT_TYPE = @UINT_TYPE@
     262USE_BOOST_POOL = @USE_BOOST_POOL@
    262263VERSION = @VERSION@
    263264_lib = @_lib@
  • trunk/Makefile.in

    r624 r708  
    330330STRIP = @STRIP@
    331331UINT_TYPE = @UINT_TYPE@
     332USE_BOOST_POOL = @USE_BOOST_POOL@
    332333VERSION = @VERSION@
    333334_lib = @_lib@
  • trunk/configure

    r696 r708  
    651651HAVE_LIBCOLPACK_FALSE
    652652HAVE_LIBCOLPACK_TRUE
     653USE_BOOST_POOL
     654BOOST_SYSTEM_LIB
     655BOOST_LDFLAGS
     656BOOST_CPPFLAGS
    653657ADVBRANCH
    654658REAL_TYPE
     
    660664ADOLC_VERSION
    661665ac_aux_dir
    662 BOOST_SYSTEM_LIB
    663 BOOST_LDFLAGS
    664 BOOST_CPPFLAGS
    665666_lib
    666667saveCXX
     
    811812with_mpicc
    812813with_mpicxx
    813 with_boost
    814 with_boost_libdir
    815 with_boost_system
    816814enable_use_calloc
    817815enable_atrig_erf
     
    825823enable_tserrno
    826824with_openmp_flag
     825with_boost
     826with_boost_libdir
     827with_boost_system
    827828enable_sparse
    828829with_colpack
     
    15381539  --with-mpicc=MPICC      name of the MPI C++ compiler to use (default mpicc)
    15391540  --with-mpicxx=MPICXX    name of the MPI C++ compiler to use (default mpicxx)
     1541  --with-openmp-flag=FLAG use FLAG to enable OpenMP at compile time
     1542                          [default=none]
    15401543  --with-boost[=ARG]      use Boost library from a standard location
    15411544                          (ARG=yes), from the specified location (ARG=<path>),
     
    15511554                          to specify a certain library for the linker e.g.
    15521555                          --with-boost-system=boost_system-gcc-mt
    1553   --with-openmp-flag=FLAG use FLAG to enable OpenMP at compile time
    1554                           [default=none]
    15551556
    15561557  --with-colpack=DIR      path to the colpack library and headers
     
    1638916390
    1639016391
     16392if test "x$enable_static" != "xno" ; then
     16393   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Linking a user program with static ADOL-C library will always result in a segmentation fault" >&5
     16394$as_echo "$as_me: WARNING: Linking a user program with static ADOL-C library will always result in a segmentation fault" >&2;}
     16395fi
     16396
    1639116397
    1639216398
     
    1705117057fi
    1705217058done
     17059
     17060
     17061# substitutions
     17062
     17063
     17064# ADOL-C configuration
     17065
     17066$as_echo "#define ADOLC_VERSION 2" >>confdefs.h
     17067
     17068
     17069$as_echo "#define ADOLC_SUBVERSION 6" >>confdefs.h
     17070
     17071
     17072$as_echo "#define ADOLC_PATCHLEVEL 2" >>confdefs.h
     17073
     17074ADOLC_VERSION=2
     17075ADOLC_SUBVERSION=6
     17076ADOLC_PATCHLEVEL=2
     17077
     17078
     17079
     17080
     17081# Checks for library functions
     17082for ac_header in stdlib.h
     17083do :
     17084  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
     17085if test "x$ac_cv_header_stdlib_h" = xyes; then :
     17086  cat >>confdefs.h <<_ACEOF
     17087#define HAVE_STDLIB_H 1
     17088_ACEOF
     17089
     17090fi
     17091
     17092done
     17093
     17094{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
     17095$as_echo_n "checking for GNU libc compatible malloc... " >&6; }
     17096if ${ac_cv_func_malloc_0_nonnull+:} false; then :
     17097  $as_echo_n "(cached) " >&6
     17098else
     17099  if test "$cross_compiling" = yes; then :
     17100  ac_cv_func_malloc_0_nonnull=no
     17101else
     17102  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     17103/* end confdefs.h.  */
     17104#if defined STDC_HEADERS || defined HAVE_STDLIB_H
     17105# include <stdlib.h>
     17106#else
     17107char *malloc ();
     17108#endif
     17109
     17110int
     17111main ()
     17112{
     17113return ! malloc (0);
     17114  ;
     17115  return 0;
     17116}
     17117_ACEOF
     17118if ac_fn_c_try_run "$LINENO"; then :
     17119  ac_cv_func_malloc_0_nonnull=yes
     17120else
     17121  ac_cv_func_malloc_0_nonnull=no
     17122fi
     17123rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
     17124  conftest.$ac_objext conftest.beam conftest.$ac_ext
     17125fi
     17126
     17127fi
     17128{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
     17129$as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
     17130if test $ac_cv_func_malloc_0_nonnull = yes; then :
     17131
     17132$as_echo "#define HAVE_MALLOC 1" >>confdefs.h
     17133
     17134else
     17135  $as_echo "#define HAVE_MALLOC 0" >>confdefs.h
     17136
     17137   case " $LIBOBJS " in
     17138  *" malloc.$ac_objext "* ) ;;
     17139  *) LIBOBJS="$LIBOBJS malloc.$ac_objext"
     17140 ;;
     17141esac
     17142
     17143
     17144$as_echo "#define malloc rpl_malloc" >>confdefs.h
     17145
     17146fi
     17147
     17148
     17149for ac_header in stdlib.h
     17150do :
     17151  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
     17152if test "x$ac_cv_header_stdlib_h" = xyes; then :
     17153  cat >>confdefs.h <<_ACEOF
     17154#define HAVE_STDLIB_H 1
     17155_ACEOF
     17156
     17157fi
     17158
     17159done
     17160
     17161{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5
     17162$as_echo_n "checking for GNU libc compatible realloc... " >&6; }
     17163if ${ac_cv_func_realloc_0_nonnull+:} false; then :
     17164  $as_echo_n "(cached) " >&6
     17165else
     17166  if test "$cross_compiling" = yes; then :
     17167  ac_cv_func_realloc_0_nonnull=no
     17168else
     17169  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     17170/* end confdefs.h.  */
     17171#if defined STDC_HEADERS || defined HAVE_STDLIB_H
     17172# include <stdlib.h>
     17173#else
     17174char *realloc ();
     17175#endif
     17176
     17177int
     17178main ()
     17179{
     17180return ! realloc (0, 0);
     17181  ;
     17182  return 0;
     17183}
     17184_ACEOF
     17185if ac_fn_c_try_run "$LINENO"; then :
     17186  ac_cv_func_realloc_0_nonnull=yes
     17187else
     17188  ac_cv_func_realloc_0_nonnull=no
     17189fi
     17190rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
     17191  conftest.$ac_objext conftest.beam conftest.$ac_ext
     17192fi
     17193
     17194fi
     17195{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5
     17196$as_echo "$ac_cv_func_realloc_0_nonnull" >&6; }
     17197if test $ac_cv_func_realloc_0_nonnull = yes; then :
     17198
     17199$as_echo "#define HAVE_REALLOC 1" >>confdefs.h
     17200
     17201else
     17202  $as_echo "#define HAVE_REALLOC 0" >>confdefs.h
     17203
     17204   case " $LIBOBJS " in
     17205  *" realloc.$ac_objext "* ) ;;
     17206  *) LIBOBJS="$LIBOBJS realloc.$ac_objext"
     17207 ;;
     17208esac
     17209
     17210
     17211$as_echo "#define realloc rpl_realloc" >>confdefs.h
     17212
     17213fi
     17214
     17215
     17216if test x$ac_cv_func_malloc_0_nonnull != xyes ; then
     17217
     17218cat >>confdefs.h <<_ACEOF
     17219#define calloc rpl_calloc
     17220_ACEOF
     17221
     17222fi
     17223
     17224{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use calloc or malloc for memory allocation" >&5
     17225$as_echo_n "checking whether to use calloc or malloc for memory allocation... " >&6; }
     17226# Check whether --enable-use-calloc was given.
     17227if test "${enable_use_calloc+set}" = set; then :
     17228  enableval=$enable_use_calloc; use_calloc=$enableval
     17229else
     17230  use_calloc=yes
     17231fi
     17232
     17233
     17234if test x$use_calloc = xyes ; then
     17235{ $as_echo "$as_me:${as_lineno-$LINENO}: result: calloc" >&5
     17236$as_echo "calloc" >&6; }
     17237
     17238$as_echo "#define ADOLC_USE_CALLOC 1" >>confdefs.h
     17239
     17240else
     17241{ $as_echo "$as_me:${as_lineno-$LINENO}: result: malloc" >&5
     17242$as_echo "malloc" >&6; }
     17243fi
     17244
     17245{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable atrig/erf functions" >&5
     17246$as_echo_n "checking whether to enable atrig/erf functions... " >&6; }
     17247# Check whether --enable-atrig-erf was given.
     17248if test "${enable_atrig_erf+set}" = set; then :
     17249  enableval=$enable_atrig_erf; use_atrig_erf=$enableval
     17250else
     17251  use_atrig_erf=no
     17252fi
     17253
     17254{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_atrig_erf" >&5
     17255$as_echo "$use_atrig_erf" >&6; }
     17256
     17257if test x$use_atrig_erf = xyes ; then
     17258  ATRIG_ERF="#define ATRIG_ERF 1"
     17259else
     17260  ATRIG_ERF="#undef ATRIG_ERF"
     17261fi
     17262
     17263
     17264{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use 32-bit or 64-bit locations" >&5
     17265$as_echo_n "checking whether to use 32-bit or 64-bit locations... " >&6; }
     17266# Check whether --enable-ulong was given.
     17267if test "${enable_ulong+set}" = set; then :
     17268  enableval=$enable_ulong; use_ulong=$enableval
     17269else
     17270  use_ulong=no
     17271fi
     17272
     17273
     17274if test x$use_ulong = xyes -a 0$ac_cv_sizeof_void_p -ge 8 ; then
     17275  UINT_TYPE=uint64_t
     17276  { $as_echo "$as_me:${as_lineno-$LINENO}: result: 64-bit" >&5
     17277$as_echo "64-bit" >&6; }
     17278else
     17279  UINT_TYPE=uint32_t
     17280  { $as_echo "$as_me:${as_lineno-$LINENO}: result: 32-bit" >&5
     17281$as_echo "32-bit" >&6; }
     17282fi
     17283
     17284
     17285{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use single or double precision" >&5
     17286$as_echo_n "checking whether to use single or double precision... " >&6; }
     17287# Check whether --enable-double was given.
     17288if test "${enable_double+set}" = set; then :
     17289  enableval=$enable_double; use_double=$enableval
     17290else
     17291  use_double=yes
     17292fi
     17293
     17294
     17295if test x$use_double = xno ; then
     17296  REAL_TYPE=float
     17297  echo
     17298  echo -n "using ${REAL_TYPE} is not well tested, please report bugs if you find any..."
     17299else
     17300  REAL_TYPE=double
     17301fi
     17302{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $REAL_TYPE" >&5
     17303$as_echo "$REAL_TYPE" >&6; }
     17304
     17305
     17306{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable advanced branching operations" >&5
     17307$as_echo_n "checking whether to enable advanced branching operations... " >&6; }
     17308# Check whether --enable-advanced-branching was given.
     17309if test "${enable_advanced_branching+set}" = set; then :
     17310  enableval=$enable_advanced_branching; use_advbranch=$enableval
     17311else
     17312  use_advbranch=no
     17313fi
     17314
     17315{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_advbranch" >&5
     17316$as_echo "$use_advbranch" >&6; }
     17317
     17318if test x$use_advbranch = xyes ; then
     17319  ADVBRANCH="#define ADOLC_ADVANCED_BRANCHING 1"
     17320else
     17321  ADVBRANCH="#undef ADOLC_ADVANCED_BRANCHING"
     17322fi
     17323
     17324
     17325
     17326{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use ADOL-C debug mode" >&5
     17327$as_echo_n "checking whether to use ADOL-C debug mode... " >&6; }
     17328# Check whether --enable-debug was given.
     17329if test "${enable_debug+set}" = set; then :
     17330  enableval=$enable_debug;
     17331  adolc_debug=$enableval
     17332   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $adolc_debug" >&5
     17333$as_echo "$adolc_debug" >&6; }
     17334
     17335else
     17336
     17337   adolc_debug=no
     17338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     17339$as_echo "no" >&6; }
     17340
     17341fi
     17342
     17343
     17344{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use ADOL-C hard debug mode" >&5
     17345$as_echo_n "checking whether to use ADOL-C hard debug mode... " >&6; }
     17346# Check whether --enable-harddebug was given.
     17347if test "${enable_harddebug+set}" = set; then :
     17348  enableval=$enable_harddebug;
     17349   adolc_harddebug=$enableval
     17350   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $adolc_harddebug" >&5
     17351$as_echo "$adolc_harddebug" >&6; }
     17352
     17353else
     17354
     17355   adolc_harddebug=no
     17356   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     17357$as_echo "no" >&6; }
     17358
     17359fi
     17360
     17361
     17362if test x$adolc_harddebug == xyes ; then
     17363adolc_debug=yes
     17364
     17365$as_echo "#define ADOLC_HARDDEBUG 1" >>confdefs.h
     17366
     17367fi
     17368
     17369if test x$adolc_debug == xyes ; then
     17370
     17371$as_echo "#define ADOLC_DEBUG 1" >>confdefs.h
     17372
     17373fi
     17374
     17375{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the default adouble constructor should initialize the value to 0" >&5
     17376$as_echo_n "checking whether the default adouble constructor should initialize the value to 0... " >&6; }
     17377# Check whether --enable-stdczero was given.
     17378if test "${enable_stdczero+set}" = set; then :
     17379  enableval=$enable_stdczero;
     17380  adolc_stdczero=no
     17381  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     17382$as_echo "no" >&6; }
     17383
     17384else
     17385
     17386  adolc_stdczero=yes
     17387  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
     17388$as_echo "yes" >&6; }
     17389
     17390fi
     17391
     17392
     17393if test x$adolc_stdczero == xyes; then
     17394
     17395$as_echo "#define ADOLC_ADOUBLE_STDCZERO 1" >>confdefs.h
     17396
     17397fi
     17398
     17399{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the adouble variables have a late initialize option for functions like malloc/realloc" >&5
     17400$as_echo_n "checking whether the adouble variables have a late initialize option for functions like malloc/realloc... " >&6; }
     17401# Check whether --enable-lateinit was given.
     17402if test "${enable_lateinit+set}" = set; then :
     17403  enableval=$enable_lateinit;
     17404  adolc_late_init=yes
     17405  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
     17406$as_echo "yes" >&6; }
     17407
     17408else
     17409
     17410  adolc_late_init=no
     17411  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     17412$as_echo "no" >&6; }
     17413
     17414fi
     17415
     17416
     17417if test x$adolc_late_init == xyes; then
     17418
     17419$as_echo "#define ADOLC_ADOUBLE_LATEINIT 1" >>confdefs.h
     17420
     17421fi
     17422
     17423{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether errno is thread save" >&5
     17424$as_echo_n "checking whether errno is thread save... " >&6; }
     17425# Check whether --enable-tserrno was given.
     17426if test "${enable_tserrno+set}" = set; then :
     17427  enableval=$enable_tserrno;
     17428  adolc_tserrno=$enableval
     17429  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $adolc_tserrno" >&5
     17430$as_echo "$adolc_tserrno" >&6; }
     17431
     17432else
     17433
     17434  adolc_tserrno=no
     17435  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     17436$as_echo "no" >&6; }
     17437
     17438fi
     17439
     17440
     17441if test x$adolc_tserrno == xyes ; then
     17442
     17443$as_echo "#define ADOLC_THREADSAVE_ERRNO 1" >>confdefs.h
     17444
     17445fi
     17446
     17447{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which flag to use to enable OpenMP" >&5
     17448$as_echo_n "checking which flag to use to enable OpenMP... " >&6; }
     17449
     17450# Check whether --with-openmp-flag was given.
     17451if test "${with_openmp_flag+set}" = set; then :
     17452  withval=$with_openmp_flag; ac_adolc_openmpflag=$withval
     17453             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_adolc_openmpflag" >&5
     17454$as_echo "$ac_adolc_openmpflag" >&6; }
     17455else
     17456  ac_adolc_openmpflag=""
     17457             { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
     17458$as_echo "none" >&6; }
     17459fi
    1705317460
    1705417461
     
    1760518012if test "x$want_boost" = xyes -a "x$boost_new" = xyes -a "x$ac_cv_header_boost_pool_pool_alloc_hpp" = xyes -a "x$link_system" = xyes ; then
    1760618013    using_boost_pool=yes
     18014    USE_BOOST_POOL="#define USE_BOOST_POOL 1"
    1760718015else
    1760818016    using_boost_pool=no
    17609 fi
    17610 
    17611 # substitutions
    17612 
    17613 
    17614 # ADOL-C configuration
    17615 
    17616 $as_echo "#define ADOLC_VERSION 2" >>confdefs.h
    17617 
    17618 
    17619 $as_echo "#define ADOLC_SUBVERSION 6" >>confdefs.h
    17620 
    17621 
    17622 $as_echo "#define ADOLC_PATCHLEVEL 2" >>confdefs.h
    17623 
    17624 ADOLC_VERSION=2
    17625 ADOLC_SUBVERSION=6
    17626 ADOLC_PATCHLEVEL=2
    17627 
    17628 
    17629 
    17630 
    17631 # Checks for library functions
    17632 for ac_header in stdlib.h
    17633 do :
    17634   ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
    17635 if test "x$ac_cv_header_stdlib_h" = xyes; then :
    17636   cat >>confdefs.h <<_ACEOF
    17637 #define HAVE_STDLIB_H 1
    17638 _ACEOF
    17639 
    17640 fi
    17641 
    17642 done
    17643 
    17644 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
    17645 $as_echo_n "checking for GNU libc compatible malloc... " >&6; }
    17646 if ${ac_cv_func_malloc_0_nonnull+:} false; then :
    17647   $as_echo_n "(cached) " >&6
    17648 else
    17649   if test "$cross_compiling" = yes; then :
    17650   ac_cv_func_malloc_0_nonnull=no
    17651 else
    17652   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    17653 /* end confdefs.h.  */
    17654 #if defined STDC_HEADERS || defined HAVE_STDLIB_H
    17655 # include <stdlib.h>
    17656 #else
    17657 char *malloc ();
    17658 #endif
    17659 
    17660 int
    17661 main ()
    17662 {
    17663 return ! malloc (0);
    17664   ;
    17665   return 0;
    17666 }
    17667 _ACEOF
    17668 if ac_fn_c_try_run "$LINENO"; then :
    17669   ac_cv_func_malloc_0_nonnull=yes
    17670 else
    17671   ac_cv_func_malloc_0_nonnull=no
    17672 fi
    17673 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
    17674   conftest.$ac_objext conftest.beam conftest.$ac_ext
    17675 fi
    17676 
    17677 fi
    17678 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
    17679 $as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
    17680 if test $ac_cv_func_malloc_0_nonnull = yes; then :
    17681 
    17682 $as_echo "#define HAVE_MALLOC 1" >>confdefs.h
    17683 
    17684 else
    17685   $as_echo "#define HAVE_MALLOC 0" >>confdefs.h
    17686 
    17687    case " $LIBOBJS " in
    17688   *" malloc.$ac_objext "* ) ;;
    17689   *) LIBOBJS="$LIBOBJS malloc.$ac_objext"
    17690  ;;
    17691 esac
    17692 
    17693 
    17694 $as_echo "#define malloc rpl_malloc" >>confdefs.h
    17695 
    17696 fi
    17697 
    17698 
    17699 for ac_header in stdlib.h
    17700 do :
    17701   ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
    17702 if test "x$ac_cv_header_stdlib_h" = xyes; then :
    17703   cat >>confdefs.h <<_ACEOF
    17704 #define HAVE_STDLIB_H 1
    17705 _ACEOF
    17706 
    17707 fi
    17708 
    17709 done
    17710 
    17711 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5
    17712 $as_echo_n "checking for GNU libc compatible realloc... " >&6; }
    17713 if ${ac_cv_func_realloc_0_nonnull+:} false; then :
    17714   $as_echo_n "(cached) " >&6
    17715 else
    17716   if test "$cross_compiling" = yes; then :
    17717   ac_cv_func_realloc_0_nonnull=no
    17718 else
    17719   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    17720 /* end confdefs.h.  */
    17721 #if defined STDC_HEADERS || defined HAVE_STDLIB_H
    17722 # include <stdlib.h>
    17723 #else
    17724 char *realloc ();
    17725 #endif
    17726 
    17727 int
    17728 main ()
    17729 {
    17730 return ! realloc (0, 0);
    17731   ;
    17732   return 0;
    17733 }
    17734 _ACEOF
    17735 if ac_fn_c_try_run "$LINENO"; then :
    17736   ac_cv_func_realloc_0_nonnull=yes
    17737 else
    17738   ac_cv_func_realloc_0_nonnull=no
    17739 fi
    17740 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
    17741   conftest.$ac_objext conftest.beam conftest.$ac_ext
    17742 fi
    17743 
    17744 fi
    17745 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5
    17746 $as_echo "$ac_cv_func_realloc_0_nonnull" >&6; }
    17747 if test $ac_cv_func_realloc_0_nonnull = yes; then :
    17748 
    17749 $as_echo "#define HAVE_REALLOC 1" >>confdefs.h
    17750 
    17751 else
    17752   $as_echo "#define HAVE_REALLOC 0" >>confdefs.h
    17753 
    17754    case " $LIBOBJS " in
    17755   *" realloc.$ac_objext "* ) ;;
    17756   *) LIBOBJS="$LIBOBJS realloc.$ac_objext"
    17757  ;;
    17758 esac
    17759 
    17760 
    17761 $as_echo "#define realloc rpl_realloc" >>confdefs.h
    17762 
    17763 fi
    17764 
    17765 
    17766 if test x$ac_cv_func_malloc_0_nonnull != xyes ; then
    17767 
    17768 cat >>confdefs.h <<_ACEOF
    17769 #define calloc rpl_calloc
    17770 _ACEOF
    17771 
    17772 fi
    17773 
    17774 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use calloc or malloc for memory allocation" >&5
    17775 $as_echo_n "checking whether to use calloc or malloc for memory allocation... " >&6; }
    17776 # Check whether --enable-use-calloc was given.
    17777 if test "${enable_use_calloc+set}" = set; then :
    17778   enableval=$enable_use_calloc; use_calloc=$enableval
    17779 else
    17780   use_calloc=yes
    17781 fi
    17782 
    17783 
    17784 if test x$use_calloc = xyes ; then
    17785 { $as_echo "$as_me:${as_lineno-$LINENO}: result: calloc" >&5
    17786 $as_echo "calloc" >&6; }
    17787 
    17788 $as_echo "#define ADOLC_USE_CALLOC 1" >>confdefs.h
    17789 
    17790 else
    17791 { $as_echo "$as_me:${as_lineno-$LINENO}: result: malloc" >&5
    17792 $as_echo "malloc" >&6; }
    17793 fi
    17794 
    17795 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable atrig/erf functions" >&5
    17796 $as_echo_n "checking whether to enable atrig/erf functions... " >&6; }
    17797 # Check whether --enable-atrig-erf was given.
    17798 if test "${enable_atrig_erf+set}" = set; then :
    17799   enableval=$enable_atrig_erf; use_atrig_erf=$enableval
    17800 else
    17801   use_atrig_erf=no
    17802 fi
    17803 
    17804 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_atrig_erf" >&5
    17805 $as_echo "$use_atrig_erf" >&6; }
    17806 
    17807 if test x$use_atrig_erf = xyes ; then
    17808   ATRIG_ERF="#define ATRIG_ERF 1"
    17809 else
    17810   ATRIG_ERF="#undef ATRIG_ERF"
    17811 fi
    17812 
    17813 
    17814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use 32-bit or 64-bit locations" >&5
    17815 $as_echo_n "checking whether to use 32-bit or 64-bit locations... " >&6; }
    17816 # Check whether --enable-ulong was given.
    17817 if test "${enable_ulong+set}" = set; then :
    17818   enableval=$enable_ulong; use_ulong=$enableval
    17819 else
    17820   use_ulong=no
    17821 fi
    17822 
    17823 
    17824 if test x$use_ulong = xyes -a 0$ac_cv_sizeof_void_p -ge 8 ; then
    17825   UINT_TYPE=uint64_t
    17826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: 64-bit" >&5
    17827 $as_echo "64-bit" >&6; }
    17828 else
    17829   UINT_TYPE=uint32_t
    17830   { $as_echo "$as_me:${as_lineno-$LINENO}: result: 32-bit" >&5
    17831 $as_echo "32-bit" >&6; }
    17832 fi
    17833 
    17834 
    17835 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use single or double precision" >&5
    17836 $as_echo_n "checking whether to use single or double precision... " >&6; }
    17837 # Check whether --enable-double was given.
    17838 if test "${enable_double+set}" = set; then :
    17839   enableval=$enable_double; use_double=$enableval
    17840 else
    17841   use_double=yes
    17842 fi
    17843 
    17844 
    17845 if test x$use_double = xno ; then
    17846   REAL_TYPE=float
    17847   echo
    17848   echo -n "using ${REAL_TYPE} is not well tested, please report bugs if you find any..."
    17849 else
    17850   REAL_TYPE=double
    17851 fi
    17852 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $REAL_TYPE" >&5
    17853 $as_echo "$REAL_TYPE" >&6; }
    17854 
    17855 
    17856 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable advanced branching operations" >&5
    17857 $as_echo_n "checking whether to enable advanced branching operations... " >&6; }
    17858 # Check whether --enable-advanced-branching was given.
    17859 if test "${enable_advanced_branching+set}" = set; then :
    17860   enableval=$enable_advanced_branching; use_advbranch=$enableval
    17861 else
    17862   use_advbranch=no
    17863 fi
    17864 
    17865 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_advbranch" >&5
    17866 $as_echo "$use_advbranch" >&6; }
    17867 
    17868 if test x$use_advbranch = xyes ; then
    17869   ADVBRANCH="#define ADOLC_ADVANCED_BRANCHING 1"
    17870 else
    17871   ADVBRANCH="#undef ADOLC_ADVANCED_BRANCHING"
    17872 fi
    17873 
    17874 
    17875 
    17876 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use ADOL-C debug mode" >&5
    17877 $as_echo_n "checking whether to use ADOL-C debug mode... " >&6; }
    17878 # Check whether --enable-debug was given.
    17879 if test "${enable_debug+set}" = set; then :
    17880   enableval=$enable_debug;
    17881   adolc_debug=$enableval
    17882    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $adolc_debug" >&5
    17883 $as_echo "$adolc_debug" >&6; }
    17884 
    17885 else
    17886 
    17887    adolc_debug=no
    17888    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    17889 $as_echo "no" >&6; }
    17890 
    17891 fi
    17892 
    17893 
    17894 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use ADOL-C hard debug mode" >&5
    17895 $as_echo_n "checking whether to use ADOL-C hard debug mode... " >&6; }
    17896 # Check whether --enable-harddebug was given.
    17897 if test "${enable_harddebug+set}" = set; then :
    17898   enableval=$enable_harddebug;
    17899    adolc_harddebug=$enableval
    17900    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $adolc_harddebug" >&5
    17901 $as_echo "$adolc_harddebug" >&6; }
    17902 
    17903 else
    17904 
    17905    adolc_harddebug=no
    17906    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    17907 $as_echo "no" >&6; }
    17908 
    17909 fi
    17910 
    17911 
    17912 if test x$adolc_harddebug == xyes ; then
    17913 adolc_debug=yes
    17914 
    17915 $as_echo "#define ADOLC_HARDDEBUG 1" >>confdefs.h
    17916 
    17917 fi
    17918 
    17919 if test x$adolc_debug == xyes ; then
    17920 
    17921 $as_echo "#define ADOLC_DEBUG 1" >>confdefs.h
    17922 
    17923 fi
    17924 
    17925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the default adouble constructor should initialize the value to 0" >&5
    17926 $as_echo_n "checking whether the default adouble constructor should initialize the value to 0... " >&6; }
    17927 # Check whether --enable-stdczero was given.
    17928 if test "${enable_stdczero+set}" = set; then :
    17929   enableval=$enable_stdczero;
    17930   adolc_stdczero=no
    17931   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    17932 $as_echo "no" >&6; }
    17933 
    17934 else
    17935 
    17936   adolc_stdczero=yes
    17937   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
    17938 $as_echo "yes" >&6; }
    17939 
    17940 fi
    17941 
    17942 
    17943 if test x$adolc_stdczero == xyes; then
    17944 
    17945 $as_echo "#define ADOLC_ADOUBLE_STDCZERO 1" >>confdefs.h
    17946 
    17947 fi
    17948 
    17949 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the adouble variables have a late initialize option for functions like malloc/realloc" >&5
    17950 $as_echo_n "checking whether the adouble variables have a late initialize option for functions like malloc/realloc... " >&6; }
    17951 # Check whether --enable-lateinit was given.
    17952 if test "${enable_lateinit+set}" = set; then :
    17953   enableval=$enable_lateinit;
    17954   adolc_late_init=yes
    17955   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
    17956 $as_echo "yes" >&6; }
    17957 
    17958 else
    17959 
    17960   adolc_late_init=no
    17961   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    17962 $as_echo "no" >&6; }
    17963 
    17964 fi
    17965 
    17966 
    17967 if test x$adolc_late_init == xyes; then
    17968 
    17969 $as_echo "#define ADOLC_ADOUBLE_LATEINIT 1" >>confdefs.h
    17970 
    17971 fi
    17972 
    17973 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether errno is thread save" >&5
    17974 $as_echo_n "checking whether errno is thread save... " >&6; }
    17975 # Check whether --enable-tserrno was given.
    17976 if test "${enable_tserrno+set}" = set; then :
    17977   enableval=$enable_tserrno;
    17978   adolc_tserrno=$enableval
    17979   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $adolc_tserrno" >&5
    17980 $as_echo "$adolc_tserrno" >&6; }
    17981 
    17982 else
    17983 
    17984   adolc_tserrno=no
    17985   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    17986 $as_echo "no" >&6; }
    17987 
    17988 fi
    17989 
    17990 
    17991 if test x$adolc_tserrno == xyes ; then
    17992 
    17993 $as_echo "#define ADOLC_THREADSAVE_ERRNO 1" >>confdefs.h
    17994 
    17995 fi
    17996 
    17997 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which flag to use to enable OpenMP" >&5
    17998 $as_echo_n "checking which flag to use to enable OpenMP... " >&6; }
    17999 
    18000 # Check whether --with-openmp-flag was given.
    18001 if test "${with_openmp_flag+set}" = set; then :
    18002   withval=$with_openmp_flag; ac_adolc_openmpflag=$withval
    18003              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_adolc_openmpflag" >&5
    18004 $as_echo "$ac_adolc_openmpflag" >&6; }
    18005 else
    18006   ac_adolc_openmpflag=""
    18007              { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
    18008 $as_echo "none" >&6; }
     18017    USE_BOOST_POOL="#define USE_BOOST_POOL 0"
    1800918018fi
    1801018019
     
    2134521354;;
    2134621355esac
     21356if test "x$enable_static" != "xno" ; then
     21357echo \
     21358" Linking a user program with a static ADOL-C library will always result
     21359  in a segmentation fault. Please always use the shared library.
     21360*****************************************************************************
     21361"
     21362fi
  • trunk/configure.ac

    r695 r708  
    7575LT_INIT([disable-static win32-dll dlopen])
    7676
     77if test "x$enable_static" != "xno" ; then
     78   AC_MSG_WARN([Linking a user program with static ADOL-C library will always result in a segmentation fault])
     79fi
     80
    7781MPI_CONF_PRE
    7882
     
    108112AC_SEARCH_LIBS([pow], [m])
    109113AC_CHECK_FUNCS([floor fmax fmin ftime pow sqrt strchr strtol trunc])
    110 
    111 AX_BOOST_BASE([1.54],[boost_new=yes],[boost_new=no])
    112 if test x$boost_new = xyes ; then
    113 CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
    114 AC_LANG_PUSH([C++])
    115 AC_CHECK_HEADERS([boost/pool/pool_alloc.hpp])
    116 AC_LANG_POP([C++])
    117 AX_BOOST_SYSTEM
    118 LDFLAGS="$LDFLAGS $BOOST_LDFLAGS $BOOST_SYSTEM_LIB"
    119 fi
    120 
    121 if test "x$want_boost" = xyes -a "x$boost_new" = xyes -a "x$ac_cv_header_boost_pool_pool_alloc_hpp" = xyes -a "x$link_system" = xyes ; then
    122     using_boost_pool=yes
    123 else
    124     using_boost_pool=no
    125 fi
    126114
    127115# substitutions
     
    313301            [ac_adolc_openmpflag=""
    314302             AC_MSG_RESULT(none)])
     303
     304AX_BOOST_BASE([1.54],[boost_new=yes],[boost_new=no])
     305if test x$boost_new = xyes ; then
     306CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
     307AC_LANG_PUSH([C++])
     308AC_CHECK_HEADERS([boost/pool/pool_alloc.hpp])
     309AC_LANG_POP([C++])
     310AX_BOOST_SYSTEM
     311LDFLAGS="$LDFLAGS $BOOST_LDFLAGS $BOOST_SYSTEM_LIB"
     312fi
     313
     314if test "x$want_boost" = xyes -a "x$boost_new" = xyes -a "x$ac_cv_header_boost_pool_pool_alloc_hpp" = xyes -a "x$link_system" = xyes ; then
     315    using_boost_pool=yes
     316    USE_BOOST_POOL="#define USE_BOOST_POOL 1"
     317else
     318    using_boost_pool=no
     319    USE_BOOST_POOL="#define USE_BOOST_POOL 0"
     320fi
     321AC_SUBST(USE_BOOST_POOL)
    315322
    316323if test "x$using_boost_pool" = xyes -a "x$ac_adolc_openmpflag" = x ; then
     
    659666;;
    660667esac
     668if test "x$enable_static" != "xno" ; then
     669echo \
     670" Linking a user program with a static ADOL-C library will always result
     671  in a segmentation fault. Please always use the shared library.
     672*****************************************************************************
     673"
     674fi
Note: See TracChangeset for help on using the changeset viewer.