From: jean-noel quintin Date: Thu, 4 Oct 2012 15:09:16 +0000 (+0100) Subject: Merge remote-tracking branch 'origin/master' X-Git-Tag: v3_8~143 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/ad5734ab76c2c430832004e0e3af55a0378e1c5d?hp=-c Merge remote-tracking branch 'origin/master' --- ad5734ab76c2c430832004e0e3af55a0378e1c5d diff --combined src/smpi/private.h index b969e6b9a1,6beed4938b..e9227f544a --- a/src/smpi/private.h +++ b/src/smpi/private.h @@@ -24,8 -24,6 +24,6 @@@ typedef struct s_smpi_process_data *smp #define RECV 0x8 - //***************************************************************************************** - // this struct is here to handle the problem of non-contignous data // for each such structure these function should be implemented (vector // index hvector hindex struct) @@@ -34,16 -32,6 +32,6 @@@ typedef struct s_smpi_subtype void (*unserialize)(const void * input, void *output, size_t count, void* subtype); } s_smpi_subtype_t; - /*one exemple of implementation for the vector is already here*/ - typedef struct s_smpi_mpi_vector{ - s_smpi_subtype_t base; - size_t block_stride; - size_t block_length; - size_t block_count; - MPI_Datatype old_type; - size_t size_oldtype; - } s_smpi_mpi_vector_t; - typedef struct s_smpi_mpi_datatype{ size_t size; /* this let us know if a serialization is required*/ @@@ -55,7 -43,6 +43,6 @@@ void *substruct; } s_smpi_mpi_datatype_t; - //***************************************************************************************** typedef struct s_smpi_mpi_request { @@@ -73,7 -60,6 +60,7 @@@ MPI_Comm comm; smx_action_t action; unsigned flags; + int detached; #ifdef HAVE_TRACING int send; int recv; @@@ -130,23 -116,6 +117,6 @@@ void smpi_datatype_create(MPI_Datatype void smpi_datatype_free(MPI_Datatype* type); void smpi_datatype_commit(MPI_Datatype* datatype); - void unserialize_vector( const void *contiguous_vector, - void *noncontiguous_vector, - size_t count, - void *type); - - void serialize_vector( const void *noncontiguous_vector, - void *contiguous_vector, - size_t count, - void *type); - - s_smpi_mpi_vector_t* smpi_datatype_vector_create( int block_stride, - int block_length, - int block_count, - MPI_Datatype old_type, - int size_oldtype); - - void smpi_empty_status(MPI_Status * status); MPI_Op smpi_op_new(MPI_User_function * function, int commute); void smpi_op_destroy(MPI_Op op); diff --combined src/smpi/smpi_mpi_dt.c index 255e5ca379,a266ec9135..b3320611dd --- a/src/smpi/smpi_mpi_dt.c +++ b/src/smpi/smpi_mpi_dt.c @@@ -201,7 -201,6 +201,7 @@@ void serialize_vector( const void *nonc noncontiguous_vector_char += type_c->block_stride*type_c->size_oldtype; } } + /* * Copies contiguous data into noncontiguous memory. * @param noncontiguous_vector - output vector @@@ -256,12 -255,12 +256,12 @@@ s_smpi_mpi_vector_t* smpi_datatype_vect void smpi_datatype_create(MPI_Datatype* new_type, int size, int has_subtype, void *struct_type, int flags){ MPI_Datatype new_t= xbt_new(s_smpi_mpi_datatype_t,1); - new_t->size=size; - new_t->has_subtype=has_subtype; - new_t->lb=0; - new_t->ub=size; - new_t->flags=flags; - new_t->substruct=struct_type; + new_t->size = size; + new_t->has_subtype = has_subtype; + new_t->lb = 0; + new_t->ub = size; + new_t->flags = flags; + new_t->substruct = struct_type; *new_type = new_t; } @@@ -305,7 -304,7 +305,7 @@@ int smpi_datatype_vector(int count, in }else{ /* in this situation the data are contignous thus it's not * required to serialize and unserialize it*/ - smpi_datatype_create(new_type, count * (blocklen) * + smpi_datatype_create(new_type, count * blocklen * smpi_datatype_size(old_type), 0, NULL, @@@ -316,6 -315,91 +316,91 @@@ return retval; } + + + /* + Hvector Implementation - Vector with stride in bytes + */ + + + /* + * Copies noncontiguous data into contiguous memory. + * @param contiguous_hvector - output hvector + * @param noncontiguous_hvector - input hvector + * @param type - pointer contening : + * - stride - stride of between noncontiguous data, in bytes + * - 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, + size_t count, + void *type) + { + s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type; + int i; + char* contiguous_vector_char = (char*)contiguous_hvector; + char* noncontiguous_vector_char = (char*)noncontiguous_hvector; + + for (i = 0; i < type_c->block_count * count; i++) { + memcpy(contiguous_vector_char, + noncontiguous_vector_char, type_c->block_length * type_c->size_oldtype); + + contiguous_vector_char += type_c->block_length*type_c->size_oldtype; + noncontiguous_vector_char += type_c->block_stride; + } + } + /* + * Copies contiguous data into noncontiguous memory. + * @param noncontiguous_vector - output hvector + * @param contiguous_vector - input hvector + * @param type - pointer contening : + * - stride - stride of between noncontiguous data, in bytes + * - 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, + size_t count, + void *type) + { + s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type; + int i; + + char* contiguous_vector_char = (char*)contiguous_vector; + char* noncontiguous_vector_char = (char*)noncontiguous_vector; + + for (i = 0; i < type_c->block_count * count; i++) { + memcpy(noncontiguous_vector_char, + contiguous_vector_char, type_c->block_length * type_c->size_oldtype); + + contiguous_vector_char += type_c->block_length*type_c->size_oldtype; + noncontiguous_vector_char += type_c->block_stride; + } + } + + /* + * Create a Sub type vector to be able to serialize and unserialize it + * the structre s_smpi_mpi_vector_t is derived from s_smpi_subtype which + * required the functions unserialize and serialize + * + */ + s_smpi_mpi_hvector_t* smpi_datatype_hvector_create( MPI_Aint block_stride, + int block_length, + int block_count, + MPI_Datatype old_type, + int size_oldtype){ + s_smpi_mpi_hvector_t *new_t= xbt_new(s_smpi_mpi_hvector_t,1); + new_t->base.serialize = &serialize_hvector; + new_t->base.unserialize = &unserialize_hvector; + new_t->block_stride = block_stride; + new_t->block_length = block_length; + new_t->block_count = block_count; + new_t->old_type = old_type; + new_t->size_oldtype = size_oldtype; + return new_t; + } + int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) { int retval; @@@ -323,20 -407,115 +408,115 @@@ if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) { retval = MPI_ERR_TYPE; } else { - /*FIXME: as for the vector the data should be serialized and - * unserialized moreover a structure derived from s_smpi_subtype should - * be created*/ - smpi_datatype_create(new_type, count * ((blocklen * - smpi_datatype_size(old_type))+stride), - 0, - NULL, - DT_FLAG_VECTOR); - retval=MPI_SUCCESS; + if(stride != blocklen*smpi_datatype_size(old_type)){ + s_smpi_mpi_hvector_t* subtype = smpi_datatype_hvector_create( stride, + blocklen, + count, + old_type, + smpi_datatype_size(old_type)); + + smpi_datatype_create(new_type, count * blocklen * + smpi_datatype_size(old_type), + 1, + subtype, + DT_FLAG_VECTOR); + retval=MPI_SUCCESS; + }else{ + smpi_datatype_create(new_type, count * blocklen * + smpi_datatype_size(old_type), + 0, + NULL, + DT_FLAG_VECTOR); + retval=MPI_SUCCESS; + } } return retval; } + /* + Indexed Implementation + */ + + /* + * Copies noncontiguous data into contiguous memory. + * @param contiguous_indexed - output indexed + * @param noncontiguous_indexed - input indexed + * @param type - pointer contening : + * - stride - stride of between noncontiguous data + * - block_length - the width or height of blocked matrix + * - count - the number of rows of matrix + */ + void serialize_indexed( const void *noncontiguous_indexed, + void *contiguous_indexed, + size_t count, + void *type) + { + s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; + int i; + char* contiguous_indexed_char = (char*)contiguous_indexed; + char* noncontiguous_indexed_char = (char*)noncontiguous_indexed; + + for (i = 0; i < type_c->block_count * count; i++) { + memcpy(contiguous_indexed_char, + noncontiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype); + + contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype; + noncontiguous_indexed_char = (char*)noncontiguous_indexed + type_c->block_indices[i+1]*type_c->size_oldtype; + } + } + /* + * Copies contiguous data into noncontiguous memory. + * @param noncontiguous_indexed - output indexed + * @param contiguous_indexed - input indexed + * @param type - pointer contening : + * - stride - stride of between noncontiguous data + * - block_length - the width or height of blocked matrix + * - count - the number of rows of matrix + */ + void unserialize_indexed( const void *contiguous_indexed, + void *noncontiguous_indexed, + size_t count, + void *type) + { + s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; + int i; + + char* contiguous_indexed_char = (char*)contiguous_indexed; + char* noncontiguous_indexed_char = (char*)noncontiguous_indexed; + + for (i = 0; i < type_c->block_count * count; i++) { + memcpy(noncontiguous_indexed_char, + contiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype); + + contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype; + noncontiguous_indexed_char = (char*)noncontiguous_indexed + type_c->block_indices[i+1]*type_c->size_oldtype; + } + } + + /* + * Create a Sub type indexed to be able to serialize and unserialize it + * the structre s_smpi_mpi_indexed_t is derived from s_smpi_subtype which + * required the functions unserialize and serialize + */ + s_smpi_mpi_indexed_t* smpi_datatype_indexed_create( int* block_lengths, + int* block_indices, + int block_count, + MPI_Datatype old_type, + int size_oldtype){ + s_smpi_mpi_indexed_t *new_t= xbt_new(s_smpi_mpi_indexed_t,1); + new_t->base.serialize = &serialize_indexed; + new_t->base.unserialize = &unserialize_indexed; + //FIXME : copy those or assume they won't be freed ? + new_t->block_lengths = block_lengths; + new_t->block_indices = block_indices; + new_t->block_count = block_count; + new_t->old_type = old_type; + new_t->size_oldtype = size_oldtype; + return new_t; + } + + int smpi_datatype_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) { int i; @@@ -350,16 -529,103 +530,103 @@@ if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) { retval = MPI_ERR_TYPE; } else { - /*FIXME: as for the vector the data should be serialized and - * unserialized moreover a structure derived from s_smpi_subtype should - * be created*/ - smpi_datatype_create(new_type, (size) * - smpi_datatype_size(old_type),0, NULL, DT_FLAG_DATA); + s_smpi_mpi_indexed_t* subtype = smpi_datatype_indexed_create( blocklens, + indices, + count, + old_type, + smpi_datatype_size(old_type)); + + smpi_datatype_create(new_type, size * + smpi_datatype_size(old_type),1, subtype, DT_FLAG_DATA); retval=MPI_SUCCESS; } return retval; } + + /* + Hindexed Implementation - Indexed with indices in bytes + */ + + /* + * Copies noncontiguous data into contiguous memory. + * @param contiguous_hindexed - output hindexed + * @param noncontiguous_hindexed - input hindexed + * @param type - pointer contening : + * - stride - stride of between noncontiguous data + * - block_length - the width or height of blocked matrix + * - count - the number of rows of matrix + */ + void serialize_hindexed( const void *noncontiguous_hindexed, + void *contiguous_hindexed, + size_t count, + void *type) + { + s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; + int i; + char* contiguous_hindexed_char = (char*)contiguous_hindexed; + char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed; + + for (i = 0; i < type_c->block_count * count; i++) { + memcpy(contiguous_hindexed_char, + noncontiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype); + + contiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype; + noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1]; + } + } + /* + * Copies contiguous data into noncontiguous memory. + * @param noncontiguous_hindexed - output hindexed + * @param contiguous_hindexed - input hindexed + * @param type - pointer contening : + * - stride - stride of between noncontiguous data + * - block_length - the width or height of blocked matrix + * - count - the number of rows of matrix + */ + void unserialize_hindexed( const void *contiguous_hindexed, + void *noncontiguous_hindexed, + size_t count, + void *type) + { + s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; + int i; + + char* contiguous_hindexed_char = (char*)contiguous_hindexed; + char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed; + + for (i = 0; i < type_c->block_count * count; i++) { + memcpy(noncontiguous_hindexed_char, + contiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype); + + contiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype; + noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1]; + } + } + + /* + * Create a Sub type hindexed to be able to serialize and unserialize it + * the structre s_smpi_mpi_hindexed_t is derived from s_smpi_subtype which + * required the functions unserialize and serialize + */ + s_smpi_mpi_hindexed_t* smpi_datatype_hindexed_create( int* block_lengths, + MPI_Aint* block_indices, + int block_count, + MPI_Datatype old_type, + int size_oldtype){ + s_smpi_mpi_hindexed_t *new_t= xbt_new(s_smpi_mpi_hindexed_t,1); + new_t->base.serialize = &serialize_hindexed; + new_t->base.unserialize = &unserialize_hindexed; + //FIXME : copy those or assume they won't be freed ? + new_t->block_lengths = block_lengths; + new_t->block_indices = block_indices; + new_t->block_count = block_count; + new_t->old_type = old_type; + new_t->size_oldtype = size_oldtype; + return new_t; + } + + int smpi_datatype_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type) { int i; @@@ -373,19 -639,105 +640,103 @@@ if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) { retval = MPI_ERR_TYPE; } else { - /*FIXME: as for the vector the data should be serialized and - * unserialized moreover a structure derived from s_smpi_subtype should - * be created*/ - smpi_datatype_create(new_type,(size * smpi_datatype_size(old_type)), 0,NULL, DT_FLAG_DATA); + s_smpi_mpi_hindexed_t* subtype = smpi_datatype_hindexed_create( blocklens, + indices, + count, + old_type, + smpi_datatype_size(old_type)); + + smpi_datatype_create(new_type, size * + smpi_datatype_size(old_type),1, subtype, DT_FLAG_DATA); retval=MPI_SUCCESS; } return retval; } + + /* + struct Implementation - Indexed with indices in bytes + */ + + /* + * Copies noncontiguous data into contiguous memory. + * @param contiguous_struct - output struct + * @param noncontiguous_struct - input struct + * @param type - pointer contening : + * - stride - stride of between noncontiguous data + * - 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, + size_t count, + void *type) + { + s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type; + int i; + char* contiguous_struct_char = (char*)contiguous_struct; + char* noncontiguous_struct_char = (char*)noncontiguous_struct; + + for (i = 0; i < type_c->block_count * count; i++) { + memcpy(contiguous_struct_char, + noncontiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i])); + contiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]); + noncontiguous_struct_char = (char*)noncontiguous_struct + type_c->block_indices[i+1]; + } + } + /* + * Copies contiguous data into noncontiguous memory. + * @param noncontiguous_struct - output struct + * @param contiguous_struct - input struct + * @param type - pointer contening : + * - stride - stride of between noncontiguous data + * - 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, + size_t count, + void *type) + { + s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type; + int i; + + char* contiguous_struct_char = (char*)contiguous_struct; + char* noncontiguous_struct_char = (char*)noncontiguous_struct; + + for (i = 0; i < type_c->block_count * count; i++) { + memcpy(noncontiguous_struct_char, + contiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i])); + contiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]); + noncontiguous_struct_char = (char*)noncontiguous_struct + type_c->block_indices[i+1]; + } + } + + /* + * Create a Sub type struct to be able to serialize and unserialize it + * the structre s_smpi_mpi_struct_t is derived from s_smpi_subtype which + * required the functions unserialize and serialize + */ + s_smpi_mpi_struct_t* smpi_datatype_struct_create( int* block_lengths, + MPI_Aint* block_indices, + int block_count, + MPI_Datatype* old_types){ + s_smpi_mpi_struct_t *new_t= xbt_new(s_smpi_mpi_struct_t,1); + new_t->base.serialize = &serialize_struct; + new_t->base.unserialize = &unserialize_struct; + //FIXME : copy those or assume they won't be freed ? + new_t->block_lengths = block_lengths; + new_t->block_indices = block_indices; + new_t->block_count = block_count; + new_t->old_types = old_types; + return new_t; + } + + int smpi_datatype_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) { int i; - size_t size; //Khalid added this - - size = 0; + size_t size = 0; for(i=0; i< count; i++){ if (blocklens[i]<=0) return MPI_ERR_ARG; @@@ -393,12 -745,15 +744,15 @@@ return MPI_ERR_TYPE; size += blocklens[i]*smpi_datatype_size(old_types[i]); } - /*FIXME: as for the vector the data should be serialized and - * unserialized moreover a structure derived from s_smpi_subtype should - * be created*/ - smpi_datatype_create(new_type, size, - 0, NULL, - DT_FLAG_DATA); + + + s_smpi_mpi_struct_t* subtype = smpi_datatype_struct_create( blocklens, + indices, + count, + old_types); + + smpi_datatype_create(new_type, size ,1, subtype, DT_FLAG_DATA); + return MPI_SUCCESS; }