Changeset 595


Ignore:
Timestamp:
Feb 16, 2015 6:08:54 AM (5 years ago)
Author:
kulshres
Message:

Merge changes from 'master' branch of 'gitclone'

The following changesets have been merged:

commit 3931a4393e4003928eed197011a8dc75aab95514
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Feb 13 16:55:03 2015 +0100

Visual Studio Compatibility

unfortunately visual studio 2010 does not support C++11 standard.

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

commit 023a1f5062e61a5761f15a7c6ec93d05ec9e4bf3
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Mon Feb 9 16:12:23 2015 +0000

correct ColPack? download website

git-svn-id: https://projects.coin-or.org/svn/ADOL-C/trunk@594 94ac48a7-3327-4b6a-8511-9a4036a20e83

commit 6a1c37c41b89b9c13b3702035d16ad78c5730166
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Feb 4 18:01:44 2015 +0100

scoping changes

forward declarations with friends and declspec(dllexport) for windows
are a bit tricky.

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

commit 199e0da8bbf28c4819cd47b5acfd5cd8a18d55a3
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Feb 4 17:42:37 2015 +0100

Add operations vec_dot and vec_axpy

This will reduce tape length and provide speed.
Dot-products and axpy operations done with
adoubles and for-loops require many temporary
adub variables and become slow.

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

commit d5f729d55ed250384fe62c64f6b5dcc5e8c09748
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Feb 3 15:30:04 2015 +0100

read unsigned values from .adolcrc

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

commit b7a9e1062c345624f27039b2a590f09bd8e70a70
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jan 30 17:12:02 2015 +0100

specify initial size of live variable store in adolcrc

if one knows approximately how many live variables
there are going to be in the program one can
specify it in the .adolcrc file with INITLIVE
This will prevent the many initially required
new and delete calls while the store grows dynamically
when adouble objects are initialized

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

commit 9ce7f63b4c7a7099781a2d2f6c7a962e24932c65
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jan 30 16:07:53 2015 +0100

provide a conversion to adouble* from advector

the memory will still be managed inside advector

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

commit 26ac5de41e0ef0e0faae26e32ea3b377570b7ef0
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jan 30 16:06:53 2015 +0100

streamline advector class

since we now use c++11 we can use the default-insertion
instead of having to copy. This saves operations.
so we don't need the dflt field anymore.
We can also use the adolc_vec_copy() function to
implement the copy constructor.

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

commit 2b2f878a05082d777ebbe5e3d445751ca68759cb
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jan 30 15:56:05 2015 +0100

add a faster vector copy operation

this should in principle be faster than calling
n assignment operators of adouble and it also
shortens the trace somewhat.

Can only be used if the arrays were allocated
with contiguous locations.

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

commit ef9babd35faea9e766c6c861d99b001510d7e5d4
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Jan 28 14:01:06 2015 +0100

try disabling multithreading support in boost

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

commit 766ac8360bb952b68ce345ea29ee96be65044c29
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Jan 27 14:28:23 2015 +0100

add DLL_EXPORT to function

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

commit fe580956f2664a743f1a981464fd398aabd9acbc
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Jan 27 12:41:51 2015 +0100

allow edf structures to be initialised to zero from outside the library

This is required to properly deallocate the memory, which is user
allocated and set as pointers in this structure, to ensure that
the structure does not call for this memory after the user deallocates
it.

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

commit 4c793005996f0af6b4a95788283e3baab233d3b8
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Jan 26 13:56:35 2015 +0100

more streamlining of next_loc()/free_loc()

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

commit 6686a248a2598a306f4502acd3158c4945d45705
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Jan 26 13:20:14 2015 +0100

a couple of warning fixes

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

commit 7a87f9f5ed97d0af7db7674229483aa782abd970
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Jan 26 11:17:10 2015 +0100

streamline StoreManagerLocintBlock::free_loc() slightly

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

commit 1e4b7a739849098fc33174138b237e5d44462822
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Jan 26 11:08:41 2015 +0100

Also check for boost::system in code

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

commit 1f9eb738280610aad49b1dff623e8aaaca9903d6
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Jan 26 11:05:02 2015 +0100

use a pool allocator from the boost library if available

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

commit 0498360e12d8590f67f19f9a1bca7dff1edb00a2
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Tue Jan 6 14:48:24 2015 +0000

copy paste typos

Thanks to Mu Wang <wangmu0701@…>

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

git-svn-id: https://projects.coin-or.org/svn/ADOL-C/trunk@593 94ac48a7-3327-4b6a-8511-9a4036a20e83

commit 80f4a743262d32daf1869cfbc4486c977de1e3a4
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Dec 24 14:45:32 2014 +0100

Scatterv/Allgatherv? and compile fixes

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

commit 6caec6d3e19f234da22241e97999cb2eebb40be2
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Dec 24 01:04:48 2014 +0100

Implement Gatherv and some compile fixes

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

commit 439ab813d8b08c0a17c6afb6180ebe914acc3e20
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Dec 23 19:56:45 2014 +0100

Don't use uninitialised pointer for status in MPI calls

From: Max Sagebaum <max.sagebaum@…>
Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit fb911b73d6f9e4729fdf5148671b3c23ed9252b8
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Dec 19 11:02:14 2014 +0100

Implement AMPI calls in forward mode

Send,Recv,Gather,Scatter,Allgather

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

commit 5eecda924840d63fa7309bfc3e4758b28f7e41ec
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Dec 16 15:55:32 2014 +0100

try out some c++11 features since we mandate it anyway

use forward_list instead of list since its unidirectional

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

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

Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • trunk/ADOL-C/include/adolc/adouble.h

    r562 r595  
    199199   ---- operates just like a badouble, but it has a destructor defined for it.
    200200*/
     201ADOLC_DLL_EXPORT adub* adubp_from_adub(const adub&);
     202/* s = adolc_vec_dot(x,y,size); <=> s = <x,y>_2 */
     203ADOLC_DLL_EXPORT adub adolc_vec_dot(const adouble*const, const adouble*const, locint);
    201204
    202205class ADOLC_DLL_EXPORT adub:public badouble {
     
    205208    friend ADOLC_DLL_EXPORT class adubref;
    206209    friend ADOLC_DLL_EXPORT class pdouble;
    207     friend ADOLC_DLL_EXPORT adub* adubp_from_adub(const adub&);
     210    friend adub* adubp_from_adub(const adub&);
    208211    adub( adub const &) {
    209212        isInit = false;
     
    233236
    234237    /*--------------------------------------------------------------------------*/
     238    /* s = adolc_vec_dot(x,y,size); <=> s = <x,y>_2 */
     239    friend adub adolc_vec_dot(const adouble*const, const adouble*const, locint);
    235240    /* Functions friends with both badouble and adub */
    236241#define _IN_CLASS_ 1
  • trunk/ADOL-C/include/adolc/advector.h

    r537 r595  
    103103};
    104104
     105/* adolc_vec_copy(dest,src,size); */
     106void ADOLC_DLL_EXPORT adolc_vec_copy(adouble *const, const adouble*const, locint);
     107/* adolc_vec_axpy(res,a,x,y,size); <=> res = a*x + y  */
     108void ADOLC_DLL_EXPORT adolc_vec_axpy(adouble *const, const badouble&, const adouble*const, const adouble*const, locint);
     109
    105110class advector {
    106111private:
    107112    struct ADOLC_DLL_EXPORT blocker {
    108         adouble *dflt;
    109113        blocker() {}
    110114        blocker(size_t n);
     
    115119public:
    116120    ADOLC_DLL_EXPORT advector() : blk(), data() {}
    117     ADOLC_DLL_EXPORT explicit advector(size_t n) : blk(n), data(n, *blk.dflt) { delete blk.dflt; }
     121    ADOLC_DLL_EXPORT explicit advector(size_t n) : blk(n), data(n) {}
    118122    ADOLC_DLL_EXPORT ~advector() {}
    119     ADOLC_DLL_EXPORT advector(const advector& x) : blk(x.data.size()), data(x.data) { delete blk.dflt; }
    120     ADOLC_DLL_EXPORT advector(const std::vector<adouble>& v) : blk(v.size()), data(v) { delete blk.dflt; }
     123    ADOLC_DLL_EXPORT advector(const advector& x) : blk(x.size()), data(x.size()) {  adolc_vec_copy(data.data(),x.data.data(),x.size()); }
     124    // in the above copy we are sure of contiguous locations
     125    // but not so in the one below
     126    ADOLC_DLL_EXPORT advector(const std::vector<adouble>& v) : blk(v.size()), data(v) {}
    121127    ADOLC_DLL_EXPORT size_t size() const { return data.size(); }
    122128    ADOLC_DLL_EXPORT operator const std::vector<adouble>&() const { return data; }
    123129    ADOLC_DLL_EXPORT operator std::vector<adouble>&() { return data; }
     130    ADOLC_DLL_EXPORT operator adouble*() { return data.data(); }
    124131    ADOLC_DLL_EXPORT adub operator[](const badouble& index) const;
    125132    ADOLC_DLL_EXPORT adubref operator[](const badouble& index);
  • trunk/ADOL-C/include/adolc/externfcts.h

    r537 r595  
    273273                                   int m, double *yp, adouble *ya);
    274274
     275/**
     276 * zeros out the edf pointers and sets bools to defaults
     277 */
     278ADOLC_DLL_EXPORT void edf_zero(ext_diff_fct *edfct);
     279
    275280#endif /* __CPLUSPLUS */
    276281
  • trunk/ADOL-C/src/advector.cpp

    r566 r595  
    390390
    391391advector::blocker::blocker(size_t n) {
    392     dflt = new adouble;
    393392    ensureContiguousLocations(n);
    394393}
     
    470469    return r;
    471470}
     471
     472void adolc_vec_copy(adouble *const dest, const adouble *const src, locint n) {
     473  ADOLC_OPENMP_THREAD_NUMBER;
     474  ADOLC_OPENMP_GET_THREAD_NUMBER;
     475  if (dest[n-1].loc() - dest[0].loc()!=(unsigned)n-1 || src[n-1].loc()-src[0].loc()!=(unsigned)n-1) fail(ADOLC_VEC_LOCATIONGAP);
     476  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
     477      put_op(vec_copy);
     478      ADOLC_PUT_LOCINT(dest[0].loc());
     479      ADOLC_PUT_LOCINT(src[0].loc());
     480      ADOLC_PUT_LOCINT(n);
     481      for (locint i=0; i<n; i++) {
     482          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     483          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     484              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[dest[0].loc()+i]);
     485      }
     486  }
     487  for (locint i=0; i<n; i++)
     488      ADOLC_GLOBAL_TAPE_VARS.store[dest[0].loc()+i] =
     489          ADOLC_GLOBAL_TAPE_VARS.store[src[0].loc()+i];
     490}
     491
     492adub adolc_vec_dot(const adouble *const x, const adouble *const y, locint n) {
     493  ADOLC_OPENMP_THREAD_NUMBER;
     494  ADOLC_OPENMP_GET_THREAD_NUMBER;
     495  if (x[n-1].loc() - x[0].loc()!=(unsigned)n-1 || y[n-1].loc()-y[0].loc()!=(unsigned)n-1) fail(ADOLC_VEC_LOCATIONGAP);
     496  locint res = next_loc();
     497  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
     498      put_op(vec_dot);
     499      ADOLC_PUT_LOCINT(res);
     500      ADOLC_PUT_LOCINT(x[0].loc());
     501      ADOLC_PUT_LOCINT(y[0].loc());
     502      ADOLC_PUT_LOCINT(n);
     503      ADOLC_CURRENT_TAPE_INFOS.num_eq_prod += 2*n;
     504      ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     505      if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     506          ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res]);
     507  }
     508  ADOLC_GLOBAL_TAPE_VARS.store[res] = 0;
     509  for (locint i=0; i<n; i++)
     510      ADOLC_GLOBAL_TAPE_VARS.store[res] +=
     511          ADOLC_GLOBAL_TAPE_VARS.store[x[0].loc()+i] *
     512          ADOLC_GLOBAL_TAPE_VARS.store[y[0].loc()+i];
     513  return res;
     514}
     515
     516void adolc_vec_axpy(adouble *const res, const badouble& a, const adouble*const x, const adouble*const y,locint n) {
     517  ADOLC_OPENMP_THREAD_NUMBER;
     518  ADOLC_OPENMP_GET_THREAD_NUMBER;
     519  if (res[n-1].loc() - res[0].loc()!=(unsigned)n-1 || x[n-1].loc() - x[0].loc()!=(unsigned)n-1 || y[n-1].loc()-y[0].loc()!=(unsigned)n-1) fail(ADOLC_VEC_LOCATIONGAP);
     520  locint a_loc = a.loc();
     521  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
     522      put_op(vec_axpy);
     523      ADOLC_PUT_LOCINT(res[0].loc());
     524      ADOLC_PUT_LOCINT(a_loc);
     525      ADOLC_PUT_LOCINT(x[0].loc());
     526      ADOLC_PUT_LOCINT(y[0].loc());
     527      ADOLC_PUT_LOCINT(n);
     528      ADOLC_CURRENT_TAPE_INFOS.num_eq_prod += 2*n -1;
     529      for (locint i=0; i<n; i++) {
     530          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
     531          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
     532              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res[0].loc()+i]);
     533      }
     534  }
     535  for (locint i=0; i<n; i++)
     536      ADOLC_GLOBAL_TAPE_VARS.store[res[0].loc()+i] =
     537          ADOLC_GLOBAL_TAPE_VARS.store[a_loc] *
     538          ADOLC_GLOBAL_TAPE_VARS.store[x[0].loc()+i] +
     539          ADOLC_GLOBAL_TAPE_VARS.store[y[0].loc()+i];
     540
     541}
  • trunk/ADOL-C/src/ampisupportAdolc.cpp

    r439 r595  
    5757static MPI_Op ourProdOp;
    5858
    59 void ADOLC_TLM_init() {
    60   MPI_Op_create(ADOLC_TLM_AMPI_PROD,1,&ourProdOp);
    61 }
    62 
    63 int ADOLC_TLM_AMPI_Send(void* buf,
    64                         int count,
    65                         MPI_Datatype datatype,
    66                         int src,
    67                         int tag,
    68                         AMPI_PairedWith pairedWith,
    69                         MPI_Comm comm) {
    70   return TLM_AMPI_Send(buf,
    71                        count,
    72                        datatype,
    73                        src,
    74                        tag,
    75                        pairedWith,
    76                        comm);
    77 }
    78 
    79 int ADOLC_TLM_AMPI_Recv(void* buf,
    80                         int count,
    81                         MPI_Datatype datatype,
    82                         int src,
    83                         int tag,
    84                         AMPI_PairedWith pairedWith,
    85                         MPI_Comm comm,
    86                         MPI_Status* status) {
    87   return TLM_AMPI_Recv(buf,
    88                        count,
    89                        datatype,
    90                        src,
    91                        tag,
    92                        pairedWith,
    93                        comm,
    94                        status);
    95 }
    96 
    97 int ADOLC_TLM_AMPI_Isend (void* buf,
    98                           int count,
    99                           MPI_Datatype datatype,
    100                           int dest,
    101                           int tag,
    102                           AMPI_PairedWith pairedWith,
    103                           MPI_Comm comm,
    104                           AMPI_Request* request) {
    105   return TLM_AMPI_Isend(buf,
    106                         count,
    107                         datatype,
    108                         dest,
    109                         tag,
    110                         pairedWith,
    111                         comm,
    112                         request);
    113 }
    114 
    115 int ADOLC_TLM_AMPI_Irecv (void* buf,
    116                           int count,
    117                           MPI_Datatype datatype,
    118                           int src,
    119                           int tag,
    120                           AMPI_PairedWith pairedWith,
    121                           MPI_Comm comm,
    122                           AMPI_Request* request) {
    123   return TLM_AMPI_Irecv(buf,
    124                         count,
    125                         datatype,
    126                         src,
    127                         tag,
    128                         pairedWith,
    129                         comm,
    130                         request);
    131 }
    132 
    133 int ADOLC_TLM_AMPI_Wait(AMPI_Request *request,
    134                         MPI_Status *status) {
    135   return TLM_AMPI_Wait(request,
    136                        status);
    137 }
    138 
    139 int ADOLC_TLM_AMPI_Barrier(MPI_Comm comm) {
    140   return TLM_AMPI_Barrier(comm);
    141 }
    142 
    143 int ADOLC_TLM_AMPI_Gather(void *sendbuf,
    144                           int sendcnt,
    145                           MPI_Datatype sendtype,
    146                           void *recvbuf,
    147                           int recvcnt,
    148                           MPI_Datatype recvtype,
    149                           int root,
    150                           MPI_Comm comm) {
    151   return TLM_AMPI_Gather(sendbuf,
    152                          sendcnt,
    153                          sendtype,
    154                          recvbuf,
    155                          recvcnt,
    156                          recvtype,
    157                          root,
    158                          comm);
    159 }
    160 
    161 int ADOLC_TLM_AMPI_Scatter(void *sendbuf,
    162                            int sendcnt,
    163                            MPI_Datatype sendtype,
    164                            void *recvbuf,
    165                            int recvcnt,
    166                            MPI_Datatype recvtype,
    167                            int root, MPI_Comm comm) {
    168   return TLM_AMPI_Scatter(sendbuf,
    169                           sendcnt,
    170                           sendtype,
    171                           recvbuf,
    172                           recvcnt,
    173                           recvtype,
    174                           root,
    175                           comm);
    176 }
    177 
    178 int ADOLC_TLM_AMPI_Allgather(void *sendbuf,
    179                              int sendcnt,
    180                              MPI_Datatype sendtype,
    181                              void *recvbuf,
    182                              int recvcnt,
    183                              MPI_Datatype recvtype,
    184                              MPI_Comm comm) {
    185   return TLM_AMPI_Allgather(sendbuf,
    186                             sendcnt,
    187                             sendtype,
    188                             recvbuf,
    189                             recvcnt,
    190                             recvtype,
    191                             comm);
    192 }
    193 
    194 int ADOLC_TLM_AMPI_Gatherv(void *sendbuf,
    195                            int sendcnt,
    196                            MPI_Datatype sendtype,
    197                            void *recvbuf,
    198                            int *recvcnts,
    199                            int *displs,
    200                            MPI_Datatype recvtype,
    201                            int root,
    202                            MPI_Comm comm) {
    203   return TLM_AMPI_Gatherv(sendbuf,
    204                           sendcnt,
    205                           sendtype,
    206                           recvbuf,
    207                           recvcnts,
    208                           displs,
    209                           recvtype,
    210                           root,
    211                           comm);
    212 }
    213 
    214 int ADOLC_TLM_AMPI_Scatterv(void *sendbuf,
    215                             int *sendcnts,
    216                             int *displs,
    217                             MPI_Datatype sendtype,
    218                             void *recvbuf,
    219                             int recvcnt,
    220                             MPI_Datatype recvtype,
    221                             int root, MPI_Comm comm) {
    222   return TLM_AMPI_Scatterv(sendbuf,
    223                            sendcnts,
    224                            displs,
    225                            sendtype,
    226                            recvbuf,
    227                            recvcnt,
    228                            recvtype,
    229                            root,
    230                            comm);
    231 }
    232 
    233 int ADOLC_TLM_AMPI_Allgatherv(void *sendbuf,
    234                               int sendcnt,
    235                               MPI_Datatype sendtype,
    236                               void *recvbuf,
    237                               int *recvcnts,
    238                               int *displs,
    239                               MPI_Datatype recvtype,
    240                               MPI_Comm comm) {
    241   return TLM_AMPI_Allgatherv(sendbuf,
    242                              sendcnt,
    243                              sendtype,
    244                              recvbuf,
    245                              recvcnts,
    246                              displs,
    247                              recvtype,
    248                              comm);
    249 }
    250 
    25159void allocatePack(void** buf,
    25260                  const locint startLoc,
     
    308116}
    309117
     118void ADOLC_TLM_init() {
     119  MPI_Op_create(ADOLC_TLM_AMPI_PROD,1,&ourProdOp);
     120}
     121
     122int ADOLC_TLM_AMPI_Send(void* buf,
     123                        int count,
     124                        MPI_Datatype datatype,
     125                        int dest,
     126                        int tag,
     127                        AMPI_PairedWith pairedWith,
     128                        MPI_Comm comm) {
     129  int rc;
     130  locint startLoc=get_locint_f();
     131  TAPE_AMPI_read_int(&count);
     132  TAPE_AMPI_read_MPI_Datatype(&datatype);
     133  TAPE_AMPI_read_int(&dest);
     134  TAPE_AMPI_read_int(&tag);
     135  TAPE_AMPI_read_int((int*)&pairedWith);
     136  TAPE_AMPI_read_MPI_Comm(&comm);
     137  int packedCount=0;
     138  MPI_Datatype packedDatatype;
     139  allocatePack(&buf,
     140               startLoc,
     141               count,
     142               packedCount,
     143               datatype,
     144               packedDatatype);
     145  rc =   TLM_AMPI_Send(buf,
     146                       count,
     147                       datatype,
     148                       dest,
     149                       tag,
     150                       pairedWith,
     151                       comm);
     152  unpackDeallocate(&buf,
     153                   startLoc,
     154                   count,
     155                   packedCount,
     156                   datatype,
     157                   packedDatatype);
     158  return rc;
     159}
     160
     161int ADOLC_TLM_AMPI_Recv(void* buf,
     162                        int count,
     163                        MPI_Datatype datatype,
     164                        int src,
     165                        int tag,
     166                        AMPI_PairedWith pairedWith,
     167                        MPI_Comm comm,
     168                        MPI_Status* status) {
     169  int rc;
     170  locint startLoc=get_locint_f();
     171  TAPE_AMPI_read_int(&count);
     172  TAPE_AMPI_read_MPI_Datatype(&datatype);
     173  TAPE_AMPI_read_int(&src);
     174  TAPE_AMPI_read_int(&tag);
     175  TAPE_AMPI_read_int((int*)&pairedWith);
     176  TAPE_AMPI_read_MPI_Comm(&comm);
     177  int packedCount=0;
     178  MPI_Datatype packedDatatype;
     179  allocatePack(&buf,
     180               startLoc,
     181               count,
     182               packedCount,
     183               datatype,
     184               packedDatatype);
     185  rc   = TLM_AMPI_Recv(buf,
     186                       count,
     187                       datatype,
     188                       src,
     189                       tag,
     190                       pairedWith,
     191                       comm,
     192                       status);
     193  unpackDeallocate(&buf,
     194                   startLoc,
     195                   count,
     196                   packedCount,
     197                   datatype,
     198                   packedDatatype);
     199  return rc;
     200}
     201
     202int ADOLC_TLM_AMPI_Isend (void* buf,
     203                          int count,
     204                          MPI_Datatype datatype,
     205                          int dest,
     206                          int tag,
     207                          AMPI_PairedWith pairedWith,
     208                          MPI_Comm comm,
     209                          AMPI_Request* request) {
     210  return TLM_AMPI_Isend(buf,
     211                        count,
     212                        datatype,
     213                        dest,
     214                        tag,
     215                        pairedWith,
     216                        comm,
     217                        request);
     218}
     219
     220int ADOLC_TLM_AMPI_Irecv (void* buf,
     221                          int count,
     222                          MPI_Datatype datatype,
     223                          int src,
     224                          int tag,
     225                          AMPI_PairedWith pairedWith,
     226                          MPI_Comm comm,
     227                          AMPI_Request* request) {
     228  return TLM_AMPI_Irecv(buf,
     229                        count,
     230                        datatype,
     231                        src,
     232                        tag,
     233                        pairedWith,
     234                        comm,
     235                        request);
     236}
     237
     238int ADOLC_TLM_AMPI_Wait(AMPI_Request *request,
     239                        MPI_Status *status) {
     240  return TLM_AMPI_Wait(request,
     241                       status);
     242}
     243
     244int ADOLC_TLM_AMPI_Barrier(MPI_Comm comm) {
     245  TAPE_AMPI_read_MPI_Comm(&comm); 
     246  return TLM_AMPI_Barrier(comm);
     247}
     248
     249int ADOLC_TLM_AMPI_Gather(void *sendbuf,
     250                          int sendcnt,
     251                          MPI_Datatype sendtype,
     252                          void *recvbuf,
     253                          int recvcnt,
     254                          MPI_Datatype recvtype,
     255                          int root,
     256                          MPI_Comm comm) {
     257  int rc;
     258  int commSizeForRootOrNull;
     259  locint startRLoc = 0, startSLoc = 0;
     260  MPI_Datatype packedRDatatype;
     261  int packedRCount;
     262  MPI_Datatype packedSDatatype;
     263      int packedSCount;
     264  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     265  if (commSizeForRootOrNull>0) {
     266      TAPE_AMPI_read_int(&recvcnt);
     267      startRLoc = get_locint_f();
     268      TAPE_AMPI_read_MPI_Datatype(&recvtype);
     269      allocatePack(&recvbuf,
     270                   startRLoc,
     271                   recvcnt,
     272                   packedRCount,
     273                   recvtype,
     274                   packedRDatatype);
     275  }
     276  startSLoc = get_locint_f();
     277  TAPE_AMPI_read_int(&sendcnt);
     278  TAPE_AMPI_read_MPI_Datatype(&sendtype);
     279  TAPE_AMPI_read_int(&root);
     280  TAPE_AMPI_read_MPI_Comm(&comm);
     281  if (sendcnt > 0) {
     282      allocatePack(&sendbuf,
     283                   startSLoc,
     284                   sendcnt,
     285                   packedSCount,
     286                   sendtype,
     287                   packedSDatatype);
     288  }
     289  rc =   TLM_AMPI_Gather(sendbuf,
     290                         sendcnt,
     291                         sendtype,
     292                         recvbuf,
     293                         recvcnt,
     294                         recvtype,
     295                         root,
     296                         comm);
     297  if (commSizeForRootOrNull>0) {
     298      unpackDeallocate(&recvbuf,
     299                       startRLoc,
     300                       recvcnt,
     301                       packedRCount,
     302                       recvtype,
     303                       packedRDatatype);
     304  }
     305  if (sendcnt > 0) {
     306      unpackDeallocate(&sendbuf,
     307                       startSLoc,
     308                       sendcnt,
     309                       packedSCount,
     310                       sendtype,
     311                       packedSDatatype);
     312  }
     313  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     314  return rc;
     315}
     316
     317int ADOLC_TLM_AMPI_Scatter(void *sendbuf,
     318                           int sendcnt,
     319                           MPI_Datatype sendtype,
     320                           void *recvbuf,
     321                           int recvcnt,
     322                           MPI_Datatype recvtype,
     323                           int root, MPI_Comm comm) {
     324  int rc;
     325  int commSizeForRootOrNull;
     326  locint startRLoc = 0, startSLoc = 0;
     327  MPI_Datatype packedRDatatype;
     328  int packedRCount;
     329  MPI_Datatype packedSDatatype;
     330  int packedSCount;
     331  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     332  if (commSizeForRootOrNull>0) {
     333      TAPE_AMPI_read_int(&recvcnt);
     334      startRLoc = get_locint_f();
     335      TAPE_AMPI_read_MPI_Datatype(&recvtype);
     336      allocatePack(&recvbuf,
     337                   startRLoc,
     338                   recvcnt,
     339                   packedRCount,
     340                   recvtype,
     341                   packedRDatatype);
     342  }
     343  startSLoc = get_locint_f();
     344  TAPE_AMPI_read_int(&sendcnt);
     345  TAPE_AMPI_read_MPI_Datatype(&sendtype);
     346  TAPE_AMPI_read_int(&root);
     347  TAPE_AMPI_read_MPI_Comm(&comm);
     348  if (sendcnt > 0) {
     349      allocatePack(&sendbuf,
     350                   startSLoc,
     351                   sendcnt,
     352                   packedSCount,
     353                   sendtype,
     354                   packedSDatatype);
     355  }
     356  rc =   TLM_AMPI_Scatter(sendbuf,
     357                          sendcnt,
     358                          sendtype,
     359                          recvbuf,
     360                          recvcnt,
     361                          recvtype,
     362                          root,
     363                          comm);
     364  if (commSizeForRootOrNull>0) {
     365      unpackDeallocate(&recvbuf,
     366                       startRLoc,
     367                       recvcnt,
     368                       packedRCount,
     369                       recvtype,
     370                       packedRDatatype);
     371  }
     372  if (sendcnt > 0) {
     373      unpackDeallocate(&sendbuf,
     374                       startSLoc,
     375                       sendcnt,
     376                       packedSCount,
     377                       sendtype,
     378                       packedSDatatype);
     379  }
     380  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     381  return rc;
     382}
     383
     384int ADOLC_TLM_AMPI_Allgather(void *sendbuf,
     385                             int sendcnt,
     386                             MPI_Datatype sendtype,
     387                             void *recvbuf,
     388                             int recvcnt,
     389                             MPI_Datatype recvtype,
     390                             MPI_Comm comm) {
     391  int rc;
     392  int rootPlaceholder;
     393  int commSizeForRootOrNull;
     394  locint startRLoc = 0, startSLoc = 0;
     395  MPI_Datatype packedRDatatype;
     396  int packedRCount;
     397  MPI_Datatype packedSDatatype;
     398  int packedSCount;
     399  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     400  if (commSizeForRootOrNull>0) {
     401      TAPE_AMPI_read_int(&recvcnt);
     402      startRLoc = get_locint_f();
     403      TAPE_AMPI_read_MPI_Datatype(&recvtype);
     404      allocatePack(&recvbuf,
     405                   startRLoc,
     406                   recvcnt,
     407                   packedRCount,
     408                   recvtype,
     409                   packedRDatatype);
     410  }
     411  startSLoc = get_locint_f();
     412  TAPE_AMPI_read_int(&sendcnt);
     413  TAPE_AMPI_read_MPI_Datatype(&sendtype);
     414  TAPE_AMPI_read_int(&rootPlaceholder);
     415  TAPE_AMPI_read_MPI_Comm(&comm);
     416  if (sendcnt > 0) {
     417      allocatePack(&sendbuf,
     418                   startSLoc,
     419                   sendcnt,
     420                   packedSCount,
     421                   sendtype,
     422                   packedSDatatype);
     423  }
     424  rc =   TLM_AMPI_Allgather(sendbuf,
     425                            sendcnt,
     426                            sendtype,
     427                            recvbuf,
     428                            recvcnt,
     429                            recvtype,
     430                            comm);
     431  if (commSizeForRootOrNull>0) {
     432      unpackDeallocate(&recvbuf,
     433                       startRLoc,
     434                       recvcnt,
     435                       packedRCount,
     436                       recvtype,
     437                       packedRDatatype);
     438  }
     439  if (sendcnt > 0) {
     440      unpackDeallocate(&sendbuf,
     441                       startSLoc,
     442                       sendcnt,
     443                       packedSCount,
     444                       sendtype,
     445                       packedSDatatype);
     446  }
     447  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     448  return rc;
     449}
     450
     451int ADOLC_TLM_AMPI_Gatherv(void *sendbuf,
     452                           int sendcnt,
     453                           MPI_Datatype sendtype,
     454                           void *recvbuf,
     455                           int *recvcnts,
     456                           int *displs,
     457                           MPI_Datatype recvtype,
     458                           int root,
     459                           MPI_Comm comm) {
     460  int rc,i;
     461  int commSizeForRootOrNull;
     462  locint startRLoc, startSLoc;
     463  MPI_Datatype packedRDatatype, packedSDatatype;
     464  int packedRCount, packedSCount;
     465  int totalrecvcnt = 0;
     466  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     467  for(i=0;i<commSizeForRootOrNull;++i) {
     468      TAPE_AMPI_read_int(&recvcnts[i]);
     469      TAPE_AMPI_read_int(&displs[i]);
     470      if ((recvcnts[i]>0) &&
     471          (totalrecvcnt<displs[i]+recvcnts[i]))
     472          totalrecvcnt=displs[i]+recvcnts[i];
     473  }
     474  if (commSizeForRootOrNull>0) {
     475      startRLoc = get_locint_f();
     476      TAPE_AMPI_read_MPI_Datatype(&recvtype);
     477      allocatePack(&recvbuf,
     478                   startRLoc,
     479                   totalrecvcnt,
     480                   packedRCount,
     481                   recvtype,
     482                   packedRDatatype);
     483  }
     484  startSLoc = get_locint_f();
     485  TAPE_AMPI_read_int(&sendcnt);
     486  TAPE_AMPI_read_MPI_Datatype(&sendtype);
     487  TAPE_AMPI_read_int(&root);
     488  TAPE_AMPI_read_MPI_Comm(&comm);
     489  if (sendcnt > 0) {
     490      allocatePack(&sendbuf,
     491                   startSLoc,
     492                   sendcnt,
     493                   packedSCount,
     494                   sendtype,
     495                   packedSDatatype);
     496  }
     497  rc =   TLM_AMPI_Gatherv(sendbuf,
     498                          sendcnt,
     499                          sendtype,
     500                          recvbuf,
     501                          recvcnts,
     502                          displs,
     503                          recvtype,
     504                          root,
     505                          comm);
     506  if (sendcnt > 0) {
     507     unpackDeallocate(&sendbuf,
     508                       startSLoc,
     509                       sendcnt,
     510                       packedSCount,
     511                       sendtype,
     512                       packedSDatatype);
     513  }
     514  if (commSizeForRootOrNull>0) {
     515      unpackDeallocate(&recvbuf,
     516                       startRLoc,
     517                       totalrecvcnt,
     518                       packedRCount,
     519                       recvtype,
     520                       packedRDatatype);
     521  }
     522  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     523  return rc;
     524}
     525
     526int ADOLC_TLM_AMPI_Scatterv(void *sendbuf,
     527                            int *sendcnts,
     528                            int *displs,
     529                            MPI_Datatype sendtype,
     530                            void *recvbuf,
     531                            int recvcnt,
     532                            MPI_Datatype recvtype,
     533                            int root, MPI_Comm comm) {
     534  int rc,i;
     535  int commSizeForRootOrNull;
     536  locint startRLoc, startSLoc;
     537  MPI_Datatype packedRDatatype, packedSDatatype;
     538  int packedRCount, packedSCount;
     539  int totalsendcnt = 0;
     540  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     541  for(i=0;i<commSizeForRootOrNull;++i) {
     542      TAPE_AMPI_read_int(&sendcnts[i]);
     543      TAPE_AMPI_read_int(&displs[i]);
     544      if ((sendcnts[i]>0) &&
     545          (totalsendcnt<displs[i]+sendcnts[i]))
     546          totalsendcnt=displs[i]+sendcnts[i];
     547  }
     548  if (commSizeForRootOrNull>0) {
     549      startSLoc = get_locint_f();
     550      TAPE_AMPI_read_MPI_Datatype(&sendtype);
     551      allocatePack(&sendbuf,
     552                   startSLoc,
     553                   totalsendcnt,
     554                   packedSCount,
     555                   sendtype,
     556                   packedSDatatype);
     557  }
     558  startRLoc = get_locint_f();
     559  TAPE_AMPI_read_int(&recvcnt);
     560  TAPE_AMPI_read_MPI_Datatype(&recvtype);
     561  TAPE_AMPI_read_int(&root);
     562  TAPE_AMPI_read_MPI_Comm(&comm);
     563  if (recvcnt > 0) {
     564      allocatePack(&recvbuf,
     565                   startRLoc,
     566                   recvcnt,
     567                   packedRCount,
     568                   recvtype,
     569                   packedRDatatype);
     570  }
     571  rc =   TLM_AMPI_Scatterv(sendbuf,
     572                           sendcnts,
     573                           displs,
     574                           sendtype,
     575                           recvbuf,
     576                           recvcnt,
     577                           recvtype,
     578                           root,
     579                           comm);
     580  if (commSizeForRootOrNull>0) {
     581     unpackDeallocate(&sendbuf,
     582                       startSLoc,
     583                       totalsendcnt,
     584                       packedSCount,
     585                       sendtype,
     586                       packedSDatatype);
     587  }
     588  if (recvcnt > 0) {
     589      unpackDeallocate(&recvbuf,
     590                       startRLoc,
     591                       recvcnt,
     592                       packedRCount,
     593                       recvtype,
     594                       packedRDatatype);
     595  }
     596  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     597  return rc;
     598}
     599
     600int ADOLC_TLM_AMPI_Allgatherv(void *sendbuf,
     601                              int sendcnt,
     602                              MPI_Datatype sendtype,
     603                              void *recvbuf,
     604                              int *recvcnts,
     605                              int *displs,
     606                              MPI_Datatype recvtype,
     607                              MPI_Comm comm) {
     608  int rc,i;
     609  int commSizeForRootOrNull, rootPlaceholder;
     610  locint startRLoc, startSLoc;
     611  MPI_Datatype packedRDatatype, packedSDatatype;
     612  int packedRCount, packedSCount;
     613  int totalrecvcnt = 0;
     614  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     615  for(i=0;i<commSizeForRootOrNull;++i) {
     616      TAPE_AMPI_read_int(&recvcnts[i]);
     617      TAPE_AMPI_read_int(&displs[i]);
     618      if ((recvcnts[i]>0) &&
     619          (totalrecvcnt<displs[i]+recvcnts[i]))
     620          totalrecvcnt=displs[i]+recvcnts[i];
     621  }
     622  if (commSizeForRootOrNull>0) {
     623      startRLoc = get_locint_f();
     624      TAPE_AMPI_read_MPI_Datatype(&recvtype);
     625      allocatePack(&recvbuf,
     626                   startRLoc,
     627                   totalrecvcnt,
     628                   packedRCount,
     629                   recvtype,
     630                   packedRDatatype);
     631  }
     632  startSLoc = get_locint_f();
     633  TAPE_AMPI_read_int(&sendcnt);
     634  TAPE_AMPI_read_MPI_Datatype(&sendtype);
     635  TAPE_AMPI_read_int(&rootPlaceholder);
     636  TAPE_AMPI_read_MPI_Comm(&comm);
     637  if (sendcnt > 0) {
     638      allocatePack(&sendbuf,
     639                   startSLoc,
     640                   sendcnt,
     641                   packedSCount,
     642                   sendtype,
     643                   packedSDatatype);
     644  }
     645  rc =   TLM_AMPI_Allgatherv(sendbuf,
     646                             sendcnt,
     647                             sendtype,
     648                             recvbuf,
     649                             recvcnts,
     650                             displs,
     651                             recvtype,
     652                             comm);
     653  if (sendcnt > 0) {
     654     unpackDeallocate(&sendbuf,
     655                       startSLoc,
     656                       sendcnt,
     657                       packedSCount,
     658                       sendtype,
     659                       packedSDatatype);
     660  }
     661  if (commSizeForRootOrNull>0) {
     662      unpackDeallocate(&recvbuf,
     663                       startRLoc,
     664                       totalrecvcnt,
     665                       packedRCount,
     666                       recvtype,
     667                       packedRDatatype);
     668  }
     669  TAPE_AMPI_read_int(&commSizeForRootOrNull);
     670  return rc;
     671}
     672
     673
    310674int ADOLC_TLM_AMPI_Bcast(void* buf,
    311675                         int count,
  • trunk/ADOL-C/src/externfcts.cpp

    r439 r595  
    2727#define ADOLC_BUFFER_TYPE \
    2828   Buffer< ext_diff_fct, EDFCTS_BLOCK_SIZE >
    29 static ADOLC_BUFFER_TYPE buffer(edf_init);
    30 
    31 void edf_init(ext_diff_fct *edf) {
     29static ADOLC_BUFFER_TYPE buffer(edf_zero);
     30
     31void edf_zero(ext_diff_fct *edf) {
    3232  // sanity settings
    3333  edf->function=0;
  • trunk/ADOL-C/src/externfcts_p.h

    r541 r595  
    2828ext_diff_fct *get_ext_diff_fct(int index);
    2929
    30 /**
    31  * initialize with defaults
    32  */
    33 void edf_init(ext_diff_fct *edfct);
    34 
    3530END_C_DECLS
    3631
  • trunk/ADOL-C/src/fo_rev.c

    r582 r595  
    389389    struct AMPI_Request_S request;
    390390#endif
    391 
    392     ADOLC_OPENMP_THREAD_NUMBER;
     391        locint qq;
     392
     393        ADOLC_OPENMP_THREAD_NUMBER;
    393394    ADOLC_OPENMP_GET_THREAD_NUMBER;
    394395
     
    23962397#endif /* !_NTIGHT_ */
    23972398                break;
     2399
     2400        case vec_copy:
     2401                size = get_locint_r();
     2402                arg = get_locint_r();
     2403                res = get_locint_r();
     2404                for (qq=0;qq<size;qq++) {
     2405
     2406                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg+qq])
     2407                ASSIGN_A( Ares, ADJOINT_BUFFER[res+qq])
     2408
     2409                FOR_0_LE_l_LT_p
     2410                {
     2411#if defined(_INT_REV_)
     2412                  AARG_INC |= ARES;
     2413                  ARES_INC = 0;
     2414#else
     2415                  AARG_INC += ARES;
     2416                  ARES_INC = 0.0;
     2417#endif
     2418                }
     2419
     2420#if !defined(_NTIGHT_)
     2421                ADOLC_GET_TAYLOR(res+qq);
     2422#endif /* !_NTIGHT_ */
     2423                }
     2424
     2425                break;
     2426
     2427        case vec_dot:
     2428                size = get_locint_r();
     2429                arg2 = get_locint_r();
     2430                arg1 = get_locint_r();
     2431                res = get_locint_r();
     2432                for (qq=0;qq<size;qq++) {
     2433                    ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     2434                    ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
     2435                    ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     2436                    FOR_0_LE_l_LT_p
     2437                    {
     2438#if defined(_INT_REV_)
     2439                        AARG2_INC |= ARES;
     2440                        AARG1_INC |= ARES_INC;
     2441#else
     2442                        AARG2_INC += ARES    * TARG1;
     2443                        AARG1_INC += ARES_INC * TARG2;
     2444#endif
     2445                    }
     2446                    arg2++;
     2447                    arg1++;
     2448                }
     2449#if !defined(_NTIGHT_)
     2450                ADOLC_GET_TAYLOR(res);
     2451#endif /* !_NTIGHT_ */
     2452                break;
     2453
     2454        case vec_axpy:
     2455                size = get_locint_r();
     2456                arg2 = get_locint_r();
     2457                arg1 = get_locint_r();
     2458                arg = get_locint_r();
     2459                res = get_locint_r();
     2460                for (qq=0;qq<size;qq++) {
     2461                    ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
     2462                    ASSIGN_A( Aarg,  ADJOINT_BUFFER[arg])
     2463                    ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
     2464                    ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
     2465                    FOR_0_LE_l_LT_p
     2466                    {
     2467#if defined(_INT_REV_)
     2468                        AARG_INC |= ARES;
     2469                        AARG2_INC |= ARES;
     2470                        AARG1_INC |= ARES_INC;
     2471#else
     2472                        AARG2_INC += ARES;
     2473                        AARG1_INC += ARES * TARG;
     2474                        AARG_INC += ARES_INC * TARG1;
     2475#endif
     2476                    }
     2477#if !defined(_NTIGHT_)
     2478                    ADOLC_GET_TAYLOR(res);
     2479#endif /* !_NTIGHT_ */
     2480                    arg2++;
     2481                    arg1++;
     2482                    res++;
     2483                }
     2484                break;
    23982485
    23992486        case ref_cond_assign:                                      /* cond_assign */
  • trunk/ADOL-C/src/ho_rev.c

    r568 r595  
    423423    int q = 1;
    424424#endif
    425 
     425        locint qq;
    426426
    427427    ADOLC_OPENMP_THREAD_NUMBER;
     
    26842684                break;
    26852685
     2686            case vec_copy:
     2687
     2688                size = get_locint_r();
     2689                arg = get_locint_r();
     2690                res = get_locint_r();
     2691
     2692                for(qq=0;qq<size;qq++) {
     2693
     2694                ASSIGN_A(Aarg, rpp_A[arg+qq])
     2695                ASSIGN_A(Ares, rpp_A[res+qq])
     2696
     2697                FOR_0_LE_l_LT_p
     2698                if  (0 == ARES) {
     2699                    HOV_INC(Aarg, k1)
     2700                    HOV_INC(Ares, k1)
     2701                } else {
     2702                    MAXDEC(AARG,ARES);
     2703                    AARG_INC_O;
     2704                    ARES_INC = 0.0;
     2705                    FOR_0_LE_i_LT_k
     2706                    { /* ! no tempory */
     2707                        AARG_INC += ARES;
     2708                        ARES_INC = 0.0;
     2709                    }
     2710                }
     2711
     2712                GET_TAYL(res+qq,k,p)
     2713
     2714                }
     2715
     2716                break;
     2717
     2718        case vec_dot:
     2719                size = get_locint_r();
     2720                arg2 = get_locint_r();
     2721                arg1 = get_locint_r();
     2722                res = get_locint_r();
     2723                for (qq=0;qq<size;qq++) {
     2724                ASSIGN_A(Ares,  rpp_A[res])
     2725                ASSIGN_A(Aarg2, rpp_A[arg2+qq])
     2726                ASSIGN_A(Aarg1, rpp_A[arg1+qq])
     2727                ASSIGN_T(Targ1, rpp_T[arg1+qq])
     2728                ASSIGN_T(Targ2, rpp_T[arg2+qq])
     2729                FOR_0_LE_l_LT_p {
     2730                if (0 == ARES) {
     2731                    HOV_INC(Aarg1, k1)
     2732                    HOV_INC(Aarg2, k1)
     2733                    HOV_INC(Ares,  k1)
     2734                } else {
     2735                    comp = (ARES > 2.0) ? ARES : 2.0 ;
     2736                    ARES_INC = comp;
     2737                    MAXDEC(AARG1,comp);
     2738                    MAXDEC(AARG2,comp);
     2739                    AARG1_INC_O;
     2740                    AARG2_INC_O;
     2741
     2742                    inconv(k,Ares,Targ1,Aarg2);
     2743                    inconv(k,Ares,Targ2,Aarg1);
     2744
     2745                    HOV_INC(Ares,  k)
     2746                    HOV_INC(Aarg1, k)
     2747                    HOV_INC(Aarg2, k)
     2748                    HOS_OV_INC(Targ1, k)
     2749                    HOS_OV_INC(Targ2, k)
     2750                    HOS_OV_INC(Tres, k)
     2751                }
     2752                }
     2753                }
     2754                GET_TAYL(res,k,p)
     2755                break;
     2756
     2757        case vec_axpy:
     2758                size = get_locint_r();
     2759                arg2 = get_locint_r();
     2760                arg1 = get_locint_r();
     2761                arg = get_locint_r();
     2762                res = get_locint_r();
     2763                for (qq=0;qq<size;qq++) {
     2764                ASSIGN_A(Ares,  rpp_A[res+qq])
     2765                ASSIGN_A(Aarg,  rpp_A[arg])
     2766                ASSIGN_A(Aarg2, rpp_A[arg2+qq])
     2767                ASSIGN_A(Aarg1, rpp_A[arg1+qq])
     2768                ASSIGN_T(Targ,  rpp_T[arg])
     2769                ASSIGN_T(Targ1, rpp_T[arg1+qq])
     2770                if (0 == ARES) {
     2771                    HOV_INC(Aarg, k1)
     2772                    HOV_INC(Aarg1, k1)
     2773                    HOV_INC(Aarg2, k1)
     2774                    HOV_INC(Ares,  k1)
     2775                } else {
     2776                    comp = (ARES > 2.0) ? ARES : 2.0 ;
     2777                    MAXDEC(AARG2,ARES);
     2778                    ARES_INC = 0.0;
     2779                    MAXDEC(AARG,comp);
     2780                    MAXDEC(AARG1,comp);
     2781                    AARG_INC_O;
     2782                    AARG1_INC_O;
     2783                    AARG2_INC_O;
     2784                    copyAndZeroset(k,Ares,rp_Atemp);
     2785                    inconv(k,rp_Atemp,Targ1,Aarg);
     2786                    inconv(k,rp_Atemp,Targ,Aarg1);
     2787                    FOR_0_LE_i_LT_k
     2788                        AARG2_INC += *rp_Atemp++;
     2789
     2790                    HOV_INC(Ares,k)
     2791                    HOV_INC(Aarg, k)
     2792                    HOV_INC(Aarg1,k)
     2793                    HOS_OV_INC(Targ,k)
     2794                    HOS_OV_INC(Targ1,k)
     2795                }
     2796                GET_TAYL(res+qq,k,p)
     2797                }
     2798                break;               
     2799
    26862800            case ref_cond_assign:                                      /* cond_assign */
    26872801            {   
  • trunk/ADOL-C/src/oplate.h

    r537 r595  
    117117  neg_sign_p,
    118118  recipr_p,
     119  vec_copy,
     120  vec_dot,
     121  vec_axpy,
    119122  eq_a_p = 119,
    120123  neq_a_p,
  • trunk/ADOL-C/src/param.cpp

    r566 r595  
    4343    } else {
    4444        fprintf(DIAG_OUT, "ADOL-C error: Parameter index %d out of bounds, "
    45                 "# existing parameters = %d\n", idx,
     45                "# existing parameters = %zu\n", idx,
    4646                ADOLC_GLOBAL_TAPE_VARS.numparam);
    4747        adolc_exit(-1,"",__func__,__FILE__,__LINE__);
  • trunk/ADOL-C/src/storemanager.h

    r541 r595  
    6666
    6767#include <adolc/internal/common.h>
    68 #include <list>
     68#include <forward_list>
     69#if defined(HAVE_BOOST_POOL_POOL_ALLOC_HPP) && defined(HAVE_BOOST_SYSTEM)
     70#include <boost/pool/pool_alloc.hpp>
     71#define USE_BOOST_POOL 1
     72#endif
     73
     74class Keeper;
    6975
    7076class StoreManager {
     77  friend class Keeper;
    7178protected:
    7279  static size_t const initialSize = 4;
    7380  double myGcTriggerRatio;
    7481  size_t myGcTriggerMaxSize;
     82  virtual void grow(size_t mingrow = 0) = 0;
    7583public:
    7684  StoreManager() : myGcTriggerRatio(1.5), myGcTriggerMaxSize(initialSize) {}
     
    97105  size_t &maxsize;
    98106  size_t &currentfill;
    99 private:
    100   void grow();
     107  virtual void grow(size_t mingrow = 0);
    101108public:
    102109
     
    127134        FreeBlock(const struct FreeBlock &block) :
    128135            next(block.next),size(block.size) {}
     136        FreeBlock(const locint& n, const size_t& s) :
     137            next(n), size(s) {}
    129138        bool operator<(const struct FreeBlock& b) const {
    130139            return (next < b.next);
     
    132141    };
    133142
    134     std::list<struct FreeBlock> indexFree;
     143    std::forward_list<struct FreeBlock
     144#if USE_BOOST_POOL
     145                      , boost::fast_pool_allocator<struct FreeBlock>
     146#endif
     147                      >  indexFree;
    135148    size_t &maxsize;
    136149    size_t &currentfill;
     
    140153    unsigned int ensure_blockCallsSinceLastConsolidateBlocks;
    141154#endif
    142 private:
    143155    /**
    144156     * when minGrow is specified we asssume that we have already
    145157     * search the blocks and found no block with minGrow locations in it
    146158     */
    147     void grow(size_t minGrow=0 );
     159    virtual void grow(size_t minGrow=0 );
    148160public:
    149161    StoreManagerLocintBlock(double * &storePtr, size_t &size, size_t &numlives);
  • trunk/ADOL-C/src/tape_handling.cpp

    r576 r595  
    5050  numparam = 0;
    5151  maxparam = 0;
     52  initialStoreSize = 0;
    5253  storeManagerPtr = new StoreManagerLocintBlock(store, storeSize, numLives);
    5354  paramStoreMgrPtr = new StoreManagerLocintBlock(pStore, maxparam, numparam);
     
    7879    branchSwitchWarning = gtv.branchSwitchWarning;
    7980    currentTapeInfosPtr = gtv.currentTapeInfosPtr;
     81    initialStoreSize = gtv.initialStoreSize;
    8082    store = new double[storeSize];
    8183    memcpy(store, gtv.store, storeSize*sizeof(double));
     
    158160}
    159161
    160 void StoreManagerLocint::grow() {
     162void StoreManagerLocint::grow(size_t mingrow) {
    161163    if (maxsize == 0) maxsize += initialSize;
    162164    size_t const oldMaxsize = maxsize;
    163165    maxsize *= 2;
     166    if (maxsize < mingrow) maxsize = mingrow;
    164167
    165168    if (maxsize > std::numeric_limits<locint>::max()) {
     
    995998            init();
    996999            readConfigFile();
     1000            if (ADOLC_GLOBAL_TAPE_VARS.initialStoreSize >
     1001                ADOLC_GLOBAL_TAPE_VARS.storeManagerPtr->initialSize)
     1002                ADOLC_GLOBAL_TAPE_VARS.storeManagerPtr->grow(
     1003                    ADOLC_GLOBAL_TAPE_VARS.initialStoreSize);
    9971004        }
    9981005        inline ~Keeper() {
     
    12761283#endif
    12771284    indexFree.clear();
    1278     list<struct FreeBlock>::const_iterator iter = stm->indexFree.begin();
     1285    forward_list<struct FreeBlock>::const_iterator iter = stm->indexFree.begin();
    12791286    for (; iter != stm->indexFree.end(); iter++)
    1280         indexFree.push_back( *iter );
     1287        indexFree.emplace_front( *iter );
    12811288}
    12821289
     
    12861293        grow();
    12871294
    1288     locint const result = indexFree.front().next;
    1289     indexFree.front().next++;
    1290     indexFree.front().size--;
     1295    struct FreeBlock &front = indexFree.front();
     1296    locint const result = front.next;
     1297    if (--front.size == 0) {
     1298        if (next(indexFree.cbegin()) == indexFree.cend()) {
     1299            front.next++;
     1300            grow();
     1301        } else
     1302          indexFree.pop_front();
     1303    } else
     1304        front.next++;
    12911305
    12921306    ++currentfill;
     
    12941308#ifdef ADOLC_LOCDEBUG
    12951309    std::cerr << "StoreManagerLocintBlock::next_loc: result: " << result << " fill: " << size() << "max: " << maxSize() << endl;
    1296     std::cerr << "Size(INDEXFELD) = " << indexFree.size() << "\n";
    1297     list<struct FreeBlock>::iterator iter = indexFree.begin();
     1310    forward_list<struct FreeBlock>::iterator iter = indexFree.begin();
    12981311    for( ; iter != indexFree.end(); iter++ )
    12991312       std::cerr << "INDEXFELD ( " << iter->next << " , " << iter->size << ")" << endl;
    13001313#endif
    1301 
    1302     if (indexFree.front().size == 0) {
    1303         if (indexFree.size() <= 1)
    1304             grow();
    1305         else
    1306           indexFree.pop_front();
    1307     }
    13081314
    13091315    return result;
     
    13251331        ensure_blockCallsSinceLastConsolidateBlocks=0;
    13261332#endif
    1327         list<struct FreeBlock>::iterator iter = indexFree.begin();
    1328         for (; iter != indexFree.end() ; iter++ ) {
     1333        forward_list<struct FreeBlock>::iterator
     1334            biter = indexFree.before_begin(),
     1335            iter = indexFree.begin();
     1336        for (; iter != indexFree.end() ; biter++, iter++ ) {
    13291337          if ( iter->size >= n) {
    13301338            if (iter != indexFree.begin() ) {
    1331               struct FreeBlock tmp(*iter);
    1332               iter = indexFree.erase(iter);
    1333               indexFree.push_front(tmp);
     1339              indexFree.emplace_front(*iter);
     1340              indexFree.erase_after(biter);
    13341341            }
    13351342            found = true;
     
    13481355#ifdef ADOLC_LOCDEBUG
    13491356    std::cerr << "StoreManagerLocintBlock::ensure_Block: " << " fill: " << size() << "max: " << maxSize() <<  " ensure_Block (" << n << ")" << endl;
    1350     std::cerr << "Size(INDEXFELD) = " << indexFree.size() << "\n";
    1351     list<struct FreeBlock>::iterator iter = indexFree.begin();
     1357    forward_list<struct FreeBlock>::iterator iter = indexFree.begin();
    13521358    for( ; iter != indexFree.end(); iter++ )
    13531359        std::cerr << "INDEXFELD ( " << iter->next << " , " << iter->size << ")" << endl;
     
    14081414
    14091415    bool foundTail = false;
    1410     list<struct FreeBlock>::iterator iter = indexFree.begin();
    1411     for (; iter != indexFree.end() ; iter++ ) {
     1416    forward_list<struct FreeBlock>::iterator
     1417        biter = indexFree.before_begin(),
     1418        iter = indexFree.begin();
     1419    for (; iter != indexFree.end() ; biter++,iter++ ) {
    14121420         if (iter->next + iter->size == oldMaxsize ) {
    14131421             iter->size += (maxsize - oldMaxsize);
    1414               struct FreeBlock tmp(*iter);
    1415               iter = indexFree.erase(iter);
    1416               indexFree.push_front(tmp);
     1422              indexFree.emplace_front(*iter);
     1423              indexFree.erase_after(biter);
    14171424              foundTail = true;
    14181425              break;
     
    14211428
    14221429    if (! foundTail) {
    1423         struct FreeBlock tmp;
    1424         tmp.next = oldMaxsize;
    1425         tmp.size = (maxsize - oldMaxsize);
    1426         indexFree.push_front(tmp);
    1427     }
    1428 
     1430        indexFree.emplace_front(oldMaxsize,(maxsize - oldMaxsize));
     1431    }
     1432
     1433    biter = indexFree.before_begin();
    14291434    iter = indexFree.begin();
    14301435    while (iter != indexFree.end()) {
    1431          if (iter->size == 0)
    1432              iter=indexFree.erase(iter); // don't leave 0 blocks around
    1433          else
     1436         if (iter->size == 0) {
     1437             indexFree.erase_after(biter); // don't leave 0 blocks around
     1438             iter = next(biter);
     1439         }
     1440         else {
     1441             biter++;
    14341442             iter++;
     1443         }
    14351444    }
    14361445#ifdef ADOLC_LOCDEBUG
    14371446    std::cerr << "Growing:" << endl;
    1438     std::cerr << "Size(INDEXFELD) = " << indexFree.size() << "\n";
    14391447    iter = indexFree.begin();
    14401448    for( ; iter != indexFree.end(); iter++ )
     
    14461454    assert( loc < maxsize);
    14471455
    1448     list<struct FreeBlock>::iterator iter = indexFree.begin();
    1449     if (loc+1 == iter->next || iter->next + iter->size == loc) {
    1450         iter->size++;
    1451         if (loc + 1 == iter->next)
    1452             iter->next = loc;
     1456    struct FreeBlock &front = indexFree.front();
     1457    if ((loc+1 == front.next)
     1458        || (front.next + front.size == loc)) {
     1459        front.size++;
     1460        if (loc + 1 == front.next)
     1461            front.next = loc;
    14531462    }
    14541463    else {
    1455          struct FreeBlock tmp;
    1456          tmp.next = loc;
    1457          tmp.size = 1;
    1458          indexFree.push_front(tmp);
     1464         indexFree.emplace_front(loc,1);
    14591465    }
    14601466
     
    14621468#ifdef ADOLC_LOCDEBUG
    14631469    std::cerr << "free_loc: " << loc << " fill: " << size() << "max: " << maxSize() << endl;
    1464     std::cerr << "Size(INDEXFELD) = " << indexFree.size() << "\n";
    1465     iter = indexFree.begin();
     1470    forward_list<struct FreeBlock>::iterator iter = indexFree.begin();
    14661471    for( ; iter != indexFree.end(); iter++ )
    14671472       std::cerr << "INDEXFELD ( " << iter->next << " , " << iter->size << ")" << endl;
     
    14831488void StoreManagerLocintBlock::consolidateBlocks() {
    14841489    indexFree.sort();
    1485     list<struct FreeBlock>::iterator iter = indexFree.begin(), niter = iter++;
     1490    forward_list<struct FreeBlock>::iterator
     1491        iter = indexFree.begin(),
     1492        niter = iter++;
    14861493    while (iter != indexFree.end()) {
    14871494        if (niter->next + niter->size == iter->next) {
    14881495            niter->size += iter->size;
    1489             indexFree.erase(iter);
    1490             iter = niter;
    1491             iter++;
     1496            indexFree.erase_after(niter);
     1497            iter = next(niter);
    14921498        } else {
    1493             niter = iter;
     1499            niter++;
    14941500            iter++;
    14951501        }
     
    14971503#ifdef ADOLC_LOCDEBUG
    14981504    std::cerr << "StoreManagerLocintBlock::consolidateBlocks: " << " fill: " << size() << "max: " << maxSize() << endl;
    1499     std::cerr << "Size(INDEXFELD) = " << indexFree.size() << "\n";
    15001505    iter = indexFree.begin();
    15011506    for( ; iter != indexFree.end(); iter++ )
  • trunk/ADOL-C/src/tapedoc/tapedoc.c

    r566 r595  
    134134#ifdef ADOLC_TAPE_DOC_VALUES /* values + constants */
    135135    /* constants (max 2) */
    136     if (opcode==ext_diff)
     136    if (opcode==ext_diff || opcode == vec_copy)
    137137        nloc=0;
     138    if (opcode == vec_dot || opcode == vec_axpy)
     139        nloc=1;
    138140    for(i=0; i<(2-ncst); i++)
    139141        fprintf(fp," &");
     
    245247    double val_a[4]={0,0,0,0}, cst_d[2]={0,0};
    246248    const char* opName;
    247 
     249#ifdef ADOLC_TAPE_DOC_VALUES
     250        locint qq;
     251#endif
    248252    ADOLC_OPENMP_THREAD_NUMBER;
    249253    ADOLC_OPENMP_GET_THREAD_NUMBER;
     
    11501154#endif
    11511155                filewrite(operation,"cond assign s $\\longrightarrow$",3,loc_a,val_a,1,cst_d);
     1156                break;
     1157
     1158            case vec_copy:
     1159                res = get_locint_f();
     1160                arg = get_locint_f();
     1161                size = get_locint_f();
     1162                loc_a[0] = res;
     1163                loc_a[1] = arg;
     1164                loc_a[2] = size;
     1165#ifdef ADOLC_TAPE_DOC_VALUES
     1166                for(qq=0;qq<size;qq++)
     1167                    dp_T0[res+qq] = dp_T0[arg+qq];
     1168#endif
     1169                filewrite(operation,"vec copy $\\longrightarrow$",3,loc_a,val_a,0,cst_d);
     1170                break;
     1171
     1172            case vec_dot:
     1173                res = get_locint_f();
     1174                arg1 = get_locint_f();
     1175                arg2 = get_locint_f();
     1176                size = get_locint_f();
     1177                loc_a[0] = res;
     1178                loc_a[1] = arg1;
     1179                loc_a[2] = arg2;
     1180                loc_a[3] = size;
     1181#ifdef ADOLC_TAPE_DOC_VALUES
     1182                dp_T0[res] = 0;
     1183                for(qq=0;qq<size;qq++)
     1184                    dp_T0[res] += dp_T0[arg1+qq] *  dp_T0[arg2+qq];
     1185                val_a[0] = dp_T0[res];
     1186#endif
     1187                filewrite(operation,"vec dot $\\longrightarrow$",4,loc_a,val_a,0,cst_d);
     1188                break;
     1189
     1190            case vec_axpy:
     1191                res = get_locint_f();
     1192                arg = get_locint_f();
     1193                arg1 = get_locint_f();
     1194                arg2 = get_locint_f();
     1195                size = get_locint_f();
     1196                loc_a[0] = res;
     1197                loc_a[1] = arg;
     1198                loc_a[1] = arg1;
     1199                loc_a[2] = arg2;
     1200                loc_a[3] = size;
     1201#ifdef ADOLC_TAPE_DOC_VALUES
     1202                val_a[0] = dp_T0[arg];
     1203                for(qq=0;qq<size;qq++)
     1204                    dp_T0[res+qq] = dp_T0[arg] * dp_T0[arg1+qq] + dp_T0[arg2+qq];
     1205#endif
     1206                filewrite(operation,"vec axpy $\\longrightarrow$",4,loc_a,val_a,0,cst_d);
    11521207                break;
    11531208
  • trunk/ADOL-C/src/taping.c

    r549 r595  
    300300                    failAdditionalInfo1);
    301301            break;
     302
     303        case ADOLC_VEC_LOCATIONGAP:
     304          fprintf(DIAG_OUT,
     305                  "ADOL-C error: arrays passed to vector operation do not have contiguous ascending locations;\nuse dynamic_cast<adouble*>(advector&) \nor call ensureContiguousLocations(size_t) to reserve  contiguous blocks prior to allocation of the arrays.\n");
     306          break;
    302307
    303308        default:
     
    456461    char *pos1 = NULL, *pos2 = NULL, *pos3 = NULL, *pos4 = NULL, *start = NULL, *end = NULL;
    457462    int base;
    458     long int number = 0;
     463    unsigned long int number = 0;
    459464    char *path = NULL;
    460465    int defdirsize = strlen(TAPE_DIR PATHSEPARATOR);
     
    513518                    base = 10;
    514519                }
    515                 number = strtol(start, &end, base);
     520                number = strtoul(start, &end, base);
    516521                if (end == start) {
    517522                    *pos2 = 0;
     
    590595                        fprintf(DIAG_OUT, "Found maximal number of taylor buffers: "
    591596                                "%d\n", (int)number);
     597                    } else if (strcmp(pos1 + 1, "INITLIVE") == 0) {
     598                        ADOLC_GLOBAL_TAPE_VARS.initialStoreSize = (locint)number;
     599                        fprintf(DIAG_OUT, "Found initial live variable store size : %u\n",
     600                                (locint)number);
    592601                    } else {
    593602                        fprintf(DIAG_OUT, "ADOL-C warning: Unable to parse "
  • trunk/ADOL-C/src/taping_p.h

    r541 r595  
    120120    ADOLC_WRONG_PLATFORM_32,
    121121    ADOLC_WRONG_PLATFORM_64,
    122     ADOLC_TAPING_NOT_ACTUALLY_TAPING
     122    ADOLC_TAPING_NOT_ACTUALLY_TAPING,
     123    ADOLC_VEC_LOCATIONGAP
    123124};
    124125/* additional infos fail can work with */
     
    326327    size_t maxparam;
    327328    double *pStore;
     329    size_t initialStoreSize;
    328330#ifdef __cplusplus
    329331    StoreManager *paramStoreMgrPtr;
  • trunk/ADOL-C/src/uni5_for.c

    r593 r595  
    10761076    enum AMPI_PairedWith_E pairedWith;
    10771077    MPI_Comm comm;
    1078     MPI_Status* status;
     1078    MPI_Status status;
    10791079    struct AMPI_Request_S request;
    10801080#endif
     1081    locint qq;
    10811082
    10821083    ADOLC_OPENMP_THREAD_NUMBER;
     
    53875388                break;
    53885389
     5390            case vec_copy:
     5391                res = get_locint_f();
     5392                arg = get_locint_f();
     5393                size = get_locint_f();
     5394
     5395                for(qq=0;qq<size;qq++) {
     5396                    IF_KEEP_WRITE_TAYLOR(res+qq,keep,k,p);
     5397#if !defined(_NTIGHT_)
     5398                    dp_T0[res+qq] = dp_T0[arg+qq];
     5399#endif /* !_NTIGHT_ */
     5400
     5401#if defined(_INDO_)
     5402#if defined(_INDOPRO_)
     5403                    copy_index_domain(res+qq, arg+qq, ind_dom);
     5404#endif
     5405#if defined(_NONLIND_)
     5406                    arg_index[res+qq] = arg_index[arg+qq];
     5407#endif
     5408#else
     5409#if !defined(_ZOS_) /* BREAK_ZOS */
     5410                    ASSIGN_T(Targ,TAYLOR_BUFFER[arg+qq])
     5411                    ASSIGN_T(Tres,TAYLOR_BUFFER[res+qq])
     5412
     5413                    FOR_0_LE_l_LT_pk
     5414                    TRES_INC = TARG_INC;
     5415#endif
     5416#endif /* ALL_TOGETHER_AGAIN */
     5417                }
     5418
     5419                break;
     5420
     5421            case vec_dot:
     5422                res = get_locint_f();
     5423                arg1 = get_locint_f();
     5424                arg2 = get_locint_f();
     5425                size = get_locint_f();
     5426                IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
     5427#if !defined(_NTIGHT_)
     5428                dp_T0[res] = 0;
     5429#endif
     5430#if defined(_INDO_)
     5431#if defined(_INDOPRO_)
     5432                ind_dom[res][0]=0;
     5433#endif
     5434#if defined(_NONLIND_)
     5435                fod[opind].entry = maxopind+2;
     5436                fod[opind].left = NULL;
     5437                fod[opind].right = NULL;
     5438                arg_index[res] = opind++;               
     5439#endif
     5440#else
     5441#if !defined(_ZOS_) /* BREAK_ZOS */
     5442                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
     5443
     5444                FOR_0_LE_l_LT_pk
     5445                TRES_INC = 0;
     5446#endif
     5447#endif /* ALL_TOGETHER_AGAIN */
     5448                for(qq=0;qq<size;qq++) {
     5449#if defined(_INDO_)
     5450#if defined(_INDOPRO_)
     5451                merge_3_index_domains(res, arg1+qq, arg2+qq, ind_dom);
     5452#endif
     5453#if defined(_NONLIND_)
     5454                // operation: v = v+u*w
     5455                // first step: z = u*w, index domains
     5456                fod[opind].entry = maxopind+2;
     5457                fod[opind].left = &fod[arg_index[arg1+qq]];
     5458                fod[opind].right = &fod[arg_index[arg2+qq]];
     5459                // first step: z = u*w,
     5460                traverse_unary(&fod[arg_index[arg1+qq]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     5461                traverse_unary(&fod[arg_index[arg2+qq]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     5462                opind++;
     5463                // second step: v = v+z, index domains
     5464                fod[opind].entry = maxopind+2;
     5465                fod[opind].left = &fod[arg_index[res]];
     5466                fod[opind].right = &fod[opind-1];
     5467                // second step: v = v+z,
     5468                arg_index[res] = opind++;
     5469#endif
     5470#if defined(_NONLIND_OLD_)
     5471                extend_nonlinearity_domain_binary(arg1+qq, arg2+qq, ind_dom, nonl_dom);
     5472#endif
     5473#else
     5474#if !defined(_ZOS_) /* BREAK_ZOS */
     5475                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
     5476                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1+qq])
     5477                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2+qq])
     5478
     5479#ifdef _INT_FOR_
     5480                FOR_0_LE_l_LT_p
     5481                TRES_FOINC |= TARG2_INC | TARG1_INC;
     5482#else
     5483                /* olvo 980915 now in reverse order to allow x = x*x etc. */
     5484                INC_pk_1(Tres)
     5485                INC_pk_1(Targ1)
     5486                INC_pk_1(Targ2)
     5487
     5488                FOR_p_GT_l_GE_0
     5489                FOR_k_GT_i_GE_0
     5490                { TRES_FODEC += dp_T0[arg1+qq]*TARG2_DEC +
     5491                                TARG1_DEC*dp_T0[arg2+qq];
     5492                  DEC_TRES_FO
     5493#if defined(_HIGHER_ORDER_)
     5494                  Targ1OP = Targ1-i+1;
     5495                  Targ2OP = Targ2;
     5496
     5497                  for (j=0;j<i;j++)
     5498                  *Tres += (*Targ1OP++) * (*Targ2OP--);
     5499                  Tres--;
     5500#endif /* _HIGHER_ORDER_ */
     5501                }
     5502#endif
     5503#endif
     5504#endif /* ALL_TOGETHER_AGAIN */
     5505#if !defined(_NTIGHT_)
     5506                dp_T0[res] += dp_T0[arg1+qq] *  dp_T0[arg2+qq];
     5507#endif /* !_NTIGHT_ */
     5508                }
     5509                break;
     5510
     5511            case vec_axpy:
     5512                res = get_locint_f();
     5513                arg = get_locint_f();
     5514                arg1 = get_locint_f();
     5515                arg2 = get_locint_f();
     5516                size = get_locint_f();
     5517               
     5518                for(qq=0;qq<size;qq++) {
     5519                    IF_KEEP_WRITE_TAYLOR(res+qq,keep,k,p);
     5520#if defined(_INDO_)
     5521#if defined(_INDOPRO_)
     5522                combine_2_index_domains(res+qq, arg, arg1+qq, ind_dom);
     5523                merge_2_index_domains(res+qq, arg2+qq, ind_dom);
     5524#endif
     5525#if defined(_NONLIND_)
     5526                // operation: v = u*w + y
     5527                // first step: z = u*w, index domains
     5528                fod[opind].entry = maxopind+2;
     5529                fod[opind].left = &fod[arg_index[arg]];
     5530                fod[opind].right = &fod[arg_index[arg1+qq]];
     5531                // first step: z = u*w,
     5532                traverse_unary(&fod[arg_index[arg]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     5533                traverse_unary(&fod[arg_index[arg1+qq]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
     5534                opind++;
     5535                // second step: v = z+y, index domains
     5536                fod[opind].entry = maxopind+2;
     5537                fod[opind].left = &fod[opind-1];
     5538                fod[opind].right = &fod[arg_index[arg2+qq]];
     5539                // second step: v = v+z,
     5540                arg_index[res+qq] = opind++;
     5541#endif
     5542#if defined(_NONLIND_OLD_)
     5543                extend_nonlinearity_domain_binary(arg, arg1+qq, ind_dom, nonl_dom);
     5544#endif
     5545#else
     5546#if !defined(_ZOS_) /* BREAK_ZOS */
     5547                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
     5548                ASSIGN_T(Tres,  TAYLOR_BUFFER[res+qq])
     5549                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1+qq])
     5550                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2+qq])
     5551#ifdef _INT_FOR_
     5552                FOR_0_LE_l_LT_p
     5553                TRES_FOINC = TARG2_INC | TARG1_INC | TARG_INC;
     5554#else
     5555                INC_pk_1(Tres)
     5556                INC_pk_1(Targ)
     5557                INC_pk_1(Targ1)
     5558                INC_pk_1(Targ2)
     5559                FOR_p_GT_l_GE_0
     5560                FOR_k_GT_i_GE_0
     5561                { 
     5562                    TRES_FODEC = dp_T0[arg] * TARG1_DEC + TARG_DEC * dp_T0[arg1+qq] + TARG2_DEC;
     5563                    DEC_TRES_FO
     5564#if defined(_HIGHER_ORDER_)
     5565                    Targ1OP = Targ - i + 1;
     5566                    Targ2OP = Targ1;
     5567
     5568                    for (j=0;j<i;j++) {
     5569                        *Tres += (*Targ1OP++) * (*Targ2OP--);
     5570                    }
     5571                    Tres--;
     5572#endif /* _HIGHER_ORDER_ */
     5573                }
     5574#endif
     5575#endif
     5576#endif /* ALL_TOGETHER_AGAIN */
     5577#if !defined(_NTIGHT_)
     5578                dp_T0[res+qq] = dp_T0[arg] * dp_T0[arg1+qq] + dp_T0[arg2+qq];
     5579#endif /* !_NTIGHT_ */
     5580
     5581                }
     5582                break;
     5583
    53895584            case ref_cond_assign:                                      /* cond_assign */
    53905585                arg   = get_locint_f();
     
    57835978                            pairedWith,
    57845979                            comm,
    5785                             status);
     5980                            &status);
    57865981              break;
    57875982            }
     
    58106005          case ampi_wait: {
    58116006            ADOLC_TLM_AMPI_Wait(&request,
    5812                           status);
     6007                          &status);
    58136008            break;
    58146009          }
  • trunk/ADOL-C/test/fminmax.cpp

    r168 r595  
    44{
    55        double x = 3, y = 4;
     6        double a,b;
    67
    7         fmax(x, y);
    8         fmin(x, y);
     8        a = fmax(x, y);
     9        b = fmin(x, y);
    910
    1011        return 0;
  • trunk/MSVisualStudio/v10/adolc.vcxproj

    r544 r595  
    208208    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\zos_forward.c" />
    209209    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\adouble_tl.cpp" />
    210     <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\fos_an_forward.c" />
    211     <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\fos_an_reverse.c" />
    212     <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\fov_an_forward.c" />
    213     <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\zos_an_forward.c" />
     210    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\fos_pl_forward.c" />
     211    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\fos_pl_sig_forward.c" />
     212    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\fov_pl_sig_forward.c" />
     213    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\fos_pl_reverse.c" />
     214    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\fov_pl_forward.c" />
     215    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\zos_pl_forward.c" />
    214216    <ClCompile Include="$(ProjectDir)..\..\ADOL-C\src\param.cpp" />
    215217  </ItemGroup>
  • trunk/configure.ac

    r549 r595  
    114114AC_CHECK_FUNCS([floor fmax fmin ftime pow sqrt strchr strtol trunc])
    115115
     116AX_BOOST_BASE([1.54],[boost_new=yes],[boost_new=no])
     117if test x$boost_new = xyes ; then
     118CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
     119AC_LANG_PUSH([C++])
     120AC_CHECK_HEADERS([boost/pool/pool_alloc.hpp])
     121AC_LANG_POP([C++])
     122AX_BOOST_SYSTEM
     123LDFLAGS="$LDFLAGS $BOOST_LDFLAGS $BOOST_SYSTEM_LIB"
     124fi
     125
     126if 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
     127    using_boost_pool=yes
     128else
     129    using_boost_pool=no
     130fi
     131
    116132# substitutions
    117133AC_SUBST(ac_aux_dir)
     
    296312             AC_MSG_RESULT(none)])
    297313
     314if test "x$using_boost_pool" = xyes -a "x$ac_adolc_openmpflag" = x ; then
     315   AC_DEFINE(BOOST_POOL_NO_MT,1,[Boost pool should not assume multithreading])
     316fi
    298317
    299318# ADOL-C Sparse facility
     
    541560  CXXFLAGS:                           ${ac_adolc_cxxflags}
    542561
     562  Use Boost pool allocator:           ${using_boost_pool}
    543563  Use ADOL-C debug mode:              ${adolc_debug}
    544564  Use ADOL-C hard debug mode:         ${adolc_harddebug}
Note: See TracChangeset for help on using the changeset viewer.