X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c66daa524a31a24910bc8a1d239743e502367e09..2c803179bcf6c7b734f6f22aa44fda9da4d1793d:/src/smpi/smpi_mpi_dt.c diff --git a/src/smpi/smpi_mpi_dt.c b/src/smpi/smpi_mpi_dt.c index 700870df07..d277579752 100644 --- a/src/smpi/smpi_mpi_dt.c +++ b/src/smpi/smpi_mpi_dt.c @@ -5,7 +5,7 @@ * 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. */ + * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include @@ -17,22 +17,27 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_mpi_dt, smpi, "Logging specific to SMPI (datatype)"); -typedef struct s_smpi_mpi_datatype { - size_t size; - MPI_Aint lb; - MPI_Aint ub; - int flags; -} s_smpi_mpi_datatype_t; - #define CREATE_MPI_DATATYPE(name, type) \ static s_smpi_mpi_datatype_t mpi_##name = { \ sizeof(type), /* size */ \ + 0, /*was 1 has_subtype*/ \ 0, /* lb */ \ sizeof(type), /* ub = lb + size */ \ - DT_FLAG_BASIC /* flags */ \ + DT_FLAG_BASIC, /* flags */ \ + NULL /* pointer on extended struct*/ \ }; \ - MPI_Datatype name = &mpi_##name; +MPI_Datatype name = &mpi_##name; +#define CREATE_MPI_DATATYPE_NULL(name) \ + static s_smpi_mpi_datatype_t mpi_##name = { \ + 0, /* size */ \ + 0, /*was 1 has_subtype*/ \ + 0, /* lb */ \ + 0, /* ub = lb + size */ \ + DT_FLAG_BASIC, /* flags */ \ + NULL /* pointer on extended struct*/ \ + }; \ +MPI_Datatype name = &mpi_##name; //The following are datatypes for the MPI functions MPI_MAXLOC and MPI_MINLOC. typedef struct { @@ -98,6 +103,8 @@ CREATE_MPI_DATATYPE(MPI_SHORT_INT, short_int); CREATE_MPI_DATATYPE(MPI_2INT, int_int); CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE_INT, long_double_int); +CREATE_MPI_DATATYPE_NULL(MPI_UB); +CREATE_MPI_DATATYPE_NULL(MPI_LB); // Internal use only CREATE_MPI_DATATYPE(MPI_PTR, void*); @@ -107,6 +114,8 @@ size_t smpi_datatype_size(MPI_Datatype datatype) return datatype->size; } + + MPI_Aint smpi_datatype_lb(MPI_Datatype datatype) { return datatype->lb; @@ -145,12 +154,736 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, sendcount *= smpi_datatype_size(sendtype); recvcount *= smpi_datatype_size(recvtype); count = sendcount < recvcount ? sendcount : recvcount; - memcpy(recvbuf, sendbuf, count); + + if(sendtype->has_subtype == 0 && recvtype->has_subtype == 0) { + memcpy(recvbuf, sendbuf, count); + } + else if (sendtype->has_subtype == 0) + { + s_smpi_subtype_t *subtype = recvtype->substruct; + subtype->unserialize( sendbuf, recvbuf,1, subtype); + } + else if (recvtype->has_subtype == 0) + { + s_smpi_subtype_t *subtype = sendtype->substruct; + subtype->serialize(sendbuf, recvbuf,1, subtype); + }else{ + s_smpi_subtype_t *subtype = sendtype->substruct; + + s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)sendtype; + + void * buf_tmp = malloc(count * type_c->size_oldtype); + + subtype->serialize( sendbuf, buf_tmp,1, subtype); + subtype = recvtype->substruct; + subtype->unserialize(recvbuf, buf_tmp,1, subtype); + + free(buf_tmp); + } retval = sendcount > recvcount ? MPI_ERR_TRUNCATE : MPI_SUCCESS; } + + return retval; +} + +/* + * Copies noncontiguous data into contiguous memory. + * @param contiguous_vector - output vector + * @param noncontiguous_vector - input vector + * @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_vector( const void *noncontiguous_vector, + void *contiguous_vector, + size_t count, + void *type) +{ + s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_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(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*type_c->size_oldtype; + } +} + +/* + * Copies contiguous data into noncontiguous memory. + * @param noncontiguous_vector - output vector + * @param contiguous_vector - input vector + * @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_vector( const void *contiguous_vector, + void *noncontiguous_vector, + size_t count, + void *type) +{ + s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_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*type_c->size_oldtype; + } +} + +/* + * Create a Sub type vector to be able to serialize and unserialize it + * the structure s_smpi_mpi_vector_t is derived from s_smpi_subtype which + * required the functions unserialize and serialize + * + */ +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){ + s_smpi_mpi_vector_t *new_t= xbt_new(s_smpi_mpi_vector_t,1); + new_t->base.serialize = &serialize_vector; + new_t->base.unserialize = &unserialize_vector; + new_t->base.subtype_free = &free_vector; + 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; +} + +void smpi_datatype_create(MPI_Datatype* new_type, int size,int extent, 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 = extent; + new_t->flags = flags; + new_t->substruct = struct_type; + *new_type = new_t; +} + +void smpi_datatype_free(MPI_Datatype* type){ + if ((*type)->has_subtype == 1){ + ((s_smpi_subtype_t *)(*type)->substruct)->subtype_free(type); + } + xbt_free(*type); +} + +int smpi_datatype_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_type) +{ + int retval; + if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) { + retval = MPI_ERR_TYPE; + } else { + smpi_datatype_create(new_type, count * + smpi_datatype_size(old_type),count * + smpi_datatype_size(old_type),0,NULL, DT_FLAG_CONTIGUOUS); + retval=MPI_SUCCESS; + } + return retval; +} + +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 ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) { + retval = MPI_ERR_TYPE; + } else { + if(stride != blocklen){ +if (old_type->has_subtype == 1) + XBT_WARN("vector contains a complex type - not yet handled"); + s_smpi_mpi_vector_t* subtype = smpi_datatype_vector_create( stride, + blocklen, + count, + old_type, + smpi_datatype_size(old_type)); + + smpi_datatype_create(new_type, count * (blocklen) * + smpi_datatype_size(old_type), + ((count -1) * stride + blocklen) * smpi_datatype_size(old_type), + 1, + subtype, + DT_FLAG_VECTOR); + retval=MPI_SUCCESS; + }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_size(old_type), ((count -1) * stride + blocklen)* + smpi_datatype_size(old_type), + 0, + NULL, + DT_FLAG_VECTOR|DT_FLAG_CONTIGUOUS); + retval=MPI_SUCCESS; + } + } + return retval; +} + +void free_vector(MPI_Datatype* d){ +} + +/* +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 structure 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->base.subtype_free = &free_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; +} + +//do nothing for vector types +void free_hvector(MPI_Datatype* d){ +} + +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 ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) { + retval = MPI_ERR_TYPE; + } else { +if (old_type->has_subtype == 1) + XBT_WARN("hvector contains a complex type - not yet handled"); + 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), (count-1) * stride + 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),count * blocklen * + smpi_datatype_size(old_type), + 0, + NULL, + DT_FLAG_VECTOR|DT_FLAG_CONTIGUOUS); + 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 : + * - block_lengths - the width or height of blocked matrix + * - 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, + size_t count, + void *type) +{ + s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; + int i,j; + char* contiguous_indexed_char = (char*)contiguous_indexed; + char* noncontiguous_indexed_char = (char*)noncontiguous_indexed; + for(j=0; jblock_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; + if (iblock_count-1)noncontiguous_indexed_char = (char*)noncontiguous_indexed + type_c->block_indices[i+1]*type_c->size_oldtype; + else noncontiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype; + } + noncontiguous_indexed=(void*)noncontiguous_indexed_char; + } +} +/* + * Copies contiguous data into noncontiguous memory. + * @param noncontiguous_indexed - output indexed + * @param contiguous_indexed - input indexed + * @param type - pointer contening : + * - block_lengths - the width or height of blocked matrix + * - 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, + size_t count, + void *type) +{ + s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; + int i,j; + + char* contiguous_indexed_char = (char*)contiguous_indexed; + char* noncontiguous_indexed_char = (char*)noncontiguous_indexed; + for(j=0; jblock_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; + if (iblock_count-1)noncontiguous_indexed_char = (char*)noncontiguous_indexed + type_c->block_indices[i+1]*type_c->size_oldtype; + else noncontiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype; + } + noncontiguous_indexed=(void*)noncontiguous_indexed_char; + } +} + +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); +} + +/* + * Create a Sub type indexed to be able to serialize and unserialize it + * the structure 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; + new_t->base.subtype_free = &free_indexed; + //TODO : add a custom function for each time to clean these + new_t->block_lengths= xbt_new(int, block_count); + new_t->block_indices= xbt_new(int, block_count); + int i; + for(i=0;iblock_lengths[i]=block_lengths[i]; + new_t->block_indices[i]=block_indices[i]; + } + 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; + int retval; + int size = 0; + int contiguous=1; + for(i=0; i< count; i++){ + if (blocklens[i]<=0) + return MPI_ERR_ARG; + size += blocklens[i]; + + if ( (i< count -1) && (indices[i]+blocklens[i] != indices[i+1]) )contiguous=0; + } + if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) { + retval = MPI_ERR_TYPE; + } else { + + if (old_type->has_subtype == 1) + XBT_WARN("indexed contains a complex type - not yet handled"); + + if(!contiguous){ + 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),(indices[count-1]+blocklens[count-1])*smpi_datatype_size(old_type),1, subtype, DT_FLAG_DATA); +}else{ + smpi_datatype_create(new_type, size * + smpi_datatype_size(old_type),size * + smpi_datatype_size(old_type),0, NULL, DT_FLAG_DATA|DT_FLAG_CONTIGUOUS); +} + 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 : + * - block_lengths - the width or height of blocked matrix + * - 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, + size_t count, + void *type) +{ + s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; + int i,j; + char* contiguous_hindexed_char = (char*)contiguous_hindexed; + char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed; + for(j=0; jblock_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; + if (iblock_count-1)noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1]; + else noncontiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype; + } + noncontiguous_hindexed=(void*)noncontiguous_hindexed_char; + } +} +/* + * Copies contiguous data into noncontiguous memory. + * @param noncontiguous_hindexed - output hindexed + * @param contiguous_hindexed - input hindexed + * @param type - pointer contening : + * - block_lengths - the width or height of blocked matrix + * - 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, + size_t count, + void *type) +{ + s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; + int i,j; + + char* contiguous_hindexed_char = (char*)contiguous_hindexed; + char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed; + for(j=0; jblock_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; + if (iblock_count-1)noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1]; + else noncontiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype; + } + noncontiguous_hindexed=(void*)noncontiguous_hindexed_char; + } +} + +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); +} + +/* + * Create a Sub type hindexed to be able to serialize and unserialize it + * the structure 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; + new_t->base.subtype_free = &free_hindexed; + //TODO : add a custom function for each time to clean these + 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]; + } + 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; + int retval; + int size = 0; + int contiguous=1; + for(i=0; i< count; i++){ + if (blocklens[i]<=0) + return MPI_ERR_ARG; + size += blocklens[i]; + + + if ( (i< count -1) && (indices[i]+blocklens[i]*smpi_datatype_size(old_type) != indices[i+1]) )contiguous=0; + } + if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) { + retval = MPI_ERR_TYPE; + } else { + if (old_type->has_subtype == 1) + XBT_WARN("hindexed contains a complex type - not yet handled"); + + if(!contiguous){ + 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),indices[count-1]+blocklens[count-1]*smpi_datatype_size(old_type) + ,1, subtype, DT_FLAG_DATA); + }else{ + smpi_datatype_create(new_type, size * + smpi_datatype_size(old_type),size * + smpi_datatype_size(old_type),0, NULL, DT_FLAG_DATA|DT_FLAG_CONTIGUOUS); + } + 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,j; + char* contiguous_struct_char = (char*)contiguous_struct; + char* noncontiguous_struct_char = (char*)noncontiguous_struct; + for(j=0; jblock_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]); + if (iblock_count-1)noncontiguous_struct_char = (char*)noncontiguous_struct + type_c->block_indices[i+1]; + else noncontiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]);//let's hope this is MPI_UB ? + } + noncontiguous_struct=(void*)noncontiguous_struct_char; + } +} +/* + * 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,j; + + char* contiguous_struct_char = (char*)contiguous_struct; + char* noncontiguous_struct_char = (char*)noncontiguous_struct; + for(j=0; jblock_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]); + if (iblock_count-1)noncontiguous_struct_char = (char*)noncontiguous_struct + type_c->block_indices[i+1]; + else noncontiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]); + } + noncontiguous_struct=(void*)noncontiguous_struct_char; + + } +} + +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); + xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->old_types); +} + +/* + * Create a Sub type struct to be able to serialize and unserialize it + * the structure 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; + new_t->base.subtype_free = &free_struct; + //TODO : add a custom function for each time to clean these + new_t->block_lengths= xbt_new(int, block_count); + new_t->block_indices= xbt_new(MPI_Aint, block_count); + new_t->old_types= xbt_new(MPI_Datatype, block_count); + int i; + for(i=0;iblock_lengths[i]=block_lengths[i]; + new_t->block_indices[i]=block_indices[i]; + new_t->old_types[i]=old_types[i]; + } + //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 = 0; + int contiguous=1; + size = 0; + for(i=0; i< count; i++){ + if (blocklens[i]<=0) + return MPI_ERR_ARG; + if ((old_types[i]->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) + return MPI_ERR_TYPE; + if (old_types[i]->has_subtype == 1) + XBT_WARN("Struct contains a complex type - not yet handled"); + size += blocklens[i]*smpi_datatype_size(old_types[i]); + + if ( (i< count -1) && (indices[i]+blocklens[i]*smpi_datatype_size(old_types[i]) != indices[i+1]) )contiguous=0; + } + + if(!contiguous){ + s_smpi_mpi_struct_t* subtype = smpi_datatype_struct_create( blocklens, + indices, + count, + old_types); + + smpi_datatype_create(new_type, size, indices[count-1] + blocklens[count-1]*smpi_datatype_size(old_types[count-1]),1, subtype, DT_FLAG_DATA); + }else{ + smpi_datatype_create(new_type, size, indices[count-1] + blocklens[count-1]*smpi_datatype_size(old_types[count-1]),0, NULL, DT_FLAG_DATA|DT_FLAG_CONTIGUOUS); + } + return MPI_SUCCESS; +} + +void smpi_datatype_commit(MPI_Datatype *datatype) +{ + (*datatype)->flags= ((*datatype)->flags | DT_FLAG_COMMITED); +} + typedef struct s_smpi_mpi_op { MPI_User_function *func; } s_smpi_mpi_op_t; @@ -170,14 +903,14 @@ typedef struct s_smpi_mpi_op { //TODO : MINLOC & MAXLOC #define APPLY_FUNC(a, b, length, type, func) \ - { \ - int i; \ - type* x = (type*)(a); \ - type* y = (type*)(b); \ - for(i = 0; i < *(length); i++) { \ - func(x[i], y[i]); \ - } \ - } +{ \ + int i; \ + type* x = (type*)(a); \ + type* y = (type*)(b); \ + for(i = 0; i < *(length); i++) { \ + func(x[i], y[i]); \ + } \ +} static void max_func(void *a, void *b, int *length, MPI_Datatype * datatype) @@ -467,7 +1200,7 @@ static void maxloc_func(void *a, void *b, int *length, #define CREATE_MPI_OP(name, func) \ static s_smpi_mpi_op_t mpi_##name = { &(func) /* func */ }; \ - MPI_Op name = &mpi_##name; +MPI_Op name = &mpi_##name; CREATE_MPI_OP(MPI_MAX, max_func); CREATE_MPI_OP(MPI_MIN, min_func);