ompi_datatype_t* test_struct( void )
{
ompi_datatype_t* types[] = { &ompi_mpi_float.dt /* ompi_datatype_basicDatatypes[DT_FLOAT] */,
NULL,
&ompi_mpi_char.dt /* ompi_datatype_basicDatatypes[DT_CHAR] */ };
int lengths[] = { 2, 1, 3 };
MPI_Aint disp[] = { 0, 16, 26 };
ompi_datatype_t* pdt, *pdt1;
printf( "test struct\n" );
ompi_datatype_create_contiguous(0, &ompi_mpi_datatype_null.dt, &pdt1);
ompi_datatype_add( pdt1, &ompi_mpi_double.dt, 1, 0, -1 );
ompi_datatype_add( pdt1, &ompi_mpi_char.dt, 1, 8, -1 );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt1 );
}
types[1] = pdt1;
ompi_datatype_create_struct( 3, lengths, disp, types, &pdt );
OBJ_RELEASE( pdt1 ); /*assert( pdt1 == NULL );*/
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt );
}
return pdt;
}
ompi_datatype_t* test_contiguous( void )
{
ompi_datatype_t *pdt, *pdt1, *pdt2;
printf( "test contiguous (alignment)\n" );
ompi_datatype_create_contiguous(0, &ompi_mpi_datatype_null.dt, &pdt1);
ompi_datatype_add( pdt1, &ompi_mpi_double.dt, 1, 0, -1 );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt1 );
}
ompi_datatype_add( pdt1, &ompi_mpi_char.dt, 1, 8, -1 );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt1 );
}
ompi_datatype_create_contiguous( 4, pdt1, &pdt2 );
OBJ_RELEASE( pdt1 ); /*assert( pdt1 == NULL );*/
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt2 );
}
ompi_datatype_create_contiguous( 2, pdt2, &pdt );
OBJ_RELEASE( pdt2 ); /*assert( pdt2 == NULL );*/
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt );
}
return pdt;
}
int32_t ompi_datatype_create_contiguous( int count, const ompi_datatype_t* oldType,
ompi_datatype_t** newType )
{
ompi_datatype_t* pdt;
if( 0 == count ) {
pdt = ompi_datatype_create( 0 );
ompi_datatype_add( pdt, &ompi_mpi_datatype_null.dt, 0, 0, 0 );
} else {
pdt = ompi_datatype_create( oldType->super.desc.used + 2 );
opal_datatype_add( &(pdt->super), &(oldType->super), count, 0, (oldType->super.ub - oldType->super.lb) );
}
*newType = pdt;
return OMPI_SUCCESS;
}
int32_t ompi_datatype_create_darray(int size,
int rank,
int ndims,
int const* gsize_array,
int const* distrib_array,
int const* darg_array,
int const* psize_array,
int order,
const ompi_datatype_t* oldtype,
ompi_datatype_t** newtype)
{
ompi_datatype_t *lastType;
ptrdiff_t orig_extent, *st_offsets = NULL;
int i, start_loop, end_loop, step;
int *coords = NULL, rc = OMPI_SUCCESS;
/* speedy corner case */
if (ndims < 1) {
/* Don't just return MPI_DATATYPE_NULL as that can't be
MPI_TYPE_FREE()ed, and that seems bad */
*newtype = ompi_datatype_create(0);
ompi_datatype_add(*newtype, &ompi_mpi_datatype_null.dt, 0, 0, 0);
return MPI_SUCCESS;
}
rc = ompi_datatype_type_extent(oldtype, &orig_extent);
if (MPI_SUCCESS != rc) goto cleanup;
/* calculate position in grid using row-major ordering */
{
int tmp_rank = rank, procs = size;
coords = (int *) malloc(ndims * sizeof(int));
for (i = 0 ; i < ndims ; i++) {
procs = procs / psize_array[i];
coords[i] = tmp_rank / procs;
tmp_rank = tmp_rank % procs;
}
}
st_offsets = (ptrdiff_t *) malloc(ndims * sizeof(ptrdiff_t));
/* duplicate type to here to 1) deal with constness without
casting and 2) eliminate need to for conditional destroy below.
Lame, yes. But cleaner code all around. */
rc = ompi_datatype_duplicate(oldtype, &lastType);
if (OMPI_SUCCESS != rc) goto cleanup;
/* figure out ordering issues */
if (MPI_ORDER_C == order) {
start_loop = ndims - 1 ; step = -1; end_loop = -1;
} else {
start_loop = 0 ; step = 1; end_loop = ndims;
}
/* Build up array */
for (i = start_loop; i != end_loop; i += step) {
int nprocs, tmp_rank;
switch(distrib_array[i]) {
case MPI_DISTRIBUTE_BLOCK:
rc = block(gsize_array, i, ndims, psize_array[i], coords[i],
darg_array[i], order, orig_extent,
lastType, newtype, st_offsets+i);
break;
case MPI_DISTRIBUTE_CYCLIC:
rc = cyclic(gsize_array, i, ndims, psize_array[i], coords[i],
darg_array[i], order, orig_extent,
lastType, newtype, st_offsets+i);
break;
case MPI_DISTRIBUTE_NONE:
/* treat it as a block distribution on 1 process */
if (order == MPI_ORDER_C) {
nprocs = psize_array[i]; tmp_rank = coords[i];
} else {
nprocs = 1; tmp_rank = 0;
}
rc = block(gsize_array, i, ndims, nprocs, tmp_rank,
MPI_DISTRIBUTE_DFLT_DARG, order, orig_extent,
lastType, newtype, st_offsets+i);
break;
default:
rc = MPI_ERR_ARG;
}
ompi_datatype_destroy(&lastType);
/* need to destroy the old type even in error condition, so
don't check return code from above until after cleanup. */
if (MPI_SUCCESS != rc) goto cleanup;
lastType = *newtype;
}
/* set displacement and UB correctly. Use struct instead of
resized for same reason as subarray */
{
ptrdiff_t displs[3], tmp_size;
ompi_datatype_t *types[3];
int blength[3] = { 1, 1, 1};
displs[1] = st_offsets[start_loop];
tmp_size = 1;
for (i = start_loop + step ; i != end_loop ; i += step) {
tmp_size *= gsize_array[i - step];
displs[1] += tmp_size * st_offsets[i];
}
displs[0] = 0;
displs[1] *= orig_extent;
displs[2] = orig_extent;
for (i = 0 ; i < ndims ; i++) {
displs[2] *= gsize_array[i];
}
types[0] = MPI_LB; types[1] = lastType; types[2] = MPI_UB;
rc = ompi_datatype_create_struct(3, blength, displs, types, newtype);
ompi_datatype_destroy(&lastType);
/* need to destroy the old type even in error condition, so
don't check return code from above until after cleanup. */
if (MPI_SUCCESS != rc) goto cleanup;
}
cleanup:
if (NULL != st_offsets) free(st_offsets);
if (NULL != coords) free(coords);
return OMPI_SUCCESS;
}
int32_t ompi_datatype_create_subarray(int ndims,
int const* size_array,
int const* subsize_array,
int const* start_array,
int order,
const ompi_datatype_t* oldtype,
ompi_datatype_t** newtype)
{
MPI_Datatype last_type;
int32_t i, step, end_loop;
MPI_Aint size, displ, extent;
/**
* If the oldtype contains the original MPI_LB and MPI_UB markers then we
* are forced to follow the MPI standard suggestion and reset these 2
* markers (MPI 3.0 page 96 line 37). Otherwise we can simply resize the
* datatype.
*/
ompi_datatype_type_extent( oldtype, &extent );
/* If the ndims is zero then return the NULL datatype */
if( ndims < 2 ) {
if( 0 == ndims ) {
*newtype = &ompi_mpi_datatype_null.dt;
return MPI_SUCCESS;
}
ompi_datatype_create_contiguous( subsize_array[0], oldtype, &last_type );
size = size_array[0];
displ = start_array[0];
goto replace_subarray_type;
}
if( MPI_ORDER_C == order ) {
i = ndims - 1;
step = -1;
end_loop = -1;
} else {
i = 0;
step = 1;
end_loop = ndims;
}
/* As we know that the ndims is at least 1 we can start by creating the
* first dimension data outside the loop, such that we dont have to create
* a duplicate of the oldtype just to be able to free it.
*/
ompi_datatype_create_vector( subsize_array[i+step], subsize_array[i], size_array[i],
oldtype, newtype );
last_type = *newtype;
size = (MPI_Aint)size_array[i] * (MPI_Aint)size_array[i+step];
displ = (MPI_Aint)start_array[i] + (MPI_Aint)start_array[i+step] * (MPI_Aint)size_array[i];
for( i += 2 * step; i != end_loop; i += step ) {
ompi_datatype_create_hvector( subsize_array[i], 1, size * extent,
last_type, newtype );
ompi_datatype_destroy( &last_type );
displ += size * start_array[i];
size *= size_array[i];
last_type = *newtype;
}
replace_subarray_type:
/**
* We need to shift the content (useful data) of the datatype, so
* we need to force the displacement to be moved. Therefore, we
* cannot use resize as it will only set the soft lb and ub
* markers without moving the data. Instead, we have to create a
* new data, and insert the last_Type with the correct
* displacement.
*/
*newtype = ompi_datatype_create( last_type->super.desc.used );
ompi_datatype_add( *newtype, last_type, 1, displ * extent, size * extent);
ompi_datatype_destroy( &last_type );
return OMPI_SUCCESS;
}
/**
* Main function. Call several tests and print-out the results. It try to stress the convertor
* using difficult data-type constructions as well as strange segment sizes for the conversion.
* Usually, it is able to detect most of the data-type and convertor problems. Any modifications
* on the data-type engine should first pass all the tests from this file, before going into other
* tests.
*/
int main( int argc, char* argv[] )
{
ompi_datatype_t *pdt, *pdt1, *pdt2, *pdt3;
int rc, length = 500;
opal_init_util(&argc, &argv);
ompi_datatype_init();
/**
* By default simulate homogeneous architectures.
*/
remote_arch = opal_local_arch;
printf( "\n\n#\n * TEST INVERSED VECTOR\n #\n\n" );
pdt = create_inversed_vector( &ompi_mpi_int.dt, 10 );
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 100);
local_copy_with_convertor(pdt, 100, 956);
}
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( "\n\n#\n * TEST STRANGE DATATYPE\n #\n\n" );
pdt = create_strange_dt();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 1);
local_copy_with_convertor(pdt, 1, 956);
}
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( "\n\n#\n * TEST UPPER TRIANGULAR MATRIX (size 100)\n #\n\n" );
pdt = upper_matrix(100);
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 1);
local_copy_with_convertor(pdt, 1, 48);
}
OBJ_RELEASE( pdt ); assert( pdt == NULL );
mpich_typeub();
mpich_typeub2();
mpich_typeub3();
printf( "\n\n#\n * TEST UPPER MATRIX\n #\n\n" );
rc = test_upper( length );
if( rc == 0 )
printf( "decode [PASSED]\n" );
else
printf( "decode [NOT PASSED]\n" );
printf( "\n\n#\n * TEST MATRIX BORDERS\n #\n\n" );
pdt = test_matrix_borders( length, 100 );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt );
}
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( "\n\n#\n * TEST CONTIGUOUS\n #\n\n" );
pdt = test_contiguous();
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( "\n\n#\n * TEST STRUCT\n #\n\n" );
pdt = test_struct();
OBJ_RELEASE( pdt ); assert( pdt == NULL );
ompi_datatype_create_contiguous(0, &ompi_mpi_datatype_null.dt, &pdt1);
ompi_datatype_create_contiguous(0, &ompi_mpi_datatype_null.dt, &pdt2);
ompi_datatype_create_contiguous(0, &ompi_mpi_datatype_null.dt, &pdt3);
ompi_datatype_add( pdt3, &ompi_mpi_int.dt, 10, 0, -1 );
ompi_datatype_add( pdt3, &ompi_mpi_float.dt, 5, 10 * sizeof(int), -1 );
ompi_datatype_add( pdt2, &ompi_mpi_float.dt, 1, 0, -1 );
ompi_datatype_add( pdt2, pdt3, 3, sizeof(int) * 1, -1 );
ompi_datatype_add( pdt1, &ompi_mpi_long_long_int.dt, 5, 0, -1 );
ompi_datatype_add( pdt1, &ompi_mpi_long_double.dt, 2, sizeof(long long) * 5, -1 );
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt1 );
}
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt2 );
}
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt3 );
}
OBJ_RELEASE( pdt1 ); assert( pdt1 == NULL );
OBJ_RELEASE( pdt2 ); assert( pdt2 == NULL );
OBJ_RELEASE( pdt3 ); assert( pdt3 == NULL );
printf( ">>--------------------------------------------<<\n" );
printf( " Contiguous data-type (MPI_DOUBLE)\n" );
pdt = MPI_DOUBLE;
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 4500);
local_copy_with_convertor( pdt, 4500, 12 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 12 );
}
printf( ">>--------------------------------------------<<\n" );
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & CHECK_PACK_UNPACK ) {
printf( "Contiguous multiple data-type (4500*1)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 4500 );
local_copy_ddt_count(pdt, 1);
local_copy_with_convertor( pdt, 1, 12 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 12 );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( "Contiguous multiple data-type (450*10)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 450 );
local_copy_ddt_count(pdt, 10);
local_copy_with_convertor( pdt, 10, 12 );
local_copy_with_convertor_2datatypes( pdt, 10, pdt, 10, 12 );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( "Contiguous multiple data-type (45*100)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 45 );
local_copy_ddt_count(pdt, 100);
local_copy_with_convertor( pdt, 100, 12 );
local_copy_with_convertor_2datatypes( pdt, 100, pdt, 100, 12 );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( "Contiguous multiple data-type (100*45)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 100 );
local_copy_ddt_count(pdt, 45);
local_copy_with_convertor( pdt, 45, 12 );
local_copy_with_convertor_2datatypes( pdt, 45, pdt, 45, 12 );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( "Contiguous multiple data-type (10*450)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 10 );
local_copy_ddt_count(pdt, 450);
local_copy_with_convertor( pdt, 450, 12 );
local_copy_with_convertor_2datatypes( pdt, 450, pdt, 450, 12 );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( "Contiguous multiple data-type (1*4500)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 1 );
local_copy_ddt_count(pdt, 4500);
local_copy_with_convertor( pdt, 4500, 12 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 12 );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
}
printf( ">>--------------------------------------------<<\n" );
printf( ">>--------------------------------------------<<\n" );
printf( "Vector data-type (450 times 10 double stride 11)\n" );
pdt = create_vector_type( MPI_DOUBLE, 450, 10, 11 );
ompi_datatype_dump( pdt );
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 1);
local_copy_with_convertor( pdt, 1, 12 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 12 );
local_copy_with_convertor( pdt, 1, 82 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 82 );
local_copy_with_convertor( pdt, 1, 6000 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 6000 );
local_copy_with_convertor( pdt, 1, 36000 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 36000 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_struct_char_double();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 4500);
local_copy_with_convertor( pdt, 4500, 12 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 12 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_create_twice_two_doubles();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 4500);
local_copy_with_convertor( pdt, 4500, 12 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 12 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_create_blacs_type();
if( outputFlags & CHECK_PACK_UNPACK ) {
ompi_datatype_dump( pdt );
local_copy_ddt_count(pdt, 2);
local_copy_ddt_count(pdt, 4500);
local_copy_with_convertor( pdt, 4500, 956 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 956 );
local_copy_with_convertor( pdt, 4500, 16*1024 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 16*1024 );
local_copy_with_convertor( pdt, 4500, 64*1024 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 64*1024 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt ); assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt1 = test_create_blacs_type1( &ompi_mpi_int.dt );
pdt2 = test_create_blacs_type2( &ompi_mpi_int.dt );
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_with_convertor_2datatypes( pdt1, 1, pdt2, 1, 100 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt1 ); assert( pdt1 == NULL );
OBJ_RELEASE( pdt2 ); assert( pdt2 == NULL );
/* clean-ups all data allocations */
ompi_datatype_finalize();
return OMPI_SUCCESS;
}
