From 52c722352d8dc8b07335653a65ce3a4277b8727e Mon Sep 17 00:00:00 2001 From: George Bosilca Date: Tue, 11 Aug 2009 18:44:06 +0000 Subject: [PATCH] The COMPLEX are back. Due to some compilers flags right now the support for _Complex is disabled until we figure out the correct black magic. So instead of using this nice C99 feature, we use the a strcture with a double type, the same approach that worked pretty well for the last couple of years. Switching from one mode to the other is done using the OPAL_USE_[FLOAT|DOUBLE|LONG_DOUBLE]__COMPLEX macros defined in opal_datatype_internal.h at line 442. This commit was SVN r21800. --- ompi/datatype/ompi_datatype.h | 6 +- ompi/datatype/ompi_datatype_internal.h | 100 +++++-------- ompi/datatype/ompi_datatype_module.c | 33 +++-- ompi/datatype/ompi_datatype_sndrcv.c | 1 - opal/datatype/opal_datatype.h | 6 +- opal/datatype/opal_datatype_internal.h | 197 ++++++++++++++++++++----- opal/datatype/opal_datatype_module.c | 56 +++---- 7 files changed, 252 insertions(+), 147 deletions(-) diff --git a/ompi/datatype/ompi_datatype.h b/ompi/datatype/ompi_datatype.h index 57af5cb65e..58ffc28aac 100644 --- a/ompi/datatype/ompi_datatype.h +++ b/ompi/datatype/ompi_datatype.h @@ -162,11 +162,7 @@ ompi_datatype_is_contiguous_memory_layout( const ompi_datatype_t* type, int32_t static inline int32_t ompi_datatype_commit( ompi_datatype_t ** type ) { - ompi_datatype_t * pData = *type; - - opal_datatype_commit ( &pData->super ); - - return OMPI_SUCCESS; + return opal_datatype_commit ( (opal_datatype_t*)*type ); } diff --git a/ompi/datatype/ompi_datatype_internal.h b/ompi/datatype/ompi_datatype_internal.h index bd6e495a4b..fed438cd41 100644 --- a/ompi/datatype/ompi_datatype_internal.h +++ b/ompi/datatype/ompi_datatype_internal.h @@ -47,77 +47,60 @@ #define OMPI_DATATYPE_MPI_FLOAT 0x0E #define OMPI_DATATYPE_MPI_DOUBLE 0x0F #define OMPI_DATATYPE_MPI_LONG_DOUBLE 0x10 -#define OMPI_DATATYPE_MPI_WCHAR 0x11 -#define OMPI_DATATYPE_MPI_PACKED 0x12 +#define OMPI_DATATYPE_MPI_COMPLEX8 0x11 +#define OMPI_DATATYPE_MPI_COMPLEX16 0x12 +#define OMPI_DATATYPE_MPI_COMPLEX32 0x13 +#define OMPI_DATATYPE_MPI_WCHAR 0x14 +#define OMPI_DATATYPE_MPI_PACKED 0x15 -#define OMPI_DATATYPE_MPI_BOOL 0x13 /* Was CXX_BOOL */ +#define OMPI_DATATYPE_MPI_BOOL 0x16 /* Was CXX_BOOL */ -#define OMPI_DATATYPE_MPI_LOGICAL 0x14 -#define OMPI_DATATYPE_MPI_CHARACTER 0x15 /* Changed */ -#define OMPI_DATATYPE_MPI_INTEGER 0x16 -#define OMPI_DATATYPE_MPI_REAL 0x17 -#define OMPI_DATATYPE_MPI_DOUBLE_PRECISION 0x18 /* Was DBLPREC */ +#define OMPI_DATATYPE_MPI_LOGICAL 0x17 +#define OMPI_DATATYPE_MPI_CHARACTER 0x18 /* Changed */ +#define OMPI_DATATYPE_MPI_INTEGER 0x19 +#define OMPI_DATATYPE_MPI_REAL 0x1A +#define OMPI_DATATYPE_MPI_DOUBLE_PRECISION 0x1B /* Was DBLPREC */ /* * Derived datatypes supposely contiguous */ -#define OMPI_DATATYPE_MPI_COMPLEX 0x19 /* Was COMPLEX_FLOAT */ -#define OMPI_DATATYPE_MPI_DOUBLE_COMPLEX 0x1A /* Was COMPLEX_DOUBLE */ -#define OMPI_DATATYPE_MPI_LONG_DOUBLE_COMPLEX 0x1B /* Was COMPLEX_LONG_DOUBLE */ -#define OMPI_DATATYPE_MPI_2INT 0x1C -#define OMPI_DATATYPE_MPI_2INTEGER 0x1D -#define OMPI_DATATYPE_MPI_2REAL 0x1E -#define OMPI_DATATYPE_MPI_2DBLPREC 0x1F -#define OMPI_DATATYPE_MPI_2COMPLEX 0x20 -#define OMPI_DATATYPE_MPI_2DOUBLE_COMPLEX 0x21 +#define OMPI_DATATYPE_MPI_COMPLEX 0x1C /* Was COMPLEX_FLOAT */ +#define OMPI_DATATYPE_MPI_DOUBLE_COMPLEX 0x1D /* Was COMPLEX_DOUBLE */ +#define OMPI_DATATYPE_MPI_LONG_DOUBLE_COMPLEX 0x1E /* Was COMPLEX_LONG_DOUBLE */ +#define OMPI_DATATYPE_MPI_2INT 0x1F +#define OMPI_DATATYPE_MPI_2INTEGER 0x20 +#define OMPI_DATATYPE_MPI_2REAL 0x21 +#define OMPI_DATATYPE_MPI_2DBLPREC 0x22 +#define OMPI_DATATYPE_MPI_2COMPLEX 0x23 +#define OMPI_DATATYPE_MPI_2DOUBLE_COMPLEX 0x24 /* * Derived datatypes which will definitively be non contiguous on some architectures. */ -#define OMPI_DATATYPE_MPI_FLOAT_INT 0x22 -#define OMPI_DATATYPE_MPI_DOUBLE_INT 0x23 -#define OMPI_DATATYPE_MPI_LONG_DOUBLE_INT 0x24 -#define OMPI_DATATYPE_MPI_LONG_INT 0x25 -#define OMPI_DATATYPE_MPI_SHORT_INT 0x26 -#define OMPI_DATATYPE_MPI_UNAVAILABLE 0x27 +#define OMPI_DATATYPE_MPI_FLOAT_INT 0x25 +#define OMPI_DATATYPE_MPI_DOUBLE_INT 0x26 +#define OMPI_DATATYPE_MPI_LONG_DOUBLE_INT 0x27 +#define OMPI_DATATYPE_MPI_LONG_INT 0x28 +#define OMPI_DATATYPE_MPI_SHORT_INT 0x29 +#define OMPI_DATATYPE_MPI_UNAVAILABLE 0x2A -#define OMPI_DATATYPE_MPI_MAX_PREDEFINED 0x28 +#define OMPI_DATATYPE_MPI_MAX_PREDEFINED 0x2B /* * Optional Fortran datatypes, previously no fixed id */ -#define OMPI_DATATYPE_MPI_LOGICAL1 0x28 -#define OMPI_DATATYPE_MPI_LOGICAL2 0x29 -#define OMPI_DATATYPE_MPI_LOGICAL4 0x30 -#define OMPI_DATATYPE_MPI_LOGICAL8 0x31 -#define OMPI_DATATYPE_MPI_INTEGER1 0x32 -#define OMPI_DATATYPE_MPI_INTEGER2 0x33 -#define OMPI_DATATYPE_MPI_INTEGER4 0x34 -#define OMPI_DATATYPE_MPI_INTEGER8 0x35 -#define OMPI_DATATYPE_MPI_INTEGER16 0x36 -#define OMPI_DATATYPE_MPI_REAL2 0x37 -#define OMPI_DATATYPE_MPI_REAL4 0x38 -#define OMPI_DATATYPE_MPI_REAL8 0x39 -#define OMPI_DATATYPE_MPI_REAL16 0x40 -#define OMPI_DATATYPE_MPI_COMPLEX8 0x41 -#define OMPI_DATATYPE_MPI_COMPLEX16 0x42 -#define OMPI_DATATYPE_MPI_COMPLEX32 0x43 - - -typedef struct { - float r; - float i; -} ompi_complex_float_t; - -typedef struct { - double r; - double i; -} ompi_complex_double_t; - -typedef struct { - long double r; - long double i; -} ompi_complex_long_double_t; - +#define OMPI_DATATYPE_MPI_LOGICAL1 0x2B +#define OMPI_DATATYPE_MPI_LOGICAL2 0x2C +#define OMPI_DATATYPE_MPI_LOGICAL4 0x2D +#define OMPI_DATATYPE_MPI_LOGICAL8 0x2E +#define OMPI_DATATYPE_MPI_INTEGER1 0x2F +#define OMPI_DATATYPE_MPI_INTEGER2 0x30 +#define OMPI_DATATYPE_MPI_INTEGER4 0x31 +#define OMPI_DATATYPE_MPI_INTEGER8 0x32 +#define OMPI_DATATYPE_MPI_INTEGER16 0x33 +#define OMPI_DATATYPE_MPI_REAL2 0x34 +#define OMPI_DATATYPE_MPI_REAL4 0x35 +#define OMPI_DATATYPE_MPI_REAL8 0x36 +#define OMPI_DATATYPE_MPI_REAL16 0x37 OMPI_DECLSPEC extern union dt_elem_desc ompi_datatype_predefined_elem_desc[2 * OMPI_DATATYPE_MPI_MAX_PREDEFINED]; extern const ompi_datatype_t* ompi_datatype_basicDatatypes[OMPI_DATATYPE_MPI_MAX_PREDEFINED]; @@ -143,9 +126,6 @@ extern const ompi_datatype_t* ompi_datatype_basicDatatypes[OMPI_DATATYPE_MPI_MAX NULL /*packed_description*/, \ "MPI_" # NAME /*name*/ -#define OMPI_DATATYPE_INITIALIZER_NULL(FLAGS) \ - OPAL_DATATYPE_INITIALIZER_NULL(OMPI_DATATYPE_FLAG_PREDEFINED | FLAGS) - #define OMPI_DATATYPE_INITIALIZER_UNAVAILABLE(FLAGS) \ OPAL_DATATYPE_INITIALIZER_UNAVAILABLE(FLAGS) diff --git a/ompi/datatype/ompi_datatype_module.c b/ompi/datatype/ompi_datatype_module.c index 4a19c018bd..735ac353dc 100644 --- a/ompi/datatype/ompi_datatype_module.c +++ b/ompi/datatype/ompi_datatype_module.c @@ -70,7 +70,7 @@ int32_t ompi_datatype_number_of_predefined_data = 0; ompi_predefined_datatype_t ompi_mpi_datatype_null = { { - OMPI_DATATYPE_INITIALIZER_NULL (0), + OPAL_DATATYPE_INITIALIZER_NULL(OMPI_DATATYPE_FLAG_PREDEFINED), OMPI_DATATYPE_EMPTY_DATA(NULL), }, {0, } /* padding */ @@ -275,35 +275,38 @@ const ompi_datatype_t* ompi_datatype_basicDatatypes[OMPI_DATATYPE_MPI_MAX_PREDEF &ompi_mpi_float.dt, &ompi_mpi_double.dt, /* 15 */ &ompi_mpi_long_double.dt, - &ompi_mpi_wchar.dt, + &ompi_mpi_complex8.dt, + &ompi_mpi_complex16.dt, + &ompi_mpi_complex32.dt, + &ompi_mpi_wchar.dt, /* 20 */ &ompi_mpi_packed.dt, /* C++ / C99 datatypes */ &ompi_mpi_cxx_bool.dt, /* Fortran datatypes */ - &ompi_mpi_logical.dt, /* 20 */ + &ompi_mpi_logical.dt, &ompi_mpi_character.dt, - &ompi_mpi_integer.dt, + &ompi_mpi_integer.dt, /* 25 */ &ompi_mpi_real.dt, &ompi_mpi_dblprec.dt, - &ompi_mpi_cplex.dt, /* 25 */ + &ompi_mpi_cplex.dt, &ompi_mpi_dblcplex.dt, - &ompi_mpi_ldblcplex.dt, + &ompi_mpi_ldblcplex.dt, /* 30 */ /* Structure types, based on two basic types */ &ompi_mpi_2int.dt, &ompi_mpi_2integer.dt, - &ompi_mpi_2real.dt, /* 30 */ + &ompi_mpi_2real.dt, &ompi_mpi_2dblprec.dt, - &ompi_mpi_2cplex.dt, + &ompi_mpi_2cplex.dt, /* 35 */ &ompi_mpi_2dblcplex.dt, &ompi_mpi_float_int.dt, - &ompi_mpi_double_int.dt, /* 35 */ + &ompi_mpi_double_int.dt, &ompi_mpi_longdbl_int.dt, - &ompi_mpi_long_int.dt, + &ompi_mpi_long_int.dt, /* 40 */ &ompi_mpi_short_int.dt, - &ompi_mpi_unavailable.dt /* 39 */ + &ompi_mpi_unavailable.dt }; opal_pointer_array_t ompi_datatype_f_to_c_table; @@ -438,16 +441,16 @@ int32_t ompi_datatype_init( void ) * in mpif.h */ - /* the 2 complex datatypes (float and double) */ + /* the complex datatypes (float, double and long double) */ DECLARE_MPI2_COMPOSED_STRUCT_DDT( &ompi_mpi_cplex.dt, OMPI_DATATYPE_COMPLEX, "MPI_COMPLEX", - float, float, OMPI_DATATYPE_FLOAT, OMPI_DATATYPE_FLOAT, + float, float, OMPI_DATATYPE_MPI_FLOAT, OMPI_DATATYPE_MPI_FLOAT, OMPI_DATATYPE_FLAG_DATA_FORTRAN | OMPI_DATATYPE_FLAG_DATA_FLOAT ); DECLARE_MPI2_COMPOSED_STRUCT_DDT( &ompi_mpi_dblcplex.dt, OMPI_DATATYPE_DOUBLE_COMPLEX, "MPI_DOUBLE_COMPLEX", - double, double, OMPI_DATATYPE_DOUBLE, OMPI_DATATYPE_DOUBLE, + double, double, OMPI_DATATYPE_MPI_DOUBLE, OMPI_DATATYPE_MPI_DOUBLE, OMPI_DATATYPE_FLAG_DATA_FORTRAN | OMPI_DATATYPE_FLAG_DATA_FLOAT ); #if HAVE_LONG_DOUBLE DECLARE_MPI2_COMPOSED_STRUCT_DDT( &ompi_mpi_ldblcplex.dt, OMPI_DATATYPE_LONG_DOUBLE_COMPLEX, "MPI_LONG_DOUBLE_COMPLEX", - long double, long double, OMPI_DATATYPE_LONG_DOUBLE, OMPI_DATATYPE_LONG_DOUBLE, + long double, long double, OMPI_DATATYPE_MPI_LONG_DOUBLE, OMPI_DATATYPE_MPI_LONG_DOUBLE, OMPI_DATATYPE_FLAG_DATA_FORTRAN | OMPI_DATATYPE_FLAG_DATA_FLOAT ); #endif /* HAVE_LONG_DOUBLE */ diff --git a/ompi/datatype/ompi_datatype_sndrcv.c b/ompi/datatype/ompi_datatype_sndrcv.c index 542b421808..f92de75f50 100644 --- a/ompi/datatype/ompi_datatype_sndrcv.c +++ b/ompi/datatype/ompi_datatype_sndrcv.c @@ -56,7 +56,6 @@ int32_t ompi_datatype_sndrcv( void *sbuf, int32_t scount, const ompi_datatype_t* } /* If same datatypes used, just copy. */ - /* XXX TODO sdtype ptr == rdtype ptr check enough??? Shouldn't the ID be the criteria for equality ?*/ if (sdtype == rdtype) { int32_t count = ( scount < rcount ? scount : rcount ); opal_datatype_copy_content_same_ddt(&(rdtype->super), count, (char*)rbuf, (char*)sbuf); diff --git a/opal/datatype/opal_datatype.h b/opal/datatype/opal_datatype.h index 9541103708..48d894dec0 100644 --- a/opal/datatype/opal_datatype.h +++ b/opal/datatype/opal_datatype.h @@ -166,9 +166,9 @@ OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_float4; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_float8; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_float12; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_float16; -OPAL_DECLSPEC extern opal_datatype_t opal_datatype_complex8; -OPAL_DECLSPEC extern opal_datatype_t opal_datatype_complex16; -OPAL_DECLSPEC extern opal_datatype_t opal_datatype_complex32; +OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_complex8; +OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_complex16; +OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_complex32; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_bool; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_wchar; diff --git a/opal/datatype/opal_datatype_internal.h b/opal/datatype/opal_datatype_internal.h index 62bffe0288..c7cdf5286f 100644 --- a/opal/datatype/opal_datatype_internal.h +++ b/opal/datatype/opal_datatype_internal.h @@ -247,8 +247,23 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ #define OPAL_DATATYPE_INIT_BTYPES_ARRAY_FLOAT8 { Z15, 0, 1, } #define OPAL_DATATYPE_INIT_BTYPES_ARRAY_FLOAT12 { Z15, 0, 0, 1, } #define OPAL_DATATYPE_INIT_BTYPES_ARRAY_FLOAT16 { Z15, 0, 0, 0, 1, } -#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_BOOL { Z15, 0, 0, 0, 0, 1, } -#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_WCHAR { Z20, 1, } /*20*/ +#if HAVE_FLOAT__COMPLEX +#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_COMPLEX8 { Z15, 0, 0, 0, 0, 1 } +#else +#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_COMPLEX8 { Z15, 2 } /* two floats */ +#endif +#if HAVE_DOUBLE__COMPLEX +#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_COMPLEX16 { Z15, 0, 0, 0, 0, 0, 1 } +#else +#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_COMPLEX16 { Z15, 0, 2, } +#endif +#if HAVE_LONG_DOUBLE__COMPLEX +#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_COMPLEX32 { Z15, 0, 0, 0, 0, 0, 0, 1 } +#else +#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_COMPLEX32 { Z15, 0, 0, 0, 2, } +#endif +#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_BOOL { Z20, 0, 1, } /*22*/ +#define OPAL_DATATYPE_INIT_BTYPES_ARRAY_WCHAR { Z20, 0, 0, 1, } #define OPAL_DATATYPE_INIT_NAME(NAME) "OPAL_" # NAME @@ -264,22 +279,6 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ } #define OPAL_DATATYPE_INIT_DESC_NULL {0 /*length*/, 0/*used*/, NULL /*desc*/} -#define OPAL_DATATYPE_INITIALIZER_NULL( FLAGS ) \ - { \ - OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ - OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS) /*flag*/, \ - 0 /*id*/, \ - 0 /*bdt_used*/, \ - 0 /*size*/, \ - 0 /*true_lb*/, 0 /*true_ub*/, 0 /*lb*/, 0 /*ub*/, \ - 0 /*align*/, \ - 1 /*nbElems*/, \ - OPAL_DATATYPE_INIT_NAME(NULL), /*name*/ \ - OPAL_DATATYPE_INIT_DESC_NULL, /*desc*/ \ - OPAL_DATATYPE_INIT_DESC_NULL, /*opt_desc*/ \ - OPAL_DATATYPE_INIT_BTYPES_ARRAY_UNAVAILABLE /*btypes*/ \ - } - #define OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS ) \ { \ OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ @@ -296,6 +295,38 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ OPAL_DATATYPE_INIT_BTYPES_ARRAY_UNAVAILABLE /*btypes*/ \ } +#define OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( NAME, FLAGS ) \ + { \ + OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ + OPAL_DATATYPE_FLAG_UNAVAILABLE | OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS) /*flag*/, \ + OPAL_DATATYPE_ ## NAME /*id*/, \ + 0 /*bdt_used*/, \ + 0 /*size*/, \ + 0 /*true_lb*/, 0 /*true_ub*/, 0 /*lb*/, 0 /*ub*/, \ + 0 /*align*/, \ + 1 /*nbElems*/, \ + OPAL_DATATYPE_INIT_NAME(NAME), /*name*/ \ + OPAL_DATATYPE_INIT_DESC_PREDEFINED(UNAVAILABLE), /*desc*/ \ + OPAL_DATATYPE_INIT_DESC_PREDEFINED(UNAVAILABLE), /*opt_desc*/ \ + OPAL_DATATYPE_INIT_BTYPES_ARRAY_UNAVAILABLE /*btypes*/ \ + } + +#define OPAL_DATATYPE_INITIALIZER_NULL( FLAGS ) \ + { \ + OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ + OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS) /*flag*/, \ + 0 /*id*/, \ + 0 /*bdt_used*/, \ + 0 /*size*/, \ + 0 /*true_lb*/, 0 /*true_ub*/, 0 /*lb*/, 0 /*ub*/, \ + 0 /*align*/, \ + 1 /*nbElems*/, \ + OPAL_DATATYPE_INIT_NAME(NULL), /*name*/ \ + OPAL_DATATYPE_INIT_DESC_NULL, /*desc*/ \ + OPAL_DATATYPE_INIT_DESC_NULL, /*opt_desc*/ \ + OPAL_DATATYPE_INIT_BTYPES_ARRAY_UNAVAILABLE /*btypes*/ \ + } + #define OPAL_DATATYPE_INIT_BASIC_TYPE( TYPE, NAME, FLAGS ) \ { \ OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ @@ -312,7 +343,6 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ OPAL_DATATYPE_INIT_BTYPES_ARRAY_ ## NAME /*btypes*/ \ } - #define OPAL_DATATYPE_INIT_BASIC_DATATYPE( TYPE, ALIGN, NAME, FLAGS ) \ { \ OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ @@ -329,7 +359,6 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ OPAL_DATATYPE_INIT_BTYPES_ARRAY_ ## NAME /*btypes*/ \ } - #define OPAL_DATATYPE_INITIALIZER_LOOP(FLAGS) OPAL_DATATYPE_INIT_BASIC_TYPE( OPAL_DATATYPE_LOOP, LOOP, FLAGS ) #define OPAL_DATATYPE_INITIALIZER_END_LOOP(FLAGS) OPAL_DATATYPE_INIT_BASIC_TYPE( OPAL_DATATYPE_END_LOOP, END_LOOP, FLAGS ) #define OPAL_DATATYPE_INITIALIZER_LB(FLAGS) OPAL_DATATYPE_INIT_BASIC_TYPE( OPAL_DATATYPE_LB, LB, FLAGS ) @@ -341,8 +370,7 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ #ifdef HAVE_INT128_T #define OPAL_DATATYPE_INITIALIZER_INT16(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( int128_t, OPAL_ALIGNMENT_INT128, INT16, FLAGS ) #else -#define OPAL_DATATYPE_INITIALIZER_INT16(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS ) -/* #warning OPAL_DATATYPE_INITIALIZER_INT16 not available */ +#define OPAL_DATATYPE_INITIALIZER_INT16(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( INT16, FLAGS ) #endif #define OPAL_DATATYPE_INITIALIZER_UINT1(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( uint8_t, OPAL_ALIGNMENT_INT8, UINT1, FLAGS ) #define OPAL_DATATYPE_INITIALIZER_UINT2(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( uint16_t, OPAL_ALIGNMENT_INT16, UINT2, FLAGS ) @@ -351,8 +379,7 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ #ifdef HAVE_UINT128_T #define OPAL_DATATYPE_INITIALIZER_UINT16(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( uint128_t, OPAL_ALIGNMENT_INT128, UINT16, FLAGS ) #else -#define OPAL_DATATYPE_INITIALIZER_UINT16(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS ) -/* #warning OPAL_DATATYPE_INITIALIZER_UINT16 not available */ +#define OPAL_DATATYPE_INITIALIZER_UINT16(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( INT16, FLAGS ) #endif #if SIZEOF_FLOAT == 2 @@ -362,8 +389,7 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ #elif SIZEOF_LONG_DOUBLE == 2 #define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT2, FLAGS ) #else -#define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS ) -/* #warning OPAL_DATATYPE_INITIALIZER_FLOAT2 not available */ +#define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT2, FLAGS ) #endif #if SIZEOF_FLOAT == 4 @@ -373,8 +399,7 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ #elif SIZEOF_LONG_DOUBLE == 4 #define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT4, FLAGS ) #else -#define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS ) -/* #warning OPAL_DATATYPE_INITIALIZER_FLOAT4 not available */ +#define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT4, FLAGS ) #endif #if SIZEOF_FLOAT == 8 @@ -384,8 +409,7 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ #elif SIZEOF_LONG_DOUBLE == 8 #define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT8, FLAGS ) #else -#define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS ) -/* #warning OPAL_DATATYPE_INITIALIZER_FLOAT8 not available */ +#define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT8, FLAGS ) #endif #if SIZEOF_FLOAT == 12 @@ -395,8 +419,7 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ #elif SIZEOF_LONG_DOUBLE == 12 #define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT12, FLAGS ) #else -#define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS ) -/* #warning OPAL_DATATYPE_INITIALIZER_FLOAT12 not available */ +#define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT12, FLAGS ) #endif #if SIZEOF_FLOAT == 16 @@ -406,17 +429,119 @@ OPAL_DECLSPEC extern const struct opal_datatype_t* opal_datatype_basicDatatypes[ #elif SIZEOF_LONG_DOUBLE == 16 #define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT16, FLAGS ) #else -#define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS ) -/* #warning OPAL_DATATYPE_INITIALIZER_FLOAT16 not available */ +#define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT16, FLAGS ) #endif +/* + * Until we figure out the whole logic behing the _Complex type, disable it. It only exists + * in C99 (i.e. __STDC_VERSION__ >= 199901L) but [evidently] not all compilers correctly + * export the __STDC_VERSION__. + * http://predef.sourceforge.net/prestd.html for more info. + */ + +#define OPAL_USE_FLOAT__COMPLEX (0 && HAVE_FLOAT__COMPLEX) +#define OPAL_USE_DOUBLE__COMPLEX (0 && HAVE_DOUBLE__COMPLEX) +#define OPAL_USE_LONG_DOUBLE__COMPLEX (0 && HAVE_LONG_DOUBLE__COMPLEX) + +#if OPAL_USE_FLOAT__COMPLEX && (SIZEOF_FLOAT__COMPLEX == 8) +#define OPAL_DATATYPE_INITIALIZER_COMPLEX8(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( float _Complex, OPAL_ALIGNMENT_FLOAT_COMPLEX, COMPLEX8, (FLAGS) ) +#else + +#if SIZEOF_FLOAT == 4 +typedef struct { + float r; + float i; +} opal_complex_float_t; + +#define OPAL_DATATYPE_INITIALIZER_COMPLEX8( FLAGS ) \ + { \ + OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ + OPAL_DATATYPE_FLAG_BASIC | (FLAGS) /*flag*/, \ + OPAL_DATATYPE_COMPLEX8 /*id*/, \ + (((uint32_t)1)<<(OPAL_DATATYPE_ ## FLOAT4)) /*bdt_used*/, \ + sizeof(opal_complex_float_t) /*size*/, \ + 0 /*true_lb*/, sizeof(opal_complex_float_t) /*true_ub*/, 0 /*lb*/, sizeof(opal_complex_float_t) /*ub*/, \ + OPAL_ALIGNMENT_FLOAT /*align*/, \ + 2 /*nbElems*/, \ + OPAL_DATATYPE_INIT_NAME(COMPLEX8) /*name*/, \ + OPAL_DATATYPE_INIT_DESC_PREDEFINED(COMPLEX8) /*desc*/, \ + OPAL_DATATYPE_INIT_DESC_PREDEFINED(COMPLEX8) /*opt_desc*/, \ + {Z15, 2, } /*btypes*/ \ + } +#else +#define OPAL_DATATYPE_INITIALIZER_COMPLEX8(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( COMPLEX8, FLAGS ) +#endif + +#endif /* HAVE_FLOAT__COMPLEX */ + +#if OPAL_USE_DOUBLE__COMPLEX && (SIZEOF_DOUBLE__COMPLEX == 16) +#define OPAL_DATATYPE_INITIALIZER_COMPLEX16(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( double _Complex, OPAL_ALIGNMENT_DOUBLE_COMPLEX, COMPLEX16, (FLAGS) ) +#else + +#if SIZEOF_DOUBLE == 8 +typedef struct { + double r; + double i; +} opal_complex_double_t; + +#define OPAL_DATATYPE_INITIALIZER_COMPLEX16( FLAGS ) \ + { \ + OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ + OPAL_DATATYPE_FLAG_BASIC | (FLAGS) /*flag*/, \ + OPAL_DATATYPE_COMPLEX16 /*id*/, \ + (((uint32_t)1)<<(OPAL_DATATYPE_ ## FLOAT8)) /*bdt_used*/, \ + sizeof(opal_complex_double_t) /*size*/, \ + 0 /*true_lb*/, sizeof(opal_complex_double_t) /*true_ub*/, 0 /*lb*/, sizeof(opal_complex_double_t) /*ub*/, \ + OPAL_ALIGNMENT_DOUBLE /*align*/, \ + 2 /*nbElems*/, \ + OPAL_DATATYPE_INIT_NAME(COMPLEX16) /*name*/, \ + OPAL_DATATYPE_INIT_DESC_PREDEFINED(COMPLEX16) /*desc*/, \ + OPAL_DATATYPE_INIT_DESC_PREDEFINED(COMPLEX16) /*opt_desc*/, \ + {Z15, 2, } /*btypes*/ \ + } +#else +#define OPAL_DATATYPE_INITIALIZER_COMPLEX16(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( COMPLEX16, FLAGS ) +#endif + +#endif /* HAVE_DOUBLE__COMPLEX */ + +#if OPAL_USE_LONG_DOUBLE__COMPLEX && (SIZEOF_LONG_DOUBLE__COMPLEX == 32) +#define OPAL_DATATYPE_INITIALIZER_COMPLEX32(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double _Complex, OPAL_ALIGNMENT_LONG_DOUBLE_COMPLEX, COMPLEX32, (FLAGS) ) +#else + +#if HAVE_LONG_DOUBLE && (SIZEOF_LONG_DOUBLE == 16) +typedef struct { + long double r; + long double i; +} opal_complex_long_double_t; + +#define OPAL_DATATYPE_INITIALIZER_COMPLEX32( FLAGS ) \ + { \ + OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ + OPAL_DATATYPE_FLAG_BASIC | (FLAGS) /*flag*/, \ + OPAL_DATATYPE_COMPLEX32 /*id*/, \ + (((uint32_t)1)<<(OPAL_DATATYPE_ ## FLOAT16)) /*bdt_used*/, \ + sizeof(opal_complex_long_double_t) /*size*/, \ + 0 /*true_lb*/, sizeof(opal_complex_long_double_t) /*true_ub*/, 0 /*lb*/, sizeof(opal_complex_long_double_t) /*ub*/, \ + OPAL_ALIGNMENT_LONG_DOUBLE /*align*/, \ + 2 /*nbElems*/, \ + OPAL_DATATYPE_INIT_NAME(COMPLEX32) /*name*/, \ + OPAL_DATATYPE_INIT_DESC_PREDEFINED(COMPLEX32) /*desc*/, \ + OPAL_DATATYPE_INIT_DESC_PREDEFINED(COMPLEX32) /*opt_desc*/, \ + {Z15, 2, } /*btypes*/ \ + } +#else +#define OPAL_DATATYPE_INITIALIZER_COMPLEX32(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( COMPLEX32, FLAGS ) +#endif + +#endif /* HAVE_LONG_DOUBLE__COMPLEX */ + #define OPAL_DATATYPE_INITIALIZER_BOOL(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( _Bool, OPAL_ALIGNMENT_BOOL, BOOL, FLAGS ) #if OPAL_ALIGNMENT_WCHAR != 0 #define OPAL_DATATYPE_INITIALIZER_WCHAR(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( wchar_t, OPAL_ALIGNMENT_WCHAR, WCHAR, FLAGS ) #else -#define OPAL_DATATYPE_INITIALIZER_WCHAR(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS ) -/* #warning OPAL_DATATYPE_INITIALIZER_WCHAR not available */ +#define OPAL_DATATYPE_INITIALIZER_WCHAR(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( WCHAR, FLAGS ) #endif diff --git a/opal/datatype/opal_datatype_module.c b/opal/datatype/opal_datatype_module.c index 50aa466572..90a7d87f70 100644 --- a/opal/datatype/opal_datatype_module.c +++ b/opal/datatype/opal_datatype_module.c @@ -66,9 +66,9 @@ OPAL_DECLSPEC const opal_datatype_t opal_datatype_float4 = OPAL_DATATYPE_IN OPAL_DECLSPEC const opal_datatype_t opal_datatype_float8 = OPAL_DATATYPE_INITIALIZER_FLOAT8(0); OPAL_DECLSPEC const opal_datatype_t opal_datatype_float12 = OPAL_DATATYPE_INITIALIZER_FLOAT12(0); OPAL_DECLSPEC const opal_datatype_t opal_datatype_float16 = OPAL_DATATYPE_INITIALIZER_FLOAT16(0); -OPAL_DECLSPEC opal_datatype_t opal_datatype_complex8 = OPAL_DATATYPE_INITIALIZER_UNAVAILABLE(0); -OPAL_DECLSPEC opal_datatype_t opal_datatype_complex16 = OPAL_DATATYPE_INITIALIZER_UNAVAILABLE(0); -OPAL_DECLSPEC opal_datatype_t opal_datatype_complex32 = OPAL_DATATYPE_INITIALIZER_UNAVAILABLE(0); +OPAL_DECLSPEC const opal_datatype_t opal_datatype_complex8 = OPAL_DATATYPE_INITIALIZER_COMPLEX8(0); +OPAL_DECLSPEC const opal_datatype_t opal_datatype_complex16 = OPAL_DATATYPE_INITIALIZER_COMPLEX16(0); +OPAL_DECLSPEC const opal_datatype_t opal_datatype_complex32 = OPAL_DATATYPE_INITIALIZER_COMPLEX32(0); OPAL_DECLSPEC const opal_datatype_t opal_datatype_bool = OPAL_DATATYPE_INITIALIZER_BOOL(0); OPAL_DECLSPEC const opal_datatype_t opal_datatype_wchar = OPAL_DATATYPE_INITIALIZER_WCHAR(0); OPAL_DECLSPEC const opal_datatype_t opal_datatype_unavailable = OPAL_DATATYPE_INITIALIZER_UNAVAILABLE(0); @@ -163,34 +163,13 @@ int opal_datatype_register_params(void) int32_t opal_datatype_init( void ) { + const opal_datatype_t* datatype; int32_t i; - opal_datatype_t* temp; - - opal_datatype_create_contiguous( 2, &opal_datatype_float4, &temp ); - temp->id = OPAL_DATATYPE_COMPLEX8; - temp->flags |= OPAL_DATATYPE_FLAG_PREDEFINED; - strcpy( temp->name, "OPAL_DATATYPE_COMPLEX8" ); - memcpy( (void*)&opal_datatype_complex8, temp, sizeof(opal_datatype_t) ); - opal_datatype_destroy(&temp); - - opal_datatype_create_contiguous( 2, &opal_datatype_float8, &temp ); - temp->id = OPAL_DATATYPE_COMPLEX16; - temp->flags |= OPAL_DATATYPE_FLAG_PREDEFINED; - strcpy( temp->name, "OPAL_DATATYPE_COMPLEX16" ); - memcpy( (void*)&opal_datatype_complex16, temp, sizeof(opal_datatype_t) ); - opal_datatype_destroy(&temp); - - opal_datatype_create_contiguous( 2, &opal_datatype_float16, &temp ); - temp->id = OPAL_DATATYPE_COMPLEX32; - temp->flags |= OPAL_DATATYPE_FLAG_PREDEFINED; - strcpy( temp->name, "OPAL_DATATYPE_COMPLEX32" ); - memcpy( (void*)&opal_datatype_complex32, temp, sizeof(opal_datatype_t) ); - opal_datatype_destroy(&temp); opal_arch_compute_local_id( &opal_local_arch ); for( i = OPAL_DATATYPE_FIRST_TYPE; i < OPAL_DATATYPE_MAX_PREDEFINED; i++ ) { - const opal_datatype_t* datatype = opal_datatype_basicDatatypes[i]; + datatype = opal_datatype_basicDatatypes[i]; /* All of the predefined OPAL types don't have any GAPS! */ datatype->desc.desc[0].elem.common.flags = OPAL_DATATYPE_FLAG_PREDEFINED | @@ -208,9 +187,32 @@ int32_t opal_datatype_init( void ) datatype->desc.desc[1].end_loop.items = 1; datatype->desc.desc[1].end_loop.first_elem_disp = datatype->desc.desc[0].elem.disp; datatype->desc.desc[1].end_loop.size = datatype->size; - } +#if !(OPAL_USE_FLOAT__COMPLEX && (SIZEOF_FLOAT__COMPLEX == 8)) && (SIZEOF_FLOAT == 4) + datatype = opal_datatype_basicDatatypes[OPAL_DATATYPE_COMPLEX8]; + + datatype->desc.desc[0].elem.common.type = OPAL_DATATYPE_FLOAT4; + datatype->desc.desc[0].elem.count = 2; + datatype->desc.desc[0].elem.extent = SIZEOF_FLOAT; +#endif + +#if !(OPAL_USE_DOUBLE__COMPLEX && (SIZEOF_DOUBLE__COMPLEX == 16)) && (SIZEOF_DOUBLE == 8) + datatype = opal_datatype_basicDatatypes[OPAL_DATATYPE_COMPLEX16]; + + datatype->desc.desc[0].elem.common.type = OPAL_DATATYPE_FLOAT8; + datatype->desc.desc[0].elem.count = 2; + datatype->desc.desc[0].elem.extent = SIZEOF_DOUBLE; +#endif + +#if !(OPAL_USE_LONG_DOUBLE__COMPLEX && (SIZEOF_LONG_DOUBLE__COMPLEX == 32)) && (HAVE_LONG_DOUBLE && (SIZEOF_LONG_DOUBLE == 16)) + datatype = opal_datatype_basicDatatypes[OPAL_DATATYPE_COMPLEX32]; + + datatype->desc.desc[0].elem.common.type = OPAL_DATATYPE_FLOAT16; + datatype->desc.desc[0].elem.count = 2; + datatype->desc.desc[0].elem.extent = SIZEOF_LONG_DOUBLE; +#endif + return OPAL_SUCCESS; }