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