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

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

Merge branch 'ampi' from 'aragonne'

The following commits were merged:

commit ba102836ff4533dc70f99c992b1fb2a6bf532c49
Author: Max Sagebaum <sagebaum@…>
Date: Mon Jun 30 15:44:54 2014 +0200

Fix of buffer length in ampi_pushSR

commit 918a9e2a60fb2c2d36617db95a96b16ca798e408
Author: Michel Schanen <schanen@…>
Date: Mon Jun 30 13:42:58 2014 +0200

Fix for the ampi tracing beyond chunk size

Using put_op_reserve instead of put_op for Gatherv and Scatterv. New function
push_CallCodeReserve with additional location number argument.

commit 00994d40a5d29bfcf40bebd22f3306bdaad86e92
Author: Jean Utke <utke@…>
Date: Fri Mar 28 15:57:29 2014 -0500

rearrange

commit a1c1d11ab0e2af58d43aaeb92f6e4982ce81d92f
Author: Jean Utke <utke@…>
Date: Fri Mar 28 15:29:47 2014 -0500

make it consistent and count in the loop rather than jumping of the duplicates like the end of tape ones and leaving it to guess to the user why the rev count doesn't got down to 1

commit bf1acc6155cd555bc35e8b9c6241097b4b833345
Author: Jean Utke <utke@…>
Date: Fri Mar 28 13:38:02 2014 -0500

fix up allgatherv output for chasing a misalignment observed in ISSM

  • Property svn:executable set to *
File size: 35.9 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     ampisupport.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 <climits>
17
18#include "taping_p.h"
19#include "oplate.h"
20#include "adolc/adouble.h"
21
22#ifdef ADOLC_AMPI_SUPPORT
23#include "ampi/ampi.h"
24#include "ampi/adTool/support.h"
25#include "ampi/tape/support.h"
26#include "ampi/libCommon/modified.h"
27#include "ampisupportAdolc.h"
28
29MPI_Comm ADTOOL_AMPI_COMM_WORLD_SHADOW;
30
31int AMPI_Init_NT(int* argc,
32                 char*** argv) {
33  int rc;
34  rc=MPI_Init(argc,
35              argv);
36  ADTOOL_AMPI_setupTypes();
37  ADOLC_TLM_init();
38  ourADTOOL_AMPI_FPCollection.pushBcastInfo_fp=&ADTOOL_AMPI_pushBcastInfo;
39  ourADTOOL_AMPI_FPCollection.popBcastInfo_fp=&ADTOOL_AMPI_popBcastInfo;
40  ourADTOOL_AMPI_FPCollection.pushDoubleArray_fp=&ADTOOL_AMPI_pushDoubleArray;
41  ourADTOOL_AMPI_FPCollection.popDoubleArray_fp=&ADTOOL_AMPI_popDoubleArray;
42  ourADTOOL_AMPI_FPCollection.pushReduceInfo_fp=&ADTOOL_AMPI_pushReduceInfo;
43  ourADTOOL_AMPI_FPCollection.popReduceCountAndType_fp=&ADTOOL_AMPI_popReduceCountAndType;
44  ourADTOOL_AMPI_FPCollection.popReduceInfo_fp=&ADTOOL_AMPI_popReduceInfo; 
45  ourADTOOL_AMPI_FPCollection.pushSRinfo_fp=&ADTOOL_AMPI_pushSRinfo;
46  ourADTOOL_AMPI_FPCollection.popSRinfo_fp=&ADTOOL_AMPI_popSRinfo;
47  ourADTOOL_AMPI_FPCollection.pushGSinfo_fp=&ADTOOL_AMPI_pushGSinfo;
48  ourADTOOL_AMPI_FPCollection.popGScommSizeForRootOrNull_fp=&ADTOOL_AMPI_popGScommSizeForRootOrNull;
49  ourADTOOL_AMPI_FPCollection.popGSinfo_fp=&ADTOOL_AMPI_popGSinfo;
50  ourADTOOL_AMPI_FPCollection.pushGSVinfo_fp=&ADTOOL_AMPI_pushGSVinfo;
51  ourADTOOL_AMPI_FPCollection.popGSVinfo_fp=&ADTOOL_AMPI_popGSVinfo;
52  ourADTOOL_AMPI_FPCollection.push_CallCode_fp=&ADTOOL_AMPI_push_CallCode;
53  ourADTOOL_AMPI_FPCollection.push_CallCodeReserve_fp=&ADTOOL_AMPI_push_CallCodeReserve;
54  ourADTOOL_AMPI_FPCollection.pop_CallCode_fp=&ADTOOL_AMPI_pop_CallCode;
55  ourADTOOL_AMPI_FPCollection.push_AMPI_Request_fp=&ADTOOL_AMPI_push_AMPI_Request;
56  ourADTOOL_AMPI_FPCollection.pop_AMPI_Request_fp=&ADTOOL_AMPI_pop_AMPI_Request;
57  ourADTOOL_AMPI_FPCollection.push_request_fp=&ADTOOL_AMPI_push_request;
58  ourADTOOL_AMPI_FPCollection.pop_request_fp=&ADTOOL_AMPI_pop_request;
59  ourADTOOL_AMPI_FPCollection.push_comm_fp=&ADTOOL_AMPI_push_comm;
60  ourADTOOL_AMPI_FPCollection.pop_comm_fp=&ADTOOL_AMPI_pop_comm;
61  ourADTOOL_AMPI_FPCollection.rawData_fp=&ADTOOL_AMPI_rawData;
62  ourADTOOL_AMPI_FPCollection.rawDataV_fp=&ADTOOL_AMPI_rawDataV;
63  ourADTOOL_AMPI_FPCollection.packDType_fp=&ADTOOL_AMPI_packDType;
64  ourADTOOL_AMPI_FPCollection.unpackDType_fp=&ADTOOL_AMPI_unpackDType;
65  ourADTOOL_AMPI_FPCollection.writeData_fp=&ADTOOL_AMPI_writeData;
66  ourADTOOL_AMPI_FPCollection.writeDataV_fp=&ADTOOL_AMPI_writeDataV;
67  ourADTOOL_AMPI_FPCollection.rawAdjointData_fp=&ADTOOL_AMPI_rawAdjointData;
68  ourADTOOL_AMPI_FPCollection.Turn_fp=&ADTOOL_AMPI_Turn;
69  ourADTOOL_AMPI_FPCollection.mapBufForAdjoint_fp=&ADTOOL_AMPI_mapBufForAdjoint;
70  ourADTOOL_AMPI_FPCollection.setBufForAdjoint_fp=&ADTOOL_AMPI_setBufForAdjoint;
71  ourADTOOL_AMPI_FPCollection.getAdjointCount_fp=&ADTOOL_AMPI_getAdjointCount;
72  ourADTOOL_AMPI_FPCollection.setAdjointCount_fp=&ADTOOL_AMPI_setAdjointCount;
73  ourADTOOL_AMPI_FPCollection.setAdjointCountAndTempBuf_fp=&ADTOOL_AMPI_setAdjointCountAndTempBuf;
74  ourADTOOL_AMPI_FPCollection.allocateTempBuf_fp=&ADTOOL_AMPI_allocateTempBuf;
75  ourADTOOL_AMPI_FPCollection.releaseAdjointTempBuf_fp=&ADTOOL_AMPI_releaseAdjointTempBuf;
76  ourADTOOL_AMPI_FPCollection.incrementAdjoint_fp=&ADTOOL_AMPI_incrementAdjoint;
77  ourADTOOL_AMPI_FPCollection.multiplyAdjoint_fp=&ADTOOL_AMPI_multiplyAdjoint;
78  ourADTOOL_AMPI_FPCollection.divideAdjoint_fp=&ADTOOL_AMPI_divideAdjoint;
79  ourADTOOL_AMPI_FPCollection.equalAdjoints_fp=&ADTOOL_AMPI_equalAdjoints;
80  ourADTOOL_AMPI_FPCollection.nullifyAdjoint_fp=&ADTOOL_AMPI_nullifyAdjoint;
81  ourADTOOL_AMPI_FPCollection.setupTypes_fp=&ADTOOL_AMPI_setupTypes;
82  ourADTOOL_AMPI_FPCollection.cleanupTypes_fp=&ADTOOL_AMPI_cleanupTypes;
83  ourADTOOL_AMPI_FPCollection.FW_rawType_fp=&ADTOOL_AMPI_FW_rawType;
84  ourADTOOL_AMPI_FPCollection.BW_rawType_fp=&ADTOOL_AMPI_BW_rawType;
85  ourADTOOL_AMPI_FPCollection.isActiveType_fp=&ADTOOL_AMPI_isActiveType;
86  ourADTOOL_AMPI_FPCollection.allocateTempActiveBuf_fp=&ADTOOL_AMPI_allocateTempActiveBuf;
87  ourADTOOL_AMPI_FPCollection.releaseTempActiveBuf_fp=&ADTOOL_AMPI_releaseTempActiveBuf;
88  ourADTOOL_AMPI_FPCollection.copyActiveBuf_fp=&ADTOOL_AMPI_copyActiveBuf;
89  return rc;
90}
91
92locint startLocAssertContiguous(adouble* adoubleBuffer, int count) { 
93  locint start=0;
94  if (count>0) { 
95    start=adoubleBuffer->loc();
96    assert(start+count-1==(adoubleBuffer+count-1)->loc()); // buf must have consecutive ascending locations
97  }
98  return start;
99} 
100
101void ADTOOL_AMPI_pushBcastInfo(void* buf,
102                               int count,
103                               MPI_Datatype datatype,
104                               int root,
105                               MPI_Comm comm) {
106  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
107    int i, dt_idx = derivedTypeIdx(datatype);
108    int activeVarCount, bitCountToFirstActive, bitCountToLastActive;
109    if (isDerivedType(dt_idx)) {
110      derivedTypeData* dtdata = getDTypeData();
111      activeVarCount = dtdata->num_actives[dt_idx]*count;
112      bitCountToFirstActive = dtdata->first_active_blocks[dt_idx];;
113      bitCountToLastActive = (count-1)*dtdata->extents[dt_idx]
114        + dtdata->last_active_blocks[dt_idx]
115        + sizeof(adouble)*(dtdata->last_active_block_lengths[dt_idx]-1);
116    }
117    else { 
118      activeVarCount = count; 
119      bitCountToFirstActive = 0; 
120      bitCountToLastActive = (count-1)*sizeof(adouble); 
121    }
122    if (count>0) {
123      assert(buf);
124      locint start=((adouble*)((char*)buf+bitCountToFirstActive))->loc();
125      locint end=((adouble*)((char*)buf+bitCountToLastActive))->loc();
126      assert(start+activeVarCount-1==end); // buf must have consecutive ascending locations
127      ADOLC_PUT_LOCINT(start);
128    }
129    else {
130      ADOLC_PUT_LOCINT(0); // have to put something
131    }
132    TAPE_AMPI_push_int(count);
133    TAPE_AMPI_push_MPI_Datatype(datatype);
134    TAPE_AMPI_push_int(root);
135    TAPE_AMPI_push_MPI_Comm(comm);
136  }
137}
138
139void ADTOOL_AMPI_popBcastInfo(void** buf,
140                              int* count,
141                              MPI_Datatype* datatype,
142                              int* root,
143                              MPI_Comm* comm,
144                              void **idx) {
145  TAPE_AMPI_pop_MPI_Comm(comm);
146  TAPE_AMPI_pop_int(root);
147  TAPE_AMPI_pop_MPI_Datatype(datatype);
148  TAPE_AMPI_pop_int(count);
149  *buf=(void*)(&(ADOLC_CURRENT_TAPE_INFOS.rp_A[get_locint_r()]));
150}
151
152void ADTOOL_AMPI_pushDoubleArray(void* buf,
153                                 int count) {
154  int i;
155  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
156    for (i=0;i<count;i++) {
157      TAPE_AMPI_push_double(((adouble*)(buf))[i].value());
158    }
159  }
160}
161
162void ADTOOL_AMPI_popDoubleArray(double* buf,
163                                int* count) {
164  int i;
165  for (i=*count-1;i>=0;i--) {
166    TAPE_AMPI_pop_double(&(buf[i]));
167  }
168}
169
170void ADTOOL_AMPI_pushReduceInfo(void* sbuf,
171                                void* rbuf,
172                                void* resultData,
173                                int pushResultData, /* push resultData if true */
174                                int count,
175                                MPI_Datatype datatype,
176                                MPI_Op op,
177                                int root,
178                                MPI_Comm comm) {
179  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
180    if (count>0) {
181      assert(rbuf);
182      ADOLC_PUT_LOCINT(startLocAssertContiguous((adouble*)rbuf,count));
183      ADOLC_PUT_LOCINT(startLocAssertContiguous((adouble*)sbuf,count));
184    }
185    else {
186      ADOLC_PUT_LOCINT(0);
187      ADOLC_PUT_LOCINT(0);
188    }
189    TAPE_AMPI_push_int(count);
190    TAPE_AMPI_push_int(pushResultData);
191    ADTOOL_AMPI_pushDoubleArray(sbuf,count);
192    if (pushResultData) ADTOOL_AMPI_pushDoubleArray(resultData,count);
193    TAPE_AMPI_push_int(pushResultData);
194    TAPE_AMPI_push_MPI_Op(op);
195    TAPE_AMPI_push_int(root);
196    TAPE_AMPI_push_MPI_Comm(comm);
197    TAPE_AMPI_push_MPI_Datatype(datatype);
198    TAPE_AMPI_push_int(count);
199  }
200}
201
202void ADTOOL_AMPI_popReduceCountAndType(int* count,
203                                       MPI_Datatype* datatype) {
204  TAPE_AMPI_pop_int(count);
205  TAPE_AMPI_pop_MPI_Datatype(datatype);
206}
207
208void ADTOOL_AMPI_popReduceInfo(void** sbuf,
209                               void** rbuf,
210                               void** prevData,
211                               void** resultData,
212                               int* count,
213                               MPI_Op* op,
214                               int* root,
215                               MPI_Comm* comm,
216                               void **idx) {
217  int popResultData;
218  TAPE_AMPI_pop_MPI_Comm(comm);
219  TAPE_AMPI_pop_int(root);
220  TAPE_AMPI_pop_MPI_Op(op);
221  TAPE_AMPI_pop_int(&popResultData);
222  if (popResultData) ADTOOL_AMPI_popDoubleArray((double*)(*resultData),count);
223  ADTOOL_AMPI_popDoubleArray((double*)(*prevData),count);
224  TAPE_AMPI_pop_int(&popResultData);
225  TAPE_AMPI_pop_int(count);
226  *sbuf=(void*)(&(ADOLC_CURRENT_TAPE_INFOS.rp_A[get_locint_r()]));
227  *rbuf=(void*)(&(ADOLC_CURRENT_TAPE_INFOS.rp_A[get_locint_r()]));
228}
229
230void ADTOOL_AMPI_pushSRinfo(void* buf, 
231                            int count,
232                            MPI_Datatype datatype, 
233                            int endPoint, 
234                            int tag,
235                            enum AMPI_PairedWith_E pairedWith,
236                            MPI_Comm comm) { 
237  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
238    int i, dt_idx = derivedTypeIdx(datatype);
239    int activeVarCount, bitCountToFirstActive, bitCountToLastActive;
240    if (isDerivedType(dt_idx)) {
241      derivedTypeData* dtdata = getDTypeData();
242      activeVarCount = dtdata->num_actives[dt_idx]*count;
243      bitCountToFirstActive = dtdata->first_active_blocks[dt_idx];
244      bitCountToLastActive = (count-1)*dtdata->extents[dt_idx]
245        + dtdata->last_active_blocks[dt_idx]
246        + sizeof(adouble)*(dtdata->last_active_block_lengths[dt_idx]-1);
247    }
248    else { activeVarCount = count; bitCountToFirstActive = 0; bitCountToLastActive = (count-1)*sizeof(adouble); }
249    if (count>0) {
250      assert(buf);
251      locint start=((adouble*)((char*)buf+bitCountToFirstActive))->loc();
252      locint end=((adouble*)((char*)buf+bitCountToLastActive))->loc();
253      assert(start+activeVarCount-1==end); // buf must have consecutive ascending locations
254      ADOLC_PUT_LOCINT(start);
255    }
256    else {
257      ADOLC_PUT_LOCINT(0); // have to put something
258    }
259    TAPE_AMPI_push_int(count);
260    TAPE_AMPI_push_MPI_Datatype(datatype);
261    TAPE_AMPI_push_int(endPoint);
262    TAPE_AMPI_push_int(tag);
263    TAPE_AMPI_push_int(pairedWith);
264    TAPE_AMPI_push_MPI_Comm(comm);
265  }
266}
267
268void ADTOOL_AMPI_popSRinfo(void** buf,
269                           int* count,
270                           MPI_Datatype* datatype,
271                           int* endPoint,
272                           int* tag,
273                           AMPI_PairedWith_E* pairedWith,
274                           MPI_Comm* comm,
275                           void **idx) {
276  TAPE_AMPI_pop_MPI_Comm(comm);
277  TAPE_AMPI_pop_int((int*)pairedWith);
278  TAPE_AMPI_pop_int(tag);
279  TAPE_AMPI_pop_int(endPoint);
280  TAPE_AMPI_pop_MPI_Datatype(datatype);
281  TAPE_AMPI_pop_int(count);
282  *buf=(void*)(&(ADOLC_CURRENT_TAPE_INFOS.rp_A[get_locint_r()]));
283}
284
285void ADTOOL_AMPI_pushGSinfo(int commSizeForRootOrNull,
286                            void *rbuf,
287                            int rcnt,
288                            MPI_Datatype rtype,
289                            void *buf,
290                            int  count,
291                            MPI_Datatype type,
292                            int  root,
293                            MPI_Comm comm) {
294  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
295    int i;
296    TAPE_AMPI_push_int(commSizeForRootOrNull);  // counter at the beginning
297    if(commSizeForRootOrNull>0) {
298      TAPE_AMPI_push_int(rcnt);
299      assert(rbuf);
300      ADOLC_PUT_LOCINT(startLocAssertContiguous((adouble*)rbuf,rcnt));
301      TAPE_AMPI_push_MPI_Datatype(rtype);
302    }
303    locint start=0; // have to put something regardless
304    if (buf!=MPI_IN_PLACE && count>0) {
305      assert(buf);
306      start=startLocAssertContiguous((adouble*)buf,count);
307    }
308    else {
309      count=0;
310    }
311    ADOLC_PUT_LOCINT(start);
312    TAPE_AMPI_push_int(count);
313    TAPE_AMPI_push_MPI_Datatype(type);
314    TAPE_AMPI_push_int(root);
315    TAPE_AMPI_push_MPI_Comm(comm);
316    TAPE_AMPI_push_int(commSizeForRootOrNull); // counter at the end
317  }
318}
319
320void ADTOOL_AMPI_popGScommSizeForRootOrNull(int *commSizeForRootOrNull) {
321  TAPE_AMPI_pop_int(commSizeForRootOrNull);
322}
323
324void ADTOOL_AMPI_popGSinfo(int commSizeForRootOrNull,
325                           void **rbuf,
326                           int *rcnt,
327                           MPI_Datatype *rtype,
328                           void **buf,
329                           int *count,
330                           MPI_Datatype *type,
331                           int *root,
332                           MPI_Comm *comm) {
333  int i;
334  TAPE_AMPI_pop_MPI_Comm(comm);
335  TAPE_AMPI_pop_int(root);
336  TAPE_AMPI_pop_MPI_Datatype(type);
337  TAPE_AMPI_pop_int(count);
338  locint bufLoc=get_locint_r();
339  if (*count==0) { 
340    if (commSizeForRootOrNull) *buf=MPI_IN_PLACE;
341    else *buf=0;
342  }
343  else *buf=(void*)(&(ADOLC_CURRENT_TAPE_INFOS.rp_A[bufLoc]));
344  if (commSizeForRootOrNull>0) {
345    TAPE_AMPI_pop_MPI_Datatype(rtype);
346    *rbuf=(void*)(&(ADOLC_CURRENT_TAPE_INFOS.rp_A[get_locint_r()]));
347    TAPE_AMPI_pop_int(rcnt);
348  }
349  else { 
350    // at least initialize to something nonrandom
351    // because we know we always have valid addresses passed in here
352    // NOTE JU: may not be true for source transformation...
353    *rbuf=0;
354    *rcnt=0;
355  }
356  TAPE_AMPI_pop_int(&commSizeForRootOrNull);
357}
358
359void ADTOOL_AMPI_pushGSVinfo(int commSizeForRootOrNull,
360                             void *rbuf,
361                             int *rcnts,
362                             int *displs,
363                             MPI_Datatype rtype,
364                             void *buf,
365                             int  count,
366                             MPI_Datatype type,
367                             int  root,
368                             MPI_Comm comm) { 
369  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
370    int i;
371    int minDispls=INT_MAX,endOffsetMax=0;
372    TAPE_AMPI_push_int(commSizeForRootOrNull);  // counter at the beginning
373    for (i=0;i<commSizeForRootOrNull;++i) {
374      TAPE_AMPI_push_int(rcnts[i]);
375      TAPE_AMPI_push_int(displs[i]);
376      if (rcnts[i]>0) {
377        if (minDispls>displs[i])  minDispls=displs[i];
378        if (endOffsetMax<displs[i]+rcnts[i]) endOffsetMax=displs[i]+rcnts[i]; 
379      }
380      if (endOffsetMax==0) minDispls=0;
381    }
382    if (commSizeForRootOrNull>0) {
383      assert(minDispls==0); // don't want to make assumptions about memory layout for nonzero displacements
384      assert(rbuf);
385      ADOLC_PUT_LOCINT(startLocAssertContiguous((adouble*)rbuf,endOffsetMax));
386      TAPE_AMPI_push_MPI_Datatype(rtype);
387    }
388    locint start=0; // have to put something regardless
389    if (count>0 && buf!=MPI_IN_PLACE) {
390      assert(buf);
391      start=startLocAssertContiguous((adouble*)buf,count);
392    }
393    else {
394      count=0;
395    }
396    ADOLC_PUT_LOCINT(start);
397    TAPE_AMPI_push_int(count);
398    TAPE_AMPI_push_MPI_Datatype(type);
399    TAPE_AMPI_push_int(root);
400    TAPE_AMPI_push_MPI_Comm(comm);
401    TAPE_AMPI_push_int(commSizeForRootOrNull); // counter at the end
402  }
403}
404
405void ADTOOL_AMPI_popGSVinfo(int commSizeForRootOrNull,
406                            void **rbuf,
407                            int *rcnts,
408                            int *displs,
409                            MPI_Datatype *rtype,
410                            void **buf,
411                            int *count,
412                            MPI_Datatype *type,
413                            int *root,
414                            MPI_Comm *comm) { 
415  int i;
416  TAPE_AMPI_pop_MPI_Comm(comm);
417  TAPE_AMPI_pop_int(root);
418  TAPE_AMPI_pop_MPI_Datatype(type);
419  TAPE_AMPI_pop_int(count);
420  locint bufLoc=get_locint_r();
421  if (*count==0) { 
422    if (commSizeForRootOrNull) *buf=MPI_IN_PLACE;
423    else *buf=0;
424  }
425  else *buf=(void*)(&(ADOLC_CURRENT_TAPE_INFOS.rp_A[bufLoc]));
426  if (commSizeForRootOrNull>0) { 
427    TAPE_AMPI_pop_MPI_Datatype(rtype);
428    *rbuf=(void*)(&(ADOLC_CURRENT_TAPE_INFOS.rp_A[get_locint_r()]));
429  }
430  else { 
431    // at least initialize to something nonrandom
432    // because we know we always have valid addresses passed in here
433    // NOTE JU: may not be true for source transformation...
434    *rbuf=0;
435  }
436  for (i=commSizeForRootOrNull-1;i>=0;--i) { 
437    TAPE_AMPI_pop_int(&(displs[i]));
438    TAPE_AMPI_pop_int(&(rcnts[i]));
439  }
440  TAPE_AMPI_pop_int(&commSizeForRootOrNull);
441}
442
443void ADTOOL_AMPI_push_CallCode(enum AMPI_CallCode_E thisCall) {
444  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
445    switch(thisCall) {
446      case AMPI_WAIT:
447        put_op(ampi_wait);
448        break;
449      case AMPI_BARRIER:
450         put_op(ampi_barrier);
451         break;
452      case AMPI_SEND:
453        put_op(ampi_send);
454        break;
455      case AMPI_RECV:
456        put_op(ampi_recv);
457        break;
458      case AMPI_ISEND:
459        put_op(ampi_isend);
460        break;
461      case AMPI_IRECV:
462        put_op(ampi_irecv);
463        break;
464      case AMPI_BCAST:
465        put_op(ampi_bcast);
466        break;
467      case AMPI_REDUCE:
468        put_op(ampi_reduce);
469        break;
470      case AMPI_ALLREDUCE:
471        put_op(ampi_allreduce);
472        break;
473      case AMPI_GATHER:
474        put_op(ampi_gather);
475        break;
476      case AMPI_SCATTER:
477        put_op(ampi_scatter);
478        break;
479      case AMPI_ALLGATHER:
480        put_op(ampi_allgather);
481        break;
482      default:
483        assert(0);
484        break;
485    }
486  }
487}
488
489void ADTOOL_AMPI_push_CallCodeReserve(enum AMPI_CallCode_E thisCall, unsigned int numlocations) {
490  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
491    switch(thisCall) {
492      case AMPI_GATHERV:
493        put_op_reserve(ampi_gatherv, numlocations);
494        break;
495      case AMPI_SCATTERV:
496        put_op_reserve(ampi_scatterv, numlocations);
497        break;
498      case AMPI_ALLGATHERV:
499         put_op_reserve(ampi_allgatherv, numlocations);
500         break;
501      default:
502        assert(0);
503        break;
504    }
505  }
506}
507
508void ADTOOL_AMPI_pop_CallCode(enum AMPI_CallCode_E *thisCall) {
509  assert(0);
510}
511
512void ADTOOL_AMPI_push_AMPI_Request(struct AMPI_Request_S  *ampiRequest) { 
513  ADTOOL_AMPI_pushSRinfo(ampiRequest->buf, 
514                         ampiRequest->count,
515                         ampiRequest->datatype,
516                         ampiRequest->endPoint,
517                         ampiRequest->tag,
518                         ampiRequest->pairedWith,
519                         ampiRequest->comm);
520  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
521    TAPE_AMPI_push_MPI_Request(ampiRequest->tracedRequest);
522    TAPE_AMPI_push_int(ampiRequest->origin);
523  }
524}
525
526void ADTOOL_AMPI_pop_AMPI_Request(struct AMPI_Request_S  *ampiRequest) { 
527  TAPE_AMPI_pop_int((int*)&(ampiRequest->origin));
528  TAPE_AMPI_pop_MPI_Request(&(ampiRequest->tracedRequest));
529  ADTOOL_AMPI_popSRinfo(&(ampiRequest->adjointBuf),
530                        &(ampiRequest->count),
531                        &(ampiRequest->datatype),
532                        &(ampiRequest->endPoint),
533                        &(ampiRequest->tag),
534                        &(ampiRequest->pairedWith),
535                        &(ampiRequest->comm),
536                        &(ampiRequest->idx));
537}
538
539void ADTOOL_AMPI_push_request(MPI_Request request) { 
540  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) TAPE_AMPI_push_MPI_Request(request);
541} 
542
543MPI_Request ADTOOL_AMPI_pop_request() {
544  MPI_Request r;
545  TAPE_AMPI_pop_MPI_Request(&r);
546  return r;
547}
548
549void ADTOOL_AMPI_push_comm(MPI_Comm comm) {
550  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) TAPE_AMPI_push_MPI_Comm(comm);
551}
552
553MPI_Comm ADTOOL_AMPI_pop_comm() {
554  MPI_Comm c;
555  TAPE_AMPI_pop_MPI_Comm(&c);
556  return c;
557}
558
559void * ADTOOL_AMPI_rawData(void* activeData, int *size) { 
560  void *ret=0;
561  if (*size>0) {
562    adouble* adouble_p=(adouble*)activeData;
563    ret=(void*)(&(ADOLC_GLOBAL_TAPE_VARS.store[adouble_p->loc()]));
564  }
565  return ret;
566}
567
568void * ADTOOL_AMPI_rawDataV(void* activeData, int commSize, int *counts, int *displs) { 
569  void *ret=NULL;
570  int nonNullCount=0;
571  int minDispls=INT_MAX;
572  for (int i=0; i< commSize; ++i)  { 
573    if (counts[i]>nonNullCount) nonNullCount=counts[i];
574    if (minDispls>displs[i]) minDispls=displs[i];
575  }
576  if (nonNullCount>0) { 
577    assert(minDispls==0);
578    adouble* adouble_p=(adouble*)activeData; 
579    ret=(void*)(&(ADOLC_GLOBAL_TAPE_VARS.store[adouble_p->loc()]));
580  }
581  return ret;
582}
583
584void * ADTOOL_AMPI_packDType(void* indata, void* outdata, int count, int idx) {
585  if (!isDerivedType(idx)) return indata; /* not derived type, or only passive elements */
586  int i, j, s, in_offset, out_offset, dt_idx;
587  MPI_Aint p_extent, extent;
588  MPI_Datatype datatype;
589  derivedTypeData* dtdata = getDTypeData();
590  char *out_addr, *in_addr;
591  p_extent = dtdata->p_extents[idx];
592  extent = dtdata->extents[idx];
593  for (j=0;j<count;j++) {
594    in_offset = j*extent;
595    out_offset = j*p_extent;
596    for (i=0;i<dtdata->counts[idx];i++) {
597      datatype = dtdata->arrays_of_types[idx][i];
598      if (datatype==MPI_UB || datatype==MPI_LB) assert(0);
599      dt_idx = derivedTypeIdx(datatype);
600      out_addr = (char*)outdata + out_offset + (int)dtdata->arrays_of_p_displacements[idx][i];
601      in_addr = (char*)indata + in_offset + (int)dtdata->arrays_of_displacements[idx][i];
602      if (ADTOOL_AMPI_isActiveType(datatype)==AMPI_ACTIVE) {
603        memcpy(out_addr,
604               ADTOOL_AMPI_rawData((void*)in_addr,&dtdata->arrays_of_blocklengths[idx][i]),
605               sizeof(revreal)*dtdata->arrays_of_blocklengths[idx][i]);
606      }
607      else if (isDerivedType(dt_idx)) {
608        ADTOOL_AMPI_packDType(in_addr,
609                              out_addr,
610                              dtdata->arrays_of_blocklengths[idx][i],
611                              dt_idx);
612      }
613      else {
614        if (datatype==MPI_DOUBLE) s = (int)sizeof(double);
615        else if (datatype==MPI_INT) s = (int)sizeof(int);
616        else if (datatype==MPI_FLOAT) s = (int)sizeof(float);
617        else if (datatype==MPI_CHAR) s = (int)sizeof(char);
618        else assert(0);
619        memcpy(out_addr,
620               in_addr,
621               s*dtdata->arrays_of_blocklengths[idx][i]);
622      }
623    }
624  }
625  return outdata;
626}
627
628void * ADTOOL_AMPI_unpackDType(void* indata, void* outdata, int count, int idx) {
629  if (!isDerivedType(idx)) return indata; /* not derived type, or only passive elements */
630  int i, j, s, in_offset, out_offset, dt_idx;
631  MPI_Aint p_extent, extent;
632  MPI_Datatype datatype;
633  derivedTypeData* dtdata = getDTypeData();
634  char *out_addr, *in_addr;
635  p_extent = dtdata->p_extents[idx];
636  extent = dtdata->extents[idx];
637  for (j=0;j<count;j++) {
638    in_offset = j*p_extent;
639    out_offset = j*extent;
640    for (i=0;i<dtdata->counts[idx];i++) {
641      datatype = dtdata->arrays_of_types[idx][i];
642      if (datatype==MPI_UB || datatype==MPI_LB) assert(0);
643      dt_idx = derivedTypeIdx(datatype);
644      out_addr = (char*)outdata + out_offset + (int)dtdata->arrays_of_displacements[idx][i];
645      in_addr = (char*)indata + in_offset + (int)dtdata->arrays_of_p_displacements[idx][i];
646      if (ADTOOL_AMPI_isActiveType(datatype)==AMPI_ACTIVE) {
647        memcpy(ADTOOL_AMPI_rawData((void*)out_addr,&dtdata->arrays_of_blocklengths[idx][i]),
648               in_addr,
649               sizeof(revreal)*dtdata->arrays_of_blocklengths[idx][i]);
650      }
651      else if (isDerivedType(dt_idx)) {
652        ADTOOL_AMPI_unpackDType(in_addr,
653                                out_addr,
654                                dtdata->arrays_of_blocklengths[idx][i],
655                                dt_idx);
656      }
657      else {
658        if (datatype==MPI_DOUBLE) s = (int)sizeof(double);
659        else if (datatype==MPI_INT) s = (int)sizeof(int);
660        else if (datatype==MPI_FLOAT) s = (int)sizeof(float);
661        else if (datatype==MPI_CHAR) s = (int)sizeof(char);
662        else assert(0);
663        memcpy(out_addr,
664               in_addr,
665               s*dtdata->arrays_of_blocklengths[idx][i]);
666      }
667    }
668  }
669  return outdata;
670}
671
672void ADTOOL_AMPI_writeData(void* activeData,int *size) {}
673
674void ADTOOL_AMPI_writeDataV(void* activeData, int *counts, int* displs) {}
675
676void * ADTOOL_AMPI_rawAdjointData(void* activeData) {
677  return activeData;
678}
679
680void ADTOOL_AMPI_mapBufForAdjoint(struct AMPI_Request_S  *ampiRequest,
681                                  void* buf) { 
682  ampiRequest->buf=buf;
683}
684
685void ADTOOL_AMPI_Turn(void* buf, void* adjointBuf) {}
686
687void ADTOOL_AMPI_setBufForAdjoint(struct AMPI_Request_S  *ampiRequest,
688                                  void* buf) { 
689  /* do nothing */
690}
691
692void ADTOOL_AMPI_getAdjointCount(int *count,
693                                 MPI_Datatype datatype) { 
694  int dt_idx = derivedTypeIdx(datatype);
695  if (isDerivedType(dt_idx)) *count *= getDTypeData()->num_actives[dt_idx];
696}
697
698void ADTOOL_AMPI_setAdjointCount(struct AMPI_Request_S  *ampiRequest) { 
699  /* for now we keep the count as is but for example in vector mode one would have to multiply by vector length */
700  ampiRequest->adjointCount=ampiRequest->count;
701}
702
703void ADTOOL_AMPI_setAdjointCountAndTempBuf(struct AMPI_Request_S *ampiRequest) { 
704  ADTOOL_AMPI_setAdjointCount(ampiRequest);
705  ampiRequest->adjointTempBuf=
706      ADTOOL_AMPI_allocateTempBuf(ampiRequest->adjointCount,
707          ampiRequest->datatype,
708          ampiRequest->comm);
709}
710
711void* ADTOOL_AMPI_allocateTempBuf(int adjointCount,
712                                  MPI_Datatype dataType,
713                                  MPI_Comm comm) {
714  size_t s=0;
715  void* buf;
716  int dt_idx = derivedTypeIdx(dataType);
717  if (dataType==AMPI_ADOUBLE) s=sizeof(revreal);
718  else if(dataType==MPI_DOUBLE) s=sizeof(double);
719  else if(dataType==MPI_FLOAT) s=sizeof(float);
720  else if(isDerivedType(dt_idx)) s=getDTypeData()->p_extents[dt_idx];
721  else MPI_Abort(comm, MPI_ERR_TYPE);
722  buf=malloc(adjointCount*s);
723  assert(buf);
724  return buf;
725}
726
727void ADTOOL_AMPI_releaseAdjointTempBuf(void *tempBuf) {
728  free(tempBuf);
729}
730
731void* ADTOOL_AMPI_allocateTempActiveBuf(int count,
732                                        MPI_Datatype datatype,
733                                        MPI_Comm comm) {
734  int dt_idx = derivedTypeIdx(datatype);
735  if (isDerivedType(dt_idx)) {
736    int i, j, extent, struct_offset, block_offset;
737    MPI_Datatype blocktype;
738    derivedTypeData* dtdata = getDTypeData();
739    void* buf;
740    extent = dtdata->extents[dt_idx];
741    buf = malloc(count*extent);
742    assert(buf);
743    for (j=0;j<count;j++) {
744      struct_offset = j*extent;
745      for (i=0;i<dtdata->counts[dt_idx];i++) {
746        blocktype = dtdata->arrays_of_types[dt_idx][i];
747        if (blocktype==MPI_UB || blocktype==MPI_LB) assert(0);
748        block_offset = struct_offset + dtdata->arrays_of_displacements[dt_idx][i];
749        if (blocktype==AMPI_ADOUBLE) {
750          new ((void*)((char*)buf + block_offset)) adouble[dtdata->arrays_of_blocklengths[dt_idx][i]];
751        }
752      }
753    }
754    return buf;
755  }
756  else if (datatype==AMPI_ADOUBLE) {
757    adouble* buf = new adouble[count];
758    assert(buf);
759    return buf;
760  }
761  else assert(0);
762}
763
764void ADTOOL_AMPI_releaseTempActiveBuf(void *buf,
765                                      int count,
766                                      MPI_Datatype datatype) {
767  int dt_idx = derivedTypeIdx(datatype);
768  if (isDerivedType(dt_idx)) {
769    int i, j, k, extent, struct_offset, block_offset;
770    MPI_Datatype blocktype;
771    derivedTypeData* dtdata = getDTypeData();
772    extent = dtdata->extents[dt_idx];
773    for (j=0;j<count;j++) {
774      struct_offset = j*extent;
775      for (i=0;i<dtdata->counts[dt_idx];i++) {
776        blocktype = dtdata->arrays_of_types[dt_idx][i];
777        block_offset = struct_offset + dtdata->arrays_of_displacements[dt_idx][i];
778        if (blocktype==AMPI_ADOUBLE) {
779          for (k=0;k<dtdata->arrays_of_blocklengths[dt_idx][i];k++) {
780            ((adouble*)((char*)buf + block_offset + k*sizeof(adouble)))->~adouble();
781          }
782        }
783      }
784    }
785    free(buf);
786  }
787  else if (datatype==AMPI_ADOUBLE) delete[] (adouble*)buf;
788  else assert(0);
789}
790
791void * ADTOOL_AMPI_copyActiveBuf(void* source,
792                                 void* target,
793                                 int count,
794                                 MPI_Datatype datatype,
795                                 MPI_Comm comm) {
796  int s, k, dt_idx = derivedTypeIdx(datatype);
797  if (ADTOOL_AMPI_isActiveType(datatype)==AMPI_ACTIVE) {
798    for (k=0;k<count;k++) ((adouble*)target)[k] = ((adouble*)source)[k];
799  }
800  else if (isDerivedType(dt_idx)) {
801    int i, j, extent, struct_offset, block_offset;
802    MPI_Datatype blocktype;
803    derivedTypeData* dtdata = getDTypeData();
804    extent = dtdata->extents[dt_idx];
805    for (j=0;j<count;j++) {
806      struct_offset = j*extent;
807      for (i=0;i<dtdata->counts[dt_idx];i++) {
808        blocktype = dtdata->arrays_of_types[dt_idx][i];
809        if (blocktype==MPI_UB || blocktype==MPI_LB) assert(0);
810        block_offset = struct_offset + (int)dtdata->arrays_of_displacements[dt_idx][i];
811        if (ADTOOL_AMPI_isActiveType(blocktype)==AMPI_ACTIVE) {
812          for (k=0;k<dtdata->arrays_of_blocklengths[dt_idx][i];k++) {
813            ((adouble*)((char*)target + block_offset))[k] = ((adouble*)((char*)source + block_offset))[k];
814          }
815        }
816        else {
817          if (blocktype==MPI_DOUBLE) s = sizeof(double);
818          else if (blocktype==MPI_INT) s = sizeof(int);
819          else if (blocktype==MPI_FLOAT) s = sizeof(float);
820          else if (blocktype==MPI_CHAR) s = sizeof(char);
821          memcpy((char*)target + block_offset,
822                 (char*)source + block_offset,
823                 s*dtdata->arrays_of_blocklengths[dt_idx][i]);
824        }
825      }
826    }
827  }
828  else assert(0);
829  return target;
830}
831
832void ADTOOL_AMPI_incrementAdjoint(int adjointCount,
833                                  MPI_Datatype datatype,
834                                  MPI_Comm comm,
835                                  void* target,
836                                  void *source,
837                                  void *idx) {
838  for (unsigned int i=0; i<adjointCount; ++i) ((revreal*)(target))[i]+=((revreal*)(source))[i];
839}
840
841void ADTOOL_AMPI_multiplyAdjoint(int adjointCount,
842                                 MPI_Datatype datatype,
843                                 MPI_Comm comm,
844                                 void* target,
845                                 void *source,
846                                 void *idx) {
847  for (unsigned int i=0; i<adjointCount; ++i) ((revreal*)(target))[i]*=((revreal*)(source))[i];
848}
849
850void ADTOOL_AMPI_divideAdjoint(int adjointCount,
851                               MPI_Datatype datatype,
852                               MPI_Comm comm,
853                               void* target,
854                               void *source,
855                               void *idx) {
856  for (unsigned int i=0; i<adjointCount; ++i) ((revreal*)(target))[i]/=((revreal*)(source))[i];
857}
858
859void ADTOOL_AMPI_equalAdjoints(int adjointCount,
860                               MPI_Datatype datatype,
861                               MPI_Comm comm,
862                               void* target,
863                               void *source1,
864                               void *source2,
865                               void *idx) {
866  for (unsigned int i=0; i<adjointCount; ++i) ((revreal*)(target))[i]=((revreal*)(source1))[i]==((revreal*)(source2))[i];
867}
868
869void ADTOOL_AMPI_nullifyAdjoint(int adjointCount,
870                                MPI_Datatype datatype,
871                                MPI_Comm comm,
872                                void* target) {
873  for (unsigned int i=0; i<adjointCount; ++i) ((revreal*)(target))[i]=0.0;
874}
875
876AMPI_Activity ADTOOL_AMPI_isActiveType(MPI_Datatype datatype) {
877  if (datatype==AMPI_ADOUBLE || datatype==AMPI_AFLOAT) return AMPI_ACTIVE;
878  return AMPI_PASSIVE;
879};
880
881void ADTOOL_AMPI_setupTypes() {
882  MPI_Type_contiguous(1,MPI_DOUBLE,&AMPI_ADOUBLE);
883  MPI_Type_commit(&AMPI_ADOUBLE);
884  MPI_Type_contiguous(1,MPI_FLOAT,&AMPI_AFLOAT);
885  MPI_Type_commit(&AMPI_AFLOAT);
886};
887
888void ADTOOL_AMPI_cleanupTypes() {
889  if (AMPI_ADOUBLE!=MPI_DATATYPE_NULL) MPI_Type_free(&AMPI_ADOUBLE);
890  if (AMPI_AFLOAT !=MPI_DATATYPE_NULL) MPI_Type_free(&AMPI_AFLOAT);
891}
892
893MPI_Datatype ADTOOL_AMPI_FW_rawType(MPI_Datatype datatype) {
894  int dt_idx = derivedTypeIdx(datatype);
895  if (datatype==AMPI_ADOUBLE) return MPI_DOUBLE;
896  else if (datatype==AMPI_AFLOAT) return MPI_FLOAT;
897  else if (isDerivedType(dt_idx)) return getDTypeData()->packed_types[dt_idx];
898  else return datatype;
899}
900
901MPI_Datatype ADTOOL_AMPI_BW_rawType(MPI_Datatype datatype) {
902  int dt_idx = derivedTypeIdx(datatype);
903  if (datatype==AMPI_ADOUBLE) return MPI_DOUBLE;
904  else if (datatype==AMPI_AFLOAT) return MPI_FLOAT;
905  else if (isDerivedType(dt_idx)) return MPI_DOUBLE;
906  else return datatype;
907}
908
909// tracing
910
911int AMPI_Send(void* buf,
912              int count,
913              MPI_Datatype datatype,
914              int src,
915              int tag,
916              AMPI_PairedWith pairedWith,
917              MPI_Comm comm) {
918  return FW_AMPI_Send(buf,
919                      count,
920                      datatype,
921                      src,
922                      tag,
923                      pairedWith,
924                      comm);
925}
926
927int AMPI_Recv(void* buf,
928              int count,
929              MPI_Datatype datatype,
930              int src,
931              int tag,
932              AMPI_PairedWith pairedWith,
933              MPI_Comm comm,
934              MPI_Status* status) {
935  return FW_AMPI_Recv(buf,
936                      count,
937                      datatype,
938                      src,
939                      tag,
940                      pairedWith,
941                      comm,
942                      status);
943}
944
945int AMPI_Isend (void* buf,
946                int count,
947                MPI_Datatype datatype,
948                int dest,
949                int tag,
950                AMPI_PairedWith pairedWith,
951                MPI_Comm comm,
952                AMPI_Request* request) {
953  return FW_AMPI_Isend(buf,
954                       count,
955                       datatype,
956                       dest,
957                       tag,
958                       pairedWith,
959                       comm,
960                       request);
961}
962
963int AMPI_Irecv (void* buf,
964                int count,
965                MPI_Datatype datatype,
966                int src,
967                int tag,
968                AMPI_PairedWith pairedWith,
969                MPI_Comm comm,
970                AMPI_Request* request) {
971  return FW_AMPI_Irecv(buf,
972                       count,
973                       datatype,
974                       src,
975                       tag,
976                       pairedWith,
977                       comm,
978                       request);
979}
980
981int AMPI_Wait(AMPI_Request *request,
982              MPI_Status *status) {
983  return FW_AMPI_Wait(request,
984                      status);
985}
986
987int AMPI_Barrier(MPI_Comm comm) {
988  return FW_AMPI_Barrier(comm);
989}
990
991int AMPI_Gather(void *sendbuf,
992                int sendcnt,
993                MPI_Datatype sendtype,
994                void *recvbuf,
995                int recvcnt,
996                MPI_Datatype recvtype,
997                int root,
998                MPI_Comm comm) {
999  return FW_AMPI_Gather(sendbuf,
1000                        sendcnt,
1001                        sendtype,
1002                        recvbuf,
1003                        recvcnt,
1004                        recvtype,
1005                        root,
1006                        comm);
1007}
1008
1009int AMPI_Scatter(void *sendbuf,
1010                 int sendcnt,
1011                 MPI_Datatype sendtype,
1012                 void *recvbuf,
1013                 int recvcnt,
1014                 MPI_Datatype recvtype,
1015                 int root, MPI_Comm comm) {
1016  return FW_AMPI_Scatter(sendbuf,
1017                         sendcnt,
1018                         sendtype,
1019                         recvbuf,
1020                         recvcnt,
1021                         recvtype,
1022                         root,
1023                         comm);
1024}
1025
1026int AMPI_Allgather(void *sendbuf,
1027                   int sendcnt,
1028                   MPI_Datatype sendtype,
1029                   void *recvbuf,
1030                   int recvcnt,
1031                   MPI_Datatype recvtype,
1032                   MPI_Comm comm) {
1033  return FW_AMPI_Allgather(sendbuf,
1034                           sendcnt,
1035                           sendtype,
1036                           recvbuf,
1037                           recvcnt,
1038                           recvtype,
1039                           comm);
1040}
1041
1042int AMPI_Gatherv(void *sendbuf,
1043                 int sendcnt,
1044                 MPI_Datatype sendtype,
1045                 void *recvbuf,
1046                 int *recvcnts,
1047                 int *displs,
1048                 MPI_Datatype recvtype,
1049                 int root,
1050                 MPI_Comm comm) {
1051  return FW_AMPI_Gatherv(sendbuf,
1052                         sendcnt,
1053                         sendtype,
1054                         recvbuf,
1055                         recvcnts,
1056                         displs,
1057                         recvtype,
1058                         root,
1059                         comm);
1060}
1061
1062int AMPI_Scatterv(void *sendbuf,
1063                  int *sendcnts,
1064                  int *displs,
1065                  MPI_Datatype sendtype,
1066                  void *recvbuf,
1067                  int recvcnt,
1068                  MPI_Datatype recvtype,
1069                  int root, MPI_Comm comm) {
1070  return FW_AMPI_Scatterv(sendbuf,
1071                          sendcnts,
1072                          displs,
1073                          sendtype,
1074                          recvbuf,
1075                          recvcnt,
1076                          recvtype,
1077                          root,
1078                          comm);
1079}
1080
1081int AMPI_Allgatherv(void *sendbuf,
1082                    int sendcnt,
1083                    MPI_Datatype sendtype,
1084                    void *recvbuf,
1085                    int *recvcnts,
1086                    int *displs,
1087                    MPI_Datatype recvtype,
1088                    MPI_Comm comm) {
1089  return FW_AMPI_Allgatherv(sendbuf,
1090                           sendcnt,
1091                           sendtype,
1092                           recvbuf,
1093                           recvcnts,
1094                           displs,
1095                           recvtype,
1096                           comm);
1097}
1098
1099int AMPI_Bcast(void* buf,
1100               int count,
1101               MPI_Datatype datatype,
1102               int root,
1103               MPI_Comm comm) {
1104  return FW_AMPI_Bcast(buf,
1105                       count,
1106                       datatype,
1107                       root,
1108                       comm);
1109}
1110
1111int AMPI_Reduce(void* sbuf,
1112                void* rbuf,
1113                int count,
1114                MPI_Datatype datatype,
1115                MPI_Op op,
1116                int root,
1117                MPI_Comm comm) {
1118  return FWB_AMPI_Reduce(sbuf,
1119                        rbuf,
1120                        count,
1121                        datatype,
1122                        op,
1123                        root,
1124                        comm);
1125}
1126
1127int AMPI_Allreduce(void* sbuf,
1128                   void* rbuf,
1129                   int count,
1130                   MPI_Datatype datatype,
1131                   MPI_Op op,
1132                   MPI_Comm comm) {
1133  return FW_AMPI_Allreduce(sbuf,
1134                           rbuf,
1135                           count,
1136                           datatype,
1137                           op,
1138                           comm);
1139}
1140
1141#endif
Note: See TracBrowser for help on using the repository browser.