source: trunk/ADOL-C/src/ampisupportAdolc.cpp @ 708

Last change on this file since 708 was 595, checked in by kulshres, 5 years ago

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@…>

File size: 24.1 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     ampisupportAdolc.cpp
4 Revision: $Id$
5
6 Copyright (c) Jean Utke
7 
8 This file is part of ADOL-C. This software is provided as open source.
9 Any use, reproduction, or distribution of the software constitutes
10 recipient's acceptance of the terms of the accompanying license file.
11 
12----------------------------------------------------------------------------*/
13
14#include <cassert>
15#include <cstring>
16#include "taping_p.h"
17#include "oplate.h"
18#include "adolc/adouble.h"
19
20#ifdef ADOLC_AMPI_SUPPORT
21#include "ampisupportAdolc.h"
22#include "ampi/adTool/support.h"
23#include "ampi/tape/support.h"
24
25extern "C" void ADOLC_TLM_AMPI_PROD(void *invec, void *inoutvec, int *len, MPI_Datatype *dtype);
26
27void ADOLC_TLM_AMPI_PROD(void *invec, void *inoutvec, int *len, MPI_Datatype *dtype){
28  int order=ADOLC_CURRENT_TAPE_INFOS.gDegree;
29  int dir=ADOLC_CURRENT_TAPE_INFOS.numTay;
30  double *in=(double*)invec;
31  double *inout=(double*)inoutvec;
32  int count=(*len)/((order*dir)+1);
33  assert((*len)%((order*dir)+1)==0); // has to evenly divide or something is wrong
34  for (int i=0;i<count;++i) {
35    for (int d=0;d<dir;++d) {
36      // compute the Taylor coefficients highest to lowest per direction
37      for (int o=order;o>0;--o) {
38        double z=0;
39        // do the convolution except for the 0-th coefficients
40        for (int conv=1;conv<o;++conv) {
41          z+=in[d*order+conv]*inout[d*order+o-conv];
42        }
43        // do the 0-th coeffients
44        z+=in[d*order+o]*inout[0]+in[0]*inout[d*order+o];
45        // set the coefficient
46        inout[d*order+o]=z;
47      }
48    }
49    // compute the value
50    inout[0] *= in[0];
51    // advance to the next block
52    in+=(order*dir)+1;
53    inout+=(order*dir)+1;
54  }
55}
56
57static MPI_Op ourProdOp;
58
59void allocatePack(void** buf,
60                  const locint startLoc,
61                  const int count,
62                  int &packedCount,
63                  const MPI_Datatype& datatype,
64                  MPI_Datatype& packedDatatype) {
65  int tayCount=ADOLC_CURRENT_TAPE_INFOS.gDegree*ADOLC_CURRENT_TAPE_INFOS.numTay;
66  double* doubleBuf=(double*)malloc((tayCount+1)*count*sizeof(double));
67  assert(doubleBuf);
68  for (int i=0; i<count; ++i) {
69    doubleBuf[i*(tayCount+1)]=ADOLC_CURRENT_TAPE_INFOS.dp_T0[startLoc+i];
70    if (ADOLC_CURRENT_TAPE_INFOS.workMode != ADOLC_ZOS_FORWARD) {
71      if (ADOLC_CURRENT_TAPE_INFOS.workMode != ADOLC_FOS_FORWARD) {
72        memcpy((void*)(doubleBuf+i*(tayCount+1)+1),(void*)(ADOLC_CURRENT_TAPE_INFOS.dpp_T[startLoc+i]),tayCount*sizeof(double));
73      }
74      else {  // dpp_T is set as &dp_T !
75        doubleBuf[i*2+1]=ADOLC_CURRENT_TAPE_INFOS.dpp_T[0][startLoc+i];
76      }
77    }
78  }
79  *buf=(void*)doubleBuf;
80  packedCount=(tayCount+1)*count;
81  packedDatatype=ADTOOL_AMPI_FW_rawType(datatype);
82}
83
84void deallocate(void** buf) {
85  free(*buf);
86  *buf=NULL;
87}
88
89void unpackDeallocate(void** buf,
90                      const locint startLoc,
91                      const int count,
92                      const int packedCount,
93                      const MPI_Datatype& datatype,
94                      const MPI_Datatype& packedDatatype) {
95  assert(buf);
96  int tayCount=ADOLC_CURRENT_TAPE_INFOS.gDegree*ADOLC_CURRENT_TAPE_INFOS.numTay;
97  double* doubleBuf=(double*)(*buf);
98  for (int i=0; i<count; ++i) {
99    ADOLC_CURRENT_TAPE_INFOS.dp_T0[startLoc+i]=doubleBuf[i*(tayCount+1)];
100    if (ADOLC_CURRENT_TAPE_INFOS.workMode != ADOLC_ZOS_FORWARD) {
101      if (ADOLC_CURRENT_TAPE_INFOS.workMode != ADOLC_FOS_FORWARD) {
102        memcpy((void*)(ADOLC_CURRENT_TAPE_INFOS.dpp_T[startLoc+i]),(void*)(doubleBuf+i*(tayCount+1)+1),tayCount*sizeof(double));
103      }
104      else {
105        ADOLC_CURRENT_TAPE_INFOS.dpp_T[0][startLoc+i]=doubleBuf[i*2+1];
106      }
107    }
108  }
109  deallocate(buf);
110}
111
112MPI_Op opForPackedData(const MPI_Op& op) {
113  MPI_Op rOp=op;
114  if (op==MPI_PROD) rOp=ourProdOp;
115  return rOp;
116}
117
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
674int ADOLC_TLM_AMPI_Bcast(void* buf,
675                         int count,
676                         MPI_Datatype datatype,
677                         int root,
678                         MPI_Comm comm) {
679  locint startLoc=get_locint_f();
680  TAPE_AMPI_read_int(&count);
681  TAPE_AMPI_read_MPI_Datatype(&datatype);
682  TAPE_AMPI_read_int(&root);
683  TAPE_AMPI_read_MPI_Comm(&comm);
684  int packedCount=0;
685  MPI_Datatype packedDatatype;
686  allocatePack(&buf,
687               startLoc,
688               count,
689               packedCount,
690               datatype,
691               packedDatatype);
692  int rc=TLM_AMPI_Bcast(buf,
693                        packedCount,
694                        packedDatatype,
695                        root,
696                        comm);
697  unpackDeallocate(&buf,
698                   startLoc,
699                   count,
700                   packedCount,
701                   datatype,
702                   packedDatatype);
703  return rc;
704}
705
706int ADOLC_TLM_AMPI_Reduce(void* sbuf,
707                          void* rbuf,
708                          int count,
709                          MPI_Datatype datatype,
710                          MPI_Op op,
711                          int root,
712                          MPI_Comm comm) {
713  locint rbufStart = get_locint_f();
714  locint sbufStart = get_locint_f();
715  TAPE_AMPI_read_int(&count);
716  int pushedResultsCount; TAPE_AMPI_read_int(&pushedResultsCount);
717  double pushedDoubles;
718  for (int i=0;i<count;++i) TAPE_AMPI_read_double(&pushedDoubles);
719  if (pushedResultsCount>0) for (int i=0;i<count;++i) TAPE_AMPI_read_double(&pushedDoubles);
720  TAPE_AMPI_read_int(&pushedResultsCount);
721  TAPE_AMPI_read_MPI_Op(&op);
722  TAPE_AMPI_read_int(&root); /* root */
723  TAPE_AMPI_read_MPI_Comm(&comm);
724  TAPE_AMPI_read_MPI_Datatype(&datatype);
725  TAPE_AMPI_read_int(&count); /* count again */
726  int packedCount=0;
727  MPI_Datatype packedDatatype;
728  int myRank; MPI_Comm_rank(comm,&myRank);
729  allocatePack(&sbuf,
730               sbufStart,
731               count,
732               packedCount,
733               datatype,
734               packedDatatype);
735  if (myRank==root) {
736    allocatePack(&rbuf,
737                 rbufStart,
738                 count,
739                 packedCount,
740                 datatype,
741                 packedDatatype);
742  }
743  MPI_Op packedOp=opForPackedData(op);
744  int rc=TLB_AMPI_Reduce(sbuf,
745                         rbuf,
746                         packedCount,
747                         packedDatatype,
748                         packedOp,
749                         root,
750                         comm);
751  deallocate(&sbuf);
752  if (myRank==root) {
753    unpackDeallocate(&rbuf,
754                     rbufStart,
755                     count,
756                     packedCount,
757                     datatype,
758                     packedDatatype);
759  }
760  return rc;
761}
762
763int ADOLC_TLM_AMPI_Allreduce(void* sbuf,
764                             void* rbuf,
765                             int count,
766                             MPI_Datatype datatype,
767                             MPI_Op op,
768                             MPI_Comm comm) {
769  return TLM_AMPI_Allreduce(sbuf,
770                            rbuf,
771                            count,
772                            datatype,
773                            op,
774                            comm);
775}
776
777#endif
Note: See TracBrowser for help on using the repository browser.