Add a flag to provide timer for the case of no objs in Meta-Balancer
[charm.git] / src / libs / ck-libs / ampi / ampif.C
1 #include "ampi.h"
2 #include "ampiimpl.h"
3
4 FDECL {
5 #define mpi_send FTN_NAME( MPI_SEND , mpi_send )
6 #define mpi_recv FTN_NAME( MPI_RECV , mpi_recv )
7 #define mpi_get_count FTN_NAME( MPI_GET_COUNT , mpi_get_count )
8 #define mpi_isend FTN_NAME( MPI_ISEND , mpi_isend )
9 #define mpi_bsend FTN_NAME( MPI_BSEND , mpi_bsend )
10 #define mpi_rsend FTN_NAME( MPI_RSEND , mpi_rsend )
11 #define mpi_ssend FTN_NAME( MPI_SSEND , mpi_ssend )
12 #define mpi_issend FTN_NAME( MPI_ISSEND , mpi_issend )
13 #define mpi_irecv FTN_NAME( MPI_IRECV , mpi_irecv )
14 #define mpi_wait FTN_NAME( MPI_WAIT , mpi_wait )
15 #define mpi_test FTN_NAME( MPI_TEST , mpi_test )
16 #define mpi_waitany FTN_NAME( MPI_WAITANY , mpi_waitany )
17 #define mpi_testany FTN_NAME( MPI_TESTANY , mpi_testany )
18 #define mpi_waitall FTN_NAME( MPI_WAITALL , mpi_waitall )
19 #define mpi_testall FTN_NAME( MPI_TESTALL , mpi_testall )
20 #define mpi_waitsome FTN_NAME( MPI_WAITSOME , mpi_waitsome )
21 #define mpi_testsome FTN_NAME( MPI_TESTSOME , mpi_testsome )
22 #define mpi_request_free FTN_NAME(MPI_REQUEST_FREE , mpi_request_free)
23 #define mpi_cancel FTN_NAME(MPI_CANCEL, mpi_cancel)
24 #define mpi_iprobe FTN_NAME( MPI_IPROBE , mpi_iprobe )
25 #define mpi_probe FTN_NAME( MPI_PROBE , mpi_probe )
26 #define mpi_send_init FTN_NAME( MPI_SEND_INIT , mpi_send_init )
27 #define mpi_recv_init FTN_NAME( MPI_RECV_INIT , mpi_recv_init )
28 #define mpi_start FTN_NAME( MPI_START , mpi_start )
29 #define mpi_startall FTN_NAME( MPI_STARTALL , mpi_startall )
30 #define mpi_sendrecv FTN_NAME( MPI_SENDRECV , mpi_sendrecv )
31 #define mpi_sendrecv_replace FTN_NAME( MPI_SENDRECV_REPLACE , mpi_sendrecv_replace )
32 #define mpi_type_contiguous FTN_NAME( MPI_TYPE_CONTIGUOUS , mpi_type_contiguous )
33 #define mpi_type_vector FTN_NAME( MPI_TYPE_VECTOR , mpi_type_vector )
34 #define mpi_type_hvector FTN_NAME( MPI_TYPE_HVECTOR , mpi_type_hvector )
35 #define mpi_type_indexed FTN_NAME( MPI_TYPE_INDEXED , mpi_type_indexed )
36 #define mpi_type_hindexed FTN_NAME( MPI_TYPE_HINDEXED , mpi_type_hindexed )
37 #define mpi_type_struct FTN_NAME( MPI_TYPE_STRUCT , mpi_type_struct )
38 #define mpi_type_commit FTN_NAME( MPI_TYPE_COMMIT , mpi_type_commit )
39 #define mpi_type_free FTN_NAME( MPI_TYPE_FREE , mpi_type_free )
40 #define mpi_type_extent FTN_NAME( MPI_TYPE_EXTENT , mpi_type_extent )
41 #define mpi_type_size FTN_NAME( MPI_TYPE_SIZE , mpi_type_size )
42 #define mpi_type_lb FTN_NAME( MPI_TYPE_LB , mpi_type_lb )
43 #define mpi_type_ub FTN_NAME( MPI_TYPE_UB , mpi_type_ub )
44 #define mpi_address FTN_NAME( MPI_ADDRESS , mpi_address )
45 #define mpi_get_elements FTN_NAME( MPI_GET_ELEMENTS , mpi_get_elements )
46 #define mpi_pack FTN_NAME( MPI_PACK , mpi_pack )
47 #define mpi_unpack FTN_NAME( MPI_UNPACK , mpi_unpack )
48 #define mpi_pack_size FTN_NAME( MPI_PACK_SIZE , mpi_pack_size )
49
50 #define mpi_barrier FTN_NAME( MPI_BARRIER , mpi_barrier )
51 #define mpi_bcast FTN_NAME( MPI_BCAST , mpi_bcast )
52 #define mpi_gather FTN_NAME( MPI_GATHER , mpi_gather )
53 #define mpi_gatherv FTN_NAME( MPI_GATHERV , mpi_gatherv )
54 #define mpi_scatter FTN_NAME( MPI_SCATTER , mpi_scatter )
55 #define mpi_scatterv FTN_NAME( MPI_SCATTERV , mpi_scatterv )
56 #define mpi_allgather FTN_NAME( MPI_ALLGATHER , mpi_allgather )
57 #define mpi_iallgather FTN_NAME( MPI_IALLGATHER , mpi_iallgather )
58 #define mpi_allgatherv FTN_NAME( MPI_ALLGATHERV , mpi_allgatherv )
59 #define mpi_alltoall FTN_NAME( MPI_ALLTOALL , mpi_alltoall )
60 #define mpi_ialltoall FTN_NAME( MPI_IALLTOALL , mpi_ialltoall )
61 #define mpi_alltoallv FTN_NAME( MPI_ALLTOALLV , mpi_alltoallv )
62 #define mpi_reduce FTN_NAME( MPI_REDUCE , mpi_reduce )
63 #define mpi_ireduce FTN_NAME( MPI_IREDUCE , mpi_ireduce )
64 #define mpi_allreduce FTN_NAME( MPI_ALLREDUCE , mpi_allreduce )
65 #define mpi_iallreduce FTN_NAME( MPI_IALLREDUCE , mpi_iallreduce )
66 #define mpi_reduce_scatter FTN_NAME( MPI_REDUCE_SCATTER , mpi_reduce_scatter )
67 #define mpi_scan FTN_NAME( MPI_SCAN , mpi_scan )
68 #define mpi_op_create FTN_NAME( MPI_OP_CREATE , mpi_op_create )
69 #define mpi_op_free FTN_NAME( MPI_OP_FREE , mpi_op_free )
70
71 #define mpi_group_size FTN_NAME( MPI_GROUP_SIZE, mpi_group_size)
72 #define mpi_group_rank FTN_NAME( MPI_GROUP_RANK, mpi_group_rank)
73 #define mpi_group_translate_ranks FTN_NAME(MPI_GROUP_TRANSLATE_RANKS, mpi_group_translate_ranks)
74 #define mpi_group_compare FTN_NAME(MPI_GROUP_COMPARE, mpi_group_compare)
75
76 #define mpi_comm_group FTN_NAME( MPI_COMM_GROUP, mpi_comm_group)
77 #define mpi_group_union FTN_NAME(MPI_GROUP_UNION, mpi_group_union)
78 #define mpi_group_intersection FTN_NAME(MPI_GROUP_INTERSECTION, mpi_group_intersection)
79 #define mpi_group_difference FTN_NAME(MPI_GROUP_DIFFERENCE, mpi_group_difference)
80 #define mpi_group_incl FTN_NAME(MPI_GROUP_INCL, mpi_group_incl)
81 #define mpi_group_excl FTN_NAME(MPI_GROUP_EXCL, mpi_group_excl)
82 #define mpi_group_range_incl FTN_NAME(MPI_GROUP_RANGE_INCL, mpi_group_range_incl)
83 #define mpi_group_range_excl FTN_NAME(MPI_GROUP_RANGE_EXCL, mpi_group_range_excl)
84 #define mpi_group_free FTN_NAME(MPI_GROUP_FREE, mpi_group_free)
85 #define mpi_comm_create FTN_NAME(MPI_COMM_CREATE, mpi_comm_create)
86
87 #define mpi_comm_rank FTN_NAME( MPI_COMM_RANK , mpi_comm_rank )
88 #define mpi_comm_size FTN_NAME( MPI_COMM_SIZE , mpi_comm_size )
89 #define mpi_comm_dup FTN_NAME( MPI_COMM_DUP , mpi_comm_dup )
90 #define mpi_comm_split FTN_NAME( MPI_COMM_SPLIT , mpi_comm_split )
91 #define mpi_comm_free FTN_NAME( MPI_COMM_FREE , mpi_comm_free )
92 #define mpi_comm_test_inter FTN_NAME( MPI_COMM_TEST_INTER , mpi_comm_test_inter )
93 #define mpi_comm_remote_size FTN_NAME ( MPI_COMM_REMOTE_SIZE , mpi_comm_remote_size )
94 #define mpi_comm_remote_group FTN_NAME ( MPI_COMM_REMOTE_GROUP , mpi_comm_remote_group )
95 #define mpi_intercomm_create FTN_NAME ( MPI_INTERCOMM_CREATE , mpi_intercomm_create )
96 #define mpi_intercomm_merge FTN_NAME ( MPI_INTERCOMM_MERGE , mpi_intercomm_merge )
97 #define mpi_keyval_create FTN_NAME ( MPI_KEYVAL_CREATE , mpi_keyval_create )
98 #define mpi_keyval_free FTN_NAME ( MPI_KEYVAL_FREE , mpi_keyval_free )
99 #define mpi_attr_put FTN_NAME ( MPI_ATTR_PUT , mpi_attr_put )
100 #define mpi_attr_get FTN_NAME ( MPI_ATTR_GET , mpi_attr_get )
101 #define mpi_attr_delete FTN_NAME ( MPI_ATTR_DELETE , mpi_attr_delete )
102
103 #define mpi_cart_create FTN_NAME ( MPI_CART_CREATE , mpi_cart_create )
104 #define mpi_graph_create FTN_NAME ( MPI_GRAPH_CREATE , mpi_graph_create )
105 #define mpi_topo_test FTN_NAME ( MPI_TOPO_TEST , mpi_topo_test )
106 #define mpi_cart_map FTN_NAME ( MPI_CART_MAP , mpi_cart_map )
107 #define mpi_graph_map FTN_NAME ( MPI_GRAPH_MAP , mpi_graph_map )
108 #define mpi_cartdim_get FTN_NAME ( MPI_CARTDIM_GET , mpi_cartdim_get )
109 #define mpi_cart_get FTN_NAME ( MPI_CART_GET , mpi_cart_get )
110 #define mpi_cart_rank FTN_NAME ( MPI_CART_RANK , mpi_cart_rank )
111 #define mpi_cart_coords FTN_NAME ( MPI_CART_COORDS , mpi_cart_coords )
112 #define mpi_cart_shift FTN_NAME ( MPI_CART_SHIFT , mpi_cart_shift )
113 #define mpi_graphdims_get FTN_NAME ( MPI_GRAPHDIMS_GET , mpi_graphdims_get )
114 #define mpi_graph_get FTN_NAME ( MPI_GRAPH_GET , mpi_graph_get )
115 #define mpi_graph_neighbors_count FTN_NAME ( MPI_GRAPH_NEIGHBORS_COUNT , mpi_graph_neighbors_count )
116 #define mpi_graph_neighbors FTN_NAME ( MPI_GRAPH_NEIGHBORS , mpi_graph_neighbors )
117 #define mpi_dims_create FTN_NAME ( MPI_DIMS_CREATE , mpi_dims_create )
118 #define mpi_cart_sub FTN_NAME ( MPI_CART_SUB , mpi_cart_sub )
119
120 #define mpi_get_processor_name FTN_NAME ( MPI_GET_PROCESSOR_NAME , mpi_get_processor_name )
121 #define mpi_errhandler_create FTN_NAME( MPI_ERRHANDLER_CREATE , mpi_errhandler_create )
122 #define mpi_errhandler_set FTN_NAME( MPI_ERRHANDLER_SET , mpi_errhandler_set )
123 #define mpi_errhandler_get FTN_NAME( MPI_ERRHANDLER_GET , mpi_errhandler_get )
124 #define mpi_errhandler_free FTN_NAME( MPI_ERRHANDLER_FREE , mpi_errhandler_free )
125 #define mpi_error_string FTN_NAME( MPI_ERROR_STRING , mpi_error_string )
126 #define mpi_error_class FTN_NAME( MPI_ERROR_CLASS , mpi_error_class )
127 #define mpi_wtime FTN_NAME( MPI_WTIME , mpi_wtime )
128 #define mpi_wtick FTN_NAME( MPI_WTICK , mpi_wtick )
129 #define mpi_init FTN_NAME( MPI_INIT , mpi_init )
130 #define mpi_initialized FTN_NAME( MPI_INITIALIZED , mpi_initialized )
131 #define mpi_init_universe FTN_NAME( MPI_INIT_UNIVERSE , mpi_init_universe )
132 #define mpi_finalize FTN_NAME( MPI_FINALIZE , mpi_finalize )
133 #define mpi_finalized FTN_NAME( MPI_FINALIZED , mpi_finalized )
134 #define mpi_abort FTN_NAME( MPI_ABORT , mpi_abort )
135
136 #define mpi_yield FTN_NAME ( MPI_YIELD , mpi_yield )
137 #define mpi_resume FTN_NAME ( MPI_RESUME, mpi_resume )
138 #define mpi_print FTN_NAME( MPI_PRINT , mpi_print )
139 #define mpi_Start_measure FTN_NAME( MPI_START_MEASURE, mpi_start_measure)
140 #define mpi_Stop_measure FTN_NAME( MPI_STOP_MEASURE, mpi_stop_measure)
141 #define mpi_set_load FTN_NAME( MPI_SET_LOAD, mpi_set_load)
142 #define mpi_register FTN_NAME( MPI_REGISTER , mpi_register )
143 #define mpi_migrate FTN_NAME( MPI_MIGRATE , mpi_migrate )
144 #define mpi_migrateto FTN_NAME( MPI_MIGRATETO , mpi_migrateto )
145 #define mpi_async_migrate FTN_NAME( MPI_ASYNC_MIGRATE , mpi_async_migrate )
146 #define mpi_allow_migrate FTN_NAME( MPI_ALLOW_MIGRATE , mpi_allow_migrate )
147 #define mpi_setmigratable FTN_NAME (MPI_SETMIGRATABLE , mpi_setmigratable )
148 #define mpi_checkpoint FTN_NAME( MPI_CHECKPOINT , mpi_checkpoint )
149 #define mpi_memcheckpoint FTN_NAME( MPI_MEMCHECKPOINT , mpi_memcheckpoint )
150
151 /* MPI-2 */
152 #define mpi_type_get_envelope FTN_NAME ( MPI_TYPE_GET_ENVELOPE , mpi_type_get_envelope )
153 #define mpi_type_get_contents FTN_NAME ( MPI_TYPE_GET_CONTENTS , mpi_type_get_contents )
154
155 #define mpi_win_create FTN_NAME ( MPI_WIN_CREATE , mpi_win_create )
156 #define mpi_win_free  FTN_NAME ( MPI_WIN_FREE  , mpi_win_free )
157 #define mpi_win_delete_attr  FTN_NAME ( MPI_WIN_DELETE_ATTR  , mpi_win_delete_attr )
158 #define mpi_win_get_group  FTN_NAME ( MPI_WIN_GET_GROUP  , mpi_win_get_group )
159 #define mpi_win_set_name  FTN_NAME ( MPI_WIN_SET_NAME  , mpi_win_set_name )
160 #define mpi_win_get_name  FTN_NAME ( MPI_WIN_GET_NAME  , mpi_win_get_name )
161 #define mpi_win_fence  FTN_NAME ( MPI_WIN_FENCE  , mpi_win_fence )
162 #define mpi_win_lock  FTN_NAME ( MPI_WIN_LOCK  , mpi_win_lock )
163 #define mpi_win_unlock  FTN_NAME ( MPI_WIN_UNLOCK  , mpi_win_unlock )
164 #define mpi_win_post  FTN_NAME ( MPI_WIN_POST  , mpi_win_post )
165 #define mpi_win_wait  FTN_NAME ( MPI_WIN_WAIT  , mpi_win_wait )
166 #define mpi_win_start  FTN_NAME ( MPI_WIN_START  , mpi_win_start )
167 #define mpi_win_complete  FTN_NAME ( MPI_WIN_COMPLETE  , mpi_win_complete )
168 #define mpi_alloc_mem  FTN_NAME ( MPI_ALLOC_MEM  , mpi_alloc_mem )
169 #define mpi_free_mem  FTN_NAME ( MPI_FREE_MEM  , mpi_free_mem )
170 #define mpi_put  FTN_NAME ( MPI_PUT  , mpi_put )
171 #define mpi_get  FTN_NAME ( MPI_GET  , mpi_get )
172 #define mpi_accumulate  FTN_NAME ( MPI_ACCUMULATE  , mpi_accumulate )
173
174 #define mpi_info_create FTN_NAME ( MPI_INFO_CREATE , mpi_info_create )
175 #define mpi_info_set FTN_NAME ( MPI_INFO_SET , mpi_info_set )
176 #define mpi_info_delete FTN_NAME ( MPI_INFO_DELETE , mpi_info_delete )
177 #define mpi_info_get FTN_NAME ( MPI_INFO_GET , mpi_info_get )
178 #define mpi_info_get_valuelen FTN_NAME ( MPI_INFO_GET_VALUELEN , mpi_info_get_valuelen )
179 #define mpi_info_get_nkeys FTN_NAME ( MPI_INFO_GET_NKEYS , mpi_info_get_nkeys )
180 #define mpi_info_get_nthkey FTN_NAME ( MPI_INFO_GET_NTHKEYS , mpi_info_get_nthkey )
181 #define mpi_info_dup FTN_NAME ( MPI_INFO_DUP , mpi_info_dup )
182 #define mpi_info_free FTN_NAME ( MPI_INFO_FREE , mpi_info_free )
183
184 #define REDUCERF(caps, nocaps) \
185 void FTN_NAME(caps, nocaps)(void *iv, void *iov, int *len, MPI_Datatype *dt){ \
186   caps(iv, iov, len, dt); \
187 }
188
189 #define mpi_info_maxmemory FTN_NAME (MPI_INFO_MAXMEMORY, mpi_info_maxmemory)
190 #define mpi_info_memory FTN_NAME (MPI_INFO_MEMORY, mpi_info_memory)    
191
192 #if !CMK_FORTRAN_USES_ALLCAPS
193 REDUCERF(MPI_MAX    , mpi_max)
194 REDUCERF(MPI_MIN    , mpi_min)
195 REDUCERF(MPI_SUM    , mpi_sum)
196 REDUCERF(MPI_PROD   , mpi_prod)
197 REDUCERF(MPI_LAND   , mpi_land)
198 REDUCERF(MPI_BAND   , mpi_band)
199 REDUCERF(MPI_LOR    , mpi_lor)
200 REDUCERF(MPI_BOR    , mpi_bor)
201 REDUCERF(MPI_LXOR   , mpi_lxor)
202 REDUCERF(MPI_BXOR   , mpi_bxor)
203 REDUCERF(MPI_MAXLOC , mpi_maxloc)
204 REDUCERF(MPI_MINLOC , mpi_minloc)
205 #endif
206
207 typedef MPI_Op  MPI_Op_Array[128];
208 CtvExtern(MPI_Op_Array, mpi_ops);
209 CtvExtern(int, mpi_opc);
210
211 // must be consistent with mpif.h
212 #define MPI_OP_FIRST   100
213
214 //#define GET_MPI_OP(idx)      (CmiAssert(idx - MPI_OP_FIRST >= 0 && idx - MPI_OP_FIRST < CtvAccess(mpi_opc)), CtvAccess(mpi_ops)[idx - MPI_OP_FIRST])
215 inline MPI_Op & GET_MPI_OP(int idx)      { MPI_Op *tab=CtvAccess(mpi_ops); return tab[idx - MPI_OP_FIRST]; }
216
217 void mpi_init_universe(int *unicomm)
218 {
219   AMPIAPI("mpi_init_universe");
220   for(int i=0;i<_mpi_nworlds; i++)
221   {
222     unicomm[i] = MPI_COMM_UNIVERSE[i];
223   }
224 }
225
226 void mpi_init(int *ierr){
227   *ierr = AMPI_Init(NULL,NULL);
228 }
229
230 void mpi_initialized(int *isInit, int* ierr)
231 {
232   *ierr = AMPI_Initialized(isInit);
233 }
234
235 void mpi_finalized(int *isFinalized, int* ierr)
236 {
237   *ierr = AMPI_Finalized(isFinalized);
238 }
239
240 void mpi_comm_rank(int *comm, int *rank, int *ierr)
241 {
242   *ierr = AMPI_Comm_rank(*comm, rank);
243 }
244
245 void mpi_comm_size(int *comm, int *size, int *ierr)
246 {
247   *ierr = AMPI_Comm_size(*comm, size);
248 }
249
250 void mpi_finalize(int *ierr)
251 {
252   *ierr = AMPI_Finalize();
253 }
254
255 void mpi_send(void *msg, int *count, int *type, int *dest,
256   int *tag, int *comm, int *ierr)
257 {
258   *ierr = AMPI_Send(msg, *count, *type, *dest, *tag, *comm);
259 }
260
261 void mpi_recv(void *msg, int *count, int *type, int *src,
262   int *tag, int *comm, int *status, int *ierr)
263 {
264   *ierr = AMPI_Recv(msg, *count, *type, *src, *tag, *comm,
265                     (MPI_Status*) status);
266 }
267
268 void mpi_bsend(void *msg, int *count, int *type, int *dest,
269   int *tag, int *comm, int *ierr)
270 {
271   *ierr = AMPI_Bsend(msg, *count, *type, *dest, *tag, *comm);
272 }
273
274 void mpi_rsend(void *msg, int *count, int *type, int *dest,
275   int *tag, int *comm, int *ierr)
276 {
277   *ierr = AMPI_Rsend(msg, *count, *type, *dest, *tag, *comm);
278 }
279
280 void mpi_ssend(void *msg, int *count, int *type, int *dest,
281   int *tag, int *comm, int *ierr)
282 {
283   *ierr = AMPI_Ssend(msg, *count, *type, *dest, *tag, *comm);
284 }
285
286 void mpi_issend(void *buf, int *count, int *datatype, int *dest,
287    int *tag, int *comm, int *request, int *ierr)
288 {
289   *ierr = AMPI_Issend(buf, *count, *datatype, *dest, *tag, *comm, (MPI_Request *)request);
290 }
291
292 void mpi_probe(int *src, int *tag, int *comm, int *status, int *ierr)
293 {
294   *ierr = AMPI_Probe(*src, *tag, *comm, (MPI_Status*) status);
295 }
296
297 void mpi_iprobe(int *src,int *tag,int *comm,int *flag,int *status,int *ierr)
298 {
299   *ierr = AMPI_Iprobe(*src, *tag, *comm, flag, (MPI_Status*) status);
300 }
301
302 void mpi_sendrecv(void *sndbuf, int *sndcount, int *sndtype,
303   int *dest, int *sndtag, void *rcvbuf,
304   int *rcvcount, int *rcvtype, int *src,
305   int *rcvtag, int *comm, int *status, int *ierr)
306 {
307   *ierr = AMPI_Sendrecv(sndbuf, *sndcount, *sndtype, *dest, *sndtag,
308                         rcvbuf, *rcvcount, *rcvtype, *src, *rcvtag,
309                         *comm, (MPI_Status*) status);
310 }
311
312 void mpi_sendrecv_replace(void *buf, int* count, int* datatype,
313                           int* dest, int* sendtag, int* source, int* recvtag,
314                           int* comm, int* status, int *ierr)
315 {
316   *ierr = AMPI_Sendrecv_replace(buf, *count, *datatype, *dest, *sendtag,
317                                *source, *recvtag, *comm, (MPI_Status*) status);
318 }
319
320 void mpi_barrier(int *comm, int *ierr)
321 {
322   *ierr = AMPI_Barrier(*comm);
323 }
324
325 void mpi_bcast(void *buf, int *count, int *type, int *root, int *comm, 
326    int *ierr)
327 {
328   *ierr = AMPI_Bcast(buf, *count, *type, *root, *comm);
329 }
330
331 void mpi_reduce(void *inbuf, void *outbuf, int *count, int *type,
332    int *opc, int *root, int *comm, int *ierr)
333 {
334   MPI_Op op = GET_MPI_OP(*opc);
335   if (inbuf == NULL) inbuf = MPI_IN_PLACE;
336   if (outbuf == NULL) outbuf = MPI_IN_PLACE;
337   *ierr = AMPI_Reduce(inbuf, outbuf, *count, *type, op, *root, *comm);
338 }
339
340 void mpi_allreduce(void *inbuf,void *outbuf,int *count,int *type,
341    int *opc, int *comm, int *ierr)
342 {
343   MPI_Op op = GET_MPI_OP(*opc);
344   if (inbuf == NULL) inbuf = MPI_IN_PLACE;
345   if (outbuf == NULL) outbuf = MPI_IN_PLACE;
346   *ierr = AMPI_Allreduce(inbuf, outbuf, *count, *type, op, *comm);
347 }
348
349 double mpi_wtime(void)
350 {
351   return AMPI_Wtime();
352 }
353
354 double mpi_wtick(void)
355 {
356   return AMPI_Wtick();
357 }
358
359 void mpi_start(int *reqnum, int *ierr)
360 {
361   *ierr = AMPI_Start((MPI_Request*) reqnum);
362 }
363
364 void mpi_startall(int *count, int *reqnum, int *ierr)
365 {
366   *ierr = AMPI_Startall(*count, (MPI_Request*) reqnum);
367 }
368
369 void mpi_waitall(int *count, int *request, int *status, int *ierr)
370 {
371   *ierr = AMPI_Waitall(*count, (MPI_Request*) request, (MPI_Status*) status);
372 }
373
374 void mpi_waitany(int *count, int *request, int *index, int *status, int *ierr)
375 {
376   *ierr = AMPI_Waitany(*count, (MPI_Request*) request, index,
377                        (MPI_Status*) status);
378 }
379
380 void mpi_wait(int *request, int *status, int *ierr)
381 {
382   *ierr = AMPI_Wait((MPI_Request*) request, (MPI_Status*) status);
383 }
384
385 void mpi_testall(int *count, int *request, int *flag, int *status, int *ierr)
386 {
387   *ierr = AMPI_Testall(*count, (MPI_Request*) request, flag,
388       (MPI_Status*) status);
389 }
390
391 void mpi_waitsome(int *incount, int *array_of_requests, int *outcount, int *array_of_indices, int *array_of_statuses, int *ierr)
392 {
393   *ierr = AMPI_Waitsome(*incount, (MPI_Request *)array_of_requests, outcount, array_of_indices, (MPI_Status*) array_of_statuses);
394 }
395
396 void mpi_testsome(int *incount, int *array_of_requests, int *outcount, int *array_of_indices, int *array_of_statuses, int *ierr)
397 {
398   *ierr = AMPI_Testsome(*incount, (MPI_Request *)array_of_requests, outcount, array_of_indices, (MPI_Status*) array_of_statuses);
399 }
400
401 void mpi_testany(int *count, int *request, int *index, int *flag, int *status, int *ierr)
402 {
403   *ierr = AMPI_Testany(*count, (MPI_Request*) request, index, flag,
404       (MPI_Status*) status);
405 }
406
407 void mpi_test(int *request, int *flag, int *status, int *ierr)
408 {
409   *ierr = AMPI_Test((MPI_Request*) request, flag, (MPI_Status*) status);
410 }
411
412 void mpi_request_free(int *request, int *ierr)
413 {
414   *ierr = AMPI_Request_free((MPI_Request *)request);
415 }
416
417 void mpi_cancel(int *request, int *ierr)
418 {
419   *ierr = AMPI_Cancel((MPI_Request *)request);
420 }
421
422 void mpi_recv_init(void *buf, int *count, int *type, int *srcpe,
423    int *tag, int *comm, int *req, int *ierr)
424 {
425   *ierr = AMPI_Recv_init(buf,*count,*type,*srcpe,*tag,*comm,(MPI_Request*)req);
426 }
427
428 void mpi_send_init(void *buf, int *count, int *type, int *destpe,
429    int *tag, int *comm, int *req, int *ierr)
430 {
431   *ierr = AMPI_Send_init(buf,*count,*type,*destpe,*tag,*comm,
432                          (MPI_Request*)req);
433 }
434
435 void mpi_type_contiguous(int *count, int *oldtype, int *newtype, int *ierr)
436 {
437   *ierr = AMPI_Type_contiguous(*count, *oldtype, newtype);
438 }
439
440 void mpi_type_vector(int *count, int *blocklength, int *stride,
441    int *oldtype, int*  newtype, int *ierr)
442 {
443   *ierr = AMPI_Type_vector(*count, *blocklength, *stride, *oldtype, newtype);
444 }
445
446 void mpi_type_hvector(int *count, int *blocklength, int *stride,
447    int* oldtype, int* newtype, int* ierr)
448 {
449   *ierr = AMPI_Type_hvector(*count, *blocklength, *stride, *oldtype, newtype);
450 }
451
452 void mpi_type_indexed(int *count, int* arrBlength, int* arrDisp,
453    int* oldtype, int*  newtype, int* ierr)
454 {
455   *ierr = AMPI_Type_indexed(*count, arrBlength, arrDisp, *oldtype, newtype);
456 }
457
458 void mpi_type_hindexed(int* count, int* arrBlength, int* arrDisp,
459    int* oldtype, int* newtype, int* ierr)
460 {
461   *ierr = AMPI_Type_hindexed(*count, arrBlength, arrDisp, *oldtype, newtype);
462 }
463
464 void mpi_type_struct(int* count, int* arrBlength, int* arrDisp,
465    int* oldtype, int* newtype, int* ierr)
466 {
467   *ierr = AMPI_Type_struct(*count, arrBlength, arrDisp, oldtype, newtype);
468 }
469
470
471 void mpi_type_commit(int *type, int *ierr)
472 {
473   *ierr = AMPI_Type_commit(type);
474 }
475
476 void mpi_type_free(int *type, int *ierr)
477 {
478   *ierr = AMPI_Type_free(type);
479 }
480
481 void  mpi_type_extent(int* type, int* extent, int* ierr)
482 {
483   *ierr = AMPI_Type_extent(*type, extent);
484 }
485
486 void  mpi_type_size(int* type, int* size, int* ierr)
487 {
488   *ierr = AMPI_Type_size(*type, size);
489 }
490
491 void mpi_type_lb(int* datatype, int* displacement, int* ierr)
492 {
493   *ierr = AMPI_Type_lb(*datatype, displacement);
494 }
495
496 void mpi_type_ub(int* datatype, int* displacement, int* ierr)
497 {
498   *ierr = AMPI_Type_ub(*datatype, displacement);
499 }
500
501 void mpi_address(int* location, int *address, int* ierr)
502 {
503   *ierr = AMPI_Address(location, address);
504 }
505
506 void mpi_get_elements(int *status, int* datatype, int *count, int* ierr)
507 {
508   *ierr = AMPI_Get_elements((MPI_Status*) status, *datatype, count);
509 }
510
511 void mpi_pack(void *inbuf, int *incount, int *datatype, void *outbuf,
512     int *outsize, int *position, int *comm, int *ierr)
513 {
514   *ierr = AMPI_Pack(inbuf, *incount, (MPI_Datatype)*datatype, outbuf,
515       *outsize, position, *comm);
516 }
517
518 void mpi_unpack(void *inbuf, int *insize, int *position, void *outbuf,
519     int *outcount, int *datatype, int *comm, int *ierr)
520 {
521   *ierr = AMPI_Unpack(inbuf, *insize, position, outbuf, *outcount,
522       (MPI_Datatype) *datatype, (MPI_Comm) *comm);
523 }
524
525 void mpi_pack_size(int *incount, int *datatype, int *comm, int *size, int *ierr)
526 {
527   *ierr = AMPI_Pack_size(*incount, (MPI_Datatype) *datatype, *comm, size);
528 }
529
530 void mpi_isend(void *buf, int *count, int *datatype, int *dest,
531    int *tag, int *comm, int *request, int *ierr)
532 {
533   *ierr = AMPI_Isend(buf, *count, *datatype, *dest, *tag, *comm, (MPI_Request *)request);
534 }
535
536 void mpi_irecv(void *buf, int *count, int *datatype, int *src,
537    int *tag, int *comm, int *request, int *ierr)
538 {
539   *ierr = AMPI_Irecv(buf, *count, *datatype, *src, *tag, *comm, (MPI_Request *)request);
540 }
541
542 void mpi_allgatherv(void *sendbuf, int *sendcount, int *sendtype,
543    void *recvbuf, int *recvcounts, int *displs,
544    int *recvtype, int *comm, int *ierr)
545 {
546   *ierr = AMPI_Allgatherv(sendbuf, *sendcount, *sendtype, recvbuf, recvcounts,
547                           displs, *recvtype, *comm);
548 }
549
550 void mpi_allgather(void *sendbuf, int *sendcount, int *sendtype,
551    void *recvbuf, int *recvcount, int *recvtype,
552    int *comm, int *ierr)
553 {
554   *ierr = AMPI_Allgather(sendbuf, *sendcount, *sendtype, recvbuf, *recvcount,
555                          *recvtype, *comm);
556 }
557
558 void mpi_gatherv(void *sendbuf, int *sendcount, int *sendtype,
559    void *recvbuf, int *recvcounts, int *displs,
560    int *recvtype, int *root, int *comm, int *ierr)
561 {
562   *ierr = AMPI_Gatherv(sendbuf, *sendcount, *sendtype, recvbuf, recvcounts,
563                        displs, *recvtype, *root, *comm);
564 }
565
566 void mpi_gather(void *sendbuf, int *sendcount, int *sendtype,
567    void *recvbuf, int *recvcount, int *recvtype,
568    int *root, int *comm, int *ierr)
569 {
570   *ierr = AMPI_Gather(sendbuf, *sendcount, *sendtype, recvbuf, *recvcount,
571                       *recvtype, *root, *comm);
572 }
573
574 void mpi_scatterv(void *sendbuf, int *sendcounts, int *displs, int *sendtype,
575    void *recvbuf, int *recvcount, int *recvtype, int *root, int *comm, int *ierr)
576 {
577   *ierr = AMPI_Scatterv(sendbuf, sendcounts, displs, *sendtype, recvbuf, *recvcount,
578                        *recvtype, *root, *comm);
579 }
580
581 void mpi_scatter(void *sendbuf, int *sendcount, int *sendtype,
582    void *recvbuf, int *recvcount, int *recvtype,
583    int *root, int *comm, int *ierr)
584 {
585   *ierr = AMPI_Scatter(sendbuf, *sendcount, *sendtype, recvbuf, *recvcount,
586                       *recvtype, *root, *comm);
587 }
588
589 void mpi_alltoallv(void *sendbuf, int *sendcounts, int *sdispls,
590    int *sendtype, void *recvbuf, int *recvcounts,
591    int *rdispls, int *recvtype, int *comm, int *ierr)
592 {
593   *ierr = AMPI_Alltoallv(sendbuf, sendcounts, sdispls, *sendtype, recvbuf,
594                          recvcounts, rdispls, *recvtype, *comm);
595 }
596
597 void mpi_alltoall(void *sendbuf, int *sendcount, int *sendtype,
598    void *recvbuf, int *recvcount, int *recvtype,
599    int *comm, int *ierr)
600 {
601   *ierr = AMPI_Alltoall(sendbuf, *sendcount, *sendtype, recvbuf, *recvcount,
602                        *recvtype, *comm);
603 }
604
605 void mpi_iallgather(void *sendbuf, int* sendcount, int* sendtype,
606                     void *recvbuf, int* recvcount, int* recvtype,
607                     int* comm, int* request, int* ierr)
608 {
609   *ierr = AMPI_Iallgather(sendbuf, *sendcount, *sendtype, recvbuf, *recvcount,
610                          *recvtype, *comm, (MPI_Request *)request);
611
612 }
613
614 void mpi_ialltoall(void *sendbuf, int* sendcount, int* sendtype,
615                  void *recvbuf, int* recvcount, int* recvtype,
616                  int* comm, int *request, int* ierr)
617 {
618   *ierr = AMPI_Ialltoall(sendbuf, *sendcount, *sendtype,
619                         recvbuf, *recvcount, *recvtype,
620                         *comm, (MPI_Request *)request);
621 }
622
623 void mpi_ireduce(void *sendbuf, void *recvbuf, int* count, int* type,
624                 int* opc, int* root, int* comm, int *request, int* ierr)
625 {
626   MPI_Op op = GET_MPI_OP(*opc);
627   *ierr = AMPI_Ireduce(sendbuf, recvbuf, *count, *type,
628                       op, *root, *comm, (MPI_Request*) request);
629 }
630
631 void mpi_iallreduce(void *inbuf, void *outbuf, int* count, int* type,
632                    int* opc, int* comm, int *request, int* ierr)
633 {
634   MPI_Op op = GET_MPI_OP(*opc);
635   *ierr = AMPI_Iallreduce(inbuf, outbuf, *count, *type,
636                          op, *comm, (MPI_Request*) request);
637 }
638 void mpi_reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts,
639                        int* datatype, int* opc, int* comm, int* ierr)
640 {
641   MPI_Op op = GET_MPI_OP(*opc);
642   *ierr = AMPI_Reduce_scatter(sendbuf, recvbuf, recvcounts,
643                              *datatype, op, *comm);
644 }
645
646 void mpi_scan(void* sendbuf, void* recvbuf, int* count, int* datatype, int* opc, int* comm, int* ierr)
647 {
648   MPI_Op op = GET_MPI_OP(*opc);
649   *ierr = AMPI_Scan(sendbuf,recvbuf,*count,*datatype,op,*comm );
650 }
651
652 void mpi_op_create(int* function, int* commute, int* opc, int* ierr){
653   MPI_Op op;
654   *ierr = MPI_Op_create((MPI_User_function *)function, *commute, (MPI_Op *)&op);
655   GET_MPI_OP(CtvAccess(mpi_opc)++) = op;
656   *opc = CtvAccess(mpi_opc)-1;
657 }
658
659 void mpi_op_free(int* opc, int* ierr){
660   MPI_Op op = GET_MPI_OP(*opc);
661   GET_MPI_OP(*opc) = NULL;
662   *ierr = MPI_Op_free((MPI_Op *)&op);
663 }
664
665 void mpi_comm_dup(int *comm, int *newcomm, int *ierr)
666 {
667   *newcomm = *comm;
668   *ierr = 0;
669 }
670
671 void mpi_comm_split(int* src, int* color, int* key, int *dest, int *ierr)
672 {
673   *ierr = AMPI_Comm_split(*src, *color, *key, dest);
674 }
675
676 void mpi_comm_free(int *comm, int *ierr)
677 {
678   *ierr = 0;
679 }
680
681 void mpi_comm_test_inter(int* comm, int* flag, int* ierr)
682 {
683   *ierr = AMPI_Comm_test_inter(*comm, flag);
684 }
685
686 void mpi_cart_create(int* comm_old, int* ndims, int *dims, int *periods,
687                     int* reorder, int* comm_cart, int* ierr)
688 {
689   *ierr = AMPI_Cart_create(*comm_old, *ndims, dims, periods, *reorder, comm_cart);
690 }
691
692 void mpi_graph_create(int* comm_old, int* nnodes, int *index, int *edges,
693                      int* reorder, int* comm_graph, int* ierr)
694 {
695   *ierr = AMPI_Graph_create(*comm_old, *nnodes, index, edges, *reorder, comm_graph);
696 }
697
698 void mpi_topo_test(int* comm, int *status, int* ierr)
699 {
700   *ierr = AMPI_Topo_test(*comm, status);
701 }
702
703 void mpi_cart_map(int* comm, int* ndims, int *dims, int *periods,
704                  int *newrank, int* ierr)
705 {
706   *ierr = AMPI_Cart_map(*comm, *ndims, dims, periods, newrank);
707 }
708
709 void mpi_graph_map(int* comm, int* nnodes, int *index, int *edges,
710                   int *newrank, int* ierr)
711 {
712   *ierr = AMPI_Graph_map(*comm, *nnodes, index, edges, newrank);
713 }
714
715 void mpi_cartdim_get(int* comm, int *ndims, int* ierr)
716 {
717   *ierr = AMPI_Cartdim_get(*comm, ndims);
718 }
719
720 void mpi_cart_get(int* comm, int* maxdims, int *dims, int *periods,
721                  int *coords, int* ierr)
722 {
723   *ierr = AMPI_Cart_get(*comm, *maxdims, dims, periods, coords);
724 }
725
726 void mpi_cart_rank(int* comm, int *coords, int *rank, int* ierr)
727 {
728   *ierr = AMPI_Cart_rank(*comm, coords, rank);
729 }
730
731 void mpi_cart_coords(int* comm, int* rank, int* maxdims, int *coords, int* ierr)
732 {
733   *ierr = AMPI_Cart_coords(*comm, *rank, *maxdims, coords);
734 }
735
736 void mpi_cart_shift(int* comm, int* direction, int* disp, int *rank_source,
737                    int *rank_dest, int* ierr)
738 {
739   *ierr = AMPI_Cart_shift(*comm, *direction, *disp, rank_source, rank_dest);
740 }
741
742 void mpi_graphdims_get(int* comm, int *nnodes, int *nedges, int* ierr)
743 {
744   *ierr = AMPI_Graphdims_get(*comm, nnodes, nedges);
745 }
746
747 void mpi_graph_get(int* comm, int *maxindex, int *maxedges, int *index,
748                   int *edges, int* ierr)
749 {
750   *ierr = AMPI_Graph_get(*comm, *maxindex, *maxedges, index, edges);
751 }
752
753 void mpi_graph_neighbors_count(int* comm, int *rank, int *nneighbors, int* ierr)
754 {
755   *ierr = AMPI_Graph_neighbors_count(*comm, *rank, nneighbors);
756 }
757
758 void mpi_graph_neighbors(int* comm, int *rank, int *maxneighbors,
759                         int *neighbors, int* ierr)
760 {
761   *ierr = AMPI_Graph_neighbors(*comm, *rank, *maxneighbors, neighbors);
762 }
763
764 void mpi_dims_create(int *nnodes, int *ndims, int *dims, int* ierr)
765 {
766   *ierr = AMPI_Dims_create(*nnodes, *ndims, dims);
767 }
768
769 void mpi_cart_sub(int* comm, int *remain_dims, int* newcomm, int* ierr)
770 {
771   *ierr = AMPI_Cart_sub(*comm, remain_dims, newcomm);
772 }
773
774 void mpi_get_processor_name(char* name, int *resultlen, int *ierr)
775 {
776   *ierr = AMPI_Get_processor_name(name, resultlen);
777 }
778
779 void mpi_errhandler_create(int *function, int *errhandler, int *ierr){  *ierr = 0;  }
780 void mpi_errhandler_set(int* comm, int* errhandler, int *ierr){  *ierr = 0;  }
781 void mpi_errhandler_get(int* comm, int *errhandler, int *ierr){  *ierr = 0;  }
782 void mpi_errhandler_free(int *errhandler, int *ierr){  *ierr = 0;  }
783 void mpi_error_string(int* errorcode, char *string, int *resultlen, int *ierr)
784 {
785   *ierr = AMPI_Error_string(*errorcode, string, resultlen);
786 }
787 void mpi_error_class(int* errorcode, int *errorclass, int *ierr)
788 {
789   *ierr = AMPI_Error_class(*errorcode, errorclass);
790 }
791
792 void mpi_group_size(int* group, int* size, int* ierror){
793   *ierror = AMPI_Group_size(*group, size);
794 }
795 void mpi_group_rank(int* group, int* rank, int* ierror){
796   *ierror = AMPI_Group_rank(*group, rank);
797 }
798 void mpi_group_translate_ranks(int* group1, int* n, int* ranks1, int* group2, int* ranks2, int* ierror){
799   *ierror = AMPI_Group_translate_ranks(*group1, *n, ranks1, *group2, ranks2);
800 }
801 void mpi_group_compare(int* group1, int* group2, int* result, int* ierror){
802   *ierror = AMPI_Group_compare(*group1, *group2, result);
803 }
804 void mpi_comm_group(int* comm, int* group, int* ierror){
805   *ierror = AMPI_Comm_group(*comm, group);
806 }
807 void mpi_group_union(int* group1, int* group2, int* newgroup, int* ierror){
808   *ierror = AMPI_Group_union(*group1, *group2, newgroup);
809 }
810 void mpi_group_intersection(int* group1, int* group2, int* newgroup, int* ierror){
811   *ierror = AMPI_Group_intersection(*group1, *group2, newgroup);
812 }
813 void mpi_group_difference(int* group1, int* group2, int* newgroup, int* ierror){
814   *ierror = AMPI_Group_difference(*group1, *group2, newgroup);
815 }
816 void mpi_group_incl(int* group, int* n, int* ranks, int* newgroup, int* ierror){
817   *ierror = AMPI_Group_incl(*group, *n, ranks, newgroup);
818 }
819 void mpi_group_excl(int* group, int* n, int* ranks, int* newgroup, int* ierror){
820   *ierror = AMPI_Group_excl(*group, *n, ranks, newgroup);
821 }
822 void mpi_group_range_incl(int* group, int* n, int ranges[][3], int* newgroup, int* ierror){
823   *ierror = AMPI_Group_range_incl(*group, *n, ranges, newgroup);
824 }
825 void mpi_group_range_excl(int* group,int*  n, int ranges[][3], int* newgroup, int* ierror){
826   *ierror = AMPI_Group_range_excl(*group, *n, ranges, newgroup);
827 }
828 void mpi_group_free(int*  group, int*  ierror){
829   *ierror = 0;
830 }
831 void mpi_comm_create(int*  comm, int*  group, int*  newcomm, int*  ierror){
832   *ierror = AMPI_Comm_create(*comm, *group, newcomm);
833 }
834
835 void mpi_abort(int *comm, int *errorcode, int *ierr)
836 {
837   *ierr = AMPI_Abort(*comm, *errorcode);
838 }
839
840 void mpi_get_count(int *sts, int *dtype, int *cnt, int *ierr)
841 {
842   *ierr = AMPI_Get_count((MPI_Status*) sts, *dtype, cnt);
843 }
844
845 void mpi_print(char *str, int *len)
846 {
847   char *buf = new char[*len+1];
848   memcpy(buf, str, *len);
849   buf[*len] = '\0';
850   AMPI_Print(buf);
851   delete [] buf;
852 }
853
854 void mpi_migrate(void)
855 {
856   AMPI_Migrate();
857 }
858
859 void mpi_setmigratable(int *comm, int *mig)
860 {
861   AMPI_Setmigratable(*comm, * mig);
862 }
863
864 void mpi_migrateto(int *destPE)
865 {
866   AMPI_Migrateto(*destPE);
867 }
868
869 void mpi_start_measure()           /* turn on auto load instrumentation */
870 {
871   AMPI_Start_measure();
872 }
873
874 void mpi_stop_measure()
875 {
876   AMPI_Stop_measure();
877 }
878
879 void mpi_set_load(double *load)
880 {
881   AMPI_Set_load(*load);
882 }
883
884 void mpi_register(void *d, MPI_PupFn f)
885 {
886   AMPI_Register(d,f);
887 }
888
889 void mpi_get_userdata(int* dn, void *data)
890 {
891   data = AMPI_Get_userdata(*dn); 
892 }
893
894 void mpi_checkpoint(char *dname){
895   AMPI_Checkpoint(dname);
896 }
897
898 void mpi_memcheckpoint(){
899   AMPI_MemCheckpoint();
900 }
901
902 void mpi_comm_remote_size(int *comm, int *size, int *ierr){
903   *ierr = AMPI_Comm_remote_size(*comm, size);
904 }
905
906 void mpi_comm_remote_group(int *comm, int *group, int *ierr){
907   *ierr = AMPI_Comm_remote_group(*comm, group);
908 }
909
910 void mpi_intercomm_create(int *local_comm, int *local_leader, int *peer_comm, int *remote_leader, int *tag, int *newintercomm, int *ierr){
911   *ierr = AMPI_Intercomm_create(*local_comm, *local_leader, *peer_comm, *remote_leader, *tag, newintercomm);
912 }
913
914 void mpi_intercomm_merge(int *intercomm, int *high, int *newintracomm, int *ierr){
915   *ierr = AMPI_Intercomm_merge(*intercomm, *high, newintracomm);
916 }
917
918 void mpi_keyval_create(MPI_Copy_function *copy_fn, MPI_Delete_function *delete_fn, int *keyval, void* extra_state, int *ierr) {
919   *ierr = AMPI_Keyval_create(copy_fn, delete_fn, keyval, extra_state);
920 }
921
922 void mpi_keyval_free(int *keyval, int *ierr){
923   *ierr = AMPI_Keyval_free(keyval);
924 }
925
926 void mpi_attr_put(int *comm, int *keyval, void* attribute_val, int *ierr){
927   *ierr = AMPI_Attr_put(*comm, *keyval, attribute_val);
928 }
929
930 void mpi_attr_get(int *comm, int *keyval, void *attribute_val, int *flag, int *ierr){
931   *ierr = AMPI_Attr_get(*comm, *keyval, attribute_val, flag);
932 }
933
934 void mpi_attr_delete(int *comm, int *keyval, int *ierr) {
935   *ierr = AMPI_Attr_delete(*comm, *keyval);
936 }
937
938 void mpi_type_get_envelope(int *datatype, int *num_integers, int *num_addresses,
939                           int *num_datatypes, int *combiner, int *ierr){
940  *ierr = AMPI_Type_get_envelope(*datatype, num_integers, num_addresses, num_datatypes, combiner);
941 }
942
943 void mpi_type_get_contents(int *datatype, int *max_integers, int *max_addresses,
944                            int *max_datatypes, int array_of_integers[], int array_of_addresses[],
945                            int array_of_datatypes[], int *ierr){
946   *ierr = AMPI_Type_get_contents(*datatype, *max_integers, *max_addresses, *max_datatypes, array_of_integers, 
947                                 array_of_addresses, array_of_datatypes);
948 }
949
950
951 void mpi_win_create(void *base, int *size, int *disp_unit,
952                    int *info, int *comm, MPI_Win *newwin, int *ierr) {
953   *ierr = AMPI_Win_create(base, *size, *disp_unit, *info, *comm, newwin);
954 }
955
956 void mpi_win_free(int *win, int *ierr) {
957   *ierr = AMPI_Win_free(win);
958 }
959
960 void mpi_win_delete_attr(int win, int *key, int *ierr){
961   *ierr = AMPI_Win_delete_attr(win, *key);
962 }
963
964 void mpi_win_get_group(int win, int *group, int *ierr){
965   *ierr = AMPI_Win_get_group(win, group);
966 }
967
968 void mpi_win_set_name(int win, char *name, int *ierr){
969   *ierr = AMPI_Win_set_name(win, name);
970 }
971
972 void mpi_win_get_name(int win, char *name, int *length, int *ierr){
973   *ierr = AMPI_Win_get_name(win, name, length);
974 }
975
976 void mpi_win_fence(int *assertion, int win, int *ierr){
977   *ierr = AMPI_Win_fence(*assertion, win);
978 }
979
980 void mpi_win_lock(int *lock_type, int *rank, int *assert, int win, int *ierr){
981   *ierr = AMPI_Win_lock(*lock_type, *rank, *assert, win);
982 }
983
984 void mpi_win_unlock(int *rank, int win, int *ierr){
985   *ierr = AMPI_Win_unlock(*rank, win);
986 }
987
988 void mpi_win_post(int *group, int *assertion, int win, int *ierr){
989   *ierr = AMPI_Win_post(*group, *assertion, win);
990 }
991
992 void mpi_win_wait(int win, int *ierr){
993   *ierr = AMPI_Win_wait(win);
994 }
995
996 void mpi_win_start(int *group, int *assertion, int win, int *ierr){
997   *ierr = AMPI_Win_start(*group, *assertion, win);
998 }
999
1000 void mpi_win_complete(int win, int *ierr){
1001   *ierr = AMPI_Win_complete(win);
1002 }
1003
1004 void mpi_alloc_mem(int *size, int *info, void *baseptr, int *ierr){
1005   *ierr = AMPI_Alloc_mem(*size, *info, baseptr);
1006 }
1007
1008 void mpi_free_mem(void *base, int *ierr){
1009   *ierr = AMPI_Free_mem(base);
1010 }
1011
1012 void mpi_put(void *orgaddr, int *orgcnt, int *orgtype, int *rank, 
1013             int *targdisp, int *targcnt, int *targtype, int win, int *ierr){
1014   *ierr = AMPI_Put(orgaddr, *orgcnt, *orgtype, *rank, *targdisp, *targcnt, *targtype, win);
1015 }
1016
1017 void mpi_get(void *orgaddr, int *orgcnt, int *orgtype, int *rank, 
1018             int *targdisp, int *targcnt, int *targtype, int win, int *ierr){
1019   *ierr = AMPI_Get(orgaddr, *orgcnt, *orgtype, *rank, *targdisp, *targcnt, *targtype, win);
1020 }
1021
1022 void mpi_accumulate(void *orgaddr, int *orgcnt, int *orgtype, int *rank,
1023                    int *targdisp, int *targcnt, int *targtype, 
1024                    int *opc, int win, int *ierr){
1025   MPI_Op op = GET_MPI_OP(*opc);
1026   *ierr = AMPI_Accumulate(orgaddr, *orgcnt, *orgtype, *rank, *targdisp, *targcnt, *targtype, op, win);
1027 }
1028
1029 void mpi_info_create(int* info, int* ierr){
1030   *ierr = MPI_Info_create(info);
1031 }
1032 void mpi_info_set(int* info, char *key, char *value, int* ierr){
1033   *ierr = MPI_Info_set(*info, key, value);
1034 }
1035 void mpi_info_delete(int* info, char* key, int* ierr){
1036   *ierr = MPI_Info_delete(*info, key);
1037 }
1038 void mpi_info_get(int* info, char *key, int *valuelen, char *value, int *flag, int* ierr){
1039   *ierr = MPI_Info_get(*info, key, *valuelen, value, flag);
1040 }
1041 void mpi_info_get_valuelen(int* info, char *key, int *valuelen, int *flag, int* ierr){
1042   *ierr = MPI_Info_get_valuelen(*info, key, valuelen, flag);
1043 }
1044 void mpi_info_get_nkeys(int* info, int *nkeys, int* ierr){
1045   *ierr = MPI_Info_get_nkeys(*info, nkeys);
1046 }
1047 void mpi_info_get_nthkey(int* info, int *n, char *key, int* ierr){
1048   *ierr = MPI_Info_get_nthkey(*info, *n, key);
1049 }
1050 void mpi_info_dup(int* info, int* newinfo, int* ierr){
1051   *ierr = MPI_Info_dup(*info, newinfo);
1052 }
1053 void mpi_info_free(int* info, int* ierr){
1054   *ierr = MPI_Info_free(info);
1055 }
1056
1057 void mpi_info_maxmemory(){
1058   CkPrintf("MaxMemory %ld\n", CmiMaxMemoryUsage());
1059 }
1060
1061 void mpi_info_memory(){
1062   CkPrintf("Memory %ld\n", CmiMemoryUsage());
1063 }
1064
1065 #define begintracebigsim FTN_NAME (BEGINTRACEBIGSIM , begintracebigsim)
1066 #define endtracebigsim FTN_NAME (ENDTRACEBIGSIM , endtracebigsim)
1067 void begintracebigsim(char* msg){
1068   beginTraceBigSim(msg);
1069 }
1070 void endtracebigsim(char* msg, char* param){
1071   endTraceBigSim(msg, param);
1072 }
1073
1074 } // extern "C"
1075