diff --git a/config/ompi_fortran_check.m4 b/config/ompi_fortran_check.m4 index 777da4779a4..e479a87ac64 100644 --- a/config/ompi_fortran_check.m4 +++ b/config/ompi_fortran_check.m4 @@ -14,6 +14,7 @@ dnl Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. dnl Copyright (c) 2015 Research Organization for Information Science dnl and Technology (RIST). All rights reserved. dnl Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. +dnl Copyright (c) 2026 NVIDIA Corporation. All rights reserved. dnl $COPYRIGHT$ dnl dnl Additional copyrights may follow @@ -115,7 +116,7 @@ AC_DEFUN([OMPI_FORTRAN_CHECK], [ # the same format -- so the compiler is allowed to define # C_LONG_DOUBLE to -1). - AC_MSG_CHECKING([for corresponding KIND value of $1]) + AC_MSG_CHECKING([for corresponding KIND value of $1 (C type $ofc_c_type)]) case "$ofc_c_type" in char) ofc_type_kind=C_SIGNED_CHAR ;; double) ofc_type_kind=C_DOUBLE ;; @@ -136,6 +137,8 @@ AC_DEFUN([OMPI_FORTRAN_CHECK], [ long*double*_Complex) ofc_type_kind=C_LONG_DOUBLE_COMPLEX ;; opal_short_float_t) ofc_type_kind=C_SHORT_FLOAT ;; opal_short_float_complex_t) ofc_type_kind=C_SHORT_FLOAT_COMPLEX ;; + _Float128) ofc_type_kind=C__FLOAT128 ;; + __float128) ofc_type_kind=C___FLOAT128 ;; *) # Skip types like "DOUBLE PRECISION" ;; @@ -182,7 +185,7 @@ AC_DEFUN([OMPI_FORTRAN_CHECK], [ [Alignment of Fortran $1]) AC_DEFINE_UNQUOTED([OMPI_KIND_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]), [$ofc_type_kind], - [Fortrn KIND number for $1]) + [Fortran KIND number for $1]) if test "$3" != "" && test "$ofc_define_type" = "yes"; then AC_DEFINE_UNQUOTED([ompi_fortran_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [A-Z], [a-z])[_t], [$ofc_c_type], diff --git a/config/ompi_fortran_check_real16_c_equiv.m4 b/config/ompi_fortran_check_real16_c_equiv.m4 index 8ae47a0f081..85141c798b6 100644 --- a/config/ompi_fortran_check_real16_c_equiv.m4 +++ b/config/ompi_fortran_check_real16_c_equiv.m4 @@ -14,6 +14,7 @@ dnl Copyright (c) 2008-2016 Cisco Systems, Inc. All rights reserved. dnl Copyright (c) 2012 Oracle and/or its affiliates. All rights reserved. dnl Copyright (c) 2015 Research Organization for Information Science dnl and Technology (RIST). All rights reserved. +dnl Copyright (c) 2026 NVIDIA Corporation. All rights reserved. dnl $COPYRIGHT$ dnl dnl Additional copyrights may follow @@ -43,26 +44,38 @@ AC_DEFUN([OMPI_FORTRAN_CHECK_REAL16_C_EQUIV],[ # type that might work AS_IF([test "$fortran_real16_happy" = "no"], [AC_MSG_RESULT([$fortran_real16_happy]) - # Intel compiler has a special type that should work - AS_IF([test "$opal_cv_c_compiler_vendor" = "intel"], - [AC_MSG_CHECKING([if intel compiler _Quad == REAL*16]) - CFLAGS_save="$CFLAGS" - OPAL_FLAGS_APPEND_UNIQ([CFLAGS], ["-Qoption,cpp,--extended_float_types"]) - OMPI_FORTRAN_CHECK_REAL16_EQUIV_TYPE([_Quad], [q]) - AS_IF([test "$fortran_real16_happy" = "yes"], - [OMPI_FORTRAN_REAL16_C_TYPE="_Quad" - AC_MSG_RESULT([works!])], - [CFLAGS="$CFLAGS_save" - AC_MSG_RESULT([does not work])]) - ]) - AS_IF([test "$opal_cv_c_compiler_vendor" = "gnu" && test "$ac_cv_type___float128" = "yes"], - [AC_MSG_CHECKING([if gnu compiler __float128 == REAL*16]) + AS_IF([test "$ac_cv_type__Float128" = "yes"], + [AC_MSG_CHECKING([if the compiler _Float128 == REAL*16]) + OMPI_FORTRAN_CHECK_REAL16_EQUIV_TYPE([_Float128], [q]) + AS_IF([test "$fortran_real16_happy" = "yes"], + [OMPI_FORTRAN_REAL16_C_TYPE="_Float128" + AC_MSG_RESULT([works!])], + [AC_MSG_RESULT([does not work])]) + ]) + # Try first the more widely available __float128 + AS_IF([test "$fortran_real16_happy" = "no" && test "$ac_cv_type___float128" = "yes"], + [AC_MSG_CHECKING([if the compiler __float128 == REAL*16]) OMPI_FORTRAN_CHECK_REAL16_EQUIV_TYPE([__float128], [q]) AS_IF([test "$fortran_real16_happy" = "yes"], [OMPI_FORTRAN_REAL16_C_TYPE="__float128" AC_MSG_RESULT([works!])], [AC_MSG_RESULT([does not work])]) ]) + # As recent Intel compilers identify as GNU we will always test for Quad support if no other tests were succesfull + AS_IF([test "$fortran_real16_happy" = "no"], + [AC_CHECK_TYPES(_Quad) + AS_IF([test "$ac_cv_type__Quad" = "yes"], + [AC_MSG_CHECKING([if the compiler _Quad == REAL*16]) + CFLAGS_save="$CFLAGS" + OPAL_FLAGS_APPEND_UNIQ([CFLAGS], ["-Qoption,cpp,--extended_float_types"]) + OMPI_FORTRAN_CHECK_REAL16_EQUIV_TYPE([_Quad], [q]) + AS_IF([test "$fortran_real16_happy" = "yes"], + [OMPI_FORTRAN_REAL16_C_TYPE="_Quad" + AC_MSG_RESULT([works!])], + [CFLAGS="$CFLAGS_save" + AC_MSG_RESULT([does not work])]) + ]) + ]) # We have to [re-]print a new message here, because # AC_CACHE_CHECK will automatically AC_MSG_RESULT AC_MSG_CHECKING([for C type matching bit representation of REAL*16]) @@ -102,7 +115,7 @@ AC_DEFUN([OMPI_FORTRAN_CHECK_REAL16_EQUIV_TYPE],[ extern "C" { #endif -void c_backend($1 *a) { +static void c_backend($1 *a) { $1 foo = 11; FILE *fp = fopen("conftestval", "w"); if (NULL == fp) exit(1); diff --git a/config/ompi_setup_mpi_fortran.m4 b/config/ompi_setup_mpi_fortran.m4 index f92a5d70c93..3474276e661 100644 --- a/config/ompi_setup_mpi_fortran.m4 +++ b/config/ompi_setup_mpi_fortran.m4 @@ -22,6 +22,7 @@ dnl Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. dnl Copyright (c) 2022 Triad National Security, LLC. All rights dnl reserved. dnl Copyright (c) 2025 Stony Brook University. All rights reserved. +dnl Copyright (c) 2026 NVIDIA Corporation. All rights reserved. dnl $COPYRIGHT$ dnl dnl Additional copyrights may follow @@ -182,13 +183,13 @@ AC_DEFUN([OMPI_SETUP_MPI_FORTRAN],[ [short float, float, double, long double, opal_short_float_t], [2], [yes]) OMPI_FORTRAN_CHECK([REAL*4], [no], - [short float, float, double, long double, opal_short_float_t], + [long double, double, float, short float, opal_short_float_t], [4], [yes]) OMPI_FORTRAN_CHECK([REAL*8], [no], - [short float, float, double, long double, opal_short_float_t], + [long double, double, float, short float, opal_short_float_t], [8], [yes]) OMPI_FORTRAN_CHECK([REAL*16], [no], - [short float, float, double, long double, opal_short_float_t], + [_Float128, __float128, long double, double, float, short float, opal_short_float_t], [16], [yes]) # In some compilers, the bit representation of REAL*16 is not the same @@ -197,7 +198,7 @@ AC_DEFUN([OMPI_SETUP_MPI_FORTRAN],[ OMPI_FORTRAN_CHECK_REAL16_C_EQUIV OMPI_FORTRAN_CHECK([DOUBLE PRECISION], [yes], - [short float, float, double, long double, opal_short_float_t], + [long double, double, float, short float, opal_short_float_t], [-1], [yes]) OMPI_FORTRAN_CHECK([COMPLEX], [yes], @@ -219,19 +220,19 @@ AC_DEFUN([OMPI_SETUP_MPI_FORTRAN],[ [short float _Complex, float _Complex, double _Complex, long double _Complex, opal_short_float_complex_t], [4], [no]) OMPI_FORTRAN_CHECK([COMPLEX*8], [no], - [short float _Complex, float _Complex, double _Complex, long double _Complex, opal_short_float_complex_t], + [long double _Complex, double _Complex, float _Complex, short float _Complex, opal_short_float_complex_t], [8], [no]) OMPI_FORTRAN_CHECK([COMPLEX*16], [no], - [short float _Complex, float _Complex, double _Complex, long double _Complex, opal_short_float_complex_t], + [long double _Complex, double _Complex, float _Complex, short float _Complex, opal_short_float_complex_t], [16], [no]) OMPI_FORTRAN_CHECK([COMPLEX*32], [no], - [short float _Complex, float _Complex, double _Complex, long double _Complex, opal_short_float_complex_t], + [_Float128 _Complex, long double _Complex, double _Complex, float _Complex, short float _Complex, opal_short_float_complex_t], [32], [no]) # Double precision complex types are not standard, but many # compilers support it. Code should be wrapped with #ifdef # OMPI_HAVE_FORTRAN_DOUBLE_COMPLEX OMPI_FORTRAN_CHECK([DOUBLE COMPLEX], [no], - [short float _Complex, float _Complex, double _Complex, long double _Complex, opal_short_float_complex_t], + [long double _Complex, double _Complex, float _Complex, short float _Complex, opal_short_float_complex_t], [-1], [no]) # Regardless of whether we have fortran bindings, or even a diff --git a/configure.ac b/configure.ac index d5fc7325933..928f41b0415 100644 --- a/configure.ac +++ b/configure.ac @@ -15,7 +15,7 @@ # Copyright (c) 2006-2017 Los Alamos National Security, LLC. All rights # reserved. # Copyright (c) 2009 Oak Ridge National Labs. All rights reserved. -# Copyright (c) 2011-2013 NVIDIA Corporation. All rights reserved. +# Copyright (c) 2011-2026 NVIDIA Corporation. All rights reserved. # Copyright (c) 2012 Oracle and/or its affiliates. All rights reserved. # Copyright (c) 2013 Mellanox Technologies, Inc. # All rights reserved. @@ -415,6 +415,7 @@ AC_CHECK_TYPES(__int128) AC_CHECK_TYPES(uint128_t) AC_CHECK_TYPES(long long) +AC_CHECK_TYPES(_Float128) AC_CHECK_TYPES(__float128) AC_CHECK_TYPES(short float) AC_CHECK_TYPES(long double) @@ -425,6 +426,8 @@ AC_CHECK_TYPES(short float _Complex) AC_CHECK_TYPES(float _Complex) AC_CHECK_TYPES(double _Complex) AC_CHECK_TYPES(long double _Complex) +AC_CHECK_TYPES(_Float128 _Complex) +AC_CHECK_TYPES(__float128 _Complex) AC_CHECK_TYPES(intptr_t) AC_CHECK_TYPES(uintptr_t) @@ -450,6 +453,9 @@ fi AC_CHECK_SIZEOF(float) AC_CHECK_SIZEOF(double) AC_CHECK_SIZEOF(long double) +if test "$ac_cv_type__Float128" = yes; then + AC_CHECK_SIZEOF(_Float128) +fi if test "$ac_cv_type___float128" = yes; then AC_CHECK_SIZEOF(__float128) fi @@ -461,6 +467,12 @@ fi AC_CHECK_SIZEOF(float _Complex) AC_CHECK_SIZEOF(double _Complex) AC_CHECK_SIZEOF(long double _Complex) +if test "$ac_cv_type__Float128__Complex" = yes; then + AC_CHECK_SIZEOF(_Float128 _Complex) +fi +if test "$ac_cv_type___float128__Complex" = yes; then + AC_CHECK_SIZEOF(__float128 _Complex) +fi AC_CHECK_SIZEOF(void *) AS_IF([test "$ac_cv_sizeof_void_p" -eq 4], @@ -510,6 +522,9 @@ fi OPAL_C_GET_ALIGNMENT(float, OPAL_ALIGNMENT_FLOAT) OPAL_C_GET_ALIGNMENT(double, OPAL_ALIGNMENT_DOUBLE) OPAL_C_GET_ALIGNMENT(long double, OPAL_ALIGNMENT_LONG_DOUBLE) +if test "$ac_cv_type__Float128" = yes; then + OPAL_C_GET_ALIGNMENT(_Float128, OPAL_ALIGNMENT__FLOAT128) +fi if test "$ac_cv_type___float128" = yes; then OPAL_C_GET_ALIGNMENT(__float128, OPAL_ALIGNMENT___FLOAT128) fi @@ -523,6 +538,12 @@ fi OPAL_C_GET_ALIGNMENT(float _Complex, OPAL_ALIGNMENT_FLOAT_COMPLEX) OPAL_C_GET_ALIGNMENT(double _Complex, OPAL_ALIGNMENT_DOUBLE_COMPLEX) OPAL_C_GET_ALIGNMENT(long double _Complex, OPAL_ALIGNMENT_LONG_DOUBLE_COMPLEX) +if test "$ac_cv_type__Float128__Complex" = yes; then + OPAL_C_GET_ALIGNMENT(_Float128 _Complex, OPAL_ALIGNMENT__FLOAT128_COMPLEX) +fi +if test "$ac_cv_type___float128__Complex" = yes; then + OPAL_C_GET_ALIGNMENT(__float128 _Complex, OPAL_ALIGNMENT___FLOAT128_COMPLEX) +fi OPAL_C_GET_ALIGNMENT(void *, OPAL_ALIGNMENT_VOID_P) OPAL_C_GET_ALIGNMENT(size_t, OPAL_ALIGNMENT_SIZE_T) diff --git a/ompi/datatype/ompi_datatype.h b/ompi/datatype/ompi_datatype.h index 86f7396abe9..495609d9a7b 100644 --- a/ompi/datatype/ompi_datatype.h +++ b/ompi/datatype/ompi_datatype.h @@ -12,6 +12,7 @@ * Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. * Copyright (c) 2021 IBM Corporation. All rights reserved. * Copyright (c) 2025 Triad National Security, LLC. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -60,7 +61,7 @@ BEGIN_C_DECLS #define OMPI_DATATYPE_FLAG_DATA_FORTRAN 0xC000 #define OMPI_DATATYPE_FLAG_DATA_LANGUAGE 0xC000 -#define OMPI_DATATYPE_MAX_PREDEFINED 52 +#define OMPI_DATATYPE_MAX_PREDEFINED 53 #if OMPI_DATATYPE_MAX_PREDEFINED > OPAL_DATATYPE_MAX_SUPPORTED #error Need to increase the number of supported dataypes by OPAL (value OPAL_DATATYPE_MAX_SUPPORTED). diff --git a/ompi/datatype/ompi_datatype_internal.h b/ompi/datatype/ompi_datatype_internal.h index 28ee9acfe4f..7c2a0140e2c 100644 --- a/ompi/datatype/ompi_datatype_internal.h +++ b/ompi/datatype/ompi_datatype_internal.h @@ -10,6 +10,7 @@ * Copyright (c) 2015-2018 Research Organization for Information Science * and Technology (RIST). All rights reserved. * Copyright (c) 2016-2018 FUJITSU LIMITED. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -28,7 +29,7 @@ #ifndef OMPI_DATATYPE_INTERNAL_H #define OMPI_DATATYPE_INTERNAL_H -#include "opal/datatype/opal_datatype_internal.h" +#include "opal/datatype/opal_datatype_constructors.h" #include "ompi/datatype/ompi_datatype.h" /* @@ -115,8 +116,13 @@ #define OMPI_DATATYPE_MPI_LONG 0x32 #define OMPI_DATATYPE_MPI_UNSIGNED_LONG 0x33 +/* + * Datatypes with different representations between C and Fortran + */ +#define OMPI_DATATYPE_MPI_FLOAT128 0x34 + /* This should __ALWAYS__ stay last */ -#define OMPI_DATATYPE_MPI_UNAVAILABLE 0x34 +#define OMPI_DATATYPE_MPI_UNAVAILABLE 0x35 #define OMPI_DATATYPE_MPI_MAX_PREDEFINED (OMPI_DATATYPE_MPI_UNAVAILABLE+1) @@ -380,17 +386,20 @@ #if OMPI_SIZEOF_FORTRAN_REAL16 == OMPI_SIZEOF_FORTRAN_REAL # define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_REAL -#elif (defined(HAVE_SHORT_FLOAT) && OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_SHORT_FLOAT) || \ +#elif ((defined(HAVE__FLOAT128) && OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF__FLOAT128) || \ + (defined(HAVE___FLOAT128) && OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF___FLOAT128)) && OMPI_REAL16_MATCHES_C +# define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_FLOAT128 +#elif OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_LONG_DOUBLE && OMPI_REAL16_MATCHES_C +# define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_LONG_DOUBLE +#elif OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_DOUBLE && OMPI_REAL16_MATCHES_C +# define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_DOUBLE +#elif OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_FLOAT && OMPI_REAL16_MATCHES_C +# define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_FLOAT +#elif (defined(HAVE_SHORT_FLOAT) && OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_SHORT_FLOAT && OMPI_REAL16_MATCHES_C) || \ (defined(HAVE_OPAL_SHORT_FLOAT_T) && OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_OPAL_SHORT_FLOAT_T) # define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_SHORT_FLOAT -#elif OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_FLOAT -# define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_FLOAT -#elif OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_DOUBLE -# define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_DOUBLE -#elif OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_LONG_DOUBLE -# define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_LONG_DOUBLE #else -# define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_UNAVAILABLE +# define OMPI_DATATYPE_MPI_REAL16 OMPI_DATATYPE_MPI_UNAVAILABLE #endif /* @@ -603,7 +612,7 @@ extern const ompi_datatype_t* ompi_datatype_basicDatatypes[OMPI_DATATYPE_MPI_MAX #define OMPI_DATATYPE_INITIALIZER_LONG_DOUBLE OPAL_DATATYPE_INITIALIZER_FLOAT4 #elif SIZEOF_LONG_DOUBLE == 8 #define OMPI_DATATYPE_INITIALIZER_LONG_DOUBLE OPAL_DATATYPE_INITIALIZER_FLOAT8 -#elif SIZEOF_LONG_DOUBLE == 12 +#elif SIZEOF_LONG_DOUBLE >= 12 && LDBL_MANT_DIG <= 64 #define OMPI_DATATYPE_INITIALIZER_LONG_DOUBLE OPAL_DATATYPE_INITIALIZER_FLOAT12 #elif SIZEOF_LONG_DOUBLE == 16 #define OMPI_DATATYPE_INITIALIZER_LONG_DOUBLE OPAL_DATATYPE_INITIALIZER_FLOAT16 diff --git a/ompi/datatype/ompi_datatype_module.c b/ompi/datatype/ompi_datatype_module.c index a094b6877e9..2a11e6ef090 100644 --- a/ompi/datatype/ompi_datatype_module.c +++ b/ompi/datatype/ompi_datatype_module.c @@ -21,6 +21,7 @@ * Copyright (c) 2018-2021 Triad National Security, LLC. All rights * reserved. * Copyright (c) 2025 Jeffrey M. Squyres. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -397,6 +398,8 @@ const ompi_datatype_t* ompi_datatype_basicDatatypes[OMPI_DATATYPE_MPI_MAX_PREDEF [OMPI_DATATYPE_MPI_SHORT_FLOAT] = &ompi_mpi_short_float.dt, [OMPI_DATATYPE_MPI_C_SHORT_FLOAT_COMPLEX] = &ompi_mpi_c_short_float_complex.dt, + [OMPI_DATATYPE_MPI_FLOAT128] = &ompi_mpi_real16.dt, + [OMPI_DATATYPE_MPI_UNAVAILABLE] = &ompi_mpi_unavailable.dt, }; diff --git a/ompi/op/op.c b/ompi/op/op.c index 11064ec6f59..3ace78f5933 100644 --- a/ompi/op/op.c +++ b/ompi/op/op.c @@ -19,6 +19,7 @@ * Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. * Copyright (c) 2018-2025 Triad National Security, LLC. All rights * reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -235,6 +236,8 @@ int ompi_op_init(void) ompi_op_ddt_map[OMPI_DATATYPE_MPI_LONG] = OMPI_OP_BASE_TYPE_LONG; ompi_op_ddt_map[OMPI_DATATYPE_MPI_UNSIGNED_LONG] = OMPI_OP_BASE_TYPE_UNSIGNED_LONG; + ompi_op_ddt_map[OMPI_DATATYPE_MPI_FLOAT128] = OMPI_OP_BASE_TYPE_REAL16; + /* Create the intrinsic ops */ if (OMPI_SUCCESS != diff --git a/opal/datatype/Makefile.am b/opal/datatype/Makefile.am index 340800a6be3..0e80a5082e4 100644 --- a/opal/datatype/Makefile.am +++ b/opal/datatype/Makefile.am @@ -36,6 +36,7 @@ headers = \ opal_datatype_pack_unpack_predefined.h \ opal_datatype_pack.h \ opal_datatype_prototypes.h \ + opal_datatype_constructors.h \ opal_datatype_unpack.h diff --git a/opal/datatype/opal_copy_functions.c b/opal/datatype/opal_copy_functions.c index fec19a2a70e..42251f05c41 100644 --- a/opal/datatype/opal_copy_functions.c +++ b/opal/datatype/opal_copy_functions.c @@ -8,6 +8,7 @@ * and Technology (RIST). All rights reserved. * Copyright (c) 2015 Cisco Systems, Inc. All rights reserved. * Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -23,7 +24,7 @@ #include "opal/datatype/opal_convertor_internal.h" #include "opal/datatype/opal_datatype.h" #include "opal/datatype/opal_datatype_checksum.h" -#include "opal/datatype/opal_datatype_internal.h" +#include "opal/datatype/opal_datatype_constructors.h" /* * This function is used to copy data from one buffer to another. The assumption @@ -192,14 +193,14 @@ COPY_TYPE(float_8, opal_short_float_t, 1) # error No basic type for copy function for opal_datatype_float8 found #endif -#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 12 -COPY_TYPE(float_12, short float, 1) -#elif SIZEOF_FLOAT == 12 -COPY_TYPE(float_12, float, 1) -#elif SIZEOF_DOUBLE == 12 -COPY_TYPE(float_12, double, 1) -#elif SIZEOF_LONG_DOUBLE == 12 +#if SIZEOF_LONG_DOUBLE == OPAL_SIZEOF_FLOAT12 COPY_TYPE(float_12, long double, 1) +#elif SIZEOF_DOUBLE == OPAL_SIZEOF_FLOAT12 +COPY_TYPE(float_12, double, 1) +#elif SIZEOF_FLOAT == OPAL_SIZEOF_FLOAT12 +COPY_TYPE(float_12, float, 1) +#elif defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == OPAL_SIZEOF_FLOAT12 +COPY_TYPE(float_12, short float, 1) #elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 12 COPY_TYPE(float_12, opal_short_float_t, 1) #else @@ -207,7 +208,11 @@ COPY_TYPE(float_12, opal_short_float_t, 1) # define copy_float_12 NULL #endif -#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 16 +#if defined(HAVE__FLOAT128) && SIZEOF__FLOAT128 == 16 +COPY_TYPE(float_16, _Float128, 1) +#elif defined(HAVE___FLOAT128) && SIZEOF___FLOAT128 == 16 +COPY_TYPE(float_16, __float128, 1) +#elif defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 16 COPY_TYPE(float_16, short float, 1) #elif SIZEOF_FLOAT == 16 COPY_TYPE(float_16, float, 1) @@ -237,6 +242,15 @@ COPY_TYPE(double_complex, double _Complex, 1) COPY_TYPE(long_double_complex, long double _Complex, 1) +#if defined(HAVE__FLOAT128) && defined(HAVE__FLOAT128__COMPLEX) +COPY_TYPE(float128_complex, _Float128 _Complex, 1) +#elif defined(HAVE___FLOAT128) && defined(HAVE___FLOAT128__COMPLEX) +COPY_TYPE(float128_complex, __float128 _Complex, 1) +#else +/* #error No _Float128 _Complex support available */ +# define copy_float128_complex NULL +#endif + #if SIZEOF__BOOL == SIZEOF_CHAR COPY_TYPE(bool, char, 1) #elif SIZEOF__BOOL == SIZEOF_SHORT @@ -286,5 +300,6 @@ conversion_fct_t opal_datatype_copy_functions[OPAL_DATATYPE_MAX_PREDEFINED] = { [OPAL_DATATYPE_LONG] = (conversion_fct_t)copy_bytes_8, [OPAL_DATATYPE_UNSIGNED_LONG] = (conversion_fct_t)copy_bytes_8, #endif + [OPAL_DATATYPE_FLOAT128_COMPLEX] = (conversion_fct_t) copy_float128_complex, [OPAL_DATATYPE_UNAVAILABLE] = NULL, }; diff --git a/opal/datatype/opal_copy_functions_heterogeneous.c b/opal/datatype/opal_copy_functions_heterogeneous.c index 25c8962374b..43ab7d171aa 100644 --- a/opal/datatype/opal_copy_functions_heterogeneous.c +++ b/opal/datatype/opal_copy_functions_heterogeneous.c @@ -9,6 +9,7 @@ * Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. * Copyright (c) 2021 IBM Corporation. All rights reserved. * Copyright (c) 2024 Jeffrey M. Squyres. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -31,7 +32,7 @@ #include "opal/datatype/opal_convertor_internal.h" #include "opal/datatype/opal_datatype.h" #include "opal/datatype/opal_datatype_checksum.h" -#include "opal/datatype/opal_datatype_internal.h" +#include "opal/datatype/opal_datatype_constructors.h" #include "opal/types.h" /* @@ -207,7 +208,7 @@ union fp_float80 union fp_float128 { - /*__float128 value;*/ + /*_Float128 value;*/ struct { #if defined(WORDS_BIGENDIAN) unsigned sign : 1; @@ -486,7 +487,7 @@ static inline void ldbl_to_f128(unsigned char *f128_buf_to, const unsigned char *ldbl_buf_from, ssize_t count, int from_arch, ptrdiff_t from_extent) { -#ifdef HAVE___FLOAT128 +#if defined(HAVE__FLOAT128) || defined(HAVE___FLOAT128) int ldbl_is_aligned; ldbl_is_aligned = 1; @@ -504,11 +505,20 @@ ldbl_to_f128(unsigned char *f128_buf_to, const unsigned char *ldbl_buf_from, ssi f128_is_aligned = 0; } +#if defined(HAVE__FLOAT128) + _Float128 f128; +#elif defined(HAVE___FLOAT128) + __float128 f128; +#endif + do { if (ldbl_is_aligned && f128_is_aligned) { +#if defined(HAVE__FLOAT128) + *(_Float128*)f128_buf_to = *(long double*)ldbl_buf_from; +#elif defined(HAVE___FLOAT128) *(__float128*)f128_buf_to = *(long double*)ldbl_buf_from; +#endif } else { - __float128 f128; long double ldbl; memcpy(&ldbl, ldbl_buf_from, sizeof(ldbl)); f128 = ldbl; @@ -516,10 +526,10 @@ ldbl_to_f128(unsigned char *f128_buf_to, const unsigned char *ldbl_buf_from, ssi } ldbl_buf_from += from_extent; - f128_buf_to += sizeof(__float128); + f128_buf_to += sizeof(f128); count--; } while (count > 0); -#else +#else /* defined(HAVE__FLOAT128) || defined(HAVE___FLOAT128) */ if (LDBL_IS_F64(from_arch)) { f64_to_f128(f128_buf_to, ldbl_buf_from, count, from_extent); } else if (LDBL_IS_F80(from_arch)) { @@ -539,7 +549,7 @@ ldbl_to_f128(unsigned char *f128_buf_to, const unsigned char *ldbl_buf_from, ssi count--; } while (count > 0); } -#endif +#endif /* defined(HAVE__FLOAT128) || defined(HAVE___FLOAT128) */ } // f128_to_ldbl (copies a float128(local_endian) to a long double(to_arch format)) @@ -547,7 +557,7 @@ static inline void f128_to_ldbl(unsigned char *ldbl_buf_to, const unsigned char *f128_buf_from, ssize_t count, int to_arch, ptrdiff_t to_extent) { -#ifdef HAVE___FLOAT128 +#if defined(HAVE__FLOAT128) || defined(HAVE___FLOAT128) int ldbl_is_aligned; ldbl_is_aligned = 1; @@ -565,11 +575,20 @@ f128_to_ldbl(unsigned char *ldbl_buf_to, const unsigned char *f128_buf_from, ssi f128_is_aligned = 0; } +#if defined(HAVE__FLOAT128) + _Float128 f128; +#elif defined(HAVE___FLOAT128) + __float128 f128; +#endif + do { if (ldbl_is_aligned && f128_is_aligned) { +#if defined(HAVE__FLOAT128) + *(long double*)ldbl_buf_to = *(_Float128*)f128_buf_from; +#elif defined(HAVE___FLOAT128) *(long double*)ldbl_buf_to = *(__float128*)f128_buf_from; +#endif } else { - __float128 f128; long double ldbl; memcpy(&f128, f128_buf_from, sizeof(f128)); ldbl = f128; @@ -577,10 +596,10 @@ f128_to_ldbl(unsigned char *ldbl_buf_to, const unsigned char *f128_buf_from, ssi } ldbl_buf_to += to_extent; - f128_buf_from += sizeof(__float128); + f128_buf_from += sizeof(f128); count--; } while (count > 0); -#else +#else /* defined(HAVE__FLOAT128) || defined(HAVE___FLOAT128) */ if (LDBL_IS_F64(to_arch)) { f128_to_f64(ldbl_buf_to, f128_buf_from, count, to_extent); } else if (LDBL_IS_F80(to_arch)) { @@ -600,7 +619,7 @@ f128_to_ldbl(unsigned char *ldbl_buf_to, const unsigned char *f128_buf_from, ssi count--; } while (count > 0); } -#endif +#endif /* defined(HAVE__FLOAT128) || defined(HAVE___FLOAT128) */ } /** @@ -612,24 +631,24 @@ f128_to_ldbl(unsigned char *ldbl_buf_to, const unsigned char *f128_buf_from, ssi #define COPY_TYPE_HETEROGENEOUS(TYPENAME, TYPE) COPY_TYPE_HETEROGENEOUS_INTERNAL(TYPENAME, TYPE, 0) /* - * Summaryizing the logic of the pFunc copy functions + * Summarizing the logic of the pFunc copy functions * with regard to long doubles: * * For terminology I'll use * f64 : float64 which some architectures use as their long double * f80 : x86 double extended format that uses 80 bytes, commonly used for long double - * f128 : ieee quad precision, sometimes available as __float128 + * f128 : ieee quad precision, sometimes available as _Float128 or the non-standard __float128 * * if !LONG_DOUBLE or both architecture have the same long double format: * byte swap based on local/remote endianness differing * else: * if from_arch is not local endianness: byte swap to local endianness * if from_arch isn't f128 : ldbl_to_f128 - * if we have __float128 : convert to __float128 + * if we have _Float128 : convert to _Float128 * else if from_arch LDBL is f80 : f80_to_f128 * else if from_arch LDBL is f64 : f64_to_f128 * if to_arch isn't f128 : f128_to_ldbl - * if we have __float128 : convert from __float128 to + * if we have _Float128 : convert from _Float128 to * if to_arch LDBL is f80 : f128_to_f80 * if to_arch LDBL is f64 : f128_to_f64 * if to_arch is not local endianness : byte swap @@ -975,22 +994,26 @@ COPY_TYPE_HETEROGENEOUS(float8, opal_short_float_t) # define copy_float8_heterogeneous NULL #endif -#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 12 -COPY_TYPE_HETEROGENEOUS(float12, short float) -#elif SIZEOF_FLOAT == 12 -COPY_TYPE_HETEROGENEOUS(float12, float) -#elif SIZEOF_DOUBLE == 12 -COPY_TYPE_HETEROGENEOUS(float12, double) -#elif SIZEOF_LONG_DOUBLE == 12 +#if SIZEOF_LONG_DOUBLE == OPAL_SIZEOF_FLOAT12 COPY_TYPE_HETEROGENEOUS(float12, long double) -#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 12 +#elif SIZEOF_DOUBLE == OPAL_SIZEOF_FLOAT12 +COPY_TYPE_HETEROGENEOUS(float12, double) +#elif SIZEOF_FLOAT == OPAL_SIZEOF_FLOAT12 +COPY_TYPE_HETEROGENEOUS(float12, float) +#elif defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == OPAL_SIZEOF_FLOAT12 +COPY_TYPE_HETEROGENEOUS(float12, short float) +#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == OPAL_SIZEOF_FLOAT12 COPY_TYPE_HETEROGENEOUS(float12, opal_short_float_t) #else /* #error No basic type for copy function for opal_datatype_float12 found */ # define copy_float12_heterogeneous NULL #endif -#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 16 +#if defined(HAVE__FLOAT128) && SIZEOF__FLOAT128 == 16 +COPY_TYPE_HETEROGENEOUS(float16, _Float128) +#elif defined(HAVE___FLOAT128) && SIZEOF___FLOAT128 == 16 +COPY_TYPE_HETEROGENEOUS(float16, __float128) +#elif defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 16 COPY_TYPE_HETEROGENEOUS(float16, short float) #elif SIZEOF_FLOAT == 16 COPY_TYPE_HETEROGENEOUS(float16, float) @@ -1020,6 +1043,15 @@ COPY_2SAMETYPE_HETEROGENEOUS(double_complex, double) COPY_2SAMETYPE_HETEROGENEOUS_INTERNAL(long_double_complex, long double, 1) +#if defined(HAVE__FLOAT128) && defined(HAVE__FLOAT128__COMPLEX) +COPY_2SAMETYPE_HETEROGENEOUS_INTERNAL(float128_complex, _Float128, 1) +#elif defined(HAVE___FLOAT128) && defined(HAVE___FLOAT128__COMPLEX) +COPY_2SAMETYPE_HETEROGENEOUS_INTERNAL(float128_complex, __float128, 1) +#else +/* #error No _Float128 _Complex support available */ +# define copy_float128_complex_heterogeneous NULL +#endif + COPY_TYPE_HETEROGENEOUS(wchar, wchar_t) #if SIZEOF_LONG == 8 @@ -1272,5 +1304,6 @@ conversion_fct_t opal_datatype_heterogeneous_copy_functions[OPAL_DATATYPE_MAX_PR [OPAL_DATATYPE_LONG] = (conversion_fct_t) copy_long_heterogeneous, [OPAL_DATATYPE_UNSIGNED_LONG] = (conversion_fct_t) copy_unsigned_long_heterogeneous, #endif + [OPAL_DATATYPE_FLOAT128_COMPLEX] = (conversion_fct_t) copy_float128_complex_heterogeneous, [OPAL_DATATYPE_UNAVAILABLE] = NULL, }; diff --git a/opal/datatype/opal_datatype.h b/opal/datatype/opal_datatype.h index 5f7fc53fa7d..5e953ccfb6b 100644 --- a/opal/datatype/opal_datatype.h +++ b/opal/datatype/opal_datatype.h @@ -19,6 +19,7 @@ * Copyright (c) 2018 Triad National Security, LLC. All rights * reserved. * Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -52,7 +53,7 @@ BEGIN_C_DECLS * This must match the same definition as in opal_datatype_internal.h */ #if !defined(OPAL_DATATYPE_MAX_PREDEFINED) -# define OPAL_DATATYPE_MAX_PREDEFINED 28 +# define OPAL_DATATYPE_MAX_PREDEFINED 29 #endif /* * Upper limit of the number of _Basic_ datatypes supported (in order to @@ -184,6 +185,7 @@ OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_short_float_complex; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_float_complex; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_double_complex; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_long_double_complex; +OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_float128_complex; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_bool; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_wchar; OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_long; diff --git a/opal/datatype/opal_datatype_constructors.h b/opal/datatype/opal_datatype_constructors.h new file mode 100644 index 00000000000..cb1edde524d --- /dev/null +++ b/opal/datatype/opal_datatype_constructors.h @@ -0,0 +1,355 @@ +/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ + +/* + * Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2019 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2006 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2006 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2009 Oak Ridge National Labs. All rights reserved. + * Copyright (c) 2013 Los Alamos National Security, LLC. All rights + * reserved. + * Copyright (c) 2013 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2017 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. + * Copyright (c) 2021 IBM Corporation. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#ifndef OPAL_DATATYPE_CONSTRUCTORS_H_HAS_BEEN_INCLUDED +#define OPAL_DATATYPE_CONSTRUCTORS_H_HAS_BEEN_INCLUDED + +#include "opal/datatype/opal_datatype_internal.h" + +#define OPAL_DATATYPE_INIT_NAME(NAME) "OPAL_" #NAME +#define OPAL_DATATYPE_INIT_NAME_WITH_TYPE(NAME, TYPE) "OPAL_" #NAME "\0:" #TYPE + +/* + * Macro to initialize the main description for basic types, setting the pointer + * into the array opal_datatype_predefined_type_desc, which is initialized at + * runtime in opal_datatype_init(). Each basic type has two desc-elements.... + */ +#define OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME) \ + { \ + .length = 1, .used = 1, \ + .desc = &(opal_datatype_predefined_elem_desc[2 * OPAL_DATATYPE_##NAME]) \ + } +#define OPAL_DATATYPE_INIT_DESC_NULL \ + { \ + .length = 0, .used = 0, .desc = NULL \ + } + +#define OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED(NAME, FLAGS) \ + { \ + .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ + .flags = OPAL_DATATYPE_FLAG_UNAVAILABLE | OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS), \ + .id = OPAL_DATATYPE_##NAME, .bdt_used = 0, .size = 0, .true_lb = 0, .true_ub = 0, .lb = 0, \ + .ub = 0, .align = 0, .nbElems = 1, .name = OPAL_DATATYPE_INIT_NAME(NAME), \ + .desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(UNAVAILABLE), \ + .opt_desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(UNAVAILABLE), \ + .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE \ + } + +#define OPAL_DATATYPE_INITIALIZER_UNAVAILABLE(FLAGS) \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED(UNAVAILABLE, (FLAGS)) + +#define OPAL_DATATYPE_INITIALIZER_EMPTY(FLAGS) \ + { \ + .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ + .flags = OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS), .id = 0, .bdt_used = 0, .size = 0, \ + .true_lb = 0, .true_ub = 0, .lb = 0, .ub = 0, .align = 0, .nbElems = 1, \ + .name = OPAL_DATATYPE_INIT_NAME(EMPTY), .desc = OPAL_DATATYPE_INIT_DESC_NULL, \ + .opt_desc = OPAL_DATATYPE_INIT_DESC_NULL, \ + .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE \ + } + +#define OPAL_DATATYPE_INIT_BASIC_TYPE(TYPE, NAME, FLAGS) \ + { \ + .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ + .flags = OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS), .id = TYPE, \ + .bdt_used = (((uint32_t) 1) << (TYPE)), .size = 0, .true_lb = 0, .true_ub = 0, .lb = 0, \ + .ub = 0, .align = 0, .nbElems = 1, .name = OPAL_DATATYPE_INIT_NAME_WITH_TYPE(NAME, TYPE), \ + .desc = OPAL_DATATYPE_INIT_DESC_NULL, .opt_desc = OPAL_DATATYPE_INIT_DESC_NULL, \ + .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE \ + } + +#define OPAL_DATATYPE_INIT_BASIC_DATATYPE(TYPE, ALIGN, NAME, FLAGS) \ + { \ + .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ + .flags = OPAL_DATATYPE_FLAG_BASIC | (FLAGS), .id = OPAL_DATATYPE_##NAME, \ + .bdt_used = (((uint32_t) 1) << (OPAL_DATATYPE_##NAME)), .size = sizeof(TYPE), \ + .true_lb = 0, .true_ub = sizeof(TYPE), .lb = 0, .ub = sizeof(TYPE), .align = (ALIGN), \ + .nbElems = 1, .name = OPAL_DATATYPE_INIT_NAME_WITH_TYPE(NAME, TYPE), \ + .desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME), \ + .opt_desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME), \ + .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE \ + } + +#define OPAL_DATATYPE_INITIALIZER_INT1(FLAGS) \ + OPAL_DATATYPE_HANDLE_INT1(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_INT2(FLAGS) \ + OPAL_DATATYPE_HANDLE_INT2(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_INT4(FLAGS) \ + OPAL_DATATYPE_HANDLE_INT4(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_INT8(FLAGS) \ + OPAL_DATATYPE_HANDLE_INT8(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_INT16(FLAGS) \ + OPAL_DATATYPE_HANDLE_INT16(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_UINT1(FLAGS) \ + OPAL_DATATYPE_HANDLE_UINT1(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_UINT2(FLAGS) \ + OPAL_DATATYPE_HANDLE_UINT2(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_UINT4(FLAGS) \ + OPAL_DATATYPE_HANDLE_UINT4(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_UINT8(FLAGS) \ + OPAL_DATATYPE_HANDLE_UINT8(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_UINT16(FLAGS) \ + OPAL_DATATYPE_HANDLE_UINT16(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS) \ + OPAL_DATATYPE_HANDLE_FLOAT2(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS) \ + OPAL_DATATYPE_HANDLE_FLOAT4(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS) \ + OPAL_DATATYPE_HANDLE_FLOAT8(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS) \ + OPAL_DATATYPE_HANDLE_FLOAT12(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS) \ + OPAL_DATATYPE_HANDLE_FLOAT16(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_SHORT_FLOAT_COMPLEX(FLAGS) \ + OPAL_DATATYPE_HANDLE_SHORT_FLOAT_COMPLEX(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_FLOAT_COMPLEX(FLAGS) \ + OPAL_DATATYPE_HANDLE_FLOAT_COMPLEX(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_DOUBLE_COMPLEX(FLAGS) \ + OPAL_DATATYPE_HANDLE_DOUBLE_COMPLEX(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_LONG_DOUBLE_COMPLEX(FLAGS) \ + OPAL_DATATYPE_HANDLE_LONG_DOUBLE_COMPLEX(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_FLOAT128_COMPLEX(FLAGS) \ + OPAL_DATATYPE_HANDLE_FLOAT128_COMPLEX(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_BOOL(FLAGS) \ + OPAL_DATATYPE_HANDLE_BOOL(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_WCHAR(FLAGS) \ + OPAL_DATATYPE_HANDLE_WCHAR(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ + OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_LOOP(FLAGS) \ + OPAL_DATATYPE_INIT_BASIC_TYPE(OPAL_DATATYPE_LOOP, LOOP_S, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_END_LOOP(FLAGS) \ + OPAL_DATATYPE_INIT_BASIC_TYPE(OPAL_DATATYPE_END_LOOP, LOOP_E, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_LB(FLAGS) \ + OPAL_DATATYPE_INIT_BASIC_TYPE(OPAL_DATATYPE_LB, LB, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_UB(FLAGS) \ + OPAL_DATATYPE_INIT_BASIC_TYPE(OPAL_DATATYPE_UB, UB, FLAGS) + +#define OPAL_DATATYPE_HANDLE_INT1(AV, NOTAV, FLAGS) AV(int8_t, OPAL_ALIGNMENT_INT8, INT1, FLAGS) +#define OPAL_DATATYPE_HANDLE_INT2(AV, NOTAV, FLAGS) AV(int16_t, OPAL_ALIGNMENT_INT16, INT2, FLAGS) +#define OPAL_DATATYPE_HANDLE_INT4(AV, NOTAV, FLAGS) AV(int32_t, OPAL_ALIGNMENT_INT32, INT4, FLAGS) +#define OPAL_DATATYPE_HANDLE_INT8(AV, NOTAV, FLAGS) AV(int64_t, OPAL_ALIGNMENT_INT64, INT8, FLAGS) +#ifdef HAVE_INT128_T +# define OPAL_DATATYPE_HANDLE_INT16(AV, NOTAV, FLAGS) \ + AV(int128_t, OPAL_ALIGNMENT_INT128, INT16, FLAGS) +#else +# define OPAL_DATATYPE_HANDLE_INT16(AV, NOTAV, FLAGS) NOTAV(INT16, FLAGS) +#endif +#define OPAL_DATATYPE_HANDLE_UINT1(AV, NOTAV, FLAGS) AV(uint8_t, OPAL_ALIGNMENT_INT8, UINT1, FLAGS) +#define OPAL_DATATYPE_HANDLE_UINT2(AV, NOTAV, FLAGS) \ + AV(uint16_t, OPAL_ALIGNMENT_INT16, UINT2, FLAGS) +#define OPAL_DATATYPE_HANDLE_UINT4(AV, NOTAV, FLAGS) \ + AV(uint32_t, OPAL_ALIGNMENT_INT32, UINT4, FLAGS) +#define OPAL_DATATYPE_HANDLE_UINT8(AV, NOTAV, FLAGS) \ + AV(uint64_t, OPAL_ALIGNMENT_INT64, UINT8, FLAGS) +#ifdef HAVE_UINT128_T +# define OPAL_DATATYPE_HANDLE_UINT16(AV, NOTAV, FLAGS) \ + AV(uint128_t, OPAL_ALIGNMENT_INT128, UINT16, FLAGS) +#else +# define OPAL_DATATYPE_HANDLE_UINT16(AV, NOTAV, FLAGS) NOTAV(INT16, FLAGS) +#endif + + +#define OPAL_DATATYPE_INITIALIZER_LONG(FLAGS) \ + OPAL_DATATYPE_INIT_BASIC_DATATYPE(long, OPAL_ALIGNMENT_LONG, LONG, FLAGS) +#define OPAL_DATATYPE_INITIALIZER_UNSIGNED_LONG(FLAGS) \ + OPAL_DATATYPE_INIT_BASIC_DATATYPE(unsigned long, OPAL_ALIGNMENT_LONG, UNSIGNED_LONG, FLAGS) + +#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 2 +# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ + AV(short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT2, FLAGS) +#elif SIZEOF_FLOAT == 2 +# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ + AV(float, OPAL_ALIGNMENT_FLOAT, FLOAT2, FLAGS) +#elif SIZEOF_DOUBLE == 2 +# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ + AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT2, FLAGS) +#elif SIZEOF_LONG_DOUBLE == 2 +# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ + AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT2, FLAGS) +#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 2 +# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ + AV(opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT2, FLAGS) +#else +# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) NOTAV(FLOAT2, FLAGS) +#endif + +#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 4 +# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ + AV(short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT4, FLAGS) +#elif SIZEOF_FLOAT == 4 +# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ + AV(float, OPAL_ALIGNMENT_FLOAT, FLOAT4, FLAGS) +#elif SIZEOF_DOUBLE == 4 +# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ + AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT4, FLAGS) +#elif SIZEOF_LONG_DOUBLE == 4 +# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ + AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT4, FLAGS) +#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 4 +# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ + AV(opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT4, FLAGS) +#else +# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) NOTAV(FLOAT4, FLAGS) +#endif + +#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 8 +# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ + AV(short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT8, FLAGS) +#elif SIZEOF_FLOAT == 8 +# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ + AV(float, OPAL_ALIGNMENT_FLOAT, FLOAT8, FLAGS) +#elif SIZEOF_DOUBLE == 8 +# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ + AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT8, FLAGS) +#elif SIZEOF_LONG_DOUBLE == 8 +# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ + AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT8, FLAGS) +#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 8 +# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ + AV(opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT8, FLAGS) +#else +# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) NOTAV(FLOAT8, FLAGS) +#endif + +/** + * The Float12 is different from the others floating point types because the name is not indicating the + * size of the type but the number of significant digits used when manipulating it. It is defined + * to handle long double types on architectures where this type only has 80 useful bits (the rest, up to + * 96 or 128 bits, are used for alignment purposes). + */ +#if SIZEOF_LONG_DOUBLE >= 12 && LDBL_MANT_DIG <= 64 +# define OPAL_DATATYPE_HANDLE_FLOAT12(AV, NOTAV, FLAGS) \ + AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT12, FLAGS) +# define OPAL_SIZEOF_FLOAT12 SIZEOF_LONG_DOUBLE +#elif SIZEOF_DOUBLE == 12 && DBL_MANT_DIG <= 64 +# define OPAL_DATATYPE_HANDLE_FLOAT12(AV, NOTAV, FLAGS) \ + AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT12, FLAGS) +# define OPAL_SIZEOF_FLOAT12 SIZEOF_DOUBLE +#else +# define OPAL_DATATYPE_HANDLE_FLOAT12(AV, NOTAV, FLAGS) NOTAV(FLOAT12, FLAGS) +# define OPAL_SIZEOF_FLOAT12 0 +#endif + +#if defined(HAVE__FLOAT128) && SIZEOF__FLOAT128 == 16 +# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ + AV(_Float128, OPAL_ALIGNMENT__FLOAT128, FLOAT16, FLAGS) +# define OPAL_SIZEOF_FLOAT16 SIZEOF__FLOAT128 +#elif defined(HAVE___FLOAT128) && SIZEOF___FLOAT128 == 16 +# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ + AV(__float128, OPAL_ALIGNMENT___FLOAT128, FLOAT16, FLAGS) +# define OPAL_SIZEOF_FLOAT16 SIZEOF___FLOAT128 +#elif SIZEOF_LONG_DOUBLE == 16 +# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ + AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT16, FLAGS) +# define OPAL_SIZEOF_FLOAT16 SIZEOF_LONG_DOUBLE +#elif SIZEOF_DOUBLE == 16 +# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ + AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT16, FLAGS) +# define OPAL_SIZEOF_FLOAT16 SIZEOF_DOUBLE +#elif SIZEOF_FLOAT == 16 +# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ + AV(float, OPAL_ALIGNMENT_FLOAT, FLOAT16, FLAGS) +# define OPAL_SIZEOF_FLOAT16 SIZEOF_FLOAT +#elif defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 16 +# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ + AV(short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT16, FLAGS) +# define OPAL_SIZEOF_FLOAT16 SIZEOF_SHORT_FLOAT +#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 16 +# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ + AV(opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT16, FLAGS) +# define OPAL_SIZEOF_FLOAT16 SIZEOF_OPAL_SHORT_FLOAT_T +#else +# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) NOTAV(FLOAT16, FLAGS) +# define OPAL_SIZEOF_FLOAT16 0 +#endif + +#if defined(HAVE_SHORT_FLOAT__COMPLEX) +# define OPAL_DATATYPE_HANDLE_SHORT_FLOAT_COMPLEX(AV, NOTAV, FLAGS) \ + AV(short float _Complex, OPAL_ALIGNMENT_SHORT_FLOAT_COMPLEX, SHORT_FLOAT_COMPLEX, FLAGS) +#elif defined(HAVE_OPAL_SHORT_FLOAT_COMPLEX_T) +# define OPAL_DATATYPE_HANDLE_SHORT_FLOAT_COMPLEX(AV, NOTAV, FLAGS) \ + AV(opal_short_float_complex_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, SHORT_FLOAT_COMPLEX, \ + FLAGS) +#else +# define OPAL_DATATYPE_HANDLE_SHORT_FLOAT_COMPLEX(AV, NOTAV, FLAGS) \ + NOTAV(SHORT_FLOAT_COMPLEX, FLAGS) +#endif + +#define OPAL_DATATYPE_HANDLE_FLOAT_COMPLEX(AV, NOTAV, FLAGS) \ + AV(float _Complex, OPAL_ALIGNMENT_FLOAT_COMPLEX, FLOAT_COMPLEX, FLAGS) + +#define OPAL_DATATYPE_HANDLE_DOUBLE_COMPLEX(AV, NOTAV, FLAGS) \ + AV(double _Complex, OPAL_ALIGNMENT_DOUBLE_COMPLEX, DOUBLE_COMPLEX, FLAGS) + +#define OPAL_DATATYPE_HANDLE_LONG_DOUBLE_COMPLEX(AV, NOTAV, FLAGS) \ + AV(long double _Complex, OPAL_ALIGNMENT_LONG_DOUBLE_COMPLEX, LONG_DOUBLE_COMPLEX, FLAGS) + +#if defined(HAVE__FLOAT128) && defined(HAVE__FLOAT128__COMPLEX) +# define OPAL_DATATYPE_HANDLE_FLOAT128_COMPLEX(AV, NOTAV, FLAGS) \ + AV(_Float128 _Complex, OPAL_ALIGNMENT__FLOAT128_COMPLEX, FLOAT128_COMPLEX, FLAGS) +#elif defined(HAVE___FLOAT128) && defined(HAVE___FLOAT128__COMPLEX) +# define OPAL_DATATYPE_HANDLE_FLOAT128_COMPLEX(AV, NOTAV, FLAGS) \ + AV(__float128 _Complex, OPAL_ALIGNMENT___FLOAT128_COMPLEX, FLOAT128_COMPLEX, FLAGS) +#else +# define OPAL_DATATYPE_HANDLE_FLOAT128_COMPLEX(AV, NOTAV, FLAGS) \ + NOTAV(FLOAT128_COMPLEX, FLAGS) +#endif + +#define OPAL_DATATYPE_HANDLE_BOOL(AV, NOTAV, FLAGS) \ + AV(_Bool, OPAL_ALIGNMENT_BOOL, BOOL, FLAGS) + +#if OPAL_ALIGNMENT_WCHAR != 0 +# define OPAL_DATATYPE_HANDLE_WCHAR(AV, NOTAV, FLAGS) \ + AV(wchar_t, OPAL_ALIGNMENT_WCHAR, WCHAR, FLAGS) +#else +# define OPAL_DATATYPE_HANDLE_WCHAR(AV, NOTAV, FLAGS) NOTAV(WCHAR, FLAGS) +#endif + +#endif /* OPAL_DATATYPE_CONSTRUCTORS_H_HAS_BEEN_INCLUDED */ diff --git a/opal/datatype/opal_datatype_internal.h b/opal/datatype/opal_datatype_internal.h index 47f6e0107cf..797e8b2904b 100644 --- a/opal/datatype/opal_datatype_internal.h +++ b/opal/datatype/opal_datatype_internal.h @@ -18,6 +18,7 @@ * and Technology (RIST). All rights reserved. * Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. * Copyright (c) 2021 IBM Corporation. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -32,6 +33,7 @@ #include #include +#include #if defined(VERBOSE) # include "opal/util/output.h" @@ -96,7 +98,8 @@ extern int opal_datatype_dfd; #define OPAL_DATATYPE_WCHAR 24 #define OPAL_DATATYPE_LONG 25 #define OPAL_DATATYPE_UNSIGNED_LONG 26 -#define OPAL_DATATYPE_UNAVAILABLE 27 +#define OPAL_DATATYPE_FLOAT128_COMPLEX 27 +#define OPAL_DATATYPE_UNAVAILABLE 28 #ifndef OPAL_DATATYPE_MAX_PREDEFINED # define OPAL_DATATYPE_MAX_PREDEFINED (OPAL_DATATYPE_UNAVAILABLE + 1) @@ -213,7 +216,7 @@ struct opal_datatype_t; /* Other fields starting after bdt_used (index of OPAL_DATATYPE_LOOP should be ONE) */ /* * NOTE: The order of initialization *MUST* match the order of the OPAL_DATATYPE_-numbers. - * Unfortunateley, I don't get the preprocessor to replace + * Unfortunately, I don't get the preprocessor to replace * OPAL_DATATYPE_INIT_BTYPES_ARRAY_ ## OPAL_DATATYPE ## NAME * into * OPAL_DATATYPE_INIT_BTYPES_ARRAY_[0-21], then order and naming would _not_ matter.... @@ -226,296 +229,6 @@ struct opal_datatype_t; [OPAL_DATATYPE_##NAME] = 1, [OPAL_DATATYPE_MAX_PREDEFINED - 1] = 0 \ } -#define OPAL_DATATYPE_INIT_NAME(NAME) "OPAL_" #NAME - -/* - * Macro to initialize the main description for basic types, setting the pointer - * into the array opal_datatype_predefined_type_desc, which is initialized at - * runtime in opal_datatype_init(). Each basic type has two desc-elements.... - */ -#define OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME) \ - { \ - .length = 1, .used = 1, \ - .desc = &(opal_datatype_predefined_elem_desc[2 * OPAL_DATATYPE_##NAME]) \ - } -#define OPAL_DATATYPE_INIT_DESC_NULL \ - { \ - .length = 0, .used = 0, .desc = NULL \ - } - -#define OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED(NAME, FLAGS) \ - { \ - .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ - .flags = OPAL_DATATYPE_FLAG_UNAVAILABLE | OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS), \ - .id = OPAL_DATATYPE_##NAME, .bdt_used = 0, .size = 0, .true_lb = 0, .true_ub = 0, .lb = 0, \ - .ub = 0, .align = 0, .nbElems = 1, .name = OPAL_DATATYPE_INIT_NAME(NAME), \ - .desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(UNAVAILABLE), \ - .opt_desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(UNAVAILABLE), \ - .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE \ - } - -#define OPAL_DATATYPE_INITIALIZER_UNAVAILABLE(FLAGS) \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED(UNAVAILABLE, (FLAGS)) - -#define OPAL_DATATYPE_INITIALIZER_EMPTY(FLAGS) \ - { \ - .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ - .flags = OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS), .id = 0, .bdt_used = 0, .size = 0, \ - .true_lb = 0, .true_ub = 0, .lb = 0, .ub = 0, .align = 0, .nbElems = 1, \ - .name = OPAL_DATATYPE_INIT_NAME(EMPTY), .desc = OPAL_DATATYPE_INIT_DESC_NULL, \ - .opt_desc = OPAL_DATATYPE_INIT_DESC_NULL, \ - .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE \ - } - -#define OPAL_DATATYPE_INIT_BASIC_TYPE(TYPE, NAME, FLAGS) \ - { \ - .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ - .flags = OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS), .id = TYPE, \ - .bdt_used = (((uint32_t) 1) << (TYPE)), .size = 0, .true_lb = 0, .true_ub = 0, .lb = 0, \ - .ub = 0, .align = 0, .nbElems = 1, .name = OPAL_DATATYPE_INIT_NAME(NAME), \ - .desc = OPAL_DATATYPE_INIT_DESC_NULL, .opt_desc = OPAL_DATATYPE_INIT_DESC_NULL, \ - .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE \ - } - -#define OPAL_DATATYPE_INIT_BASIC_DATATYPE(TYPE, ALIGN, NAME, FLAGS) \ - { \ - .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t), \ - .flags = OPAL_DATATYPE_FLAG_BASIC | (FLAGS), .id = OPAL_DATATYPE_##NAME, \ - .bdt_used = (((uint32_t) 1) << (OPAL_DATATYPE_##NAME)), .size = sizeof(TYPE), \ - .true_lb = 0, .true_ub = sizeof(TYPE), .lb = 0, .ub = sizeof(TYPE), .align = (ALIGN), \ - .nbElems = 1, .name = OPAL_DATATYPE_INIT_NAME(NAME), \ - .desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME), \ - .opt_desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME), \ - .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE \ - } - -#define OPAL_DATATYPE_INITIALIZER_INT1(FLAGS) \ - OPAL_DATATYPE_HANDLE_INT1(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_INT2(FLAGS) \ - OPAL_DATATYPE_HANDLE_INT2(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_INT4(FLAGS) \ - OPAL_DATATYPE_HANDLE_INT4(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_INT8(FLAGS) \ - OPAL_DATATYPE_HANDLE_INT8(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_INT16(FLAGS) \ - OPAL_DATATYPE_HANDLE_INT16(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_UINT1(FLAGS) \ - OPAL_DATATYPE_HANDLE_UINT1(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_UINT2(FLAGS) \ - OPAL_DATATYPE_HANDLE_UINT2(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_UINT4(FLAGS) \ - OPAL_DATATYPE_HANDLE_UINT4(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_UINT8(FLAGS) \ - OPAL_DATATYPE_HANDLE_UINT8(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_UINT16(FLAGS) \ - OPAL_DATATYPE_HANDLE_UINT16(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS) \ - OPAL_DATATYPE_HANDLE_FLOAT2(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS) \ - OPAL_DATATYPE_HANDLE_FLOAT4(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS) \ - OPAL_DATATYPE_HANDLE_FLOAT8(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS) \ - OPAL_DATATYPE_HANDLE_FLOAT12(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS) \ - OPAL_DATATYPE_HANDLE_FLOAT16(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_SHORT_FLOAT_COMPLEX(FLAGS) \ - OPAL_DATATYPE_HANDLE_SHORT_FLOAT_COMPLEX(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_FLOAT_COMPLEX(FLAGS) \ - OPAL_DATATYPE_HANDLE_FLOAT_COMPLEX(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_DOUBLE_COMPLEX(FLAGS) \ - OPAL_DATATYPE_HANDLE_DOUBLE_COMPLEX(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_LONG_DOUBLE_COMPLEX(FLAGS) \ - OPAL_DATATYPE_HANDLE_LONG_DOUBLE_COMPLEX(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_BOOL(FLAGS) \ - OPAL_DATATYPE_HANDLE_BOOL(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_WCHAR(FLAGS) \ - OPAL_DATATYPE_HANDLE_WCHAR(OPAL_DATATYPE_INIT_BASIC_DATATYPE, \ - OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_LOOP(FLAGS) \ - OPAL_DATATYPE_INIT_BASIC_TYPE(OPAL_DATATYPE_LOOP, LOOP_S, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_END_LOOP(FLAGS) \ - OPAL_DATATYPE_INIT_BASIC_TYPE(OPAL_DATATYPE_END_LOOP, LOOP_E, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_LB(FLAGS) \ - OPAL_DATATYPE_INIT_BASIC_TYPE(OPAL_DATATYPE_LB, LB, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_UB(FLAGS) \ - OPAL_DATATYPE_INIT_BASIC_TYPE(OPAL_DATATYPE_UB, UB, FLAGS) - -#define OPAL_DATATYPE_HANDLE_INT1(AV, NOTAV, FLAGS) AV(int8_t, OPAL_ALIGNMENT_INT8, INT1, FLAGS) -#define OPAL_DATATYPE_HANDLE_INT2(AV, NOTAV, FLAGS) AV(int16_t, OPAL_ALIGNMENT_INT16, INT2, FLAGS) -#define OPAL_DATATYPE_HANDLE_INT4(AV, NOTAV, FLAGS) AV(int32_t, OPAL_ALIGNMENT_INT32, INT4, FLAGS) -#define OPAL_DATATYPE_HANDLE_INT8(AV, NOTAV, FLAGS) AV(int64_t, OPAL_ALIGNMENT_INT64, INT8, FLAGS) -#ifdef HAVE_INT128_T -# define OPAL_DATATYPE_HANDLE_INT16(AV, NOTAV, FLAGS) \ - AV(int128_t, OPAL_ALIGNMENT_INT128, INT16, FLAGS) -#else -# define OPAL_DATATYPE_HANDLE_INT16(AV, NOTAV, FLAGS) NOTAV(INT16, FLAGS) -#endif -#define OPAL_DATATYPE_HANDLE_UINT1(AV, NOTAV, FLAGS) AV(uint8_t, OPAL_ALIGNMENT_INT8, UINT1, FLAGS) -#define OPAL_DATATYPE_HANDLE_UINT2(AV, NOTAV, FLAGS) \ - AV(uint16_t, OPAL_ALIGNMENT_INT16, UINT2, FLAGS) -#define OPAL_DATATYPE_HANDLE_UINT4(AV, NOTAV, FLAGS) \ - AV(uint32_t, OPAL_ALIGNMENT_INT32, UINT4, FLAGS) -#define OPAL_DATATYPE_HANDLE_UINT8(AV, NOTAV, FLAGS) \ - AV(uint64_t, OPAL_ALIGNMENT_INT64, UINT8, FLAGS) -#ifdef HAVE_UINT128_T -# define OPAL_DATATYPE_HANDLE_UINT16(AV, NOTAV, FLAGS) \ - AV(uint128_t, OPAL_ALIGNMENT_INT128, UINT16, FLAGS) -#else -# define OPAL_DATATYPE_HANDLE_UINT16(AV, NOTAV, FLAGS) NOTAV(INT16, FLAGS) -#endif - - -#define OPAL_DATATYPE_INITIALIZER_LONG(FLAGS) \ - OPAL_DATATYPE_INIT_BASIC_DATATYPE(long, OPAL_ALIGNMENT_LONG, LONG, FLAGS) -#define OPAL_DATATYPE_INITIALIZER_UNSIGNED_LONG(FLAGS) \ - OPAL_DATATYPE_INIT_BASIC_DATATYPE(unsigned long, OPAL_ALIGNMENT_LONG, UNSIGNED_LONG, FLAGS) - -#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 2 -# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ - AV(short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT2, FLAGS) -#elif SIZEOF_FLOAT == 2 -# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ - AV(float, OPAL_ALIGNMENT_FLOAT, FLOAT2, FLAGS) -#elif SIZEOF_DOUBLE == 2 -# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ - AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT2, FLAGS) -#elif SIZEOF_LONG_DOUBLE == 2 -# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ - AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT2, FLAGS) -#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 2 -# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) \ - AV(opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT2, FLAGS) -#else -# define OPAL_DATATYPE_HANDLE_FLOAT2(AV, NOTAV, FLAGS) NOTAV(FLOAT2, FLAGS) -#endif - -#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 4 -# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ - AV(short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT4, FLAGS) -#elif SIZEOF_FLOAT == 4 -# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ - AV(float, OPAL_ALIGNMENT_FLOAT, FLOAT4, FLAGS) -#elif SIZEOF_DOUBLE == 4 -# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ - AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT4, FLAGS) -#elif SIZEOF_LONG_DOUBLE == 4 -# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ - AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT4, FLAGS) -#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 4 -# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) \ - AV(opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT4, FLAGS) -#else -# define OPAL_DATATYPE_HANDLE_FLOAT4(AV, NOTAV, FLAGS) NOTAV(FLOAT4, FLAGS) -#endif - -#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 8 -# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ - AV(short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT8, FLAGS) -#elif SIZEOF_FLOAT == 8 -# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ - AV(float, OPAL_ALIGNMENT_FLOAT, FLOAT8, FLAGS) -#elif SIZEOF_DOUBLE == 8 -# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ - AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT8, FLAGS) -#elif SIZEOF_LONG_DOUBLE == 8 -# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ - AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT8, FLAGS) -#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 8 -# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) \ - AV(opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT8, FLAGS) -#else -# define OPAL_DATATYPE_HANDLE_FLOAT8(AV, NOTAV, FLAGS) NOTAV(FLOAT8, FLAGS) -#endif - -#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 12 -# define OPAL_DATATYPE_HANDLE_FLOAT12(AV, NOTAV, FLAGS) \ - AV(short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT12, FLAGS) -#elif SIZEOF_FLOAT == 12 -# define OPAL_DATATYPE_HANDLE_FLOAT12(AV, NOTAV, FLAGS) \ - AV(float, OPAL_ALIGNMENT_FLOAT, FLOAT12, FLAGS) -#elif SIZEOF_DOUBLE == 12 -# define OPAL_DATATYPE_HANDLE_FLOAT12(AV, NOTAV, FLAGS) \ - AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT12, FLAGS) -#elif SIZEOF_LONG_DOUBLE == 12 -# define OPAL_DATATYPE_HANDLE_FLOAT12(AV, NOTAV, FLAGS) \ - AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT12, FLAGS) -#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 12 -# define OPAL_DATATYPE_HANDLE_FLOAT12(AV, NOTAV, FLAGS) \ - AV(opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT12, FLAGS) -#else -# define OPAL_DATATYPE_HANDLE_FLOAT12(AV, NOTAV, FLAGS) NOTAV(FLOAT12, FLAGS) -#endif - -#if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 16 -# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ - AV(short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT16, FLAGS) -#elif SIZEOF_FLOAT == 16 -# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ - AV(float, OPAL_ALIGNMENT_FLOAT, FLOAT16, FLAGS) -#elif SIZEOF_DOUBLE == 16 -# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ - AV(double, OPAL_ALIGNMENT_DOUBLE, FLOAT16, FLAGS) -#elif SIZEOF_LONG_DOUBLE == 16 -# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ - AV(long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT16, FLAGS) -#elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 16 -# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) \ - AV(opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT16, FLAGS) -#else -# define OPAL_DATATYPE_HANDLE_FLOAT16(AV, NOTAV, FLAGS) NOTAV(FLOAT16, FLAGS) -#endif - -#if defined(HAVE_SHORT_FLOAT__COMPLEX) -# define OPAL_DATATYPE_HANDLE_SHORT_FLOAT_COMPLEX(AV, NOTAV, FLAGS) \ - AV(short float _Complex, OPAL_ALIGNMENT_SHORT_FLOAT_COMPLEX, SHORT_FLOAT_COMPLEX, FLAGS) -#elif defined(HAVE_OPAL_SHORT_FLOAT_COMPLEX_T) -# define OPAL_DATATYPE_HANDLE_SHORT_FLOAT_COMPLEX(AV, NOTAV, FLAGS) \ - AV(opal_short_float_complex_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, SHORT_FLOAT_COMPLEX, \ - FLAGS) -#else -# define OPAL_DATATYPE_HANDLE_SHORT_FLOAT_COMPLEX(AV, NOTAV, FLAGS) \ - NOTAV(SHORT_FLOAT_COMPLEX, FLAGS) -#endif - -#define OPAL_DATATYPE_HANDLE_FLOAT_COMPLEX(AV, NOTAV, FLAGS) \ - AV(float _Complex, OPAL_ALIGNMENT_FLOAT_COMPLEX, FLOAT_COMPLEX, FLAGS) - -#define OPAL_DATATYPE_HANDLE_DOUBLE_COMPLEX(AV, NOTAV, FLAGS) \ - AV(double _Complex, OPAL_ALIGNMENT_DOUBLE_COMPLEX, DOUBLE_COMPLEX, FLAGS) - -#define OPAL_DATATYPE_HANDLE_LONG_DOUBLE_COMPLEX(AV, NOTAV, FLAGS) \ - AV(long double _Complex, OPAL_ALIGNMENT_LONG_DOUBLE_COMPLEX, LONG_DOUBLE_COMPLEX, FLAGS) - -#define OPAL_DATATYPE_HANDLE_BOOL(AV, NOTAV, FLAGS) \ - AV(_Bool, OPAL_ALIGNMENT_BOOL, BOOL, FLAGS) - -#if OPAL_ALIGNMENT_WCHAR != 0 -# define OPAL_DATATYPE_HANDLE_WCHAR(AV, NOTAV, FLAGS) \ - AV(wchar_t, OPAL_ALIGNMENT_WCHAR, WCHAR, FLAGS) -#else -# define OPAL_DATATYPE_HANDLE_WCHAR(AV, NOTAV, FLAGS) NOTAV(WCHAR, FLAGS) -#endif #define BASIC_DDT_FROM_ELEM(ELEM) (opal_datatype_basicDatatypes[(ELEM).elem.common.type]) diff --git a/opal/datatype/opal_datatype_module.c b/opal/datatype/opal_datatype_module.c index 527bb310bb1..f91106e56fc 100644 --- a/opal/datatype/opal_datatype_module.c +++ b/opal/datatype/opal_datatype_module.c @@ -20,6 +20,7 @@ * Copyright (c) 2018 Triad National Security, LLC. All rights * reserved. * Copyright (c) 2018 FUJITSU LIMITED. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -33,7 +34,7 @@ #include "opal/datatype/opal_convertor_internal.h" #include "opal/datatype/opal_datatype.h" -#include "opal/datatype/opal_datatype_internal.h" +#include "opal/datatype/opal_datatype_constructors.h" #include "opal/mca/base/mca_base_var.h" #include "opal/runtime/opal.h" #include "opal/util/arch.h" @@ -84,6 +85,8 @@ OPAL_DECLSPEC const opal_datatype_t opal_datatype_double_complex = OPAL_DATATYPE_INITIALIZER_DOUBLE_COMPLEX(0); OPAL_DECLSPEC const opal_datatype_t opal_datatype_long_double_complex = OPAL_DATATYPE_INITIALIZER_LONG_DOUBLE_COMPLEX(0); +OPAL_DECLSPEC const opal_datatype_t opal_datatype_float128_complex + = OPAL_DATATYPE_INITIALIZER_FLOAT128_COMPLEX(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_long = OPAL_DATATYPE_INITIALIZER_LONG(0); @@ -93,7 +96,6 @@ OPAL_DECLSPEC const opal_datatype_t opal_datatype_unavailable OPAL_DECLSPEC dt_elem_desc_t opal_datatype_predefined_elem_desc[2 * OPAL_DATATYPE_MAX_PREDEFINED] = {{{{0}}}}; - /* * NOTE: The order of this array *MUST* match the order in opal_datatype_basicDatatypes * (use of designated initializers should relax this restrictions some) @@ -103,17 +105,17 @@ OPAL_DECLSPEC const size_t opal_datatype_local_sizes[OPAL_DATATYPE_MAX_PREDEFINE [OPAL_DATATYPE_INT2] = sizeof(int16_t), [OPAL_DATATYPE_INT4] = sizeof(int32_t), [OPAL_DATATYPE_INT8] = sizeof(int64_t), - [OPAL_DATATYPE_INT16] = 16, /* sizeof (int128_t) */ + [OPAL_DATATYPE_INT16] = 16, /* sizeof (int128_t) */ [OPAL_DATATYPE_UINT1] = sizeof(uint8_t), [OPAL_DATATYPE_UINT2] = sizeof(uint16_t), [OPAL_DATATYPE_UINT4] = sizeof(uint32_t), [OPAL_DATATYPE_UINT8] = sizeof(uint64_t), - [OPAL_DATATYPE_UINT16] = 16, /* sizeof (uint128_t) */ - [OPAL_DATATYPE_FLOAT2] = 2, /* sizeof (float2) */ - [OPAL_DATATYPE_FLOAT4] = 4, /* sizeof (float4) */ - [OPAL_DATATYPE_FLOAT8] = 8, /* sizeof (float8) */ - [OPAL_DATATYPE_FLOAT12] = 12, /* sizeof (float12) */ - [OPAL_DATATYPE_FLOAT16] = 16, /* sizeof (float16) */ + [OPAL_DATATYPE_UINT16] = 16, /* sizeof (uint128_t) */ + [OPAL_DATATYPE_FLOAT2] = 2, /* sizeof (float2) */ + [OPAL_DATATYPE_FLOAT4] = 4, /* sizeof (float4) */ + [OPAL_DATATYPE_FLOAT8] = 8, /* sizeof (float8) */ + [OPAL_DATATYPE_FLOAT12] = OPAL_SIZEOF_FLOAT12, /* sizeof (float12) */ + [OPAL_DATATYPE_FLOAT16] = OPAL_SIZEOF_FLOAT16, /* sizeof (float16) */ #if defined(HAVE_SHORT_FLOAT__COMPLEX) [OPAL_DATATYPE_SHORT_FLOAT_COMPLEX] = sizeof(short float _Complex), #elif defined(HAVE_OPAL_SHORT_FLOAT_COMPLEX_T) @@ -128,6 +130,13 @@ OPAL_DECLSPEC const size_t opal_datatype_local_sizes[OPAL_DATATYPE_MAX_PREDEFINE [OPAL_DATATYPE_WCHAR] = sizeof(wchar_t), [OPAL_DATATYPE_LONG] = sizeof(long), [OPAL_DATATYPE_UNSIGNED_LONG] = sizeof(unsigned long), +#if defined(HAVE__FLOAT128) && defined(HAVE__FLOAT128__COMPLEX) + [OPAL_DATATYPE_FLOAT128_COMPLEX] = sizeof(_Float128 _Complex), +#elif defined(HAVE___FLOAT128) && defined(HAVE___FLOAT128__COMPLEX) + [OPAL_DATATYPE_FLOAT128_COMPLEX] = sizeof(__float128 _Complex), +#else + [OPAL_DATATYPE_FLOAT128_COMPLEX] = 32, /* typical sizeof(_Float128 _Complex) */ +#endif }; /* @@ -164,6 +173,7 @@ OPAL_DECLSPEC const opal_datatype_t *opal_datatype_basicDatatypes[OPAL_DATATYPE_ [OPAL_DATATYPE_WCHAR] = &opal_datatype_wchar, [OPAL_DATATYPE_LONG] = &opal_datatype_long, [OPAL_DATATYPE_UNSIGNED_LONG] = &opal_datatype_unsigned_long, + [OPAL_DATATYPE_FLOAT128_COMPLEX] = &opal_datatype_float128_complex, [OPAL_DATATYPE_UNAVAILABLE] = &opal_datatype_unavailable, }; @@ -285,6 +295,9 @@ int32_t opal_datatype_init(void) opal_finalize_register_cleanup(opal_datatype_finalize); + /* Sanity check*/ + assert(opal_datatype_local_sizes[OPAL_DATATYPE_FLOAT12] == opal_datatype_float12.size); + return OPAL_SUCCESS; } diff --git a/opal/datatype/opal_datatype_pack_unpack_predefined.h b/opal/datatype/opal_datatype_pack_unpack_predefined.h index b16fce0f111..ee072f7a487 100644 --- a/opal/datatype/opal_datatype_pack_unpack_predefined.h +++ b/opal/datatype/opal_datatype_pack_unpack_predefined.h @@ -3,6 +3,7 @@ * Copyright (c) 2002 University of Chicago * Copyright (c) 2001 Argonne National Laboratory * Copyright (c) 2022 Amazon.com, Inc. or its affiliates. All Rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow @@ -56,7 +57,7 @@ #include "opal_config.h" #include - +#include "opal/datatype/opal_datatype_constructors.h" /* Improve predefined pack/unpack performance using mpich methods. * * For reference implementation, see: @@ -356,6 +357,9 @@ static inline int opal_datatype_unpack_predefined_element(unsigned char **rtn_sr case OPAL_DATATYPE_LONG_DOUBLE_COMPLEX: OPAL_DATATYPE_MYUNPACK(LONG_DOUBLE_COMPLEX); break; + case OPAL_DATATYPE_FLOAT128_COMPLEX: + OPAL_DATATYPE_MYUNPACK(FLOAT128_COMPLEX); + break; case OPAL_DATATYPE_BOOL: OPAL_DATATYPE_MYUNPACK(BOOL); break; @@ -467,6 +471,9 @@ static inline int opal_datatype_pack_predefined_element(unsigned char **rtn_src, case OPAL_DATATYPE_LONG_DOUBLE_COMPLEX: OPAL_DATATYPE_MYPACK(LONG_DOUBLE_COMPLEX); break; + case OPAL_DATATYPE_FLOAT128_COMPLEX: + OPAL_DATATYPE_MYPACK(FLOAT128_COMPLEX); + break; case OPAL_DATATYPE_BOOL: OPAL_DATATYPE_MYPACK(BOOL); break; diff --git a/opal/include/opal/align.h b/opal/include/opal/align.h index 5df9d9485ea..fa198a260f8 100644 --- a/opal/include/opal/align.h +++ b/opal/include/opal/align.h @@ -11,6 +11,7 @@ * All rights reserved. * Copyright (c) 2006 Voltaire All rights reserved. * Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2026 NVIDIA Corporation. All rights reserved. * * $COPYRIGHT$ * @@ -32,7 +33,9 @@ # include # define OPAL_ALIGN_MIN (_Alignof(max_align_t)) #else -# if defined(OPAL_ALIGNMENT___FLOAT128) +# if defined(OPAL_ALIGNMENT__FLOAT128) +# define OPAL_ALIGN_MIN (OPAL_ALIGNMENT__FLOAT128) +# elif defined(OPAL_ALIGNMENT___FLOAT128) # define OPAL_ALIGN_MIN (OPAL_ALIGNMENT___FLOAT128) # elif defined(OPAL_ALIGNMENT_LONG_DOUBLE_COMPLEX) # define OPAL_ALIGN_MIN (OPAL_ALIGNMENT_LONG_DOUBLE_COMPLEX)