From 6ba53704b9e08e2ad82f008aeec1c8a3f568b3b6 Mon Sep 17 00:00:00 2001 From: degomme Date: Mon, 8 Oct 2012 10:23:04 +0200 Subject: [PATCH] add a free method for datatypes --- src/smpi/private.h | 1 + src/smpi/smpi_mpi_dt.c | 31 ++++++++++++++++++++++++++++++- src/smpi/smpi_mpi_dt_private.h | 10 ++++++++++ 3 files changed, 41 insertions(+), 1 deletion(-) diff --git a/src/smpi/private.h b/src/smpi/private.h index ad810c0465..7769ef4f8d 100644 --- a/src/smpi/private.h +++ b/src/smpi/private.h @@ -30,6 +30,7 @@ typedef struct s_smpi_process_data *smpi_process_data_t; typedef struct s_smpi_subtype{ void (*serialize)(const void * input, void *output, size_t count, void* subtype); void (*unserialize)(const void * input, void *output, size_t count, void* subtype); + void (*subtype_free)(MPI_Datatype* type); } s_smpi_subtype_t; typedef struct s_smpi_mpi_datatype{ diff --git a/src/smpi/smpi_mpi_dt.c b/src/smpi/smpi_mpi_dt.c index d5a1421b7b..46dba74977 100644 --- a/src/smpi/smpi_mpi_dt.c +++ b/src/smpi/smpi_mpi_dt.c @@ -257,6 +257,7 @@ s_smpi_mpi_vector_t* smpi_datatype_vector_create( int block_stride, 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; @@ -278,6 +279,9 @@ void smpi_datatype_create(MPI_Datatype* new_type, int size, int has_subtype, } void smpi_datatype_free(MPI_Datatype* type){ + if ((*type)->has_subtype == 1){ + ((s_smpi_subtype_t *)(*type)->substruct)->subtype_free(type); + } xbt_free(*type); } @@ -330,7 +334,8 @@ if (old_type->has_subtype == 1) return retval; } - +void free_vector(MPI_Datatype* d){ +} /* Hvector Implementation - Vector with stride in bytes @@ -407,6 +412,7 @@ s_smpi_mpi_hvector_t* smpi_datatype_hvector_create( MPI_Aint block_stride, 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; @@ -415,6 +421,10 @@ s_smpi_mpi_hvector_t* smpi_datatype_hvector_create( MPI_Aint block_stride, 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; @@ -516,6 +526,11 @@ void unserialize_indexed( const void *contiguous_indexed, } } +void free_indexed(MPI_Datatype* type){ + xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_lengths); + xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_indices); +} + /* * 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 @@ -529,6 +544,7 @@ s_smpi_mpi_indexed_t* smpi_datatype_indexed_create( int* block_lengths, 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); @@ -649,6 +665,11 @@ void unserialize_hindexed( const void *contiguous_hindexed, } } +void free_hindexed(MPI_Datatype* type){ + xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_lengths); + xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_indices); +} + /* * 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 @@ -662,6 +683,7 @@ s_smpi_mpi_hindexed_t* smpi_datatype_hindexed_create( int* block_lengths, 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); @@ -781,6 +803,12 @@ void unserialize_struct( const void *contiguous_struct, } } +void free_struct(MPI_Datatype* type){ + xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_lengths); + xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_indices); + 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 @@ -793,6 +821,7 @@ s_smpi_mpi_struct_t* smpi_datatype_struct_create( int* block_lengths, 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); diff --git a/src/smpi/smpi_mpi_dt_private.h b/src/smpi/smpi_mpi_dt_private.h index 89fcd659eb..608beffc69 100644 --- a/src/smpi/smpi_mpi_dt_private.h +++ b/src/smpi/smpi_mpi_dt_private.h @@ -99,6 +99,8 @@ void serialize_vector( const void *noncontiguous_vector, size_t count, void *type); +void free_vector(MPI_Datatype* type); + s_smpi_mpi_vector_t* smpi_datatype_vector_create( int block_stride, int block_length, int block_count, @@ -115,6 +117,8 @@ void serialize_hvector( const void *noncontiguous_vector, size_t count, void *type); +void free_hvector(MPI_Datatype* type); + s_smpi_mpi_hvector_t* smpi_datatype_hvector_create( MPI_Aint block_stride, int block_length, int block_count, @@ -132,6 +136,8 @@ void serialize_indexed( const void *noncontiguous_vector, size_t count, void *type); +void free_indexed(MPI_Datatype* type); + s_smpi_mpi_indexed_t* smpi_datatype_indexed_create(int* block_lengths, int* block_indices, int block_count, @@ -148,6 +154,8 @@ void serialize_hindexed( const void *noncontiguous_vector, size_t count, void *type); +void free_hindexed(MPI_Datatype* type); + s_smpi_mpi_hindexed_t* smpi_datatype_hindexed_create(int* block_lengths, MPI_Aint* block_indices, int block_count, @@ -164,6 +172,8 @@ void serialize_struct( const void *noncontiguous_vector, size_t count, void *type); +void free_struct(MPI_Datatype* type); + s_smpi_mpi_struct_t* smpi_datatype_struct_create(int* block_lengths, MPI_Aint* block_indices, int block_count, -- 2.20.1