+ MPI_Aint* target_disp, int *target_count, int* tarsmpi_type_f2c, int* win, int* ierr){
+ *ierr = MPI_Get( (void*)origin_addr,*origin_count, smpi_type_f2c(*origin_datatype),*target_rank,
+ *target_disp, *target_count,smpi_type_f2c(*tarsmpi_type_f2c), smpi_win_f2c(*win));
+}
+
+void mpi_accumulate_( int *origin_addr, int* origin_count, int* origin_datatype, int *target_rank,
+ MPI_Aint* target_disp, int *target_count, int* tarsmpi_type_f2c, int* op, int* win, int* ierr){
+ *ierr = MPI_Accumulate( (void*)origin_addr,*origin_count, smpi_type_f2c(*origin_datatype),*target_rank,
+ *target_disp, *target_count,smpi_type_f2c(*tarsmpi_type_f2c), smpi_op_f2c(*op), smpi_win_f2c(*win));
+}
+
+void mpi_put_( int *origin_addr, int* origin_count, int* origin_datatype, int *target_rank,
+ MPI_Aint* target_disp, int *target_count, int* tarsmpi_type_f2c, int* win, int* ierr){
+ *ierr = MPI_Put( (void*)origin_addr,*origin_count, smpi_type_f2c(*origin_datatype),*target_rank,
+ *target_disp, *target_count,smpi_type_f2c(*tarsmpi_type_f2c), smpi_win_f2c(*win));
+}
+
+
+//following are automatically generated, and have to be checked
+void mpi_finalized_ (int * flag, int* ierr){
+
+ *ierr = MPI_Finalized(flag);
+}
+
+void mpi_init_thread_ (int* required, int *provided, int* ierr){
+ smpi_init_fortran_types();
+ *ierr = MPI_Init_thread(NULL, NULL,*required, provided);
+ running_processes++;
+}
+
+void mpi_query_thread_ (int *provided, int* ierr){
+
+ *ierr = MPI_Query_thread(provided);
+}
+
+void mpi_is_thread_main_ (int *flag, int* ierr){
+
+ *ierr = MPI_Is_thread_main(flag);
+}
+
+void mpi_address_ (void *location, MPI_Aint * address, int* ierr){
+
+ *ierr = MPI_Address(location, address);
+}
+
+void mpi_get_address_ (void *location, MPI_Aint * address, int* ierr){
+
+ *ierr = MPI_Get_address(location, address);
+}
+
+void mpi_type_dup_ (int* datatype, int* newdatatype, int* ierr){
+ MPI_Datatype tmp;
+ *ierr = MPI_Type_dup(smpi_type_f2c(*datatype), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newdatatype = smpi_type_c2f(tmp);
+ }
+}
+
+void mpi_type_set_name_ (int* datatype, char * name, int* ierr, int size){
+ char* tname = xbt_malloc((size+1)*sizeof(char));
+ strncpy(tname, name, size);
+ tname[size]='\0';
+ *ierr = MPI_Type_set_name(smpi_type_f2c(*datatype), tname);
+ xbt_free(tname);
+}
+
+void mpi_type_get_name_ (int* datatype, char * name, int* len, int* ierr){
+ *ierr = MPI_Type_get_name(smpi_type_f2c(*datatype),name,len);
+ if(*len>0) name[*len]=' ';
+}
+
+void mpi_type_get_attr_ (int* type, int* type_keyval, void *attribute_val, int* flag, int* ierr){
+
+ *ierr = MPI_Type_get_attr ( smpi_type_f2c(*type), *type_keyval, attribute_val,flag);
+}
+
+void mpi_type_set_attr_ (int* type, int* type_keyval, void *attribute_val, int* ierr){
+
+ *ierr = MPI_Type_set_attr ( smpi_type_f2c(*type), *type_keyval, attribute_val);
+}
+
+void mpi_type_delete_attr_ (int* type, int* type_keyval, int* ierr){
+
+ *ierr = MPI_Type_delete_attr ( smpi_type_f2c(*type), *type_keyval);
+}
+
+void mpi_type_create_keyval_ (void* copy_fn, void* delete_fn, int* keyval, void* extra_state, int* ierr){
+
+ *ierr = MPI_Type_create_keyval((MPI_Type_copy_attr_function*)copy_fn, (MPI_Type_delete_attr_function*) delete_fn, keyval, extra_state) ;
+}
+
+void mpi_type_free_keyval_ (int* keyval, int* ierr) {
+ *ierr = MPI_Type_free_keyval( keyval);
+}
+
+void mpi_pcontrol_ (int* level , int* ierr){
+ *ierr = MPI_Pcontrol(*(const int*)level);
+}
+
+void mpi_type_get_extent_ (int* datatype, MPI_Aint * lb, MPI_Aint * extent, int* ierr){
+
+ *ierr = MPI_Type_get_extent(smpi_type_f2c(*datatype), lb, extent);
+}
+
+void mpi_type_get_true_extent_ (int* datatype, MPI_Aint * lb, MPI_Aint * extent, int* ierr){
+
+ *ierr = MPI_Type_get_true_extent(smpi_type_f2c(*datatype), lb, extent);
+}
+
+void mpi_op_create_ (void * function, int* commute, int* op, int* ierr){
+ MPI_Op tmp;
+ *ierr = MPI_Op_create((MPI_User_function*)function,* commute, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *op = smpi_op_c2f(tmp);
+ }
+}
+
+void mpi_op_free_ (int* op, int* ierr){
+ MPI_Op tmp=smpi_op_f2c(*op);
+ *ierr = MPI_Op_free(& tmp);
+ if(*ierr == MPI_SUCCESS) {
+ free_op(*op);
+ }
+}
+
+void mpi_group_free_ (int* group, int* ierr){
+ MPI_Group tmp=smpi_group_f2c(*group);
+ *ierr = MPI_Group_free(&tmp);
+ if(*ierr == MPI_SUCCESS) {
+ free_group(*group);
+ }
+}
+
+void mpi_group_size_ (int* group, int *size, int* ierr){
+
+ *ierr = MPI_Group_size(smpi_group_f2c(*group), size);
+}
+
+void mpi_group_rank_ (int* group, int *rank, int* ierr){
+
+ *ierr = MPI_Group_rank(smpi_group_f2c(*group), rank);
+}
+
+void mpi_group_translate_ranks_ (int* group1, int* n, int *ranks1, int* group2, int *ranks2, int* ierr)
+{
+
+ *ierr = MPI_Group_translate_ranks(smpi_group_f2c(*group1), *n, ranks1, smpi_group_f2c(*group2), ranks2);
+}
+
+void mpi_group_compare_ (int* group1, int* group2, int *result, int* ierr){
+
+ *ierr = MPI_Group_compare(smpi_group_f2c(*group1), smpi_group_f2c(*group2), result);
+}
+
+void mpi_group_union_ (int* group1, int* group2, int* newgroup, int* ierr){
+ MPI_Group tmp;
+ *ierr = MPI_Group_union(smpi_group_f2c(*group1), smpi_group_f2c(*group2), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newgroup = smpi_group_c2f(tmp);
+ }
+}
+
+void mpi_group_intersection_ (int* group1, int* group2, int* newgroup, int* ierr){
+ MPI_Group tmp;
+ *ierr = MPI_Group_intersection(smpi_group_f2c(*group1), smpi_group_f2c(*group2), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newgroup = smpi_group_c2f(tmp);
+ }
+}
+
+void mpi_group_difference_ (int* group1, int* group2, int* newgroup, int* ierr){
+ MPI_Group tmp;
+ *ierr = MPI_Group_difference(smpi_group_f2c(*group1), smpi_group_f2c(*group2), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newgroup = smpi_group_c2f(tmp);
+ }
+}
+
+void mpi_group_excl_ (int* group, int* n, int *ranks, int* newgroup, int* ierr){
+ MPI_Group tmp;
+ *ierr = MPI_Group_excl(smpi_group_f2c(*group), *n, ranks, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newgroup = smpi_group_c2f(tmp);
+ }
+}
+
+void mpi_group_range_incl_ (int* group, int* n, int ranges[][3], int* newgroup, int* ierr)
+{
+ MPI_Group tmp;
+ *ierr = MPI_Group_range_incl(smpi_group_f2c(*group), *n, ranges, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newgroup = smpi_group_c2f(tmp);
+ }
+}
+
+void mpi_group_range_excl_ (int* group, int* n, int ranges[][3], int* newgroup, int* ierr)
+{
+ MPI_Group tmp;
+ *ierr = MPI_Group_range_excl(smpi_group_f2c(*group), *n, ranges, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newgroup = smpi_group_c2f(tmp);
+ }
+}
+
+void mpi_comm_get_attr_ (int* comm, int* comm_keyval, void *attribute_val, int *flag, int* ierr){
+
+ *ierr = MPI_Comm_get_attr (smpi_comm_f2c(*comm), *comm_keyval, attribute_val, flag);
+}
+
+void mpi_comm_set_attr_ (int* comm, int* comm_keyval, void *attribute_val, int* ierr){
+
+ *ierr = MPI_Comm_set_attr ( smpi_comm_f2c(*comm), *comm_keyval, attribute_val);
+}
+
+void mpi_comm_delete_attr_ (int* comm, int* comm_keyval, int* ierr){
+
+ *ierr = MPI_Comm_delete_attr (smpi_comm_f2c(*comm), *comm_keyval);
+}
+
+void mpi_comm_create_keyval_ (void* copy_fn, void* delete_fn, int* keyval, void* extra_state, int* ierr){
+
+ *ierr = MPI_Comm_create_keyval((MPI_Comm_copy_attr_function*)copy_fn, (MPI_Comm_delete_attr_function*)delete_fn, keyval, extra_state) ;
+}
+
+void mpi_comm_free_keyval_ (int* keyval, int* ierr) {
+ *ierr = MPI_Comm_free_keyval( keyval);
+}
+
+void mpi_comm_get_name_ (int* comm, char* name, int* len, int* ierr){
+ *ierr = MPI_Comm_get_name(smpi_comm_f2c(*comm), name, len);
+ if(*len>0) name[*len]=' ';
+}
+
+void mpi_comm_compare_ (int* comm1, int* comm2, int *result, int* ierr){
+
+ *ierr = MPI_Comm_compare(smpi_comm_f2c(*comm1), smpi_comm_f2c(*comm2), result);
+}
+
+void mpi_comm_disconnect_ (int* comm, int* ierr){
+ MPI_Comm tmp=smpi_comm_f2c(*comm);
+ *ierr = MPI_Comm_disconnect(&tmp);
+ if(*ierr == MPI_SUCCESS) {
+ free_comm(*comm);
+ }
+}
+
+void mpi_request_free_ (int* request, int* ierr){
+ MPI_Request tmp=smpi_request_f2c(*request);
+ *ierr = MPI_Request_free(&tmp);
+ if(*ierr == MPI_SUCCESS) {
+ free_request(*request);
+ }
+}
+
+void mpi_sendrecv_replace_ (void *buf, int* count, int* datatype, int* dst, int* sendtag, int* src, int* recvtag,
+ int* comm, MPI_Status* status, int* ierr)
+{
+
+ *ierr = MPI_Sendrecv_replace(buf, *count, smpi_type_f2c(*datatype), *dst, *sendtag, *src,
+ *recvtag, smpi_comm_f2c(*comm), FORT_STATUS_IGNORE(status));
+}
+
+void mpi_testany_ (int* count, int* requests, int *index, int *flag, MPI_Status* status, int* ierr)
+{
+ MPI_Request* reqs;
+ int i;
+
+ reqs = xbt_new(MPI_Request, *count);
+ for(i = 0; i < *count; i++) {
+ reqs[i] = smpi_request_f2c(requests[i]);
+ }
+ *ierr = MPI_Testany(*count, reqs, index, flag, FORT_STATUS_IGNORE(status));
+ if(*index!=MPI_UNDEFINED)
+ if(reqs[*index]==MPI_REQUEST_NULL){
+ free_request(requests[*index]);
+ requests[*index]=MPI_FORTRAN_REQUEST_NULL;
+ }
+ free(reqs);
+}
+
+void mpi_waitsome_ (int* incount, int* requests, int *outcount, int *indices, MPI_Status* status, int* ierr)
+{
+ MPI_Request* reqs;
+ int i;
+
+ reqs = xbt_new(MPI_Request, *incount);
+ for(i = 0; i < *incount; i++) {
+ reqs[i] = smpi_request_f2c(requests[i]);
+ }
+ *ierr = MPI_Waitsome(*incount, reqs, outcount, indices, status);
+ for(i=0;i<*outcount;i++){
+ if(reqs[indices[i]]==MPI_REQUEST_NULL){
+ free_request(requests[indices[i]]);
+ requests[indices[i]]=MPI_FORTRAN_REQUEST_NULL;
+ }
+ }
+ free(reqs);
+}
+
+void mpi_reduce_local_ (void *inbuf, void *inoutbuf, int* count, int* datatype, int* op, int* ierr){
+
+ *ierr = MPI_Reduce_local(inbuf, inoutbuf, *count, smpi_type_f2c(*datatype), smpi_op_f2c(*op));
+}
+
+void mpi_reduce_scatter_block_ (void *sendbuf, void *recvbuf, int* recvcount, int* datatype, int* op, int* comm, int* ierr)
+{
+ sendbuf = (char *) FORT_IN_PLACE(sendbuf);
+ *ierr = MPI_Reduce_scatter_block(sendbuf, recvbuf, *recvcount, smpi_type_f2c(*datatype), smpi_op_f2c(*op), smpi_comm_f2c(*comm));
+}
+
+void mpi_pack_size_ (int* incount, int* datatype, int* comm, int* size, int* ierr) {
+ *ierr = MPI_Pack_size(*incount, smpi_type_f2c(*datatype), smpi_comm_f2c(*comm), size);
+}
+
+void mpi_cart_coords_ (int* comm, int* rank, int* maxdims, int* coords, int* ierr) {
+ *ierr = MPI_Cart_coords(smpi_comm_f2c(*comm), *rank, *maxdims, coords);
+}
+
+void mpi_cart_create_ (int* comm_old, int* ndims, int* dims, int* periods, int* reorder, int* comm_cart, int* ierr) {
+ MPI_Comm tmp;
+ *ierr = MPI_Cart_create(smpi_comm_f2c(*comm_old), *ndims, dims, periods, *reorder, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *comm_cart = smpi_comm_c2f(tmp);
+ }
+}
+
+void mpi_cart_get_ (int* comm, int* maxdims, int* dims, int* periods, int* coords, int* ierr) {
+ *ierr = MPI_Cart_get(smpi_comm_f2c(*comm), *maxdims, dims, periods, coords);
+}
+
+void mpi_cart_map_ (int* comm_old, int* ndims, int* dims, int* periods, int* newrank, int* ierr) {
+ *ierr = MPI_Cart_map(smpi_comm_f2c(*comm_old), *ndims, dims, periods, newrank);
+}
+
+void mpi_cart_rank_ (int* comm, int* coords, int* rank, int* ierr) {
+ *ierr = MPI_Cart_rank(smpi_comm_f2c(*comm), coords, rank);
+}
+
+void mpi_cart_shift_ (int* comm, int* direction, int* displ, int* source, int* dest, int* ierr) {
+ *ierr = MPI_Cart_shift(smpi_comm_f2c(*comm), *direction, *displ, source, dest);
+}
+
+void mpi_cart_sub_ (int* comm, int* remain_dims, int* comm_new, int* ierr) {
+ MPI_Comm tmp;
+ *ierr = MPI_Cart_sub(smpi_comm_f2c(*comm), remain_dims, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *comm_new = smpi_comm_c2f(tmp);
+ }
+}
+
+void mpi_cartdim_get_ (int* comm, int* ndims, int* ierr) {
+ *ierr = MPI_Cartdim_get(smpi_comm_f2c(*comm), ndims);
+}
+
+void mpi_graph_create_ (int* comm_old, int* nnodes, int* index, int* edges, int* reorder, int* comm_graph, int* ierr) {
+ MPI_Comm tmp;
+ *ierr = MPI_Graph_create(smpi_comm_f2c(*comm_old), *nnodes, index, edges, *reorder, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *comm_graph = smpi_comm_c2f(tmp);
+ }
+}
+
+void mpi_graph_get_ (int* comm, int* maxindex, int* maxedges, int* index, int* edges, int* ierr) {
+ *ierr = MPI_Graph_get(smpi_comm_f2c(*comm), *maxindex, *maxedges, index, edges);
+}
+
+void mpi_graph_map_ (int* comm_old, int* nnodes, int* index, int* edges, int* newrank, int* ierr) {
+ *ierr = MPI_Graph_map(smpi_comm_f2c(*comm_old), *nnodes, index, edges, newrank);
+}
+
+void mpi_graph_neighbors_ (int* comm, int* rank, int* maxneighbors, int* neighbors, int* ierr) {
+ *ierr = MPI_Graph_neighbors(smpi_comm_f2c(*comm), *rank, *maxneighbors, neighbors);
+}
+
+void mpi_graph_neighbors_count_ (int* comm, int* rank, int* nneighbors, int* ierr) {
+ *ierr = MPI_Graph_neighbors_count(smpi_comm_f2c(*comm), *rank, nneighbors);
+}
+
+void mpi_graphdims_get_ (int* comm, int* nnodes, int* nedges, int* ierr) {
+ *ierr = MPI_Graphdims_get(smpi_comm_f2c(*comm), nnodes, nedges);
+}
+
+void mpi_topo_test_ (int* comm, int* top_type, int* ierr) {
+ *ierr = MPI_Topo_test(smpi_comm_f2c(*comm), top_type);
+}
+
+void mpi_error_class_ (int* errorcode, int* errorclass, int* ierr) {
+ *ierr = MPI_Error_class(*errorcode, errorclass);
+}
+
+void mpi_errhandler_create_ (void* function, void* errhandler, int* ierr) {
+ *ierr = MPI_Errhandler_create((MPI_Handler_function*)function, (MPI_Errhandler*)errhandler);
+}
+
+void mpi_errhandler_free_ (void* errhandler, int* ierr) {
+ *ierr = MPI_Errhandler_free((MPI_Errhandler*)errhandler);
+}
+
+void mpi_errhandler_get_ (int* comm, void* errhandler, int* ierr) {
+ *ierr = MPI_Errhandler_get(smpi_comm_f2c(*comm), (MPI_Errhandler*) errhandler);
+}
+
+void mpi_errhandler_set_ (int* comm, void* errhandler, int* ierr) {
+ *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), *(MPI_Errhandler*)errhandler);
+}
+
+void mpi_comm_set_errhandler_ (int* comm, void* errhandler, int* ierr) {
+ *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), *(MPI_Errhandler*)errhandler);
+}
+
+void mpi_comm_get_errhandler_ (int* comm, void* errhandler, int* ierr) {
+ *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), (MPI_Errhandler*)errhandler);
+}
+
+void mpi_type_contiguous_ (int* count, int* old_type, int* newtype, int* ierr) {
+ MPI_Datatype tmp;
+ *ierr = MPI_Type_contiguous(*count, smpi_type_f2c(*old_type), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newtype = smpi_type_c2f(tmp);
+ }
+}
+
+void mpi_cancel_ (int* request, int* ierr) {
+ MPI_Request tmp=smpi_request_f2c(*request);
+ *ierr = MPI_Cancel(&tmp);
+}
+
+void mpi_buffer_attach_ (void* buffer, int* size, int* ierr) {
+ *ierr = MPI_Buffer_attach(buffer, *size);
+}
+
+void mpi_buffer_detach_ (void* buffer, int* size, int* ierr) {
+ *ierr = MPI_Buffer_detach(buffer, size);
+}
+
+void mpi_testsome_ (int* incount, int* requests, int* outcount, int* indices, MPI_Status* statuses, int* ierr) {
+ MPI_Request* reqs;
+ int i;
+
+ reqs = xbt_new(MPI_Request, *incount);
+ for(i = 0; i < *incount; i++) {
+ reqs[i] = smpi_request_f2c(requests[i]);
+ indices[i]=0;
+ }
+ *ierr = MPI_Testsome(*incount, reqs, outcount, indices, FORT_STATUSES_IGNORE(statuses));
+ for(i=0;i<*incount;i++){
+ if(indices[i]){
+ if(reqs[indices[i]]==MPI_REQUEST_NULL){
+ free_request(requests[indices[i]]);
+ requests[indices[i]]=MPI_FORTRAN_REQUEST_NULL;
+ }
+ }
+ }
+ free(reqs);
+}
+
+void mpi_comm_test_inter_ (int* comm, int* flag, int* ierr) {
+ *ierr = MPI_Comm_test_inter(smpi_comm_f2c(*comm), flag);
+}
+
+void mpi_unpack_ (void* inbuf, int* insize, int* position, void* outbuf, int* outcount, int* type, int* comm, int* ierr) {
+ *ierr = MPI_Unpack(inbuf, *insize, position, outbuf, *outcount, smpi_type_f2c(*type), smpi_comm_f2c(*comm));
+}
+
+void mpi_pack_external_size_ (char *datarep, int* incount, int* datatype, MPI_Aint *size, int* ierr){
+ *ierr = MPI_Pack_external_size(datarep, *incount, smpi_type_f2c(*datatype), size);
+}
+
+void mpi_pack_external_ (char *datarep, void *inbuf, int* incount, int* datatype, void *outbuf, MPI_Aint* outcount, MPI_Aint *position, int* ierr){
+ *ierr = MPI_Pack_external(datarep, inbuf, *incount, smpi_type_f2c(*datatype), outbuf, *outcount, position);
+}
+
+void mpi_unpack_external_ ( char *datarep, void *inbuf, MPI_Aint* insize, MPI_Aint *position, void *outbuf, int* outcount, int* datatype, int* ierr){
+ *ierr = MPI_Unpack_external( datarep, inbuf, *insize, position, outbuf, *outcount, smpi_type_f2c(*datatype));
+}
+
+void mpi_type_hindexed_ (int* count, int* blocklens, MPI_Aint* indices, int* old_type, int* newtype, int* ierr) {
+ MPI_Datatype tmp;
+ *ierr = MPI_Type_hindexed(*count, blocklens, indices, smpi_type_f2c(*old_type), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newtype = smpi_type_c2f(tmp);
+ }
+}
+
+void mpi_type_create_hindexed_ (int* count, int* blocklens, MPI_Aint* indices, int* old_type, int* newtype, int* ierr) {
+ MPI_Datatype tmp;
+ *ierr = MPI_Type_create_hindexed(*count, blocklens, indices, smpi_type_f2c(*old_type), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newtype = smpi_type_c2f(tmp);
+ }
+}
+
+void mpi_type_create_hindexed_block_ (int* count, int* blocklength, MPI_Aint* indices, int* old_type, int* newtype, int* ierr) {
+ MPI_Datatype tmp;
+ *ierr = MPI_Type_create_hindexed_block(*count, *blocklength, indices, smpi_type_f2c(*old_type), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newtype = smpi_type_c2f(tmp);
+ }
+}
+
+void mpi_type_indexed_ (int* count, int* blocklens, int* indices, int* old_type, int* newtype, int* ierr) {
+ MPI_Datatype tmp;
+ *ierr = MPI_Type_indexed(*count, blocklens, indices, smpi_type_f2c(*old_type), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newtype = smpi_type_c2f(tmp);
+ }
+}
+
+void mpi_type_create_indexed_block_ (int* count, int* blocklength, int* indices, int* old_type, int*newtype, int* ierr){
+ MPI_Datatype tmp;
+ *ierr = MPI_Type_create_indexed_block(*count, *blocklength, indices, smpi_type_f2c(*old_type), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newtype = smpi_type_c2f(tmp);
+ }
+}
+
+void mpi_type_struct_ (int* count, int* blocklens, MPI_Aint* indices, int* old_types, int* newtype, int* ierr) {
+ MPI_Datatype tmp;
+ int i=0;
+ MPI_Datatype* types = (MPI_Datatype*)xbt_malloc(*count*sizeof(MPI_Datatype));
+ for(i=0; i< *count; i++){
+ types[i] = smpi_type_f2c(old_types[i]);
+ }
+ *ierr = MPI_Type_struct(*count, blocklens, indices, types, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newtype = smpi_type_c2f(tmp);
+ }
+ xbt_free(types);
+}
+
+void mpi_type_create_struct_ (int* count, int* blocklens, MPI_Aint* indices, int* old_types, int* newtype, int* ierr) {
+ MPI_Datatype tmp;
+ int i=0;
+ MPI_Datatype* types = (MPI_Datatype*)xbt_malloc(*count*sizeof(MPI_Datatype));
+ for(i=0; i< *count; i++){
+ types[i] = smpi_type_f2c(old_types[i]);
+ }
+ *ierr = MPI_Type_create_struct(*count, blocklens, indices, types, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *newtype = smpi_type_c2f(tmp);
+ }
+ xbt_free(types);
+}
+
+void mpi_ssend_ (void* buf, int* count, int* datatype, int* dest, int* tag, int* comm, int* ierr) {
+ *ierr = MPI_Ssend(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm));
+}
+
+void mpi_ssend_init_ (void* buf, int* count, int* datatype, int* dest, int* tag, int* comm, int* request, int* ierr) {
+ MPI_Request tmp;
+ *ierr = MPI_Ssend_init(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *request = smpi_request_c2f(tmp);
+ }
+}
+
+void mpi_intercomm_create_ (int* local_comm, int *local_leader, int* peer_comm, int* remote_leader, int* tag, int* comm_out, int* ierr) {
+ MPI_Comm tmp;
+ *ierr = MPI_Intercomm_create(smpi_comm_f2c(*local_comm), *local_leader,smpi_comm_f2c(*peer_comm), *remote_leader, *tag, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *comm_out = smpi_comm_c2f(tmp);
+ }
+}
+
+void mpi_intercomm_merge_ (int* comm, int* high, int* comm_out, int* ierr) {
+ MPI_Comm tmp;
+ *ierr = MPI_Intercomm_merge(smpi_comm_f2c(*comm), *high, &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *comm_out = smpi_comm_c2f(tmp);
+ }
+}
+
+void mpi_bsend_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* ierr) {
+ *ierr = MPI_Bsend(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm));
+}
+
+void mpi_bsend_init_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* request, int* ierr) {
+ MPI_Request tmp;
+ *ierr = MPI_Bsend_init(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *request = smpi_request_c2f(tmp);
+ }
+}
+
+void mpi_ibsend_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* request, int* ierr) {
+ MPI_Request tmp;
+ *ierr = MPI_Ibsend(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *request = smpi_request_c2f(tmp);
+ }
+}
+
+void mpi_comm_remote_group_ (int* comm, int* group, int* ierr) {
+ MPI_Group tmp;
+ *ierr = MPI_Comm_remote_group(smpi_comm_f2c(*comm), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *group = smpi_group_c2f(tmp);
+ }
+}
+
+void mpi_comm_remote_size_ (int* comm, int* size, int* ierr) {
+ *ierr = MPI_Comm_remote_size(smpi_comm_f2c(*comm), size);
+}
+
+void mpi_issend_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* request, int* ierr) {
+ MPI_Request tmp;
+ *ierr = MPI_Issend(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *request = smpi_request_c2f(tmp);
+ }
+}
+
+void mpi_probe_ (int* source, int* tag, int* comm, MPI_Status* status, int* ierr) {
+ *ierr = MPI_Probe(*source, *tag, smpi_comm_f2c(*comm), FORT_STATUS_IGNORE(status));
+}
+
+void mpi_attr_delete_ (int* comm, int* keyval, int* ierr) {
+ *ierr = MPI_Attr_delete(smpi_comm_f2c(*comm), *keyval);
+}
+
+void mpi_attr_put_ (int* comm, int* keyval, void* attr_value, int* ierr) {
+ *ierr = MPI_Attr_put(smpi_comm_f2c(*comm), *keyval, attr_value);
+}
+
+void mpi_rsend_init_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* request, int* ierr) {
+ MPI_Request tmp;
+ *ierr = MPI_Rsend_init(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp);
+ if(*ierr == MPI_SUCCESS) {
+ *request = smpi_request_c2f(tmp);
+ }
+}
+
+void mpi_keyval_create_ (void* copy_fn, void* delete_fn, int* keyval, void* extra_state, int* ierr) {
+ *ierr = MPI_Keyval_create((MPI_Copy_function*)copy_fn, (MPI_Delete_function*)delete_fn, keyval, extra_state);
+}
+
+void mpi_keyval_free_ (int* keyval, int* ierr) {
+ *ierr = MPI_Keyval_free(keyval);
+}
+
+void mpi_test_cancelled_ (MPI_Status* status, int* flag, int* ierr) {
+ *ierr = MPI_Test_cancelled(status, flag);