if (datatype == MPI_DATATYPE_NULL) {
retval = MPI_ERR_TYPE;
} else {
- *newtype = smpi_datatype_dup(datatype);
- retval = MPI_SUCCESS;
+ retval = smpi_datatype_dup(datatype, newtype);
}
return retval;
}
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;
}
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]){
if(rank > ranges[i][1])
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]){
if(rank > ranges[i][1])
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]){
if(rank > ranges[i][1])
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]){
if(rank > ranges[i][1])
break;
} 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;
}
int PMPI_Win_get_name(MPI_Win win, char * name, int* len)
{
- int retval = 0;
+ int retval = MPI_SUCCESS;
if (win == MPI_WIN_NULL) {
- retval = MPI_ERR_TYPE;
+ retval = MPI_ERR_WIN;
} 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_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;
}
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_comm_keyval_create(copy_fn, delete_fn, keyval, extra_state);
+}
+
+int PMPI_Keyval_free(int* keyval) {
+ return smpi_comm_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_comm_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_comm_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_comm_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);
+}
+
+
+int PMPI_Type_get_attr (MPI_Datatype type, int type_keyval, void *attribute_val, int* flag)
+{
+ if (type==MPI_DATATYPE_NULL)
+ return MPI_ERR_TYPE;
+ else
+ return smpi_type_attr_get(type, type_keyval, attribute_val, flag);
+}
+
+int PMPI_Type_set_attr (MPI_Datatype type, int type_keyval, void *attribute_val)
+{
+ if (type==MPI_DATATYPE_NULL)
+ return MPI_ERR_TYPE;
+ else
+ return smpi_type_attr_put(type, type_keyval, attribute_val);
+}
+
+int PMPI_Type_delete_attr (MPI_Datatype type, int type_keyval)
+{
+ if (type==MPI_DATATYPE_NULL)
+ return MPI_ERR_TYPE;
+ else
+ return smpi_type_attr_delete(type, type_keyval);
+}
+
+int PMPI_Type_create_keyval(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval, void* extra_state)
+{
+ return smpi_type_keyval_create(copy_fn, delete_fn, keyval, extra_state);
+}
+
+int PMPI_Type_free_keyval(int* keyval) {
+ return smpi_type_keyval_free(keyval);
+}
+
/* The following calls are not yet implemented and will fail at runtime. */
/* Once implemented, please move them above this notice. */
}
+MPI_Info PMPI_Info_f2c(MPI_Fint info){
+ NOT_YET_IMPLEMENTED
+}
+
+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
+}
int PMPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) {
NOT_YET_IMPLEMENTED
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
NOT_YET_IMPLEMENTED
}
-int PMPI_Type_get_attr (MPI_Datatype type, int type_keyval, void *attribute_val, int* flag)
-{
- NOT_YET_IMPLEMENTED
-}
-
-int PMPI_Type_set_attr (MPI_Datatype type, int type_keyval, void *attribute_val)
-{
- NOT_YET_IMPLEMENTED
-}
-
-int PMPI_Type_delete_attr (MPI_Datatype type, int comm_keyval)
-{
- NOT_YET_IMPLEMENTED
-}
-
-int PMPI_Type_create_keyval(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval, void* extra_state)
-{
- NOT_YET_IMPLEMENTED
-}
-
-int PMPI_Type_free_keyval(int* keyval) {
- NOT_YET_IMPLEMENTED
-}
-
int PMPI_Intercomm_create(MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm, int remote_leader, int tag, MPI_Comm* comm_out) {
NOT_YET_IMPLEMENTED
}
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
}
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
}
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
+}
