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