opal_datatype_t* test_contiguous( void ) { opal_datatype_t *pdt, *pdt1, *pdt2; printf( "test contiguous (alignement)\n" ); opal_datatype_create_contiguous(0, &opal_datatype_empty, &pdt1); opal_datatype_add( pdt1, &opal_datatype_float8, 1, 0, -1 ); if( outputFlags & DUMP_DATA_AFTER_COMMIT ) { opal_datatype_dump( pdt1 ); } opal_datatype_add( pdt1, &opal_datatype_int1, 1, 8, -1 ); if( outputFlags & DUMP_DATA_AFTER_COMMIT ) { opal_datatype_dump( pdt1 ); } opal_datatype_create_contiguous( 4, pdt1, &pdt2 ); OBJ_RELEASE( pdt1 ); /*assert( pdt1 == NULL );*/ if( outputFlags & DUMP_DATA_AFTER_COMMIT ) { opal_datatype_dump( pdt2 ); } opal_datatype_create_contiguous( 2, pdt2, &pdt ); OBJ_RELEASE( pdt2 ); /*assert( pdt2 == NULL );*/ if( outputFlags & DUMP_DATA_AFTER_COMMIT ) { opal_datatype_dump( pdt ); } return pdt; }
opal_datatype_t* create_strange_dt( void ) { sdata_intern v[2]; OPAL_PTRDIFF_TYPE displ[3]; sstrange t[2]; int pBlock[3] = {1, 10, 1}, dispi[3]; opal_datatype_t *pdt, *pdt1, *pdt2, *pdtTemp; opal_datatype_create_contiguous(0, &opal_datatype_empty, &pdt1); opal_datatype_add( pdt1, &opal_datatype_float8, 1, 0, -1 ); opal_datatype_add( pdt1, &opal_datatype_int1, 1, 8, -1 ); #ifdef USE_RESIZED /* optional */ displ[0] = 0; displ[1] = (char*)&(v[1]) - (char*)&(v[0]); opal_datatype_resize( pdt1, displ[0], displ[1]); #endif /* USE_RESIZED */ opal_datatype_create_contiguous( SSTRANGE_CNT, pdt1, &pdt ); OBJ_RELEASE( pdt1 ); printf( "\nStrange datatype BEFORE COMMIT\n" ); if( outputFlags & DUMP_DATA_AFTER_COMMIT ) { opal_datatype_dump( pdt ); } opal_datatype_commit( pdt ); printf( "\nStrange datatype AFTER COMMIT\n" ); if( outputFlags & DUMP_DATA_AFTER_COMMIT ) { opal_datatype_dump( pdt ); } return pdt; }
static int32_t opal_datatype_create_hvector( int count, int bLength, OPAL_PTRDIFF_TYPE stride, const opal_datatype_t* oldType, opal_datatype_t** newType ) { opal_datatype_t *pTempData, *pData; OPAL_PTRDIFF_TYPE extent = oldType->ub - oldType->lb; if( 0 == count ) { *newType = opal_datatype_create( 0 ); opal_datatype_add( *newType, &opal_datatype_empty, 0, 0, 0); return OPAL_SUCCESS; } pTempData = opal_datatype_create( oldType->desc.used + 2 ); if( ((extent * bLength) == stride) || (1 >= count) ) { /* contiguous */ pData = pTempData; opal_datatype_add( pData, oldType, count * bLength, 0, extent ); } else { if( 1 == bLength ) { pData = pTempData; opal_datatype_add( pData, oldType, count, 0, stride ); } else { opal_datatype_add( pTempData, oldType, bLength, 0, extent ); pData = opal_datatype_create( oldType->desc.used + 2 + 2 ); opal_datatype_add( pData, pTempData, count, 0, stride ); OBJ_RELEASE( pTempData ); } } *newType = pData; return OPAL_SUCCESS; }
opal_datatype_t* test_struct( void ) { const opal_datatype_t* types[] = { (opal_datatype_t*)&opal_datatype_float4, NULL, (opal_datatype_t*)&opal_datatype_int1 }; int lengths[] = { 2, 1, 3 }; OPAL_PTRDIFF_TYPE disp[] = { 0, 16, 26 }; opal_datatype_t* pdt, *pdt1; printf( "test struct\n" ); opal_datatype_create_contiguous(0, &opal_datatype_empty, &pdt1); opal_datatype_add( pdt1, &opal_datatype_float8, 1, 0, -1 ); opal_datatype_add( pdt1, &opal_datatype_int1, 1, 8, -1 ); if( outputFlags & DUMP_DATA_AFTER_COMMIT ) { opal_datatype_dump( pdt1 ); } types[1] = pdt1; opal_datatype_create_struct( 3, lengths, disp, types, &pdt ); OBJ_RELEASE( pdt1 ); /*assert( pdt1 == NULL );*/ if( outputFlags & DUMP_DATA_AFTER_COMMIT ) { opal_datatype_dump( pdt ); } return pdt; }
static int32_t opal_datatype_create_hindexed( int count, const int* pBlockLength, const OPAL_PTRDIFF_TYPE* pDisp, const opal_datatype_t* oldType, opal_datatype_t** newType ) { opal_datatype_t* pdt; int i, dLength; OPAL_PTRDIFF_TYPE extent, disp, endat; if( 0 == count ) { *newType = opal_datatype_create( 0 ); opal_datatype_add( *newType, &opal_datatype_empty, 0, 0, 0); return OPAL_SUCCESS; } opal_datatype_type_extent( oldType, &extent ); pdt = opal_datatype_create( count * (2 + oldType->desc.used) ); disp = pDisp[0]; dLength = pBlockLength[0]; endat = disp + dLength * extent; if( 1 >= count ) { pdt = opal_datatype_create( oldType->desc.used + 2 ); /* multiply by count to make it zero if count is zero */ opal_datatype_add( pdt, oldType, count * dLength, disp, extent ); } else { for( i = 1; i < count; i++ ) { if( endat == pDisp[i] ) { /* contiguous with the previsious */ dLength += pBlockLength[i]; endat += pBlockLength[i] * extent; } else { opal_datatype_add( pdt, oldType, dLength, disp, extent ); disp = pDisp[i]; dLength = pBlockLength[i]; endat = disp + pBlockLength[i] * extent; } } opal_datatype_add( pdt, oldType, dLength, disp, extent ); } *newType = pdt; return OPAL_SUCCESS; }
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; }
static int32_t opal_datatype_create_struct( int count, const int* pBlockLength, const OPAL_PTRDIFF_TYPE* pDisp, opal_datatype_t* const * pTypes, opal_datatype_t** newType ) { int i; OPAL_PTRDIFF_TYPE disp = 0, endto, lastExtent, lastDisp; int lastBlock; opal_datatype_t *pdt, *lastType; if( 0 == count ) { *newType = opal_datatype_create( 0 ); opal_datatype_add( *newType, &opal_datatype_empty, 0, 0, 0); return OPAL_SUCCESS; } /* if we compute the total number of elements before we can * avoid increasing the size of the desc array often. */ lastType = (opal_datatype_t*)pTypes[0]; lastBlock = pBlockLength[0]; lastExtent = lastType->ub - lastType->lb; lastDisp = pDisp[0]; endto = pDisp[0] + lastExtent * lastBlock; for( i = 1; i < count; i++ ) { if( (pTypes[i] == lastType) && (pDisp[i] == endto) ) { lastBlock += pBlockLength[i]; endto = lastDisp + lastBlock * lastExtent; } else { disp += lastType->desc.used; if( lastBlock > 1 ) disp += 2; lastType = (opal_datatype_t*)pTypes[i]; lastExtent = lastType->ub - lastType->lb; lastBlock = pBlockLength[i]; lastDisp = pDisp[i]; endto = lastDisp + lastExtent * lastBlock; } } disp += lastType->desc.used; if( lastBlock != 1 ) disp += 2; lastType = (opal_datatype_t*)pTypes[0]; lastBlock = pBlockLength[0]; lastExtent = lastType->ub - lastType->lb; lastDisp = pDisp[0]; endto = pDisp[0] + lastExtent * lastBlock; pdt = opal_datatype_create( (int32_t)disp ); /* Do again the same loop but now add the elements */ for( i = 1; i < count; i++ ) { if( (pTypes[i] == lastType) && (pDisp[i] == endto) ) { lastBlock += pBlockLength[i]; endto = lastDisp + lastBlock * lastExtent; } else { opal_datatype_add( pdt, lastType, lastBlock, lastDisp, lastExtent ); lastType = (opal_datatype_t*)pTypes[i]; lastExtent = lastType->ub - lastType->lb; lastBlock = pBlockLength[i]; lastDisp = pDisp[i]; endto = lastDisp + lastExtent * lastBlock; } } opal_datatype_add( pdt, lastType, lastBlock, lastDisp, lastExtent ); *newType = pdt; 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[] ) { 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; }