X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/48eccb2c1532e35819830ca56fad7cf89887359f..36fa571a13985879dc627c70ecc2340af606aa42:/src/smpi/smpi_mpi_dt.cpp diff --git a/src/smpi/smpi_mpi_dt.cpp b/src/smpi/smpi_mpi_dt.cpp index 3463eb8a44..630ca733df 100644 --- a/src/smpi/smpi_mpi_dt.cpp +++ b/src/smpi/smpi_mpi_dt.cpp @@ -1,8 +1,5 @@ -/* smpi_mpi_dt.c -- MPI primitives to handle datatypes */ -/* FIXME: a very incomplete implementation */ - -/* Copyright (c) 2009-2015. The SimGrid Team. - * All rights reserved. */ +/* smpi_mpi_dt.c -- MPI primitives to handle datatypes */ +/* Copyright (c) 2009-2017. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ @@ -15,23 +12,24 @@ #include "smpi_mpi_dt_private.h" #include "mc/mc.h" #include "xbt/replay.h" +#include #include "simgrid/modelchecker.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_mpi_dt, smpi, "Logging specific to SMPI (datatype)"); -xbt_dict_t smpi_type_keyvals = NULL; +xbt_dict_t smpi_type_keyvals = nullptr; int type_keyval_id=0;//avoid collisions #define CREATE_MPI_DATATYPE(name, type) \ static s_smpi_mpi_datatype_t mpi_##name = { \ (char*) # name, \ sizeof(type), /* size */ \ - 0, /*was 1 sizeof_substruct*/ \ + 0, /*was 1 sizeof_substruct*/ \ 0, /* lb */ \ sizeof(type), /* ub = lb + size */ \ DT_FLAG_BASIC, /* flags */ \ - NULL, /* attributes */ \ - NULL, /* pointer on extended struct*/ \ + nullptr, /* attributes */ \ + nullptr, /* pointer on extended struct*/ \ 0 /* in_use counter */ \ }; \ const MPI_Datatype name = &mpi_##name; @@ -40,12 +38,12 @@ const MPI_Datatype name = &mpi_##name; static s_smpi_mpi_datatype_t mpi_##name = { \ (char*) # name, \ 0, /* size */ \ - 0, /* was 1 sizeof_substruct*/ \ + 0, /* was 1 sizeof_substruct*/ \ 0, /* lb */ \ 0, /* ub = lb + size */ \ DT_FLAG_BASIC, /* flags */ \ - NULL, /* attributes */ \ - NULL, /* pointer on extended struct*/ \ + nullptr, /* attributes */ \ + nullptr, /* pointer on extended struct*/ \ 0 /* in_use counter */ \ }; \ const MPI_Datatype name = &mpi_##name; @@ -154,8 +152,8 @@ CREATE_MPI_DATATYPE(MPI_PACKED, char); CREATE_MPI_DATATYPE(MPI_PTR, void*); /** Check if the datatype is usable for communications */ -int is_datatype_valid(MPI_Datatype datatype) { - return datatype != MPI_DATATYPE_NULL && (datatype->flags & DT_FLAG_COMMITED); +bool is_datatype_valid(MPI_Datatype datatype) { + return datatype != MPI_DATATYPE_NULL && ((datatype->flags & DT_FLAG_COMMITED) != 0); } size_t smpi_datatype_size(MPI_Datatype datatype) @@ -179,32 +177,34 @@ int smpi_datatype_dup(MPI_Datatype datatype, MPI_Datatype* new_t) *new_t= xbt_new(s_smpi_mpi_datatype_t,1); memcpy(*new_t, datatype, sizeof(s_smpi_mpi_datatype_t)); (*new_t)->in_use=1; + (*new_t)->flags &= ~DT_FLAG_PREDEFINED; if (datatype->sizeof_substruct){ (*new_t)->substruct=xbt_malloc(datatype->sizeof_substruct); memcpy((*new_t)->substruct, datatype->substruct, datatype->sizeof_substruct); } if(datatype->name) (*new_t)->name = xbt_strdup(datatype->name); - if(datatype->attributes !=NULL){ - (*new_t)->attributes=xbt_dict_new(); - xbt_dict_cursor_t cursor = NULL; - int *key; - int flag; - void* value_in; - void* value_out; - xbt_dict_foreach(datatype->attributes, cursor, key, value_in){ - smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)key, sizeof(int))); - if(elem && elem->copy_fn!=MPI_NULL_COPY_FN){ - ret = elem->copy_fn(datatype, *key, NULL, value_in, &value_out, &flag ); - if(ret!=MPI_SUCCESS){ - smpi_datatype_unuse(*new_t); - *new_t=MPI_DATATYPE_NULL; - return ret; - } - if(flag) - xbt_dict_set_ext((*new_t)->attributes, (const char*)key, sizeof(int),value_out, NULL); + if(datatype->attributes !=nullptr){ + (*new_t)->attributes = xbt_dict_new_homogeneous(nullptr); + xbt_dict_cursor_t cursor = nullptr; + int* key; + int flag; + void* value_in; + void* value_out; + xbt_dict_foreach (datatype->attributes, cursor, key, value_in) { + smpi_type_key_elem elem = static_cast( + xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(key), sizeof(int))); + if (elem != nullptr && elem->copy_fn != MPI_NULL_COPY_FN) { + ret = elem->copy_fn(datatype, *key, nullptr, value_in, &value_out, &flag); + if (ret != MPI_SUCCESS) { + smpi_datatype_unuse(*new_t); + *new_t = MPI_DATATYPE_NULL; + xbt_dict_cursor_free(&cursor); + return ret; } + if (flag) + xbt_dict_set_ext((*new_t)->attributes, reinterpret_cast(key), sizeof(int), value_out, nullptr); + } } } return ret; @@ -231,11 +231,13 @@ MPI_Aint smpi_datatype_get_extent(MPI_Datatype datatype){ void smpi_datatype_get_name(MPI_Datatype datatype, char* name, int* length){ *length = strlen(datatype->name); - strcpy(name, datatype->name); + strncpy(name, datatype->name, *length+1); } void smpi_datatype_set_name(MPI_Datatype datatype, char* name){ - datatype->name = xbt_strdup(name);; + if(datatype->name!=nullptr && (datatype->flags & DT_FLAG_PREDEFINED) == 0) + xbt_free(datatype->name); + datatype->name = xbt_strdup(name); } int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, @@ -253,7 +255,8 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, count = sendcount < recvcount ? sendcount : recvcount; if(sendtype->sizeof_substruct == 0 && recvtype->sizeof_substruct == 0) { - if(!smpi_process_get_replaying()) memcpy(recvbuf, sendbuf, count); + if(!smpi_process_get_replaying()) + memcpy(recvbuf, sendbuf, count); } else if (sendtype->sizeof_substruct == 0) { @@ -273,7 +276,7 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, subtype = static_cast(recvtype->substruct); subtype->unserialize( buf_tmp, recvbuf,count/smpi_datatype_size(recvtype), subtype, MPI_REPLACE); - free(buf_tmp); + xbt_free(buf_tmp); } } @@ -284,23 +287,23 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, * Copies noncontiguous data into contiguous memory. * @param contiguous_vector - output vector * @param noncontiguous_vector - input vector - * @param type - pointer contening : + * @param type - pointer containing : * - stride - stride of between noncontiguous data * - block_length - the width or height of blocked matrix * - count - the number of rows of matrix */ -void serialize_vector( const void *noncontiguous_vector, void *contiguous_vector, int count, void *type) +void serialize_vector( void* noncontiguous_vector, void *contiguous_vector, int count, void *type) { - s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type; + s_smpi_mpi_vector_t* type_c = reinterpret_cast(type); int i; - char* contiguous_vector_char = (char*)contiguous_vector; - char* noncontiguous_vector_char = (char*)noncontiguous_vector; + char* contiguous_vector_char = static_cast(contiguous_vector); + char* noncontiguous_vector_char = static_cast(noncontiguous_vector); for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->sizeof_substruct == 0) memcpy(contiguous_vector_char, noncontiguous_vector_char, type_c->block_length * type_c->size_oldtype); else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_vector_char, + static_cast(type_c->old_type->substruct)->serialize( noncontiguous_vector_char, contiguous_vector_char, type_c->block_length, type_c->old_type->substruct); @@ -321,22 +324,20 @@ void serialize_vector( const void *noncontiguous_vector, void *contiguous_vector * - block_length - the width or height of blocked matrix * - count - the number of rows of matrix */ -void unserialize_vector( const void *contiguous_vector, void *noncontiguous_vector, int count, void *type, MPI_Op op) +void unserialize_vector( void* contiguous_vector, void *noncontiguous_vector, int count, void *type, MPI_Op op) { - s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type; + s_smpi_mpi_vector_t* type_c = reinterpret_cast(type); int i; - char* contiguous_vector_char = (char*)contiguous_vector; - char* noncontiguous_vector_char = (char*)noncontiguous_vector; + char* contiguous_vector_char = static_cast(contiguous_vector); + char* noncontiguous_vector_char = static_cast(noncontiguous_vector); for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->sizeof_substruct == 0) 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, + static_cast(type_c->old_type->substruct)->unserialize(contiguous_vector_char, noncontiguous_vector_char, type_c->block_length,type_c->old_type->substruct, op); contiguous_vector_char += type_c->block_length*type_c->size_oldtype; @@ -368,7 +369,7 @@ s_smpi_mpi_vector_t* smpi_datatype_vector_create( int block_stride, int block_le void smpi_datatype_create(MPI_Datatype* new_type, int size,int lb, int ub, int sizeof_substruct, void *struct_type, int flags){ MPI_Datatype new_t= xbt_new(s_smpi_mpi_datatype_t,1); - new_t->name = NULL; + new_t->name = nullptr; new_t->size = size; new_t->sizeof_substruct = size>0? sizeof_substruct:0; new_t->lb = lb; @@ -376,7 +377,7 @@ void smpi_datatype_create(MPI_Datatype* new_type, int size,int lb, int ub, int s new_t->flags = flags; new_t->substruct = struct_type; new_t->in_use=1; - new_t->attributes=NULL; + new_t->attributes=nullptr; *new_type = new_t; #if HAVE_MC @@ -387,43 +388,47 @@ void smpi_datatype_create(MPI_Datatype* new_type, int size,int lb, int ub, int s void smpi_datatype_free(MPI_Datatype* type){ xbt_assert((*type)->in_use >= 0); - if((*type)->attributes !=NULL){ - xbt_dict_cursor_t cursor = NULL; + + if((*type)->flags & DT_FLAG_PREDEFINED) + return; + + //if still used, mark for deletion + if((*type)->in_use!=0){ + (*type)->flags |=DT_FLAG_DESTROYED; + return; + } + + if((*type)->attributes !=nullptr){ + xbt_dict_cursor_t cursor = nullptr; int* key; void * value; int flag; xbt_dict_foreach((*type)->attributes, cursor, key, value){ smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)key, sizeof(int))); - if(elem && elem->delete_fn) + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(key), sizeof(int))); + if(elem!=nullptr && elem->delete_fn!=nullptr) elem->delete_fn(*type,*key, value, &flag); } - } - - if((*type)->flags & DT_FLAG_PREDEFINED)return; - - //if still used, mark for deletion - if((*type)->in_use!=0){ - (*type)->flags |=DT_FLAG_DESTROYED; - return; + xbt_dict_free(&(*type)->attributes); } if ((*type)->sizeof_substruct != 0){ //((s_smpi_subtype_t *)(*type)->substruct)->subtype_free(type); xbt_free((*type)->substruct); } - if ((*type)->name != NULL){ - xbt_free((*type)->name); - } + xbt_free((*type)->name); + xbt_free(*type); *type = MPI_DATATYPE_NULL; } void smpi_datatype_use(MPI_Datatype type){ - if(type)type->in_use++; + if(type == MPI_DATATYPE_NULL) + return; + type->in_use++; if(type->sizeof_substruct!=0){ - ((s_smpi_subtype_t *)(type)->substruct)->subtype_use(&type); + static_cast((type)->substruct)->subtype_use(&type); } #if HAVE_MC if(MC_is_active()) @@ -431,21 +436,21 @@ void smpi_datatype_use(MPI_Datatype type){ #endif } -void smpi_datatype_unuse(MPI_Datatype type){ +void smpi_datatype_unuse(MPI_Datatype type) +{ + if (type == MPI_DATATYPE_NULL) + return; + if (type->in_use > 0) type->in_use--; if(type->sizeof_substruct!=0){ - ((s_smpi_subtype_t *)(type)->substruct)->subtype_free(&type); + static_cast((type)->substruct)->subtype_free(&type); } - if(type && type->in_use == 0){ - MPI_Datatype t = type; - if (!(type->flags & DT_FLAG_DESTROYED)) - smpi_datatype_free(&type); - if(t->flags & DT_FLAG_PREDEFINED) return; - xbt_free(t); - } + if (type->in_use == 0) + smpi_datatype_free(&type); + #if HAVE_MC if(MC_is_active()) MC_ignore(&(type->in_use), sizeof(type->in_use)); @@ -462,11 +467,11 @@ void smpi_datatype_unuse(MPI_Datatype type){ * - block_length - the width or height of blocked matrix * - count - the number of rows of matrix */ -void serialize_contiguous( const void *noncontiguous_hvector, void *contiguous_hvector, int count, void *type) +void serialize_contiguous( void* noncontiguous_hvector, void *contiguous_hvector, int count, void *type) { - s_smpi_mpi_contiguous_t* type_c = (s_smpi_mpi_contiguous_t*)type; - char* contiguous_vector_char = (char*)contiguous_hvector; - char* noncontiguous_vector_char = (char*)noncontiguous_hvector+type_c->lb; + s_smpi_mpi_contiguous_t* type_c = reinterpret_cast(type); + char* contiguous_vector_char = static_cast(contiguous_hvector); + char* noncontiguous_vector_char = static_cast(noncontiguous_hvector)+type_c->lb; memcpy(contiguous_vector_char, noncontiguous_vector_char, count* type_c->block_count * type_c->size_oldtype); } /* Copies contiguous data into noncontiguous memory. @@ -477,28 +482,29 @@ void serialize_contiguous( const void *noncontiguous_hvector, void *contiguous_h * - block_length - the width or height of blocked matrix * - count - the number of rows of matrix */ -void unserialize_contiguous(const void *contiguous_vector, void *noncontiguous_vector, int count, void *type, MPI_Op op) +void unserialize_contiguous(void* contiguous_vector, void *noncontiguous_vector, 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; + s_smpi_mpi_contiguous_t* type_c = reinterpret_cast(type); + char* contiguous_vector_char = static_cast(contiguous_vector); + char* noncontiguous_vector_char = static_cast(noncontiguous_vector)+type_c->lb; 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); + smpi_datatype_unuse(reinterpret_cast((*d)->substruct)->old_type); } void use_contiguous(MPI_Datatype* d){ - smpi_datatype_use(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*d)->substruct)->old_type); } /* Create a Sub type contiguous to be able to serialize and unserialize it the structure s_smpi_mpi_contiguous_t is - * erived from s_smpi_subtype which required the functions unserialize and serialize */ + * derived from s_smpi_subtype which required the functions unserialize and serialize */ s_smpi_mpi_contiguous_t* smpi_datatype_contiguous_create( MPI_Aint lb, int block_count, MPI_Datatype old_type, int size_oldtype){ + if(block_count==0) + return nullptr; s_smpi_mpi_contiguous_t *new_t= xbt_new(s_smpi_mpi_contiguous_t,1); new_t->base.serialize = &serialize_contiguous; new_t->base.unserialize = &unserialize_contiguous; @@ -532,14 +538,15 @@ int smpi_datatype_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new int smpi_datatype_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type) { int retval; - if (blocklen<0) return MPI_ERR_ARG; + if (blocklen<0) + return MPI_ERR_ARG; MPI_Aint lb = 0; MPI_Aint ub = 0; if(count>0){ lb=smpi_datatype_lb(old_type); ub=((count-1)*stride+blocklen-1)*smpi_datatype_get_extent(old_type)+smpi_datatype_ub(old_type); } - if(old_type->sizeof_substruct || stride != blocklen){ + if(old_type->sizeof_substruct != 0 || stride != blocklen){ s_smpi_mpi_vector_t* subtype = smpi_datatype_vector_create(stride, blocklen, count, old_type, smpi_datatype_size(old_type)); @@ -547,20 +554,20 @@ int smpi_datatype_vector(int count, int blocklen, int stride, MPI_Datatype old_t DT_FLAG_VECTOR); retval=MPI_SUCCESS; }else{ - /* in this situation the data are contignous thus it's not required to serialize and unserialize it*/ + /* in this situation the data are contiguous thus it's not required to serialize and unserialize it*/ smpi_datatype_create(new_type, count * blocklen * smpi_datatype_size(old_type), 0, ((count -1) * stride + blocklen)* - smpi_datatype_size(old_type), 0, NULL, DT_FLAG_VECTOR|DT_FLAG_CONTIGUOUS); + smpi_datatype_size(old_type), 0, nullptr, DT_FLAG_VECTOR|DT_FLAG_CONTIGUOUS); retval=MPI_SUCCESS; } return retval; } void free_vector(MPI_Datatype* d){ - smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); + smpi_datatype_unuse(reinterpret_cast((*d)->substruct)->old_type); } void use_vector(MPI_Datatype* d){ - smpi_datatype_use(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*d)->substruct)->old_type); } /* Hvector Implementation - Vector with stride in bytes */ @@ -573,18 +580,18 @@ void use_vector(MPI_Datatype* d){ * - block_length - the width or height of blocked matrix * - count - the number of rows of matrix */ -void serialize_hvector( const void *noncontiguous_hvector, void *contiguous_hvector, int count, void *type) +void serialize_hvector( void* noncontiguous_hvector, void *contiguous_hvector, int count, void *type) { - s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type; + s_smpi_mpi_hvector_t* type_c = reinterpret_cast(type); int i; - char* contiguous_vector_char = (char*)contiguous_hvector; - char* noncontiguous_vector_char = (char*)noncontiguous_hvector; + char* contiguous_vector_char = static_cast(contiguous_hvector); + char* noncontiguous_vector_char = static_cast(noncontiguous_hvector); for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->sizeof_substruct == 0) memcpy(contiguous_vector_char, noncontiguous_vector_char, type_c->block_length * type_c->size_oldtype); else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_vector_char, + static_cast(type_c->old_type->substruct)->serialize( noncontiguous_vector_char, contiguous_vector_char, type_c->block_length, type_c->old_type->substruct); @@ -603,21 +610,19 @@ void serialize_hvector( const void *noncontiguous_hvector, void *contiguous_hvec * - block_length - the width or height of blocked matrix * - count - the number of rows of matrix */ -void unserialize_hvector( const void *contiguous_vector, void *noncontiguous_vector, int count, void *type, MPI_Op op) +void unserialize_hvector( void* contiguous_vector, void *noncontiguous_vector, int count, void *type, MPI_Op op) { - s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type; + s_smpi_mpi_hvector_t* type_c = reinterpret_cast(type); int i; - char* contiguous_vector_char = (char*)contiguous_vector; - char* noncontiguous_vector_char = (char*)noncontiguous_vector; + char* contiguous_vector_char = static_cast(contiguous_vector); + char* noncontiguous_vector_char = static_cast(noncontiguous_vector); for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->sizeof_substruct == 0) 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, + static_cast(type_c->old_type->substruct)->unserialize( contiguous_vector_char, noncontiguous_vector_char, type_c->block_length, type_c->old_type->substruct, op); contiguous_vector_char += type_c->block_length*type_c->size_oldtype; @@ -650,24 +655,25 @@ s_smpi_mpi_hvector_t* smpi_datatype_hvector_create( MPI_Aint block_stride, int b //do nothing for vector types void free_hvector(MPI_Datatype* d){ - smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); + smpi_datatype_unuse(reinterpret_cast((*d)->substruct)->old_type); } void use_hvector(MPI_Datatype* d){ - smpi_datatype_use(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*d)->substruct)->old_type); } int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) { int retval; - if (blocklen<0) return MPI_ERR_ARG; + if (blocklen<0) + return MPI_ERR_ARG; MPI_Aint lb = 0; MPI_Aint ub = 0; if(count>0){ lb=smpi_datatype_lb(old_type); ub=((count-1)*stride)+(blocklen-1)*smpi_datatype_get_extent(old_type)+smpi_datatype_ub(old_type); } - if(old_type->sizeof_substruct || stride != blocklen*smpi_datatype_get_extent(old_type)){ + if(old_type->sizeof_substruct != 0 || stride != blocklen*smpi_datatype_get_extent(old_type)){ s_smpi_mpi_hvector_t* subtype = smpi_datatype_hvector_create( stride, blocklen, count, old_type, smpi_datatype_size(old_type)); @@ -675,7 +681,7 @@ int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype retval=MPI_SUCCESS; }else{ smpi_datatype_create(new_type, count * blocklen * smpi_datatype_size(old_type),0,count * blocklen * - smpi_datatype_size(old_type), 0, NULL, DT_FLAG_VECTOR|DT_FLAG_CONTIGUOUS); + smpi_datatype_size(old_type), 0, nullptr, DT_FLAG_VECTOR|DT_FLAG_CONTIGUOUS); retval=MPI_SUCCESS; } return retval; @@ -691,18 +697,18 @@ int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype * - block_indices - indices of each data, in element * - count - the number of rows of matrix */ -void serialize_indexed( const void *noncontiguous_indexed, void *contiguous_indexed, int count, void *type) +void serialize_indexed( void* noncontiguous_indexed, void *contiguous_indexed, int count, void *type) { - s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; + s_smpi_mpi_indexed_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_indexed_char = (char*)contiguous_indexed; - char* noncontiguous_indexed_char = (char*)noncontiguous_indexed+type_c->block_indices[0] * type_c->size_oldtype; + char* contiguous_indexed_char = static_cast(contiguous_indexed); + char* noncontiguous_indexed_char = static_cast(noncontiguous_indexed)+type_c->block_indices[0] * type_c->size_oldtype; for(j=0; jblock_count; i++) { if (type_c->old_type->sizeof_substruct == 0) memcpy(contiguous_indexed_char, noncontiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype); else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_indexed_char, + static_cast(type_c->old_type->substruct)->serialize( noncontiguous_indexed_char, contiguous_indexed_char, type_c->block_lengths[i], type_c->old_type->substruct); @@ -710,11 +716,11 @@ void serialize_indexed( const void *noncontiguous_indexed, void *contiguous_inde contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype; if (iblock_count-1) noncontiguous_indexed_char = - (char*)noncontiguous_indexed + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type); + static_cast(noncontiguous_indexed) + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type); else noncontiguous_indexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type); } - noncontiguous_indexed=(void*)noncontiguous_indexed_char; + noncontiguous_indexed=static_cast< void*>(noncontiguous_indexed_char); } } /* Copies contiguous data into noncontiguous memory. @@ -725,22 +731,20 @@ void serialize_indexed( const void *noncontiguous_indexed, void *contiguous_inde * - block_indices - indices of each data, in element * - count - the number of rows of matrix */ -void unserialize_indexed( const void *contiguous_indexed, void *noncontiguous_indexed, int count, void *type, MPI_Op op) +void unserialize_indexed( void* contiguous_indexed, void *noncontiguous_indexed, int count, void *type, MPI_Op op) { - s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; + s_smpi_mpi_indexed_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_indexed_char = (char*)contiguous_indexed; + char* contiguous_indexed_char = static_cast(contiguous_indexed); char* noncontiguous_indexed_char = - (char*)noncontiguous_indexed+type_c->block_indices[0]*smpi_datatype_get_extent(type_c->old_type); + static_cast(noncontiguous_indexed)+type_c->block_indices[0]*smpi_datatype_get_extent(type_c->old_type); for(j=0; jblock_count; i++) { if (type_c->old_type->sizeof_substruct == 0) 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, + static_cast(type_c->old_type->substruct)->unserialize( contiguous_indexed_char, noncontiguous_indexed_char, type_c->block_lengths[i], type_c->old_type->substruct, op); @@ -748,24 +752,24 @@ void unserialize_indexed( const void *contiguous_indexed, void *noncontiguous_in contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype; if (iblock_count-1) noncontiguous_indexed_char = - (char*)noncontiguous_indexed + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type); + static_cast(noncontiguous_indexed) + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type); else noncontiguous_indexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type); } - noncontiguous_indexed=(void*)noncontiguous_indexed_char; + noncontiguous_indexed=static_cast(noncontiguous_indexed_char); } } void free_indexed(MPI_Datatype* type){ if((*type)->in_use==0){ - xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_lengths); - xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_indices); + xbt_free(reinterpret_cast((*type)->substruct)->block_lengths); + xbt_free(reinterpret_cast((*type)->substruct)->block_indices); } - smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*type)->substruct)->old_type); + smpi_datatype_unuse(reinterpret_cast((*type)->substruct)->old_type); } void use_indexed(MPI_Datatype* type){ - smpi_datatype_use(((s_smpi_mpi_indexed_t *)(*type)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*type)->substruct)->old_type); } @@ -797,7 +801,7 @@ int smpi_datatype_indexed(int count, int* blocklens, int* indices, MPI_Datatype int i; int retval; int size = 0; - int contiguous=1; + bool contiguous=true; MPI_Aint lb = 0; MPI_Aint ub = 0; if(count>0){ @@ -815,10 +819,11 @@ int smpi_datatype_indexed(int count, int* blocklens, int* indices, MPI_Datatype if(indices[i]*smpi_datatype_get_extent(old_type)+blocklens[i]*smpi_datatype_ub(old_type)>ub) ub = indices[i]*smpi_datatype_get_extent(old_type)+blocklens[i]*smpi_datatype_ub(old_type); - if ( (i< count -1) && (indices[i]+blocklens[i] != indices[i+1]) )contiguous=0; + if ( (i< count -1) && (indices[i]+blocklens[i] != indices[i+1]) ) + contiguous=false; } if (old_type->sizeof_substruct != 0) - contiguous=0; + contiguous=false; if(!contiguous){ s_smpi_mpi_indexed_t* subtype = smpi_datatype_indexed_create( blocklens, indices, count, old_type, @@ -843,29 +848,29 @@ int smpi_datatype_indexed(int count, int* blocklens, int* indices, MPI_Datatype * - block_indices - indices of each data, in bytes * - count - the number of rows of matrix */ -void serialize_hindexed( const void *noncontiguous_hindexed, void *contiguous_hindexed, int count, void *type) +void serialize_hindexed( void* noncontiguous_hindexed, void *contiguous_hindexed, int count, void *type) { - s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; + s_smpi_mpi_hindexed_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_hindexed_char = (char*)contiguous_hindexed; - char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed+ type_c->block_indices[0]; + char* contiguous_hindexed_char = static_cast(contiguous_hindexed); + char* noncontiguous_hindexed_char = static_cast(noncontiguous_hindexed)+ type_c->block_indices[0]; for(j=0; jblock_count; i++) { if (type_c->old_type->sizeof_substruct == 0) memcpy(contiguous_hindexed_char, noncontiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype); else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_hindexed_char, + static_cast(type_c->old_type->substruct)->serialize( noncontiguous_hindexed_char, contiguous_hindexed_char, type_c->block_lengths[i], type_c->old_type->substruct); 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]; + noncontiguous_hindexed_char = static_cast(noncontiguous_hindexed) + type_c->block_indices[i+1]; else noncontiguous_hindexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type); } - noncontiguous_hindexed=(void*)noncontiguous_hindexed_char; + noncontiguous_hindexed=static_cast(noncontiguous_hindexed_char); } } /* Copies contiguous data into noncontiguous memory. @@ -876,46 +881,45 @@ void serialize_hindexed( const void *noncontiguous_hindexed, void *contiguous_hi * - block_indices - indices of each data, in bytes * - count - the number of rows of matrix */ -void unserialize_hindexed( const void *contiguous_hindexed, void *noncontiguous_hindexed, int count, void *type, +void unserialize_hindexed( void* contiguous_hindexed, void *noncontiguous_hindexed, int count, void *type, MPI_Op op) { - s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; + s_smpi_mpi_hindexed_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_hindexed_char = (char*)contiguous_hindexed; - char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed+ type_c->block_indices[0]; + char* contiguous_hindexed_char = static_cast(contiguous_hindexed); + char* noncontiguous_hindexed_char = static_cast(noncontiguous_hindexed)+ type_c->block_indices[0]; for(j=0; jblock_count; i++) { if (type_c->old_type->sizeof_substruct == 0) 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, + static_cast(type_c->old_type->substruct)->unserialize( contiguous_hindexed_char, noncontiguous_hindexed_char, type_c->block_lengths[i], 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]; + noncontiguous_hindexed_char = static_cast(noncontiguous_hindexed) + type_c->block_indices[i+1]; else noncontiguous_hindexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type); } - noncontiguous_hindexed=(void*)noncontiguous_hindexed_char; + noncontiguous_hindexed=static_cast(noncontiguous_hindexed_char); } } void free_hindexed(MPI_Datatype* type){ if((*type)->in_use==0){ - xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_lengths); - xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_indices); + xbt_free(reinterpret_cast((*type)->substruct)->block_lengths); + xbt_free(reinterpret_cast((*type)->substruct)->block_indices); } - smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*type)->substruct)->old_type); + smpi_datatype_unuse(reinterpret_cast((*type)->substruct)->old_type); } void use_hindexed(MPI_Datatype* type){ - smpi_datatype_use(((s_smpi_mpi_indexed_t *)(*type)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*type)->substruct)->old_type); } /* Create a Sub type hindexed to be able to serialize and unserialize it the structure s_smpi_mpi_hindexed_t is derived @@ -930,8 +934,7 @@ s_smpi_mpi_hindexed_t* smpi_datatype_hindexed_create( int* block_lengths, MPI_Ai new_t->base.subtype_use = &use_hindexed; new_t->block_lengths= xbt_new(int, block_count); new_t->block_indices= xbt_new(MPI_Aint, block_count); - int i; - for(i=0;iblock_lengths[i]=block_lengths[i]; new_t->block_indices[i]=block_indices[i]; } @@ -947,7 +950,7 @@ int smpi_datatype_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Dat int i; int retval; int size = 0; - int contiguous=1; + bool contiguous=true; MPI_Aint lb = 0; MPI_Aint ub = 0; if(count>0){ @@ -959,14 +962,16 @@ int smpi_datatype_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Dat return MPI_ERR_ARG; size += blocklens[i]; - if(indices[i]+smpi_datatype_lb(old_type)ub) ub = indices[i]+blocklens[i]*smpi_datatype_ub(old_type); + if(indices[i]+smpi_datatype_lb(old_type)ub) + ub = indices[i]+blocklens[i]*smpi_datatype_ub(old_type); - if ( (i< count -1) && (indices[i]+blocklens[i]*static_cast(smpi_datatype_size(old_type)) != indices[i+1]) ) - contiguous=0; + if ( (i< count -1) && (indices[i]+blocklens[i]*(static_cast(smpi_datatype_size(old_type))) != indices[i+1]) ) + contiguous=false; } if (old_type->sizeof_substruct != 0 || lb!=0) - contiguous=0; + contiguous=false; if(!contiguous){ s_smpi_mpi_hindexed_t* subtype = smpi_datatype_hindexed_create( blocklens, indices, count, old_type, @@ -991,19 +996,19 @@ int smpi_datatype_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Dat * - block_length - the width or height of blocked matrix * - count - the number of rows of matrix */ -void serialize_struct( const void *noncontiguous_struct, void *contiguous_struct, int count, void *type) +void serialize_struct( void* noncontiguous_struct, void *contiguous_struct, int count, void *type) { - s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type; + s_smpi_mpi_struct_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_struct_char = (char*)contiguous_struct; - char* noncontiguous_struct_char = (char*)noncontiguous_struct+ type_c->block_indices[0]; + char* contiguous_struct_char = static_cast(contiguous_struct); + char* noncontiguous_struct_char = static_cast(noncontiguous_struct)+ type_c->block_indices[0]; for(j=0; jblock_count; i++) { if (type_c->old_types[i]->sizeof_substruct == 0) memcpy(contiguous_struct_char, noncontiguous_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)->serialize( noncontiguous_struct_char, + static_cast(type_c->old_types[i]->substruct)->serialize( noncontiguous_struct_char, contiguous_struct_char, type_c->block_lengths[i], type_c->old_types[i]->substruct); @@ -1011,11 +1016,11 @@ void serialize_struct( const void *noncontiguous_struct, void *contiguous_struct 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]; + noncontiguous_struct_char = static_cast(noncontiguous_struct) + type_c->block_indices[i+1]; else //let's hope this is MPI_UB ? noncontiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_types[i]); } - noncontiguous_struct=(void*)noncontiguous_struct_char; + noncontiguous_struct=static_cast(noncontiguous_struct_char); } } @@ -1027,51 +1032,49 @@ void serialize_struct( const void *noncontiguous_struct, void *contiguous_struct * - block_length - the width or height of blocked matrix * - count - the number of rows of matrix */ -void unserialize_struct( const void *contiguous_struct, void *noncontiguous_struct, int count, void *type, MPI_Op op) +void unserialize_struct( void* contiguous_struct, void *noncontiguous_struct, int count, void *type, MPI_Op op) { - s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type; + s_smpi_mpi_struct_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_struct_char = (char*)contiguous_struct; - char* noncontiguous_struct_char = (char*)noncontiguous_struct+ type_c->block_indices[0]; + char* contiguous_struct_char = static_cast(contiguous_struct); + char* noncontiguous_struct_char = static_cast(noncontiguous_struct)+ type_c->block_indices[0]; for(j=0; jblock_count; i++) { if (type_c->old_types[i]->sizeof_substruct == 0) 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, + static_cast(type_c->old_types[i]->substruct)->unserialize( contiguous_struct_char, noncontiguous_struct_char, type_c->block_lengths[i], 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]; + noncontiguous_struct_char = static_cast(noncontiguous_struct) + type_c->block_indices[i+1]; else noncontiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_types[i]); } - noncontiguous_struct=(void*)noncontiguous_struct_char; + noncontiguous_struct=reinterpret_cast(noncontiguous_struct_char); } } void free_struct(MPI_Datatype* type){ 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]); + for (i = 0; i < reinterpret_cast((*type)->substruct)->block_count; i++) + smpi_datatype_unuse(reinterpret_cast((*type)->substruct)->old_types[i]); if((*type)->in_use==0){ - xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_lengths); - xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_indices); - xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->old_types); + xbt_free(reinterpret_cast((*type)->substruct)->block_lengths); + xbt_free(reinterpret_cast((*type)->substruct)->block_indices); + xbt_free(reinterpret_cast((*type)->substruct)->old_types); } } void use_struct(MPI_Datatype* type){ int i=0; - for (i = 0; i < ((s_smpi_mpi_struct_t *)(*type)->substruct)->block_count; i++) - smpi_datatype_use(((s_smpi_mpi_struct_t *)(*type)->substruct)->old_types[i]); + for (i = 0; i < reinterpret_cast((*type)->substruct)->block_count; i++) + smpi_datatype_use(reinterpret_cast((*type)->substruct)->old_types[i]); } /* Create a Sub type struct to be able to serialize and unserialize it the structure s_smpi_mpi_struct_t is derived @@ -1102,7 +1105,7 @@ int smpi_datatype_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datat { int i; size_t size = 0; - int contiguous=1; + bool contiguous=true; size = 0; MPI_Aint lb = 0; MPI_Aint ub = 0; @@ -1110,30 +1113,31 @@ int smpi_datatype_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datat lb=indices[0] + smpi_datatype_lb(old_types[0]); ub=indices[0] + blocklens[0]*smpi_datatype_ub(old_types[0]); } - int forced_lb=0; - int forced_ub=0; + bool forced_lb=false; + bool forced_ub=false; for(i=0; i< count; i++){ if (blocklens[i]<0) return MPI_ERR_ARG; if (old_types[i]->sizeof_substruct != 0) - contiguous=0; + contiguous=false; size += blocklens[i]*smpi_datatype_size(old_types[i]); if (old_types[i]==MPI_LB){ lb=indices[i]; - forced_lb=1; + forced_lb=true; } if (old_types[i]==MPI_UB){ ub=indices[i]; - forced_ub=1; + forced_ub=true; } - if(!forced_lb && indices[i]+smpi_datatype_lb(old_types[i])ub) ub = indices[i]+blocklens[i]*smpi_datatype_ub(old_types[i]); if ( (i< count -1) && (indices[i]+blocklens[i]*static_cast(smpi_datatype_size(old_types[i])) != indices[i+1]) ) - contiguous=0; + contiguous=false; } if(!contiguous){ @@ -1154,7 +1158,8 @@ void smpi_datatype_commit(MPI_Datatype *datatype) typedef struct s_smpi_mpi_op { MPI_User_function *func; - int is_commute; + bool is_commute; + bool is_fortran_op; } s_smpi_mpi_op_t; #define MAX_OP(a, b) (b) = (a) < (b) ? (b) : (a) @@ -1180,308 +1185,157 @@ typedef struct s_smpi_mpi_op { } \ } +#define APPLY_OP_LOOP(dtype, type, op) \ + if (*datatype == dtype) {\ + APPLY_FUNC(a, b, length, type, op)\ + } else \ + + +#define APPLY_BASIC_OP_LOOP(op)\ +APPLY_OP_LOOP(MPI_CHAR, char,op)\ +APPLY_OP_LOOP(MPI_SHORT, short,op)\ +APPLY_OP_LOOP(MPI_INT, int,op)\ +APPLY_OP_LOOP(MPI_LONG, long,op)\ +APPLY_OP_LOOP(MPI_LONG_LONG, long long,op)\ +APPLY_OP_LOOP(MPI_SIGNED_CHAR, signed char,op)\ +APPLY_OP_LOOP(MPI_UNSIGNED_CHAR, unsigned char,op)\ +APPLY_OP_LOOP(MPI_UNSIGNED_SHORT, unsigned short,op)\ +APPLY_OP_LOOP(MPI_UNSIGNED, unsigned int,op)\ +APPLY_OP_LOOP(MPI_UNSIGNED_LONG, unsigned long,op)\ +APPLY_OP_LOOP(MPI_UNSIGNED_LONG_LONG, unsigned long long,op)\ +APPLY_OP_LOOP(MPI_WCHAR, wchar_t,op)\ +APPLY_OP_LOOP(MPI_BYTE, int8_t,op)\ +APPLY_OP_LOOP(MPI_INT8_T, int8_t,op)\ +APPLY_OP_LOOP(MPI_INT16_T, int16_t,op)\ +APPLY_OP_LOOP(MPI_INT32_T, int32_t,op)\ +APPLY_OP_LOOP(MPI_INT64_T, int64_t,op)\ +APPLY_OP_LOOP(MPI_UINT8_T, uint8_t,op)\ +APPLY_OP_LOOP(MPI_UINT16_T, uint16_t,op)\ +APPLY_OP_LOOP(MPI_UINT32_T, uint32_t,op)\ +APPLY_OP_LOOP(MPI_UINT64_T, uint64_t,op)\ +APPLY_OP_LOOP(MPI_AINT, MPI_Aint,op)\ +APPLY_OP_LOOP(MPI_OFFSET, MPI_Offset,op)\ +APPLY_OP_LOOP(MPI_INTEGER1, int,op)\ +APPLY_OP_LOOP(MPI_INTEGER2, int16_t,op)\ +APPLY_OP_LOOP(MPI_INTEGER4, int32_t,op)\ +APPLY_OP_LOOP(MPI_INTEGER8, int64_t,op) + +#define APPLY_BOOL_OP_LOOP(op)\ +APPLY_OP_LOOP(MPI_C_BOOL, bool,op) + +#define APPLY_FLOAT_OP_LOOP(op)\ +APPLY_OP_LOOP(MPI_FLOAT, float,op)\ +APPLY_OP_LOOP(MPI_DOUBLE, double,op)\ +APPLY_OP_LOOP(MPI_LONG_DOUBLE, long double,op)\ +APPLY_OP_LOOP(MPI_REAL, float,op)\ +APPLY_OP_LOOP(MPI_REAL4, float,op)\ +APPLY_OP_LOOP(MPI_REAL8, float,op)\ +APPLY_OP_LOOP(MPI_REAL16, double,op) + +#define APPLY_COMPLEX_OP_LOOP(op)\ +APPLY_OP_LOOP(MPI_C_FLOAT_COMPLEX, float _Complex,op)\ +APPLY_OP_LOOP(MPI_C_DOUBLE_COMPLEX, double _Complex,op)\ +APPLY_OP_LOOP(MPI_C_LONG_DOUBLE_COMPLEX, long double _Complex,op) + +#define APPLY_PAIR_OP_LOOP(op)\ +APPLY_OP_LOOP(MPI_FLOAT_INT, float_int,op)\ +APPLY_OP_LOOP(MPI_LONG_INT, long_int,op)\ +APPLY_OP_LOOP(MPI_DOUBLE_INT, double_int,op)\ +APPLY_OP_LOOP(MPI_SHORT_INT, short_int,op)\ +APPLY_OP_LOOP(MPI_2INT, int_int,op)\ +APPLY_OP_LOOP(MPI_2FLOAT, float_float,op)\ +APPLY_OP_LOOP(MPI_2DOUBLE, double_double,op)\ +APPLY_OP_LOOP(MPI_LONG_DOUBLE_INT, long_double_int,op)\ +APPLY_OP_LOOP(MPI_2LONG, long_long,op) + +#define APPLY_END_OP_LOOP(op)\ + {\ + xbt_die("Failed to apply " #op " to type %s", (*datatype)->name);\ + } + + static void max_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, MAX_OP); - } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, MAX_OP); - } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, MAX_OP); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, MAX_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, MAX_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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) { - APPLY_FUNC(a, b, length, double, MAX_OP); - } else if (*datatype == MPI_LONG_DOUBLE) { - APPLY_FUNC(a, b, length, long double, MAX_OP); - } + APPLY_BASIC_OP_LOOP(MAX_OP) + APPLY_FLOAT_OP_LOOP(MAX_OP) + APPLY_END_OP_LOOP(MAX_OP) } static void min_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, MIN_OP); - } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, MIN_OP); - } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, MIN_OP); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, MIN_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, MIN_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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) { - APPLY_FUNC(a, b, length, double, MIN_OP); - } else if (*datatype == MPI_LONG_DOUBLE) { - APPLY_FUNC(a, b, length, long double, MIN_OP); - } + APPLY_BASIC_OP_LOOP(MIN_OP) + APPLY_FLOAT_OP_LOOP(MIN_OP) + APPLY_END_OP_LOOP(MIN_OP) } static void sum_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, SUM_OP); - } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, SUM_OP); - } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, SUM_OP); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, SUM_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, SUM_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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) { - APPLY_FUNC(a, b, length, double, SUM_OP); - } else if (*datatype == MPI_LONG_DOUBLE) { - APPLY_FUNC(a, b, length, long double, SUM_OP); - } else if (*datatype == MPI_C_FLOAT_COMPLEX) { - APPLY_FUNC(a, b, length, float _Complex, SUM_OP); - } else if (*datatype == MPI_C_DOUBLE_COMPLEX) { - APPLY_FUNC(a, b, length, double _Complex, SUM_OP); - } else if (*datatype == MPI_C_LONG_DOUBLE_COMPLEX) { - APPLY_FUNC(a, b, length, long double _Complex, SUM_OP); - } + APPLY_BASIC_OP_LOOP(SUM_OP) + APPLY_FLOAT_OP_LOOP(SUM_OP) + APPLY_COMPLEX_OP_LOOP(SUM_OP) + APPLY_END_OP_LOOP(SUM_OP) } static void prod_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, PROD_OP); - } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, PROD_OP); - } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, PROD_OP); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, PROD_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, PROD_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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) { - APPLY_FUNC(a, b, length, double, PROD_OP); - } else if (*datatype == MPI_LONG_DOUBLE) { - APPLY_FUNC(a, b, length, long double, PROD_OP); - } else if (*datatype == MPI_C_FLOAT_COMPLEX) { - APPLY_FUNC(a, b, length, float _Complex, PROD_OP); - } else if (*datatype == MPI_C_DOUBLE_COMPLEX) { - APPLY_FUNC(a, b, length, double _Complex, PROD_OP); - } else if (*datatype == MPI_C_LONG_DOUBLE_COMPLEX) { - APPLY_FUNC(a, b, length, long double _Complex, PROD_OP); - } + APPLY_BASIC_OP_LOOP(PROD_OP) + APPLY_FLOAT_OP_LOOP(PROD_OP) + APPLY_COMPLEX_OP_LOOP(PROD_OP) + APPLY_END_OP_LOOP(PROD_OP) } static void land_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, LAND_OP); - } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, LAND_OP); - } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, LAND_OP); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, LAND_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, LAND_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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); - } + APPLY_BASIC_OP_LOOP(LAND_OP) + APPLY_BOOL_OP_LOOP(LAND_OP) + APPLY_END_OP_LOOP(LAND_OP) } static void lor_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, LOR_OP); - } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, LOR_OP); - } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, LOR_OP); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, LOR_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, LOR_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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); - } + APPLY_BASIC_OP_LOOP(LOR_OP) + APPLY_BOOL_OP_LOOP(LOR_OP) + APPLY_END_OP_LOOP(LOR_OP) } static void lxor_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, LXOR_OP); - } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, LXOR_OP); - } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, LXOR_OP); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, LXOR_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, LXOR_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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); - } + APPLY_BASIC_OP_LOOP(LXOR_OP) + APPLY_BOOL_OP_LOOP(LXOR_OP) + APPLY_END_OP_LOOP(LXOR_OP) } static void band_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, BAND_OP); - }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); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, BAND_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, BAND_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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); - } + APPLY_BASIC_OP_LOOP(BAND_OP) + APPLY_BOOL_OP_LOOP(BAND_OP) + APPLY_END_OP_LOOP(BAND_OP) } static void bor_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, BOR_OP); - } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, BOR_OP); - } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, BOR_OP); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, BOR_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, BOR_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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); - } + APPLY_BASIC_OP_LOOP(BOR_OP) + APPLY_BOOL_OP_LOOP(BOR_OP) + APPLY_END_OP_LOOP(BOR_OP) } static void bxor_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, BXOR_OP); - } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, BXOR_OP); - } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, BXOR_OP); - } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, BXOR_OP); - } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, BXOR_OP); - } else if (*datatype == MPI_UNSIGNED) { - 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); - } + APPLY_BASIC_OP_LOOP(BXOR_OP) + APPLY_BOOL_OP_LOOP(BXOR_OP) + APPLY_END_OP_LOOP(BXOR_OP) } static void minloc_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_FLOAT_INT) { - APPLY_FUNC(a, b, length, float_int, MINLOC_OP); - } else if (*datatype == MPI_LONG_INT) { - APPLY_FUNC(a, b, length, long_int, MINLOC_OP); - } else if (*datatype == MPI_DOUBLE_INT) { - 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) { - APPLY_FUNC(a, b, length, long_double_int, MINLOC_OP); - } else if (*datatype == MPI_2FLOAT) { - APPLY_FUNC(a, b, length, float_float, MINLOC_OP); - } else if (*datatype == MPI_2DOUBLE) { - APPLY_FUNC(a, b, length, double_double, MINLOC_OP); - } + APPLY_PAIR_OP_LOOP(MINLOC_OP) + APPLY_END_OP_LOOP(MINLOC_OP) } static void maxloc_func(void *a, void *b, int *length, MPI_Datatype * datatype) { - if (*datatype == MPI_FLOAT_INT) { - APPLY_FUNC(a, b, length, float_int, MAXLOC_OP); - } else if (*datatype == MPI_LONG_INT) { - APPLY_FUNC(a, b, length, long_int, MAXLOC_OP); - } else if (*datatype == MPI_DOUBLE_INT) { - 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) { - APPLY_FUNC(a, b, length, long_double_int, MAXLOC_OP); - } else if (*datatype == MPI_2FLOAT) { - APPLY_FUNC(a, b, length, float_float, MAXLOC_OP); - } else if (*datatype == MPI_2DOUBLE) { - APPLY_FUNC(a, b, length, double_double, MAXLOC_OP); - } + APPLY_PAIR_OP_LOOP(MAXLOC_OP) + APPLY_END_OP_LOOP(MAXLOC_OP) } static void replace_func(void *a, void *b, int *length, MPI_Datatype * datatype) @@ -1490,7 +1344,7 @@ static void replace_func(void *a, void *b, int *length, MPI_Datatype * datatype) } #define CREATE_MPI_OP(name, func) \ - static s_smpi_mpi_op_t mpi_##name = { &(func) /* func */, true }; \ + static s_smpi_mpi_op_t mpi_##name = { &(func) /* func */, true, false }; \ MPI_Op name = &mpi_##name; CREATE_MPI_OP(MPI_MAX, max_func); @@ -1507,18 +1361,19 @@ 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) +MPI_Op smpi_op_new(MPI_User_function * function, bool commute) { MPI_Op op; op = xbt_new(s_smpi_mpi_op_t, 1); op->func = function; op-> is_commute = commute; + op-> is_fortran_op = false; return op; } -int smpi_op_is_commute(MPI_Op op) +bool smpi_op_is_commute(MPI_Op op) { - return (op==MPI_OP_NULL) ? 1 : op-> is_commute; + return (op==MPI_OP_NULL) ? true : op-> is_commute; } void smpi_op_destroy(MPI_Op op) @@ -1526,6 +1381,12 @@ void smpi_op_destroy(MPI_Op op) xbt_free(op); } +void smpi_op_set_fortran(MPI_Op op) +{ + //tell that we were created from fortran, so we need to translate the type to fortran when called + op->is_fortran_op = true; +} + void smpi_op_apply(MPI_Op op, void *invec, void *inoutvec, int *len, MPI_Datatype * datatype) { if(op==MPI_OP_NULL) @@ -1536,76 +1397,84 @@ void smpi_op_apply(MPI_Op op, void *invec, void *inoutvec, int *len, MPI_Datatyp smpi_switch_data_segment(smpi_process_index()); } - if(!smpi_process_get_replaying()) - op->func(invec, inoutvec, len, datatype); + if(!smpi_process_get_replaying()){ + if(! op->is_fortran_op) + op->func(invec, inoutvec, len, datatype); + else{ + int tmp = smpi_type_c2f(*datatype); + /* Unfortunately, the C and Fortran version of the MPI standard do not agree on the type here, + thus the reinterpret_cast. */ + op->func(invec, inoutvec, len, reinterpret_cast(&tmp) ); + } + } } int smpi_type_attr_delete(MPI_Datatype type, int keyval){ smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)&keyval, sizeof(int))); - if(!elem) + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(&keyval), sizeof(int))); + if(elem==nullptr) return MPI_ERR_ARG; if(elem->delete_fn!=MPI_NULL_DELETE_FN){ - void * value; + void * value = nullptr; int flag; if(smpi_type_attr_get(type, keyval, &value, &flag)==MPI_SUCCESS){ int ret = elem->delete_fn(type, keyval, value, &flag); - if(ret!=MPI_SUCCESS) return ret; + if(ret!=MPI_SUCCESS) + return ret; } } - if(type->attributes==NULL) + if(type->attributes==nullptr) return MPI_ERR_ARG; - xbt_dict_remove_ext(type->attributes, (const char*)&keyval, sizeof(int)); + xbt_dict_remove_ext(type->attributes, reinterpret_cast(&keyval), sizeof(int)); return MPI_SUCCESS; } int smpi_type_attr_get(MPI_Datatype type, int keyval, void* attr_value, int* flag){ smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)&keyval, sizeof(int))); - if(!elem) + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(&keyval), sizeof(int))); + if(elem==nullptr) return MPI_ERR_ARG; - xbt_ex_t ex; - if(type->attributes==NULL){ + if(type->attributes==nullptr){ *flag=0; return MPI_SUCCESS; } - TRY { - *(void**)attr_value = xbt_dict_get_ext(type->attributes, (const char*)&keyval, sizeof(int)); + try { + *static_cast(attr_value) = xbt_dict_get_ext(type->attributes, reinterpret_cast(&keyval), sizeof(int)); *flag=1; } - CATCH(ex) { + catch (xbt_ex& ex) { *flag=0; - xbt_ex_free(ex); } return MPI_SUCCESS; } int smpi_type_attr_put(MPI_Datatype type, int keyval, void* attr_value){ - if(!smpi_type_keyvals) - smpi_type_keyvals = xbt_dict_new(); + if(smpi_type_keyvals==nullptr) + smpi_type_keyvals = xbt_dict_new_homogeneous(nullptr); smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)&keyval, sizeof(int))); - if(!elem ) + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(&keyval), sizeof(int))); + if(elem==nullptr) return MPI_ERR_ARG; int flag; - void* value; + void* value = nullptr; smpi_type_attr_get(type, keyval, &value, &flag); - if(flag && elem->delete_fn!=MPI_NULL_DELETE_FN){ + if(flag!=0 && elem->delete_fn!=MPI_NULL_DELETE_FN){ int ret = elem->delete_fn(type, keyval, value, &flag); - if(ret!=MPI_SUCCESS) return ret; + if(ret!=MPI_SUCCESS) + return ret; } - if(type->attributes==NULL) - type->attributes=xbt_dict_new(); + if(type->attributes==nullptr) + type->attributes = xbt_dict_new_homogeneous(nullptr); - xbt_dict_set_ext(type->attributes, (const char*)&keyval, sizeof(int), attr_value, NULL); + xbt_dict_set_ext(type->attributes, reinterpret_cast(&keyval), sizeof(int), attr_value, nullptr); return MPI_SUCCESS; } int smpi_type_keyval_create(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval, void* extra_state){ - if(!smpi_type_keyvals) - smpi_type_keyvals = xbt_dict_new(); + if(smpi_type_keyvals==nullptr) + smpi_type_keyvals = xbt_dict_new_homogeneous(nullptr); smpi_type_key_elem value = (smpi_type_key_elem) xbt_new0(s_smpi_mpi_type_key_elem_t,1); @@ -1613,18 +1482,18 @@ int smpi_type_keyval_create(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delet value->delete_fn=delete_fn; *keyval = type_keyval_id; - xbt_dict_set_ext(smpi_type_keyvals,(const char*)keyval, sizeof(int),(void*)value, NULL); + xbt_dict_set_ext(smpi_type_keyvals,reinterpret_cast(keyval), sizeof(int),reinterpret_cast(value), nullptr); type_keyval_id++; return MPI_SUCCESS; } int smpi_type_keyval_free(int* keyval){ smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)keyval, sizeof(int))); - if(!elem){ + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(keyval), sizeof(int))); + if(elem==0){ return MPI_ERR_ARG; } - xbt_dict_remove_ext(smpi_type_keyvals, (const char*)keyval, sizeof(int)); + xbt_dict_remove_ext(smpi_type_keyvals, reinterpret_cast(keyval), sizeof(int)); xbt_free(elem); return MPI_SUCCESS; } @@ -1633,7 +1502,7 @@ int smpi_mpi_pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int size_t size = smpi_datatype_size(type); if (outcount - *position < incount*static_cast(size)) return MPI_ERR_BUFFER; - smpi_datatype_copy(inbuf, incount, type, (char*)outbuf + *position, outcount, MPI_CHAR); + smpi_datatype_copy(inbuf, incount, type, static_cast(outbuf) + *position, outcount, MPI_CHAR); *position += incount * size; return MPI_SUCCESS; } @@ -1642,7 +1511,7 @@ int smpi_mpi_unpack(void* inbuf, int insize, int* position, void* outbuf, int ou int size = static_cast(smpi_datatype_size(type)); if (outcount*size> insize) return MPI_ERR_BUFFER; - smpi_datatype_copy((char*)inbuf + *position, insize, MPI_CHAR, outbuf, outcount, type); + smpi_datatype_copy(static_cast(inbuf) + *position, insize, MPI_CHAR, outbuf, outcount, type); *position += outcount * size; return MPI_SUCCESS; }