X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3e650953e3a2b3adb8ec8c194d7e520ba721cc5b..e7d7d4a985338bffc0574da0889c604489a84c13:/src/smpi/smpi_pmpi.c diff --git a/src/smpi/smpi_pmpi.c b/src/smpi/smpi_pmpi.c index b42f6a623f..4d20502f2e 100644 --- a/src/smpi/smpi_pmpi.c +++ b/src/smpi/smpi_pmpi.c @@ -1,3 +1,4 @@ + /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ @@ -126,15 +127,7 @@ int PMPI_Abort(MPI_Comm comm, int errorcode) double PMPI_Wtime(void) { - double time; - if (smpi_process_initialized() && !smpi_process_finalized() && !smpi_process_get_sampling()) { - smpi_bench_end(); - time = SIMIX_get_clock(); - smpi_bench_begin(); - } else { - time = SIMIX_get_clock(); - } - return time; + return smpi_mpi_wtime(); } extern double sg_maxmin_precision; @@ -164,8 +157,9 @@ int PMPI_Get_address(void *location, MPI_Aint * address) int PMPI_Type_free(MPI_Datatype * datatype) { int retval = 0; - - if (!datatype) { + /* Free a predefined datatype is an error according to the standard, and + should be checked for */ + if (*datatype == MPI_DATATYPE_NULL) { retval = MPI_ERR_ARG; } else { smpi_datatype_free(datatype); @@ -253,6 +247,18 @@ int PMPI_Type_ub(MPI_Datatype datatype, MPI_Aint * disp) return retval; } +int PMPI_Type_dup(MPI_Datatype datatype, MPI_Datatype *newtype){ + int retval = 0; + + if (datatype == MPI_DATATYPE_NULL) { + retval = MPI_ERR_TYPE; + } else { + *newtype = smpi_datatype_dup(datatype); + retval = MPI_SUCCESS; + } + return retval; +} + int PMPI_Op_create(MPI_User_function * function, int commute, MPI_Op * op) { int retval = 0; @@ -472,30 +478,14 @@ int PMPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group * newgro int PMPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup) { - int retval, i, index; + int retval; if (group == MPI_GROUP_NULL) { retval = MPI_ERR_GROUP; } else if (newgroup == NULL) { retval = MPI_ERR_ARG; } else { - if (n == 0) { - *newgroup = MPI_GROUP_EMPTY; - } else if (n == smpi_group_size(group)) { - *newgroup = group; - if(group!= smpi_comm_group(MPI_COMM_WORLD) - && group != MPI_GROUP_NULL - && group != smpi_comm_group(MPI_COMM_SELF) - && group != MPI_GROUP_EMPTY) - smpi_group_use(group); - } else { - *newgroup = smpi_group_new(n); - for (i = 0; i < n; i++) { - index = smpi_group_index(group, ranks[i]); - smpi_group_set_mapping(*newgroup, index, i); - } - } - retval = MPI_SUCCESS; + retval = smpi_group_incl(group, n, ranks, newgroup); } return retval; } @@ -561,10 +551,12 @@ int PMPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], size = 0; for (i = 0; i < n; i++) { for (rank = ranges[i][0]; /* First */ - rank >= 0; /* Last */ + rank >= 0 && rank < smpi_group_size(group); /* Last */ ) { size++; - + if(rank == ranges[i][1]){/*already last ?*/ + break; + } rank += ranges[i][2]; /* Stride */ if (ranges[i][0] ranges[i][1]) @@ -580,11 +572,14 @@ int PMPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], j = 0; for (i = 0; i < n; i++) { for (rank = ranges[i][0]; /* First */ - rank >= 0; /* Last */ + rank >= 0 && rank < smpi_group_size(group); /* Last */ ) { index = smpi_group_index(group, rank); smpi_group_set_mapping(*newgroup, index, j); j++; + if(rank == ranges[i][1]){/*already last ?*/ + break; + } rank += ranges[i][2]; /* Stride */ if (ranges[i][0] ranges[i][1]) @@ -622,10 +617,12 @@ int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], size = smpi_group_size(group); for (i = 0; i < n; i++) { for (rank = ranges[i][0]; /* First */ - rank >= 0; /* Last */ + rank >= 0 && rank < smpi_group_size(group); /* Last */ ) { size--; - + if(rank == ranges[i][1]){/*already last ?*/ + break; + } rank += ranges[i][2]; /* Stride */ if (ranges[i][0] ranges[i][1]) @@ -645,14 +642,17 @@ int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], while (newrank < size) { add=1; for (i = 0; i < n; i++) { - for (rank = ranges[i][0];rank >= 0;){ + for (rank = ranges[i][0]; + rank >= 0 && rank < smpi_group_size(group); + ){ if(rank==oldrank){ add=0; break; } - + if(rank == ranges[i][1]){/*already last ?*/ + break; + } rank += ranges[i][2]; /* Stride */ - if (ranges[i][0] ranges[i][1]) break; @@ -858,14 +858,16 @@ int PMPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dst, smpi_bench_end(); if (request == NULL) { - retval = MPI_ERR_ARG; + retval = MPI_ERR_ARG; } else if (comm == MPI_COMM_NULL) { - retval = MPI_ERR_COMM; + retval = MPI_ERR_COMM; + } else if (!is_datatype_valid(datatype)) { + retval = MPI_ERR_TYPE; } else if (dst == MPI_PROC_NULL) { - retval = MPI_SUCCESS; + retval = MPI_SUCCESS; } else { - *request = smpi_mpi_send_init(buf, count, datatype, dst, tag, comm); - retval = MPI_SUCCESS; + *request = smpi_mpi_send_init(buf, count, datatype, dst, tag, comm); + retval = MPI_SUCCESS; } smpi_bench_begin(); if (retval != MPI_SUCCESS && request) @@ -883,6 +885,8 @@ int PMPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int src, retval = MPI_ERR_ARG; } else if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; + } else if (!is_datatype_valid(datatype)) { + retval = MPI_ERR_TYPE; } else if (src == MPI_PROC_NULL) { retval = MPI_SUCCESS; } else { @@ -905,6 +909,8 @@ int PMPI_Ssend_init(void* buf, int count, MPI_Datatype datatype, retval = MPI_ERR_ARG; } else if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; + } else if (!is_datatype_valid(datatype)) { + retval = MPI_ERR_TYPE; } else if (dst == MPI_PROC_NULL) { retval = MPI_SUCCESS; } else { @@ -923,7 +929,7 @@ int PMPI_Start(MPI_Request * request) smpi_bench_end(); if (request == NULL || *request == MPI_REQUEST_NULL) { - retval = MPI_ERR_ARG; + retval = MPI_ERR_REQUEST; } else { smpi_mpi_start(*request); retval = MPI_SUCCESS; @@ -934,14 +940,21 @@ int PMPI_Start(MPI_Request * request) int PMPI_Startall(int count, MPI_Request * requests) { - int retval = 0; - + int retval; + int i = 0; smpi_bench_end(); if (requests == NULL) { retval = MPI_ERR_ARG; } else { - smpi_mpi_startall(count, requests); retval = MPI_SUCCESS; + for (i = 0 ; i < count ; i++) { + if(requests[i] == MPI_REQUEST_NULL) { + retval = MPI_ERR_REQUEST; + } + } + if(retval != MPI_ERR_REQUEST) { + smpi_mpi_startall(count, requests); + } } smpi_bench_begin(); return retval; @@ -977,13 +990,13 @@ int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, *request = MPI_REQUEST_NULL; retval = MPI_SUCCESS; } else if (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0)){ - retval = MPI_ERR_COMM; + retval = MPI_ERR_RANK; } else if (count < 0) { retval = MPI_ERR_COUNT; } else if (buf==NULL && count > 0) { retval = MPI_ERR_COUNT; - } else if (datatype == MPI_DATATYPE_NULL){ - retval = MPI_ERR_TYPE; + } else if (!is_datatype_valid(datatype)) { + retval = MPI_ERR_TYPE; } else if(tag<0 && tag != MPI_ANY_TAG){ retval = MPI_ERR_TAG; } else { @@ -1036,8 +1049,8 @@ int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst, retval = MPI_ERR_COUNT; } else if (buf==NULL && count > 0) { retval = MPI_ERR_COUNT; - } else if (datatype == MPI_DATATYPE_NULL){ - retval = MPI_ERR_TYPE; + } else if (!is_datatype_valid(datatype)) { + retval = MPI_ERR_TYPE; } else if(tag<0 && tag != MPI_ANY_TAG){ retval = MPI_ERR_TAG; } else { @@ -1090,8 +1103,8 @@ int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, retval = MPI_ERR_COUNT; } else if (buf==NULL && count > 0) { retval = MPI_ERR_COUNT; - } else if (datatype == MPI_DATATYPE_NULL){ - retval = MPI_ERR_TYPE; + } else if (!is_datatype_valid(datatype)) { + retval = MPI_ERR_TYPE; } else if(tag<0 && tag != MPI_ANY_TAG){ retval = MPI_ERR_TAG; } else { @@ -1142,8 +1155,8 @@ int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, retval = MPI_ERR_COUNT; } else if (buf==NULL && count > 0) { retval = MPI_ERR_COUNT; - } else if (datatype == MPI_DATATYPE_NULL){ - retval = MPI_ERR_TYPE; + } else if (!is_datatype_valid(datatype)) { + retval = MPI_ERR_TYPE; } else if(tag<0 && tag != MPI_ANY_TAG){ retval = MPI_ERR_TAG; } else { @@ -1193,8 +1206,8 @@ int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag, retval = MPI_ERR_COUNT; } else if (buf==NULL && count > 0) { retval = MPI_ERR_COUNT; - } else if (datatype == MPI_DATATYPE_NULL){ - retval = MPI_ERR_TYPE; + } else if (!is_datatype_valid(datatype)) { + retval = MPI_ERR_TYPE; } else if(tag<0 && tag != MPI_ANY_TAG){ retval = MPI_ERR_TAG; } else { @@ -1241,7 +1254,7 @@ int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MP retval = MPI_ERR_COUNT; } else if (buf==NULL && count > 0) { retval = MPI_ERR_COUNT; - } else if (datatype == MPI_DATATYPE_NULL){ + } else if (!is_datatype_valid(datatype)){ retval = MPI_ERR_TYPE; } else if(tag<0 && tag != MPI_ANY_TAG){ retval = MPI_ERR_TAG; @@ -1282,8 +1295,8 @@ int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; - } else if (sendtype == MPI_DATATYPE_NULL - || recvtype == MPI_DATATYPE_NULL) { + } else if (!is_datatype_valid(sendtype) + || !is_datatype_valid(recvtype)) { retval = MPI_ERR_TYPE; } else if (src == MPI_PROC_NULL || dst == MPI_PROC_NULL) { smpi_empty_status(status); @@ -1340,7 +1353,7 @@ int PMPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype, //TODO: suboptimal implementation void *recvbuf; int retval = 0; - if (datatype == MPI_DATATYPE_NULL) { + if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; } else if (count < 0) { retval = MPI_ERR_COUNT; @@ -1362,7 +1375,6 @@ int PMPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype, int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status) { int retval = 0; - smpi_bench_end(); if (request == NULL || flag == NULL) { retval = MPI_ERR_ARG; @@ -1371,7 +1383,19 @@ int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status) smpi_empty_status(status); retval = MPI_ERR_REQUEST; } else { +#ifdef HAVE_TRACING + int rank = request && (*request)->comm != MPI_COMM_NULL + ? smpi_process_index() + : -1; + + instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); + extra->type = TRACING_TEST; + TRACE_smpi_testing_in(rank, extra); +#endif *flag = smpi_mpi_test(request, status); +#ifdef HAVE_TRACING + TRACE_smpi_testing_out(rank); +#endif retval = MPI_SUCCESS; } smpi_bench_begin(); @@ -1661,6 +1685,8 @@ int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm c if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; + } else if (!is_datatype_valid(datatype)) { + retval = MPI_ERR_ARG; } else { #ifdef HAVE_TRACING int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; @@ -1926,10 +1952,13 @@ int PMPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype, if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; - } else if (((smpi_comm_rank(comm)==root) && (sendtype == MPI_DATATYPE_NULL)) - || ((recvbuf !=MPI_IN_PLACE) && (recvtype == MPI_DATATYPE_NULL))) { + } else if (((smpi_comm_rank(comm)==root) && (!is_datatype_valid(sendtype))) + || ((recvbuf !=MPI_IN_PLACE) && (!is_datatype_valid(recvtype)))){ retval = MPI_ERR_TYPE; - } else { + } else if ((sendbuf == recvbuf) || + ((smpi_comm_rank(comm)==root) && sendcount>0 && (sendbuf == NULL))){ + retval = MPI_ERR_BUFFER; + }else { if (recvbuf == MPI_IN_PLACE) { recvtype=sendtype; @@ -2020,7 +2049,7 @@ int PMPI_Reduce(void *sendbuf, void *recvbuf, int count, if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; - } else if (datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) { + } else if (!is_datatype_valid(datatype) || op == MPI_OP_NULL) { retval = MPI_ERR_ARG; } else { #ifdef HAVE_TRACING @@ -2051,7 +2080,7 @@ int PMPI_Reduce_local(void *inbuf, void *inoutbuf, int count, int retval = 0; smpi_bench_end(); - if (datatype == MPI_DATATYPE_NULL || op == MPI_OP_NULL) { + if (!is_datatype_valid(datatype) || op == MPI_OP_NULL) { retval = MPI_ERR_ARG; } else { smpi_op_apply(op, inbuf, inoutbuf, &count, &datatype); @@ -2070,7 +2099,7 @@ int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count, if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; - } else if (datatype == MPI_DATATYPE_NULL) { + } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; } else if (op == MPI_OP_NULL) { retval = MPI_ERR_OP; @@ -2115,7 +2144,7 @@ int PMPI_Scan(void *sendbuf, void *recvbuf, int count, if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; - } else if (datatype == MPI_DATATYPE_NULL) { + } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; } else if (op == MPI_OP_NULL) { retval = MPI_ERR_OP; @@ -2148,7 +2177,7 @@ int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; - } else if (datatype == MPI_DATATYPE_NULL) { + } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; } else if (op == MPI_OP_NULL) { retval = MPI_ERR_OP; @@ -2181,7 +2210,7 @@ int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts, if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; - } else if (datatype == MPI_DATATYPE_NULL) { + } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; } else if (op == MPI_OP_NULL) { retval = MPI_ERR_OP; @@ -2228,7 +2257,7 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount, if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; - } else if (datatype == MPI_DATATYPE_NULL) { + } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; } else if (op == MPI_OP_NULL) { retval = MPI_ERR_OP; @@ -2378,7 +2407,7 @@ int PMPI_Get_count(MPI_Status * status, MPI_Datatype datatype, int *count) if (status == NULL || count == NULL) { retval = MPI_ERR_ARG; - } else if (datatype == MPI_DATATYPE_NULL) { + } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; } else { size = smpi_datatype_size(datatype); @@ -2561,20 +2590,16 @@ int PMPI_Initialized(int* flag) { int PMPI_Cart_create(MPI_Comm comm_old, int ndims, int* dims, int* periodic, int reorder, MPI_Comm* comm_cart) { int retval = 0; - smpi_bench_end(); if (comm_old == MPI_COMM_NULL){ - return MPI_ERR_COMM; - } - else if (ndims < 0 || + retval = MPI_ERR_COMM; + } else if (ndims < 0 || (ndims > 0 && (dims == NULL || periodic == NULL)) || comm_cart == NULL) { - return MPI_ERR_ARG; + retval = MPI_ERR_ARG; + } else{ + retval = smpi_mpi_cart_create(comm_old, ndims, dims, periodic, reorder, comm_cart); } - retval = smpi_mpi_cart_create(comm_old, ndims, dims, periodic, reorder, comm_cart); - - smpi_bench_begin(); - return retval; } @@ -2655,6 +2680,265 @@ int PMPI_Cart_sub(MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new) { return smpi_mpi_cart_sub(comm, remain_dims, comm_new); } +int PMPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){ + if(oldtype == MPI_DATATYPE_NULL) { + return MPI_ERR_TYPE; + } + int blocks[3] = { 1, 1, 1 }; + MPI_Aint disps[3] = { lb, 0, lb+extent }; + MPI_Datatype types[3] = { MPI_LB, oldtype, MPI_UB }; + + s_smpi_mpi_struct_t* subtype = smpi_datatype_struct_create( blocks, + disps, + 3, + types + ); + smpi_datatype_create(newtype,oldtype->size, lb, lb + extent, 1 , subtype, DT_FLAG_VECTOR); + + (*newtype)->flags &= ~DT_FLAG_COMMITED; + return MPI_SUCCESS; +} + + + +int PMPI_Win_create( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win){ + int retval = 0; + smpi_bench_end(); + if (comm == MPI_COMM_NULL) { + retval= MPI_ERR_COMM; + }else if ((base == NULL && size != 0) + || disp_unit <= 0 || size < 0 ){ + retval= MPI_ERR_OTHER; + }else{ + *win = smpi_mpi_win_create( base, size, disp_unit, info, comm); + retval = MPI_SUCCESS; + } + smpi_bench_begin(); + return retval; +} + +int PMPI_Win_free( MPI_Win* win){ + int retval = 0; + smpi_bench_end(); + if (win == NULL || *win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + }else{ + retval=smpi_mpi_win_free(win); + } + smpi_bench_begin(); + return retval; +} + +int PMPI_Win_set_name(MPI_Win win, char * name) +{ + int retval = 0; + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_TYPE; + } else if (name == NULL) { + retval = MPI_ERR_ARG; + } else { + smpi_mpi_win_set_name(win, name); + retval = MPI_SUCCESS; + } + return retval; +} + +int PMPI_Win_get_name(MPI_Win win, char * name, int* len) +{ + int retval = 0; + + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_TYPE; + } else if (name == NULL) { + retval = MPI_ERR_ARG; + } else { + smpi_mpi_win_get_name(win, name, len); + retval = MPI_SUCCESS; + } + return retval; +} + + +int PMPI_Win_fence( int assert, MPI_Win win){ + int retval = 0; + smpi_bench_end(); + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + } else { + retval = smpi_mpi_win_fence(assert, win); + } + smpi_bench_begin(); + return retval; +} + +int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, + MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){ + int retval = 0; + smpi_bench_end(); + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + } else if (target_rank == MPI_PROC_NULL) { + retval = MPI_SUCCESS; + } else if (target_rank <0){ + retval = MPI_ERR_RANK; + } else if (target_disp <0){ + retval = MPI_ERR_ARG; + } else if (origin_count < 0 || target_count < 0) { + retval = MPI_ERR_COUNT; + } else if (origin_addr==NULL && origin_count > 0){ + retval = MPI_ERR_COUNT; + } else if ((!is_datatype_valid(origin_datatype)) || + (!is_datatype_valid(target_datatype))) { + retval = MPI_ERR_TYPE; + } else { + retval = smpi_mpi_get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win); + } + smpi_bench_begin(); + return retval; +} + +int PMPI_Put( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, + MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){ + int retval = 0; + smpi_bench_end(); + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + } else if (target_rank == MPI_PROC_NULL) { + retval = MPI_SUCCESS; + } else if (target_rank <0){ + retval = MPI_ERR_RANK; + } else if (target_disp <0){ + retval = MPI_ERR_ARG; + } else if (origin_count < 0 || target_count < 0) { + retval = MPI_ERR_COUNT; + } else if (origin_addr==NULL && origin_count > 0){ + retval = MPI_ERR_COUNT; + } else if ((!is_datatype_valid(origin_datatype)) || + (!is_datatype_valid(target_datatype))) { + retval = MPI_ERR_TYPE; + } else { + retval = smpi_mpi_put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win); + } + smpi_bench_begin(); + return retval; +} + + +int PMPI_Accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, + MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win){ + int retval = 0; + smpi_bench_end(); + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + } else if (target_rank == MPI_PROC_NULL) { + retval = MPI_SUCCESS; + } else if (target_rank <0){ + retval = MPI_ERR_RANK; + } else if (target_disp <0){ + retval = MPI_ERR_ARG; + } else if (origin_count < 0 || target_count < 0) { + retval = MPI_ERR_COUNT; + } else if (origin_addr==NULL && origin_count > 0){ + retval = MPI_ERR_COUNT; + } else if ((!is_datatype_valid(origin_datatype)) || + (!is_datatype_valid(target_datatype))) { + retval = MPI_ERR_TYPE; + } else if (op == MPI_OP_NULL) { + retval = MPI_ERR_OP; + } else { + retval = smpi_mpi_accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, op, win); + } + smpi_bench_begin(); + return retval; +} + + +int PMPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr){ + void *ptr = xbt_malloc(size); + if(!ptr) + return MPI_ERR_NO_MEM; + else { + *(void **)baseptr = ptr; + return MPI_SUCCESS; + } +} + +int PMPI_Free_mem(void *baseptr){ + xbt_free(baseptr); + return MPI_SUCCESS; +} + +int PMPI_Type_set_name(MPI_Datatype datatype, char * name) +{ + int retval = 0; + if (datatype == MPI_DATATYPE_NULL) { + retval = MPI_ERR_TYPE; + } else if (name == NULL) { + retval = MPI_ERR_ARG; + } else { + smpi_datatype_set_name(datatype, name); + retval = MPI_SUCCESS; + } + return retval; +} + +int PMPI_Type_get_name(MPI_Datatype datatype, char * name, int* len) +{ + int retval = 0; + + if (datatype == MPI_DATATYPE_NULL) { + retval = MPI_ERR_TYPE; + } else if (name == NULL) { + retval = MPI_ERR_ARG; + } else { + smpi_datatype_get_name(datatype, name, len); + retval = MPI_SUCCESS; + } + return retval; +} + + +MPI_Datatype PMPI_Type_f2c(MPI_Fint datatype){ + return smpi_type_f2c(datatype); +} + +MPI_Fint PMPI_Type_c2f(MPI_Datatype datatype){ + return smpi_type_c2f( datatype); +} + +MPI_Group PMPI_Group_f2c(MPI_Fint group){ + return smpi_group_f2c( group); +} + +MPI_Fint PMPI_Group_c2f(MPI_Group group){ + return smpi_group_c2f(group); +} + +MPI_Request PMPI_Request_f2c(MPI_Fint request){ + return smpi_request_f2c(request); +} + +MPI_Fint PMPI_Request_c2f(MPI_Request request) { + return smpi_request_c2f(request); +} + +MPI_Win PMPI_Win_f2c(MPI_Fint win){ + return smpi_win_f2c(win); +} + +MPI_Fint PMPI_Win_c2f(MPI_Win win){ + return smpi_win_c2f(win); +} + +MPI_Op PMPI_Op_f2c(MPI_Fint op){ + return smpi_op_f2c(op); +} + +MPI_Fint PMPI_Op_c2f(MPI_Op op){ + return smpi_op_c2f(op); +} + + /* The following calls are not yet implemented and will fail at runtime. */ /* Once implemented, please move them above this notice. */ @@ -2665,17 +2949,19 @@ int PMPI_Cart_sub(MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new) { } -int PMPI_Type_dup(MPI_Datatype datatype, MPI_Datatype *newtype){ +MPI_Info PMPI_Info_f2c(MPI_Fint info){ NOT_YET_IMPLEMENTED } -int PMPI_Type_set_name(MPI_Datatype datatype, char * name) -{ +MPI_Fint PMPI_Info_c2f(MPI_Info info){ NOT_YET_IMPLEMENTED } -int PMPI_Type_get_name(MPI_Datatype datatype, char * name, int* len) -{ +MPI_Errhandler PMPI_Errhandler_f2c(MPI_Fint errhandler){ + NOT_YET_IMPLEMENTED +} + +MPI_Fint PMPI_Errhandler_c2f(MPI_Errhandler errhandler){ NOT_YET_IMPLEMENTED } @@ -2741,6 +3027,10 @@ int PMPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler) { NOT_YET_IMPLEMENTED } +int PMPI_Win_set_errhandler(MPI_Win win, MPI_Errhandler errhandler) { + NOT_YET_IMPLEMENTED +} + int PMPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler* errhandler) { NOT_YET_IMPLEMENTED } @@ -2902,18 +3192,6 @@ int PMPI_Get_elements(MPI_Status* status, MPI_Datatype datatype, int* elements) NOT_YET_IMPLEMENTED } -int PMPI_Win_fence( int assert, MPI_Win win){ - NOT_YET_IMPLEMENTED -} - -int PMPI_Win_free( MPI_Win* win){ - NOT_YET_IMPLEMENTED -} - -int PMPI_Win_create( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win){ - NOT_YET_IMPLEMENTED -} - int PMPI_Info_create( MPI_Info *info){ NOT_YET_IMPLEMENTED } @@ -2926,11 +3204,6 @@ int PMPI_Info_free( MPI_Info *info){ NOT_YET_IMPLEMENTED } -int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, - MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){ - NOT_YET_IMPLEMENTED -} - int PMPI_Type_get_envelope( MPI_Datatype datatype, int *num_integers, int *num_addresses, int *num_datatypes, int *combiner){ NOT_YET_IMPLEMENTED @@ -2948,10 +3221,6 @@ int PMPI_Type_create_darray(int size, int rank, int ndims, int* array_of_gsizes, NOT_YET_IMPLEMENTED } -int PMPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){ - NOT_YET_IMPLEMENTED -} - int PMPI_Type_create_subarray(int ndims,int *array_of_sizes, int *array_of_subsizes, int *array_of_starts, int order, MPI_Datatype oldtype, MPI_Datatype *newtype){ NOT_YET_IMPLEMENTED }