int32_t ompi_datatype_finalize( void ) { /* As the synonyms are just copies of the internal data we should not free them. * Anyway they are over the limit of OMPI_DATATYPE_MPI_MAX_PREDEFINED so they will never get freed. */ /* As they are statically allocated they cannot be released. * XXX But we can call OBJ_DESTRUCT, just to free all internally allocated ressources. */ #if 0 int i; for( i = 0; i < OMPI_DATATYPE_MAX_PREDEFINED; i++ ) { OBJ_DESTRUCT( ompi_datatype_basicDatatypes[i] ); } #endif /* 0 */ /* Get rid of the Fortran2C translation table */ OBJ_DESTRUCT(&ompi_datatype_f_to_c_table); #if defined(VERBOSE) if( ompi_datatype_dfd != -1 ) opal_output_close( ompi_datatype_dfd ); ompi_datatype_dfd = -1; #endif /* VERBOSE */ /* release the local convertors (external32 and local) */ ompi_datatype_default_convertors_fini(); opal_datatype_finalize(); return OMPI_SUCCESS; }
int32_t ompi_datatype_finalize( void ) { /* As the synonyms are just copies of the internal data we should not free them. * Anyway they are over the limit of OMPI_DATATYPE_MPI_MAX_PREDEFINED so they will never get freed. */ /* As they are statically allocated they cannot be released. * But we can call OBJ_DESTRUCT, just to free all internally allocated ressources. */ for( int i = 0; i < ompi_mpi_count.dt.d_f_to_c_index; i++ ) { opal_datatype_t* datatype = (opal_datatype_t*)opal_pointer_array_get_item(&ompi_datatype_f_to_c_table, i ); OBJ_DESTRUCT(datatype); } /* Get rid of the Fortran2C translation table */ OBJ_DESTRUCT(&ompi_datatype_f_to_c_table); #if defined(VERBOSE) if( ompi_datatype_dfd != -1 ) opal_output_close( ompi_datatype_dfd ); ompi_datatype_dfd = -1; #endif /* VERBOSE */ /* release the local convertors (external32 and local) */ ompi_datatype_default_convertors_fini(); opal_datatype_finalize(); 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[] ) { opal_datatype_init(); /** * By default simulate homogeneous architectures. */ remote_arch = opal_local_arch ^ OPAL_ARCH_ISBIGENDIAN; opal_convertor_t * pConv; int sbuf[2], rbuf[2]; size_t max_data; struct iovec a; uint32_t iov_count; sbuf[0] = 0x01000000; sbuf[1] = 0x02000000; printf( "\n\n#\n * TEST UNPACKING 1 int out of 1\n#\n\n" ); pConv = opal_convertor_create( remote_arch, 0 ); rbuf[0] = -1; rbuf[1] = -1; if( OPAL_SUCCESS != opal_convertor_prepare_for_recv( pConv, &opal_datatype_int4, 1, rbuf ) ) { printf( "Cannot attach the datatype to a convertor\n" ); return OPAL_ERROR; } a.iov_base = sbuf; a.iov_len = 4; iov_count = 1; max_data = 4; opal_unpack_general( pConv, &a, &iov_count, &max_data ); assert(1 == rbuf[0]); assert(-1 == rbuf[1]); OBJ_RELEASE(pConv); printf( "\n\n#\n * TEST UNPACKING 1 int out of 2\n#\n\n" ); pConv = opal_convertor_create( remote_arch, 0 ); rbuf[0] = -1; rbuf[1] = -1; if( OPAL_SUCCESS != opal_convertor_prepare_for_recv( pConv, &opal_datatype_int4, 2, rbuf ) ) { printf( "Cannot attach the datatype to a convertor\n" ); return OPAL_ERROR; } a.iov_base = sbuf; a.iov_len = 4; iov_count = 1; max_data = 4; opal_unpack_general( pConv, &a, &iov_count, &max_data ); assert(1 == rbuf[0]); assert(-1 == rbuf[1]); OBJ_RELEASE(pConv); /* clean-ups all data allocations */ opal_datatype_finalize(); opal_finalize(); return OPAL_SUCCESS; }
int opal_finalize_util(void) { if( --opal_util_initialized != 0 ) { if( opal_util_initialized < 0 ) { return OPAL_ERROR; } return OPAL_SUCCESS; } /* close interfaces code. */ (void) mca_base_framework_close(&opal_if_base_framework); (void) mca_base_framework_close(&opal_event_base_framework); /* Clear out all the registered MCA params */ opal_deregister_params(); mca_base_var_finalize(); opal_net_finalize(); /* keyval lex-based parser */ opal_util_keyval_parse_finalize(); (void) mca_base_framework_close(&opal_installdirs_base_framework); mca_base_close(); /* finalize the memory allocator */ opal_malloc_finalize(); /* finalize the show_help system */ opal_show_help_finalize(); /* finalize the output system. This has to come *after* the malloc code, as the malloc code needs to call into this, but the malloc code turning off doesn't affect opal_output that much */ opal_output_finalize(); /* close the dss */ opal_dss_close(); opal_datatype_finalize(); /* finalize the class/object system */ opal_class_finalize(); free (opal_process_info.nodename); opal_process_info.nodename = NULL; 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; }