X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/977a3789653e4d793b2401cf3f5fa65dcf6795ba..0a139bd8427bafd28aa6577166c315071e10e618:/src/smpi/smpi_pmpi.c diff --git a/src/smpi/smpi_pmpi.c b/src/smpi/smpi_pmpi.c index 5d7836022a..a40bccb707 100644 --- a/src/smpi/smpi_pmpi.c +++ b/src/smpi/smpi_pmpi.c @@ -127,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; @@ -486,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; } @@ -575,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]) @@ -594,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]) @@ -636,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]) @@ -659,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; @@ -787,8 +773,7 @@ int PMPI_Comm_dup(MPI_Comm comm, MPI_Comm * newcomm) } else if (newcomm == NULL) { retval = MPI_ERR_ARG; } else { - *newcomm = smpi_comm_new(smpi_comm_group(comm), smpi_comm_topo(comm)); - retval = MPI_SUCCESS; + retval = smpi_comm_dup(comm, newcomm); } return retval; } @@ -1699,6 +1684,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; @@ -1964,10 +1951,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; @@ -2738,6 +2728,44 @@ int PMPI_Win_free( MPI_Win* win){ 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 = MPI_SUCCESS; + + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + } else if (name == NULL) { + retval = MPI_ERR_ARG; + } else { + smpi_mpi_win_get_name(win, name, len); + } + return retval; +} + +int PMPI_Win_get_group(MPI_Win win, MPI_Group * group){ + int retval = MPI_SUCCESS; + if (win == MPI_WIN_NULL) { + retval = MPI_ERR_WIN; + }else { + smpi_mpi_win_get_group(win, group); + } + return retval; +} + int PMPI_Win_fence( int assert, MPI_Win win){ int retval = 0; @@ -2848,7 +2876,155 @@ int PMPI_Free_mem(void *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); +} + +MPI_Comm PMPI_Comm_f2c(MPI_Fint comm){ + return smpi_comm_f2c(comm); +} + +MPI_Fint PMPI_Comm_c2f(MPI_Comm comm){ + return smpi_comm_c2f(comm); +} + +int PMPI_Keyval_create(MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state) { + return smpi_keyval_create(copy_fn, delete_fn, keyval, extra_state); +} + +int PMPI_Keyval_free(int* keyval) { + return smpi_keyval_free(keyval); +} + +int PMPI_Attr_delete(MPI_Comm comm, int keyval) { + if(keyval == MPI_TAG_UB||keyval == MPI_HOST||keyval == MPI_IO + ||keyval == MPI_WTIME_IS_GLOBAL||keyval == MPI_APPNUM + ||keyval == MPI_UNIVERSE_SIZE||keyval == MPI_LASTUSEDCODE) + return MPI_ERR_ARG; + else if (comm==MPI_COMM_NULL) + return MPI_ERR_COMM; + else + return smpi_attr_delete(comm, keyval); +} + +int PMPI_Attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag) { + if (comm==MPI_COMM_NULL){ + *flag=0; + return MPI_ERR_COMM; + } else if(keyval == MPI_TAG_UB||keyval == MPI_HOST||keyval == MPI_IO + ||keyval == MPI_WTIME_IS_GLOBAL||keyval == MPI_APPNUM + ||keyval == MPI_UNIVERSE_SIZE||keyval == MPI_LASTUSEDCODE){ + *flag=1; + //FIXME : not ideal and leaky, but should not be called too much + int* res = xbt_new(int, 1); + *res=keyval; + *(int**)attr_value=res; + return MPI_SUCCESS; + } else + return smpi_attr_get(comm, keyval, attr_value, flag); +} + +int PMPI_Attr_put(MPI_Comm comm, int keyval, void* attr_value) { + if(keyval == MPI_TAG_UB||keyval == MPI_HOST||keyval == MPI_IO + ||keyval == MPI_WTIME_IS_GLOBAL||keyval == MPI_APPNUM + ||keyval == MPI_UNIVERSE_SIZE||keyval == MPI_LASTUSEDCODE) + return MPI_ERR_ARG; + else if (comm==MPI_COMM_NULL) + return MPI_ERR_COMM; + else + return smpi_attr_put(comm, keyval, attr_value); +} + + +int PMPI_Comm_get_attr (MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag) +{ + return PMPI_Attr_get(comm, comm_keyval, attribute_val,flag); +} + +int PMPI_Comm_set_attr (MPI_Comm comm, int comm_keyval, void *attribute_val) +{ + return PMPI_Attr_put(comm, comm_keyval, attribute_val); +} +int PMPI_Comm_delete_attr (MPI_Comm comm, int comm_keyval) +{ + return PMPI_Attr_delete(comm, comm_keyval); +} + +int PMPI_Comm_create_keyval(MPI_Comm_copy_attr_function* copy_fn, MPI_Comm_delete_attr_function* delete_fn, int* keyval, void* extra_state) +{ + return PMPI_Keyval_create(copy_fn, delete_fn, keyval, extra_state); +} + +int PMPI_Comm_free_keyval(int* keyval) { + return PMPI_Keyval_free(keyval); +} /* The following calls are not yet implemented and will fail at runtime. */ /* Once implemented, please move them above this notice. */ @@ -2858,13 +3034,20 @@ int PMPI_Free_mem(void *baseptr){ return MPI_SUCCESS; \ } -int PMPI_Type_set_name(MPI_Datatype datatype, char * name) -{ + +MPI_Info PMPI_Info_f2c(MPI_Fint info){ NOT_YET_IMPLEMENTED } -int PMPI_Type_get_name(MPI_Datatype datatype, char * name, int* len) -{ +MPI_Fint PMPI_Info_c2f(MPI_Info info){ + NOT_YET_IMPLEMENTED +} + +MPI_Errhandler PMPI_Errhandler_f2c(MPI_Fint errhandler){ + NOT_YET_IMPLEMENTED +} + +MPI_Fint PMPI_Errhandler_c2f(MPI_Errhandler errhandler){ NOT_YET_IMPLEMENTED } @@ -2954,30 +3137,6 @@ int PMPI_Comm_test_inter(MPI_Comm comm, int* flag) { NOT_YET_IMPLEMENTED } -int PMPI_Comm_get_attr (MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag) -{ - NOT_YET_IMPLEMENTED -} - -int PMPI_Comm_set_attr (MPI_Comm comm, int comm_keyval, void *attribute_val) -{ - NOT_YET_IMPLEMENTED -} - -int PMPI_Comm_delete_attr (MPI_Comm comm, int comm_keyval) -{ - NOT_YET_IMPLEMENTED -} - -int PMPI_Comm_create_keyval(MPI_Comm_copy_attr_function* copy_fn, MPI_Comm_delete_attr_function* delete_fn, int* keyval, void* extra_state) -{ - NOT_YET_IMPLEMENTED -} - -int PMPI_Comm_free_keyval(int* keyval) { - NOT_YET_IMPLEMENTED -} - int PMPI_Pcontrol(const int level ) { NOT_YET_IMPLEMENTED @@ -3039,18 +3198,6 @@ int PMPI_Comm_remote_size(MPI_Comm comm, int* size) { NOT_YET_IMPLEMENTED } -int PMPI_Attr_delete(MPI_Comm comm, int keyval) { - NOT_YET_IMPLEMENTED -} - -int PMPI_Attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag) { - NOT_YET_IMPLEMENTED -} - -int PMPI_Attr_put(MPI_Comm comm, int keyval, void* attr_value) { - NOT_YET_IMPLEMENTED -} - int PMPI_Rsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm) { NOT_YET_IMPLEMENTED } @@ -3063,14 +3210,6 @@ int PMPI_Irsend(void* buf, int count, MPI_Datatype datatype, int dest, int tag, NOT_YET_IMPLEMENTED } -int PMPI_Keyval_create(MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state) { - NOT_YET_IMPLEMENTED -} - -int PMPI_Keyval_free(int* keyval) { - NOT_YET_IMPLEMENTED -} - int PMPI_Test_cancelled(MPI_Status* status, int* flag) { NOT_YET_IMPLEMENTED } @@ -3267,3 +3406,31 @@ int PMPI_Comm_spawn_multiple( int count, char **array_of_commands, char*** array int PMPI_Comm_get_parent( MPI_Comm *parent){ NOT_YET_IMPLEMENTED } + +int PMPI_Win_complete(MPI_Win win){ + NOT_YET_IMPLEMENTED +} + +int PMPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win) { + NOT_YET_IMPLEMENTED +} + +int PMPI_Win_post(MPI_Group group, int assert, MPI_Win win){ + NOT_YET_IMPLEMENTED +} + +int PMPI_Win_start(MPI_Group group, int assert, MPI_Win win){ + NOT_YET_IMPLEMENTED +} + +int PMPI_Win_test(MPI_Win win, int *flag){ + NOT_YET_IMPLEMENTED +} + +int PMPI_Win_unlock(int rank, MPI_Win win){ + NOT_YET_IMPLEMENTED +} + +int PMPI_Win_wait(MPI_Win win){ + NOT_YET_IMPLEMENTED +}