X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/ce1289d4421b08ce6f69d8203784ee648671972e..8d6a10ac1e9fcb029988ac60ac57d309b49db412:/src/smpi/smpi_mpi_dt.c diff --git a/src/smpi/smpi_mpi_dt.c b/src/smpi/smpi_mpi_dt.c index 7cb76b7949..bedd20559a 100644 --- a/src/smpi/smpi_mpi_dt.c +++ b/src/smpi/smpi_mpi_dt.c @@ -22,6 +22,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_mpi_dt, smpi, #define CREATE_MPI_DATATYPE(name, type) \ static s_smpi_mpi_datatype_t mpi_##name = { \ + (char*) # name, \ sizeof(type), /* size */ \ 0, /*was 1 has_subtype*/ \ 0, /* lb */ \ @@ -33,6 +34,7 @@ MPI_Datatype name = &mpi_##name; #define CREATE_MPI_DATATYPE_NULL(name) \ static s_smpi_mpi_datatype_t mpi_##name = { \ + (char*) # name, \ 0, /* size */ \ 0, /*was 1 has_subtype*/ \ 0, /* lb */ \ @@ -51,6 +53,10 @@ typedef struct { float value; float index; } float_float; +typedef struct { + long value; + long index; +} long_long; typedef struct { double value; double index; @@ -75,7 +81,10 @@ typedef struct { long double value; int index; } long_double_int; - +typedef struct { + int64_t value; + int64_t index; +} integer128_t; // Predefined data types CREATE_MPI_DATATYPE(MPI_CHAR, char); CREATE_MPI_DATATYPE(MPI_SHORT, short); @@ -93,6 +102,7 @@ CREATE_MPI_DATATYPE(MPI_DOUBLE, double); CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE, long double); CREATE_MPI_DATATYPE(MPI_WCHAR, wchar_t); CREATE_MPI_DATATYPE(MPI_C_BOOL, _Bool); +CREATE_MPI_DATATYPE(MPI_BYTE, int8_t); CREATE_MPI_DATATYPE(MPI_INT8_T, int8_t); CREATE_MPI_DATATYPE(MPI_INT16_T, int16_t); CREATE_MPI_DATATYPE(MPI_INT32_T, int32_t); @@ -114,6 +124,19 @@ CREATE_MPI_DATATYPE(MPI_SHORT_INT, short_int); CREATE_MPI_DATATYPE(MPI_2INT, int_int); CREATE_MPI_DATATYPE(MPI_2FLOAT, float_float); CREATE_MPI_DATATYPE(MPI_2DOUBLE, double_double); +CREATE_MPI_DATATYPE(MPI_2LONG, long_long); + +CREATE_MPI_DATATYPE(MPI_REAL4, float); +CREATE_MPI_DATATYPE(MPI_REAL8, float); +CREATE_MPI_DATATYPE(MPI_REAL16, double); +CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX8); +CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX16); +CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX32); +CREATE_MPI_DATATYPE(MPI_INTEGER1, int); +CREATE_MPI_DATATYPE(MPI_INTEGER2, int16_t); +CREATE_MPI_DATATYPE(MPI_INTEGER4, int32_t); +CREATE_MPI_DATATYPE(MPI_INTEGER8, int64_t); +CREATE_MPI_DATATYPE(MPI_INTEGER16, integer128_t); CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE_INT, long_double_int); @@ -127,7 +150,8 @@ CREATE_MPI_DATATYPE(MPI_PTR, void*); */ int is_datatype_valid(MPI_Datatype datatype) { return datatype != MPI_DATATYPE_NULL - && (datatype->flags & DT_FLAG_COMMITED); + && (datatype->flags & DT_FLAG_COMMITED) + && (smpi_datatype_size(datatype)>0); } size_t smpi_datatype_size(MPI_Datatype datatype) @@ -145,18 +169,46 @@ MPI_Aint smpi_datatype_ub(MPI_Datatype datatype) return datatype->ub; } +MPI_Datatype smpi_datatype_dup(MPI_Datatype datatype) +{ + MPI_Datatype new_t= xbt_new(s_smpi_mpi_datatype_t,1); + memcpy(new_t, datatype, sizeof(s_smpi_mpi_datatype_t)); + if (datatype->has_subtype) + memcpy(new_t->substruct, datatype->substruct, sizeof(s_smpi_subtype_t)); + if(datatype->name) + new_t->name = strdup(datatype->name); + return new_t; +} + int smpi_datatype_extent(MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent) { + if(datatype == MPI_DATATYPE_NULL){ + *lb=0; + *extent=0; + return MPI_SUCCESS; + } *lb = datatype->lb; *extent = datatype->ub - datatype->lb; return MPI_SUCCESS; } MPI_Aint smpi_datatype_get_extent(MPI_Datatype datatype){ + if(datatype == MPI_DATATYPE_NULL){ + return 0; + } return datatype->ub - datatype->lb; } +void smpi_datatype_get_name(MPI_Datatype datatype, char* name, int* length){ + *length = strlen(datatype->name); + strcpy(name, datatype->name); +} + +void smpi_datatype_set_name(MPI_Datatype datatype, char* name){ + datatype->name = strdup(name);; +} + int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype) { @@ -177,7 +229,7 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, else if (sendtype->has_subtype == 0) { s_smpi_subtype_t *subtype = recvtype->substruct; - subtype->unserialize( sendbuf, recvbuf,1, subtype); + subtype->unserialize( sendbuf, recvbuf,1, subtype, MPI_REPLACE); } else if (recvtype->has_subtype == 0) { @@ -191,7 +243,7 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, subtype->serialize( sendbuf, buf_tmp,count/smpi_datatype_size(sendtype), subtype); subtype = recvtype->substruct; - subtype->unserialize( buf_tmp, recvbuf,count/smpi_datatype_size(recvtype), subtype); + subtype->unserialize( buf_tmp, recvbuf,count/smpi_datatype_size(recvtype), subtype, MPI_REPLACE); free(buf_tmp); } @@ -211,7 +263,7 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, */ void serialize_vector( const void *noncontiguous_vector, void *contiguous_vector, - size_t count, + int count, void *type) { s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type; @@ -248,8 +300,9 @@ void serialize_vector( const void *noncontiguous_vector, */ void unserialize_vector( const void *contiguous_vector, void *noncontiguous_vector, - size_t count, - void *type) + int count, + void *type, + MPI_Op op) { s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type; int i; @@ -259,13 +312,16 @@ void unserialize_vector( const void *contiguous_vector, for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->has_subtype == 0) - memcpy(noncontiguous_vector_char, - contiguous_vector_char, type_c->block_length * type_c->size_oldtype); + smpi_op_apply(op, contiguous_vector_char, noncontiguous_vector_char, &type_c->block_length, + &type_c->old_type); + /* memcpy(noncontiguous_vector_char, + contiguous_vector_char, type_c->block_length * type_c->size_oldtype);*/ else ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_vector_char, noncontiguous_vector_char, type_c->block_length, - type_c->old_type->substruct); + type_c->old_type->substruct, + op); contiguous_vector_char += type_c->block_length*type_c->size_oldtype; if((i+1)%type_c->block_count ==0) noncontiguous_vector_char += type_c->block_length*smpi_datatype_get_extent(type_c->old_type); @@ -292,6 +348,7 @@ s_smpi_mpi_vector_t* smpi_datatype_vector_create( int block_stride, new_t->block_stride = block_stride; new_t->block_length = block_length; new_t->block_count = block_count; + smpi_datatype_use(old_type); new_t->old_type = old_type; new_t->size_oldtype = size_oldtype; return new_t; @@ -300,6 +357,7 @@ s_smpi_mpi_vector_t* smpi_datatype_vector_create( int block_stride, void smpi_datatype_create(MPI_Datatype* new_type, int size,int lb, int ub, int has_subtype, void *struct_type, int flags){ MPI_Datatype new_t= xbt_new(s_smpi_mpi_datatype_t,1); + new_t->name = NULL; new_t->size = size; new_t->has_subtype = size>0? has_subtype:0; new_t->lb = lb; @@ -329,6 +387,9 @@ void smpi_datatype_free(MPI_Datatype* type){ ((s_smpi_subtype_t *)(*type)->substruct)->subtype_free(type); xbt_free((*type)->substruct); } + if ((*type)->name != NULL){ + xbt_free((*type)->name); + } xbt_free(*type); *type = MPI_DATATYPE_NULL; } @@ -346,7 +407,7 @@ void smpi_datatype_use(MPI_Datatype type){ void smpi_datatype_unuse(MPI_Datatype type){ if(type && type->in_use-- == 0 && (type->flags & DT_FLAG_DESTROYED)) smpi_datatype_free(&type); - + #ifdef HAVE_MC if(MC_is_active()) MC_ignore(&(type->in_use), sizeof(type->in_use)); @@ -372,7 +433,7 @@ Contiguous Implementation */ void serialize_contiguous( const void *noncontiguous_hvector, void *contiguous_hvector, - size_t count, + int count, void *type) { s_smpi_mpi_contiguous_t* type_c = (s_smpi_mpi_contiguous_t*)type; @@ -392,18 +453,22 @@ void serialize_contiguous( const void *noncontiguous_hvector, */ void unserialize_contiguous( const void *contiguous_vector, void *noncontiguous_vector, - size_t count, - void *type) + int count, + void *type, + MPI_Op op) { s_smpi_mpi_contiguous_t* type_c = (s_smpi_mpi_contiguous_t*)type; char* contiguous_vector_char = (char*)contiguous_vector; char* noncontiguous_vector_char = (char*)noncontiguous_vector+type_c->lb; - - memcpy(noncontiguous_vector_char, - contiguous_vector_char, count* type_c->block_count * type_c->size_oldtype); + int n= count* type_c->block_count; + smpi_op_apply(op, contiguous_vector_char, noncontiguous_vector_char, &n, + &type_c->old_type); + /*memcpy(noncontiguous_vector_char, + contiguous_vector_char, count* type_c->block_count * type_c->size_oldtype);*/ } void free_contiguous(MPI_Datatype* d){ + smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); } /* @@ -424,6 +489,7 @@ s_smpi_mpi_contiguous_t* smpi_datatype_contiguous_create( MPI_Aint lb, new_t->block_count = block_count; new_t->old_type = old_type; new_t->size_oldtype = size_oldtype; + smpi_datatype_use(old_type); return new_t; } @@ -491,6 +557,7 @@ int smpi_datatype_vector(int count, int blocklen, int stride, MPI_Datatype old_t } void free_vector(MPI_Datatype* d){ + smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); } /* @@ -509,7 +576,7 @@ Hvector Implementation - Vector with stride in bytes */ void serialize_hvector( const void *noncontiguous_hvector, void *contiguous_hvector, - size_t count, + int count, void *type) { s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type; @@ -545,8 +612,9 @@ void serialize_hvector( const void *noncontiguous_hvector, */ void unserialize_hvector( const void *contiguous_vector, void *noncontiguous_vector, - size_t count, - void *type) + int count, + void *type, + MPI_Op op) { s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type; int i; @@ -556,13 +624,16 @@ void unserialize_hvector( const void *contiguous_vector, for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->has_subtype == 0) - memcpy(noncontiguous_vector_char, - contiguous_vector_char, type_c->block_length * type_c->size_oldtype); + smpi_op_apply(op, contiguous_vector_char, noncontiguous_vector_char, &type_c->block_length, + &type_c->old_type); + /*memcpy(noncontiguous_vector_char, + contiguous_vector_char, type_c->block_length * type_c->size_oldtype);*/ else ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_vector_char, noncontiguous_vector_char, type_c->block_length, - type_c->old_type->substruct); + type_c->old_type->substruct, + op); contiguous_vector_char += type_c->block_length*type_c->size_oldtype; if((i+1)%type_c->block_count ==0) noncontiguous_vector_char += type_c->block_length*type_c->size_oldtype; @@ -591,11 +662,13 @@ s_smpi_mpi_hvector_t* smpi_datatype_hvector_create( MPI_Aint block_stride, new_t->block_count = block_count; new_t->old_type = old_type; new_t->size_oldtype = size_oldtype; + smpi_datatype_use(old_type); return new_t; } //do nothing for vector types void free_hvector(MPI_Datatype* d){ + smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); } int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) @@ -649,7 +722,7 @@ Indexed Implementation */ void serialize_indexed( const void *noncontiguous_indexed, void *contiguous_indexed, - size_t count, + int count, void *type) { s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; @@ -686,8 +759,9 @@ void serialize_indexed( const void *noncontiguous_indexed, */ void unserialize_indexed( const void *contiguous_indexed, void *noncontiguous_indexed, - size_t count, - void *type) + int count, + void *type, + MPI_Op op) { s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; @@ -697,13 +771,16 @@ void unserialize_indexed( const void *contiguous_indexed, for(j=0; jblock_count; i++) { if (type_c->old_type->has_subtype == 0) - memcpy(noncontiguous_indexed_char , - contiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype); + smpi_op_apply(op, contiguous_indexed_char, noncontiguous_indexed_char, &type_c->block_lengths[i], + &type_c->old_type); + /*memcpy(noncontiguous_indexed_char , + contiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype);*/ else ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_indexed_char, noncontiguous_indexed_char, type_c->block_lengths[i], - type_c->old_type->substruct); + type_c->old_type->substruct, + op); contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype; if (iblock_count-1) @@ -717,6 +794,7 @@ void unserialize_indexed( const void *contiguous_indexed, void free_indexed(MPI_Datatype* type){ xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_lengths); xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_indices); + smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*type)->substruct)->old_type); } /* @@ -742,6 +820,7 @@ s_smpi_mpi_indexed_t* smpi_datatype_indexed_create( int* block_lengths, new_t->block_indices[i]=block_indices[i]; } new_t->block_count = block_count; + smpi_datatype_use(old_type); new_t->old_type = old_type; new_t->size_oldtype = size_oldtype; return new_t; @@ -812,7 +891,7 @@ Hindexed Implementation - Indexed with indices in bytes */ void serialize_hindexed( const void *noncontiguous_hindexed, void *contiguous_hindexed, - size_t count, + int count, void *type) { s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; @@ -848,8 +927,9 @@ void serialize_hindexed( const void *noncontiguous_hindexed, */ void unserialize_hindexed( const void *contiguous_hindexed, void *noncontiguous_hindexed, - size_t count, - void *type) + int count, + void *type, + MPI_Op op) { s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; int i,j; @@ -859,13 +939,16 @@ void unserialize_hindexed( const void *contiguous_hindexed, for(j=0; jblock_count; i++) { if (type_c->old_type->has_subtype == 0) - memcpy(noncontiguous_hindexed_char, - contiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype); + smpi_op_apply(op, contiguous_hindexed_char, noncontiguous_hindexed_char, &type_c->block_lengths[i], + &type_c->old_type); + /*memcpy(noncontiguous_hindexed_char, + contiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype);*/ else ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_hindexed_char, noncontiguous_hindexed_char, type_c->block_lengths[i], - type_c->old_type->substruct); + type_c->old_type->substruct, + op); contiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype; if (iblock_count-1)noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1]; @@ -878,6 +961,7 @@ void unserialize_hindexed( const void *contiguous_hindexed, void free_hindexed(MPI_Datatype* type){ xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_lengths); xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_indices); + smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*type)->substruct)->old_type); } /* @@ -973,7 +1057,7 @@ struct Implementation - Indexed with indices in bytes */ void serialize_struct( const void *noncontiguous_struct, void *contiguous_struct, - size_t count, + int count, void *type) { s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type; @@ -1010,8 +1094,9 @@ void serialize_struct( const void *noncontiguous_struct, */ void unserialize_struct( const void *contiguous_struct, void *noncontiguous_struct, - size_t count, - void *type) + int count, + void *type, + MPI_Op op) { s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type; int i,j; @@ -1021,13 +1106,16 @@ void unserialize_struct( const void *contiguous_struct, for(j=0; jblock_count; i++) { if (type_c->old_types[i]->has_subtype == 0) - memcpy(noncontiguous_struct_char, - contiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i])); + smpi_op_apply(op, contiguous_struct_char, noncontiguous_struct_char, &type_c->block_lengths[i], + & type_c->old_types[i]); + /*memcpy(noncontiguous_struct_char, + contiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i]));*/ else ((s_smpi_subtype_t*)type_c->old_types[i]->substruct)->unserialize( contiguous_struct_char, noncontiguous_struct_char, type_c->block_lengths[i], - type_c->old_types[i]->substruct); + type_c->old_types[i]->substruct, + op); contiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]); if (iblock_count-1)noncontiguous_struct_char = (char*)noncontiguous_struct + type_c->block_indices[i+1]; @@ -1041,6 +1129,9 @@ void unserialize_struct( const void *contiguous_struct, void free_struct(MPI_Datatype* type){ xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_lengths); xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_indices); + int i=0; + for (i = 0; i < ((s_smpi_mpi_struct_t *)(*type)->substruct)->block_count; i++) + smpi_datatype_unuse(((s_smpi_mpi_struct_t *)(*type)->substruct)->old_types[i]); xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->old_types); } @@ -1066,6 +1157,7 @@ s_smpi_mpi_struct_t* smpi_datatype_struct_create( int* block_lengths, new_t->block_lengths[i]=block_lengths[i]; new_t->block_indices[i]=block_indices[i]; new_t->old_types[i]=old_types[i]; + smpi_datatype_use(new_t->old_types[i]); } //new_t->block_lengths = block_lengths; //new_t->block_indices = block_indices; @@ -1150,7 +1242,6 @@ typedef struct s_smpi_mpi_op { #define BXOR_OP(a, b) (b) ^= (a) #define MAXLOC_OP(a, b) (b) = (a.value) < (b.value) ? (b) : (a) #define MINLOC_OP(a, b) (b) = (a.value) < (b.value) ? (a) : (b) -//TODO : MINLOC & MAXLOC #define APPLY_FUNC(a, b, length, type, func) \ { \ @@ -1179,6 +1270,8 @@ static void max_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, MAX_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, MAX_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, MAX_OP); } else if (*datatype == MPI_FLOAT) { APPLY_FUNC(a, b, length, float, MAX_OP); } else if (*datatype == MPI_DOUBLE) { @@ -1205,6 +1298,8 @@ static void min_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, MIN_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, MIN_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, MIN_OP); } else if (*datatype == MPI_FLOAT) { APPLY_FUNC(a, b, length, float, MIN_OP); } else if (*datatype == MPI_DOUBLE) { @@ -1231,6 +1326,8 @@ static void sum_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, SUM_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, SUM_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, SUM_OP); } else if (*datatype == MPI_FLOAT) { APPLY_FUNC(a, b, length, float, SUM_OP); } else if (*datatype == MPI_DOUBLE) { @@ -1263,6 +1360,8 @@ static void prod_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, PROD_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, PROD_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, PROD_OP); } else if (*datatype == MPI_FLOAT) { APPLY_FUNC(a, b, length, float, PROD_OP); } else if (*datatype == MPI_DOUBLE) { @@ -1295,6 +1394,8 @@ static void land_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, LAND_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, LAND_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, LAND_OP); } else if (*datatype == MPI_C_BOOL) { APPLY_FUNC(a, b, length, _Bool, LAND_OP); } @@ -1317,6 +1418,8 @@ static void lor_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, LOR_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, LOR_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, LOR_OP); } else if (*datatype == MPI_C_BOOL) { APPLY_FUNC(a, b, length, _Bool, LOR_OP); } @@ -1339,6 +1442,8 @@ static void lxor_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, LXOR_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, LXOR_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, LXOR_OP); } else if (*datatype == MPI_C_BOOL) { APPLY_FUNC(a, b, length, _Bool, LXOR_OP); } @@ -1349,8 +1454,7 @@ static void band_func(void *a, void *b, int *length, { if (*datatype == MPI_CHAR) { APPLY_FUNC(a, b, length, char, BAND_OP); - } - if (*datatype == MPI_SHORT) { + }else if (*datatype == MPI_SHORT) { APPLY_FUNC(a, b, length, short, BAND_OP); } else if (*datatype == MPI_INT) { APPLY_FUNC(a, b, length, int, BAND_OP); @@ -1362,6 +1466,8 @@ static void band_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, BAND_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, BAND_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, BAND_OP); } else if (*datatype == MPI_BYTE) { APPLY_FUNC(a, b, length, uint8_t, BAND_OP); } @@ -1384,6 +1490,8 @@ static void bor_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, BOR_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, BOR_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, BOR_OP); } else if (*datatype == MPI_BYTE) { APPLY_FUNC(a, b, length, uint8_t, BOR_OP); } @@ -1406,6 +1514,8 @@ static void bxor_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, unsigned int, BXOR_OP); } else if (*datatype == MPI_UNSIGNED_LONG) { APPLY_FUNC(a, b, length, unsigned long, BXOR_OP); + } else if (*datatype == MPI_UNSIGNED_CHAR) { + APPLY_FUNC(a, b, length, unsigned char, BXOR_OP); } else if (*datatype == MPI_BYTE) { APPLY_FUNC(a, b, length, uint8_t, BXOR_OP); } @@ -1422,6 +1532,8 @@ static void minloc_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, double_int, MINLOC_OP); } else if (*datatype == MPI_SHORT_INT) { APPLY_FUNC(a, b, length, short_int, MINLOC_OP); + } else if (*datatype == MPI_2LONG) { + APPLY_FUNC(a, b, length, long_long, MINLOC_OP); } else if (*datatype == MPI_2INT) { APPLY_FUNC(a, b, length, int_int, MINLOC_OP); } else if (*datatype == MPI_LONG_DOUBLE_INT) { @@ -1444,6 +1556,8 @@ static void maxloc_func(void *a, void *b, int *length, APPLY_FUNC(a, b, length, double_int, MAXLOC_OP); } else if (*datatype == MPI_SHORT_INT) { APPLY_FUNC(a, b, length, short_int, MAXLOC_OP); + } else if (*datatype == MPI_2LONG) { + APPLY_FUNC(a, b, length, long_long, MAXLOC_OP); } else if (*datatype == MPI_2INT) { APPLY_FUNC(a, b, length, int_int, MAXLOC_OP); } else if (*datatype == MPI_LONG_DOUBLE_INT) { @@ -1455,6 +1569,11 @@ static void maxloc_func(void *a, void *b, int *length, } } +static void replace_func(void *a, void *b, int *length, + MPI_Datatype * datatype) +{ + memcpy(b, a, *length * smpi_datatype_size(*datatype)); +} #define CREATE_MPI_OP(name, func) \ static s_smpi_mpi_op_t mpi_##name = { &(func) /* func */, TRUE }; \ @@ -1472,6 +1591,8 @@ CREATE_MPI_OP(MPI_BOR, bor_func); CREATE_MPI_OP(MPI_BXOR, bxor_func); CREATE_MPI_OP(MPI_MAXLOC, maxloc_func); CREATE_MPI_OP(MPI_MINLOC, minloc_func); +CREATE_MPI_OP(MPI_REPLACE, replace_func); + MPI_Op smpi_op_new(MPI_User_function * function, int commute) {