static int test_upper( unsigned int length )
{
ompi_datatype_t *pdt;
opal_convertor_t * pConv;
int rc = OMPI_SUCCESS;
unsigned int i, iov_count, split_chunk, total_length;
size_t max_data;
struct iovec iov[5];
TIMER_DATA_TYPE start, end;
long total_time;
printf( "test upper matrix\n" );
pdt = upper_matrix( length );
/*dt_dump( pdt );*/
total_length = length * (length + 1) * ( sizeof(double) / 2);
pConv = opal_convertor_create( remote_arch, 0 );
if( OMPI_SUCCESS != opal_convertor_prepare_for_send( pConv, &(pdt->super), 1, NULL ) ) {
printf( "Cannot attach the datatype to a convertor\n" );
return OMPI_ERROR;
}
GET_TIME( start );
split_chunk = (length + 1) * sizeof(double);
/* split_chunk = (total_length + 1) * sizeof(double); */
for( i = total_length; i > 0; ) {
iov_count = 5;
max_data = 0;
opal_convertor_raw( pConv, iov, &iov_count, &max_data );
i -= max_data;
}
GET_TIME( end );
total_time = ELAPSED_TIME( start, end );
printf( "complete raw in %ld microsec\n", total_time );
/* test the automatic destruction pf the data */
ompi_datatype_destroy( &pdt );
assert( pdt == NULL );
OBJ_RELEASE( pConv );
return rc;
}
static int test_upper( unsigned int length )
{
double *mat1, *mat2, *inbuf;
opal_datatype_t *pdt;
opal_convertor_t * pConv;
char *ptr;
int rc;
unsigned int i, j, iov_count, split_chunk, total_length;
size_t max_data;
struct iovec a;
TIMER_DATA_TYPE start, end;
long total_time;
printf( "test upper matrix\n" );
pdt = upper_matrix( length );
opal_datatype_dump( pdt );
mat1 = malloc( length * length * sizeof(double) );
init_random_upper_matrix( length, mat1 );
mat2 = calloc( length * length, sizeof(double) );
total_length = length * (length + 1) * ( sizeof(double) / 2);
inbuf = (double*)malloc( total_length );
ptr = (char*)inbuf;
/* copy upper matrix in the array simulating the input buffer */
for( i = 0; i < length; i++ ) {
uint32_t pos = i * length + i;
for( j = i; j < length; j++, pos++ ) {
*inbuf = mat1[pos];
inbuf++;
}
}
inbuf = (double*)ptr;
pConv = opal_convertor_create( remote_arch, 0 );
if( OPAL_SUCCESS != opal_convertor_prepare_for_recv( pConv, pdt, 1, mat2 ) ) {
printf( "Cannot attach the datatype to a convertor\n" );
return OPAL_ERROR;
}
GET_TIME( start );
split_chunk = (length + 1) * sizeof(double);
/* split_chunk = (total_length + 1) * sizeof(double); */
for( i = total_length; i > 0; ) {
if( i <= split_chunk ) { /* equal test just to be able to set a breakpoint */
split_chunk = i;
}
a.iov_base = ptr;
a.iov_len = split_chunk;
iov_count = 1;
max_data = split_chunk;
opal_convertor_unpack( pConv, &a, &iov_count, &max_data );
ptr += max_data;
i -= max_data;
if( mat2[0] != inbuf[0] ) assert(0);
}
GET_TIME( end );
total_time = ELAPSED_TIME( start, end );
printf( "complete unpacking in %ld microsec\n", total_time );
free( inbuf );
rc = check_diag_matrix( length, mat1, mat2 );
free( mat1 );
free( mat2 );
/* test the automatic destruction pf the data */
opal_datatype_destroy( &pdt );
assert( pdt == NULL );
OBJ_RELEASE( pConv );
return rc;
}
/**
* 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[] )
{
opal_datatype_t *pdt, *pdt1, *pdt2, *pdt3;
int rc, length = 500;
opal_datatype_init();
/**
* By default simulate homogeneous architectures.
*/
remote_arch = opal_local_arch;
printf( "\n\n#\n * TEST CREATE CONTIGUOUS\n #\n\n" );
pdt = create_contiguous_type( &opal_datatype_int1, 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 ) {
opal_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 );
opal_datatype_create_contiguous(0, &opal_datatype_empty, &pdt1);
opal_datatype_create_contiguous(0, &opal_datatype_empty, &pdt2);
opal_datatype_create_contiguous(0, &opal_datatype_empty, &pdt3);
opal_datatype_add( pdt3, &opal_datatype_int4, 10, 0, -1 );
opal_datatype_add( pdt3, &opal_datatype_float4, 5, 10 * sizeof(int), -1 );
opal_datatype_add( pdt2, &opal_datatype_float4, 1, 0, -1 );
opal_datatype_add( pdt2, pdt3, 3, sizeof(int) * 1, -1 );
opal_datatype_add( pdt1, &opal_datatype_int8, 5, 0, -1 );
opal_datatype_add( pdt1, &opal_datatype_float16, 2, sizeof(long long) * 5, -1 );
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
opal_datatype_dump( pdt1 );
}
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
opal_datatype_dump( pdt2 );
}
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
opal_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 (opal_datatype_float8)\n" );
if( outputFlags & CHECK_PACK_UNPACK ) {
const opal_datatype_t const* ddt = &opal_datatype_float8;
local_copy_ddt_count( ddt, 4500);
local_copy_with_convertor( ddt, 4500, 12 );
local_copy_with_convertor_2datatypes( ddt, 4500, ddt, 4500, 12 );
}
printf( ">>--------------------------------------------<<\n" );
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & CHECK_PACK_UNPACK ) {
printf( "Contiguous multiple data-type (4500*1)\n" );
pdt = create_contiguous_type( &opal_datatype_float8, 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( &opal_datatype_float8, 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( &opal_datatype_float8, 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( &opal_datatype_float8, 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( &opal_datatype_float8, 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( &opal_datatype_float8, 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( &opal_datatype_float8, 450, 10, 11 );
opal_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 ) {
opal_datatype_dump( pdt );
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( &opal_datatype_int4 );
pdt2 = test_create_blacs_type2( &opal_datatype_int4 );
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 */
opal_datatype_finalize();
return OPAL_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, iov_num = 5;
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_raw(pdt, 100, iov_num);
}
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_raw(pdt, 1, iov_num);
}
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_raw(pdt, 1, iov_num);
}
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_raw(pdt, 4500, iov_num);
}
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_raw(pdt, 1, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (450*10)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 450 );
local_copy_ddt_raw(pdt, 10, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (45*100)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 45 );
local_copy_ddt_raw(pdt, 100, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (100*45)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 100 );
local_copy_ddt_raw(pdt, 45, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (10*450)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 10 );
local_copy_ddt_raw(pdt, 450, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (1*4500)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 1 );
local_copy_ddt_raw(pdt, 4500, iov_num);
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 );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt );
}
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 1, iov_num);
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_struct_char_double();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 4500, iov_num);
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_create_twice_two_doubles();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 4500, iov_num);
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_create_blacs_type();
if( outputFlags & CHECK_PACK_UNPACK ) {
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt );
}
local_copy_ddt_raw(pdt, 4500, iov_num);
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt1 = test_create_blacs_type1( &ompi_mpi_int.dt );
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw( pdt1, 1, iov_num );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt1 );
assert( pdt1 == NULL );
/* clean-ups all data allocations */
ompi_datatype_finalize();
return OMPI_SUCCESS;
}