opal/datatype/opal_datatype

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
DUMP
DUMP
GET_FIRST_NON_LOOP
   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
   4  *                         University Research and Technology
   5  *                         Corporation.  All rights reserved.
   6  * Copyright (c) 2004-2018 The University of Tennessee and The University
   7  *                         of Tennessee Research Foundation.  All rights
   8  *                         reserved.
   9  * Copyright (c) 2004-2006 High Performance Computing Center Stuttgart,
  10  *                         University of Stuttgart.  All rights reserved.
  11  * Copyright (c) 2004-2006 The Regents of the University of California.
  12  *                         All rights reserved.
  13  * Copyright (c) 2009      Oak Ridge National Labs.  All rights reserved.
  14  * Copyright (c) 2013      Los Alamos National Security, LLC. All rights
  15  *                         reserved.
  16  * Copyright (c) 2013      Cisco Systems, Inc.  All rights reserved.
  17  * Copyright (c) 2017      Research Organization for Information Science
  18  *                         and Technology (RIST). All rights reserved.
  19  * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
  20  * $COPYRIGHT$
  21  *
  22  * Additional copyrights may follow
  23  *
  24  * $HEADER$
  25  */
  26 
  27 #ifndef OPAL_DATATYPE_INTERNAL_H_HAS_BEEN_INCLUDED
  28 #define OPAL_DATATYPE_INTERNAL_H_HAS_BEEN_INCLUDED
  29 
  30 #include "opal_config.h"
  31 
  32 #include <stdarg.h>
  33 #include <string.h>
  34 
  35 #if defined(VERBOSE)
  36 #include "opal/util/output.h"
  37 
  38 extern int opal_datatype_dfd;
  39 
  40 #  define DDT_DUMP_STACK( PSTACK, STACK_POS, PDESC, NAME ) \
  41      opal_datatype_dump_stack( (PSTACK), (STACK_POS), (PDESC), (NAME) )
  42 #  if defined(ACCEPT_C99)
  43 #    define DUMP( ARGS... )          opal_output(opal_datatype_dfd, __VA_ARGS__)
  44 #  else
  45 #    if defined(__GNUC__) && !defined(__STDC__)
  46 #      define DUMP(ARGS...)          opal_output( opal_datatype_dfd, ARGS)
  47 #  else
  48 static inline void DUMP( char* fmt, ... )
  49 {
  50    va_list list;
  51 
  52    va_start( list, fmt );
  53    opal_output_vverbose( 0, opal_datatype_dfd, fmt, list );
  54    va_end( list );
  55 }
  56 #    endif  /* __GNUC__ && !__STDC__ */
  57 #  endif  /* ACCEPT_C99 */
  58 #else
  59 #  define DDT_DUMP_STACK( PSTACK, STACK_POS, PDESC, NAME )
  60 #  if defined(ACCEPT_C99)
  61 #    define DUMP(ARGS...)
  62 #  else
  63 #    if defined(__GNUC__) && !defined(__STDC__)
  64 #      define DUMP(ARGS...)
  65 #    else
  66        /* If we do not compile with PGI, mark the parameter as unused */
  67 #      if !defined(__PGI)
  68 #        define __opal_attribute_unused_tmp__  __opal_attribute_unused__
  69 #      else
  70 #        define __opal_attribute_unused_tmp__
  71 #      endif
  72 static inline void DUMP( char* fmt __opal_attribute_unused_tmp__, ... )
  73 {
  74 #if defined(__PGI)
  75            /* Some compilers complain if we have "..." arguments and no
  76               corresponding va_start() */
  77            va_list arglist;
  78            va_start(arglist, fmt);
  79            va_end(arglist);
  80 #endif
  81 }
  82 #         undef __opal_attribute_unused_tmp__
  83 #    endif  /* __GNUC__ && !__STDC__ */
  84 #  endif  /* ACCEPT_C99 */
  85 #endif  /* VERBOSE */
  86 
  87 
  88 /*
  89  * There 3 types of predefined data types.
  90  * - the basic one composed by just one basic datatype which are
  91  *   definitively contiguous
  92  * - the derived ones where the same basic type is used multiple times.
  93  *   They should be most of the time contiguous.
  94  * - and finally the derived one where multiple basic types are used.
  95  *   Depending on the architecture they can be contiguous or not.
  96  *
  97  * At the OPAL-level we do not care from which language the datatype came from
  98  * (C, C++ or FORTRAN), we only focus on their internal representation in
  99  * the host memory.
 100  *
 101  * NOTE: This predefined datatype order should be matched by any upper-level
 102  * users of the OPAL datatype.
 103  */
 104 #define OPAL_DATATYPE_LOOP           0
 105 #define OPAL_DATATYPE_END_LOOP       1
 106 #define OPAL_DATATYPE_LB             2
 107 #define OPAL_DATATYPE_UB             3
 108 #define OPAL_DATATYPE_FIRST_TYPE     4 /* Number of first real type */
 109 #define OPAL_DATATYPE_INT1           4
 110 #define OPAL_DATATYPE_INT2           5
 111 #define OPAL_DATATYPE_INT4           6
 112 #define OPAL_DATATYPE_INT8           7
 113 #define OPAL_DATATYPE_INT16          8
 114 #define OPAL_DATATYPE_UINT1          9
 115 #define OPAL_DATATYPE_UINT2          10
 116 #define OPAL_DATATYPE_UINT4          11
 117 #define OPAL_DATATYPE_UINT8          12
 118 #define OPAL_DATATYPE_UINT16         13
 119 #define OPAL_DATATYPE_FLOAT2         14
 120 #define OPAL_DATATYPE_FLOAT4         15
 121 #define OPAL_DATATYPE_FLOAT8         16
 122 #define OPAL_DATATYPE_FLOAT12        17
 123 #define OPAL_DATATYPE_FLOAT16        18
 124 #define OPAL_DATATYPE_SHORT_FLOAT_COMPLEX 19
 125 #define OPAL_DATATYPE_FLOAT_COMPLEX  20
 126 #define OPAL_DATATYPE_DOUBLE_COMPLEX 21
 127 #define OPAL_DATATYPE_LONG_DOUBLE_COMPLEX 22
 128 #define OPAL_DATATYPE_BOOL           23
 129 #define OPAL_DATATYPE_WCHAR          24
 130 #define OPAL_DATATYPE_UNAVAILABLE    25
 131 
 132 #ifndef OPAL_DATATYPE_MAX_PREDEFINED
 133 #define OPAL_DATATYPE_MAX_PREDEFINED (OPAL_DATATYPE_UNAVAILABLE+1)
 134 #elif OPAL_DATATYPE_MAX_PREDEFINED <= OPAL_DATATYPE_UNAVAILABLE
 135 /*
 136  * If the number of basic datatype should change update
 137  * OPAL_DATATYPE_MAX_PREDEFINED in opal_datatype.h
 138  */
 139 #error OPAL_DATATYPE_MAX_PREDEFINED should be updated to the next value after the OPAL_DATATYPE_UNAVAILABLE define
 140 #endif
 141 
 142 #define DT_INCREASE_STACK     8
 143 
 144 BEGIN_C_DECLS
 145 
 146 struct ddt_elem_id_description {
 147     uint16_t   flags;  /**< flags for the record */
 148     uint16_t   type;   /**< the basic data type id */
 149 };
 150 typedef struct ddt_elem_id_description ddt_elem_id_description;
 151 
 152 /**
 153  * The data element description. It is similar to a vector type, a contiguous
 154  * blocklen number of basic elements, with a displacement for the first element
 155  * and then an extent for all the extra count.
 156  */
 157 struct ddt_elem_desc {
 158     ddt_elem_id_description common;           /**< basic data description and flags */
 159     uint32_t                blocklen;         /**< number of elements on each block */
 160     size_t                  count;            /**< number of blocks */
 161     ptrdiff_t               extent;           /**< extent of each block (in bytes) */
 162     ptrdiff_t               disp;             /**< displacement of the first block */
 163 };
 164 typedef struct ddt_elem_desc ddt_elem_desc_t;
 165 
 166 /**
 167  * The loop description, with it's two markers: one for the begining and one for
 168  * the end. The initial marker contains the number of repetitions, the number of
 169  * elements in the loop, and the extent of each loop. The end marker contains in
 170  * addition to the number of elements (so that we can easily pair together the
 171  * two markers), the size of the data contained inside and the displacement of
 172  * the first element.
 173  */
 174 struct ddt_loop_desc {
 175     ddt_elem_id_description common;           /**< basic data description and flags */
 176     uint32_t                items;            /**< number of items in the loop */
 177     uint32_t                loops;            /**< number of elements */
 178     size_t                  unused;           /**< not used right now */
 179     ptrdiff_t               extent;           /**< extent of the whole loop */
 180 };
 181 typedef struct ddt_loop_desc ddt_loop_desc_t;
 182 
 183 struct ddt_endloop_desc {
 184     ddt_elem_id_description common;           /**< basic data description and flags */
 185     uint32_t                items;            /**< number of elements */
 186     uint32_t                unused;           /**< not used right now */
 187     size_t                  size;             /**< real size of the data in the loop */
 188     ptrdiff_t               first_elem_disp;  /**< the displacement of the first block in the loop */
 189 };
 190 typedef struct ddt_endloop_desc ddt_endloop_desc_t;
 191 
 192 union dt_elem_desc {
 193     ddt_elem_desc_t    elem;
 194     ddt_loop_desc_t    loop;
 195     ddt_endloop_desc_t end_loop;
 196 };
 197 
 198 #define CREATE_LOOP_START( _place, _count, _items, _extent, _flags )           \
 199     do {                                                                       \
 200         (_place)->loop.common.type   = OPAL_DATATYPE_LOOP;                     \
 201         (_place)->loop.common.flags  = (_flags) & ~OPAL_DATATYPE_FLAG_DATA;    \
 202         (_place)->loop.loops         = (_count);                               \
 203         (_place)->loop.items         = (_items);                               \
 204         (_place)->loop.extent        = (_extent);                              \
 205         (_place)->loop.unused        = -1;                                     \
 206     } while(0)
 207 
 208 #define CREATE_LOOP_END( _place, _items, _first_item_disp, _size, _flags )     \
 209     do {                                                                       \
 210         (_place)->end_loop.common.type = OPAL_DATATYPE_END_LOOP;               \
 211         (_place)->end_loop.common.flags = (_flags) & ~OPAL_DATATYPE_FLAG_DATA; \
 212         (_place)->end_loop.items = (_items);                                   \
 213         (_place)->end_loop.first_elem_disp = (_first_item_disp);               \
 214         (_place)->end_loop.size = (_size);  /* the size inside the loop */     \
 215         (_place)->end_loop.unused = -1;                                        \
 216     } while(0)
 217 
 218 
 219 /**
 220  * Create one or more elements depending on the value of _count. If the value
 221  * is too large for the type of elem.count then use oth the elem.count and
 222  * elem.blocklen to create it. If the number is prime then create a second
 223  * element to account for the difference.
 224  */
 225 #define CREATE_ELEM( _place, _type, _flags, _count, _disp, _extent )           \
 226     do {                                                                       \
 227         (_place)->elem.common.flags = (_flags) | OPAL_DATATYPE_FLAG_DATA;      \
 228         (_place)->elem.common.type  = (_type);                                 \
 229         (_place)->elem.disp         = (_disp);                                 \
 230         (_place)->elem.extent       = (_extent);                               \
 231         (_place)->elem.count        = (_count);                                \
 232         (_place)->elem.blocklen     = 1;                                       \
 233     } while(0)
 234 /*
 235  * This array holds the descriptions desc.desc[2] of the predefined basic datatypes.
 236  */
 237 OPAL_DECLSPEC extern union dt_elem_desc opal_datatype_predefined_elem_desc[2 * OPAL_DATATYPE_MAX_PREDEFINED];
 238 struct opal_datatype_t;
 239 
 240 /* Other fields starting after bdt_used (index of OPAL_DATATYPE_LOOP should be ONE) */
 241 /*
 242  * NOTE: The order of initialization *MUST* match the order of the OPAL_DATATYPE_-numbers.
 243  * Unfortunateley, I don't get the preprocessor to replace
 244  *     OPAL_DATATYPE_INIT_BTYPES_ARRAY_ ## OPAL_DATATYPE ## NAME
 245  * into
 246  *     OPAL_DATATYPE_INIT_BTYPES_ARRAY_[0-21], then order and naming would _not_ matter....
 247  */
 248 
 249 #define OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE NULL
 250 #define OPAL_DATATYPE_INIT_PTYPES_ARRAY(NAME) (size_t[OPAL_DATATYPE_MAX_PREDEFINED]){ [OPAL_DATATYPE_ ## NAME] = 1, [OPAL_DATATYPE_MAX_PREDEFINED-1] = 0 }
 251 
 252 #define OPAL_DATATYPE_INIT_NAME(NAME) "OPAL_" #NAME
 253 
 254 /*
 255  * Macro to initialize the main description for basic types, setting the pointer
 256  * into the array opal_datatype_predefined_type_desc, which is initialized at
 257  * runtime in opal_datatype_init(). Each basic type has two desc-elements....
 258  */
 259 #define OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME)                                     \
 260     {                                                                                \
 261         .length = 1, .used = 1,                                                      \
 262         .desc = &(opal_datatype_predefined_elem_desc[2 * OPAL_DATATYPE_ ## NAME])    \
 263     }
 264 #define OPAL_DATATYPE_INIT_DESC_NULL  {.length = 0, .used = 0, .desc = NULL}
 265 
 266 #define OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( NAME, FLAGS )                   \
 267     {                                                                                \
 268         .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t),                              \
 269         .flags = OPAL_DATATYPE_FLAG_UNAVAILABLE | OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS), \
 270         .id = OPAL_DATATYPE_ ## NAME,                                                \
 271         .bdt_used = 0,                                                               \
 272         .size = 0,                                                                   \
 273         .true_lb = 0, .true_ub = 0, .lb = 0, .ub = 0,                                \
 274         .align = 0,                                                                  \
 275         .nbElems = 1,                                                                \
 276         .name = OPAL_DATATYPE_INIT_NAME(NAME),                                       \
 277         .desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(UNAVAILABLE),                     \
 278         .opt_desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(UNAVAILABLE),                 \
 279         .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE                        \
 280     }
 281 
 282 #define OPAL_DATATYPE_INITIALIZER_UNAVAILABLE( FLAGS )                               \
 283     OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( UNAVAILABLE, (FLAGS) )
 284 
 285 #define OPAL_DATATYPE_INITIALIZER_EMPTY( FLAGS )                        \
 286     {                                                                   \
 287         .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t),                 \
 288         .flags = OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS),               \
 289         .id = 0,                                                        \
 290         .bdt_used = 0,                                                  \
 291         .size = 0,                                                      \
 292         .true_lb = 0, .true_ub = 0, .lb = 0, .ub = 0,                   \
 293         .align = 0,                                                     \
 294         .nbElems = 1,                                                   \
 295         .name = OPAL_DATATYPE_INIT_NAME(EMPTY),                         \
 296         .desc = OPAL_DATATYPE_INIT_DESC_NULL,                           \
 297         .opt_desc = OPAL_DATATYPE_INIT_DESC_NULL,                       \
 298         .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE           \
 299     }
 300 
 301 #define OPAL_DATATYPE_INIT_BASIC_TYPE( TYPE, NAME, FLAGS )              \
 302     {                                                                   \
 303         .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t),                 \
 304         .flags = OPAL_DATATYPE_FLAG_PREDEFINED | (FLAGS),               \
 305         .id = TYPE,                                                     \
 306         .bdt_used = (((uint32_t)1)<<(TYPE)),                            \
 307         .size = 0,                                                      \
 308         .true_lb = 0, .true_ub = 0, .lb = 0, .ub = 0,                   \
 309         .align = 0,                                                     \
 310         .nbElems = 1,                                                   \
 311         .name = OPAL_DATATYPE_INIT_NAME(NAME),                          \
 312         .desc = OPAL_DATATYPE_INIT_DESC_NULL,                           \
 313         .opt_desc = OPAL_DATATYPE_INIT_DESC_NULL,                       \
 314         .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE           \
 315     }
 316 
 317 #define OPAL_DATATYPE_INIT_BASIC_DATATYPE( TYPE, ALIGN, NAME, FLAGS )                \
 318     {                                                                                \
 319         .super = OPAL_OBJ_STATIC_INIT(opal_datatype_t),                              \
 320         .flags = OPAL_DATATYPE_FLAG_BASIC | (FLAGS),                                 \
 321         .id = OPAL_DATATYPE_ ## NAME,                                                \
 322         .bdt_used = (((uint32_t)1)<<(OPAL_DATATYPE_ ## NAME)),                       \
 323         .size = sizeof(TYPE),                                                        \
 324         .true_lb = 0, .true_ub = sizeof(TYPE), .lb = 0, .ub = sizeof(TYPE),          \
 325         .align = (ALIGN),                                                            \
 326         .nbElems = 1,                                                                \
 327         .name = OPAL_DATATYPE_INIT_NAME(NAME),                                       \
 328         .desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME),                            \
 329         .opt_desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME),                        \
 330         .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE                        \
 331     }
 332 
 333 #define OPAL_DATATYPE_INITIALIZER_LOOP(FLAGS)       OPAL_DATATYPE_INIT_BASIC_TYPE( OPAL_DATATYPE_LOOP, LOOP_S, FLAGS )
 334 #define OPAL_DATATYPE_INITIALIZER_END_LOOP(FLAGS)   OPAL_DATATYPE_INIT_BASIC_TYPE( OPAL_DATATYPE_END_LOOP, LOOP_E, FLAGS )
 335 #define OPAL_DATATYPE_INITIALIZER_LB(FLAGS)         OPAL_DATATYPE_INIT_BASIC_TYPE( OPAL_DATATYPE_LB, LB, FLAGS )
 336 #define OPAL_DATATYPE_INITIALIZER_UB(FLAGS)         OPAL_DATATYPE_INIT_BASIC_TYPE( OPAL_DATATYPE_UB, UB, FLAGS )
 337 #define OPAL_DATATYPE_INITIALIZER_INT1(FLAGS)       OPAL_DATATYPE_INIT_BASIC_DATATYPE( int8_t, OPAL_ALIGNMENT_INT8, INT1, FLAGS )
 338 #define OPAL_DATATYPE_INITIALIZER_INT2(FLAGS)       OPAL_DATATYPE_INIT_BASIC_DATATYPE( int16_t, OPAL_ALIGNMENT_INT16, INT2, FLAGS )
 339 #define OPAL_DATATYPE_INITIALIZER_INT4(FLAGS)       OPAL_DATATYPE_INIT_BASIC_DATATYPE( int32_t, OPAL_ALIGNMENT_INT32, INT4, FLAGS )
 340 #define OPAL_DATATYPE_INITIALIZER_INT8(FLAGS)       OPAL_DATATYPE_INIT_BASIC_DATATYPE( int64_t, OPAL_ALIGNMENT_INT64, INT8, FLAGS )
 341 #ifdef HAVE_INT128_T
 342 #define OPAL_DATATYPE_INITIALIZER_INT16(FLAGS)      OPAL_DATATYPE_INIT_BASIC_DATATYPE( int128_t, OPAL_ALIGNMENT_INT128, INT16, FLAGS )
 343 #else
 344 #define OPAL_DATATYPE_INITIALIZER_INT16(FLAGS)      OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( INT16, FLAGS )
 345 #endif
 346 #define OPAL_DATATYPE_INITIALIZER_UINT1(FLAGS)      OPAL_DATATYPE_INIT_BASIC_DATATYPE( uint8_t, OPAL_ALIGNMENT_INT8, UINT1, FLAGS )
 347 #define OPAL_DATATYPE_INITIALIZER_UINT2(FLAGS)      OPAL_DATATYPE_INIT_BASIC_DATATYPE( uint16_t, OPAL_ALIGNMENT_INT16, UINT2, FLAGS )
 348 #define OPAL_DATATYPE_INITIALIZER_UINT4(FLAGS)      OPAL_DATATYPE_INIT_BASIC_DATATYPE( uint32_t, OPAL_ALIGNMENT_INT32, UINT4, FLAGS )
 349 #define OPAL_DATATYPE_INITIALIZER_UINT8(FLAGS)      OPAL_DATATYPE_INIT_BASIC_DATATYPE( uint64_t, OPAL_ALIGNMENT_INT64, UINT8, FLAGS )
 350 #ifdef HAVE_UINT128_T
 351 #define OPAL_DATATYPE_INITIALIZER_UINT16(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( uint128_t, OPAL_ALIGNMENT_INT128, UINT16, FLAGS )
 352 #else
 353 #define OPAL_DATATYPE_INITIALIZER_UINT16(FLAGS)     OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( INT16, FLAGS )
 354 #endif
 355 
 356 #if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 2
 357 #define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT2, FLAGS )
 358 #elif SIZEOF_FLOAT == 2
 359 #define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( float, OPAL_ALIGNMENT_FLOAT, FLOAT2, FLAGS )
 360 #elif SIZEOF_DOUBLE == 2
 361 #define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( double, OPAL_ALIGNMENT_DOUBLE, FLOAT2, FLAGS )
 362 #elif SIZEOF_LONG_DOUBLE == 2
 363 #define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT2, FLAGS )
 364 #elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 2
 365 #define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT2, FLAGS )
 366 #else
 367 #define OPAL_DATATYPE_INITIALIZER_FLOAT2(FLAGS)     OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT2, FLAGS )
 368 #endif
 369 
 370 #if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 4
 371 #define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT4, FLAGS )
 372 #elif SIZEOF_FLOAT == 4
 373 #define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( float, OPAL_ALIGNMENT_FLOAT, FLOAT4, FLAGS )
 374 #elif SIZEOF_DOUBLE == 4
 375 #define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( double, OPAL_ALIGNMENT_DOUBLE, FLOAT4, FLAGS )
 376 #elif SIZEOF_LONG_DOUBLE == 4
 377 #define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT4, FLAGS )
 378 #elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 4
 379 #define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT4, FLAGS )
 380 #else
 381 #define OPAL_DATATYPE_INITIALIZER_FLOAT4(FLAGS)     OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT4, FLAGS )
 382 #endif
 383 
 384 #if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 8
 385 #define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT8, FLAGS )
 386 #elif SIZEOF_FLOAT == 8
 387 #define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( float, OPAL_ALIGNMENT_FLOAT, FLOAT8, FLAGS )
 388 #elif SIZEOF_DOUBLE == 8
 389 #define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( double, OPAL_ALIGNMENT_DOUBLE, FLOAT8, FLAGS )
 390 #elif SIZEOF_LONG_DOUBLE == 8
 391 #define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT8, FLAGS )
 392 #elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 8
 393 #define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS)     OPAL_DATATYPE_INIT_BASIC_DATATYPE( opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT8, FLAGS )
 394 #else
 395 #define OPAL_DATATYPE_INITIALIZER_FLOAT8(FLAGS)     OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT8, FLAGS )
 396 #endif
 397 
 398 #if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 12
 399 #define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT12, FLAGS )
 400 #elif SIZEOF_FLOAT == 12
 401 #define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( float, OPAL_ALIGNMENT_FLOAT, FLOAT12, FLAGS )
 402 #elif SIZEOF_DOUBLE == 12
 403 #define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( double, OPAL_ALIGNMENT_DOUBLE, FLOAT12, FLAGS )
 404 #elif SIZEOF_LONG_DOUBLE == 12
 405 #define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT12, FLAGS )
 406 #elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 12
 407 #define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT12, FLAGS )
 408 #else
 409 #define OPAL_DATATYPE_INITIALIZER_FLOAT12(FLAGS)    OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT12, FLAGS )
 410 #endif
 411 
 412 #if defined(HAVE_SHORT_FLOAT) && SIZEOF_SHORT_FLOAT == 16
 413 #define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( short float, OPAL_ALIGNMENT_SHORT_FLOAT, FLOAT16, FLAGS )
 414 #elif SIZEOF_FLOAT == 16
 415 #define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( float, OPAL_ALIGNMENT_FLOAT, FLOAT16, FLAGS )
 416 #elif SIZEOF_DOUBLE == 16
 417 #define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( double, OPAL_ALIGNMENT_DOUBLE, FLOAT16, FLAGS )
 418 #elif SIZEOF_LONG_DOUBLE == 16
 419 #define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double, OPAL_ALIGNMENT_LONG_DOUBLE, FLOAT16, FLAGS )
 420 #elif defined(HAVE_OPAL_SHORT_FLOAT_T) && SIZEOF_OPAL_SHORT_FLOAT_T == 16
 421 #define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS)    OPAL_DATATYPE_INIT_BASIC_DATATYPE( opal_short_float_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, FLOAT16, FLAGS )
 422 #else
 423 #define OPAL_DATATYPE_INITIALIZER_FLOAT16(FLAGS)    OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( FLOAT16, FLAGS )
 424 #endif
 425 
 426 #if defined(HAVE_SHORT_FLOAT__COMPLEX)
 427 #define OPAL_DATATYPE_INITIALIZER_SHORT_FLOAT_COMPLEX(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( short float _Complex, OPAL_ALIGNMENT_SHORT_FLOAT_COMPLEX, SHORT_FLOAT_COMPLEX, FLAGS )
 428 #elif defined(HAVE_OPAL_SHORT_FLOAT_COMPLEX_T)
 429 #define OPAL_DATATYPE_INITIALIZER_SHORT_FLOAT_COMPLEX(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( opal_short_float_complex_t, OPAL_ALIGNMENT_OPAL_SHORT_FLOAT_T, SHORT_FLOAT_COMPLEX, FLAGS )
 430 #else
 431 #define OPAL_DATATYPE_INITIALIZER_SHORT_FLOAT_COMPLEX(FLAGS) OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( SHORT_FLOAT_COMPLEX, FLAGS)
 432 #endif
 433 
 434 #define OPAL_DATATYPE_INITIALIZER_FLOAT_COMPLEX(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( float _Complex, OPAL_ALIGNMENT_FLOAT_COMPLEX, FLOAT_COMPLEX, FLAGS )
 435 
 436 #define OPAL_DATATYPE_INITIALIZER_DOUBLE_COMPLEX(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( double _Complex, OPAL_ALIGNMENT_DOUBLE_COMPLEX, DOUBLE_COMPLEX, FLAGS )
 437 
 438 #define OPAL_DATATYPE_INITIALIZER_LONG_DOUBLE_COMPLEX(FLAGS) OPAL_DATATYPE_INIT_BASIC_DATATYPE( long double _Complex, OPAL_ALIGNMENT_LONG_DOUBLE_COMPLEX, LONG_DOUBLE_COMPLEX, FLAGS )
 439 
 440 #define OPAL_DATATYPE_INITIALIZER_BOOL(FLAGS)       OPAL_DATATYPE_INIT_BASIC_DATATYPE( _Bool, OPAL_ALIGNMENT_BOOL, BOOL, FLAGS )
 441 
 442 #if OPAL_ALIGNMENT_WCHAR != 0
 443 #define OPAL_DATATYPE_INITIALIZER_WCHAR(FLAGS)      OPAL_DATATYPE_INIT_BASIC_DATATYPE( wchar_t, OPAL_ALIGNMENT_WCHAR, WCHAR, FLAGS )
 444 #else
 445 #define OPAL_DATATYPE_INITIALIZER_WCHAR(FLAGS)      OPAL_DATATYPE_INITIALIZER_UNAVAILABLE_NAMED( WCHAR, FLAGS )
 446 #endif
 447 
 448 #define BASIC_DDT_FROM_ELEM( ELEM ) (opal_datatype_basicDatatypes[(ELEM).elem.common.type])
 449 
 450 #define SAVE_STACK( PSTACK, INDEX, TYPE, COUNT, DISP) \
 451 do { \
 452    (PSTACK)->index    = (INDEX); \
 453    (PSTACK)->type     = (TYPE); \
 454    (PSTACK)->count    = (COUNT); \
 455    (PSTACK)->disp     = (DISP); \
 456 } while(0)
 457 
 458 #define PUSH_STACK( PSTACK, STACK_POS, INDEX, TYPE, COUNT, DISP) \
 459 do { \
 460    dt_stack_t* pTempStack = (PSTACK) + 1; \
 461    SAVE_STACK( pTempStack, (INDEX), (TYPE), (COUNT), (DISP) );  \
 462    (STACK_POS)++; \
 463    (PSTACK) = pTempStack; \
 464 } while(0)
 465 
 466 #if OPAL_ENABLE_DEBUG
 467 #define OPAL_DATATYPE_SAFEGUARD_POINTER( ACTPTR, LENGTH, INITPTR, PDATA, COUNT ) \
 468     {                                                                   \
 469         unsigned char *__lower_bound = (INITPTR), *__upper_bound;       \
 470         assert( ((LENGTH) != 0) && ((COUNT) != 0) );                    \
 471         __lower_bound += (PDATA)->true_lb;                              \
 472         __upper_bound = (INITPTR) + (PDATA)->true_ub +                  \
 473             ((PDATA)->ub - (PDATA)->lb) * ((COUNT) - 1);                \
 474         if( ((ACTPTR) < __lower_bound) || ((ACTPTR) >= __upper_bound) ) { \
 475             opal_datatype_safeguard_pointer_debug_breakpoint( (ACTPTR), (LENGTH), (INITPTR), (PDATA), (COUNT) ); \
 476             opal_output( 0, "%s:%d\n\tPointer %p size %lu is outside [%p,%p] for\n\tbase ptr %p count %lu and data \n", \
 477                          __FILE__, __LINE__, (void*)(ACTPTR), (unsigned long)(LENGTH), (void*)__lower_bound, (void*)__upper_bound, \
 478                          (void*)(INITPTR), (unsigned long)(COUNT) );    \
 479             opal_datatype_dump( (PDATA) );                              \
 480         }                                                               \
 481     }
 482 
 483 #else
 484 #define OPAL_DATATYPE_SAFEGUARD_POINTER( ACTPTR, LENGTH, INITPTR, PDATA, COUNT )
 485 #endif  /* OPAL_ENABLE_DEBUG */
 486 
 487 static inline int GET_FIRST_NON_LOOP( const union dt_elem_desc* _pElem )
 488 {
 489     int element_index = 0;
 490 
 491     /* We dont have to check for the end as we always put an END_LOOP
 492      * at the end of all datatype descriptions.
 493      */
 494     while( _pElem->elem.common.type == OPAL_DATATYPE_LOOP ) {
 495         ++_pElem; element_index++;
 496     }
 497     return element_index;
 498 }
 499 
 500 #define UPDATE_INTERNAL_COUNTERS( DESCRIPTION, POSITION, ELEMENT, COUNTER ) \
 501     do {                                                                \
 502         (ELEMENT) = &((DESCRIPTION)[(POSITION)]);                       \
 503         if( OPAL_DATATYPE_LOOP == (ELEMENT)->elem.common.type )         \
 504             (COUNTER) = (ELEMENT)->loop.loops;                          \
 505         else                                                            \
 506             (COUNTER) = (ELEMENT)->elem.count;                          \
 507     } while (0)
 508 
 509 OPAL_DECLSPEC int opal_datatype_contain_basic_datatypes( const struct opal_datatype_t* pData, char* ptr, size_t length );
 510 OPAL_DECLSPEC int opal_datatype_dump_data_flags( unsigned short usflags, char* ptr, size_t length );
 511 OPAL_DECLSPEC int opal_datatype_dump_data_desc( union dt_elem_desc* pDesc, int nbElems, char* ptr, size_t length );
 512 
 513 #if OPAL_ENABLE_DEBUG
 514 extern bool opal_position_debug;
 515 extern bool opal_copy_debug;
 516 #endif  /* OPAL_ENABLE_DEBUG */
 517 
 518 END_C_DECLS
 519 #endif  /* OPAL_DATATYPE_INTERNAL_H_HAS_BEEN_INCLUDED */
/* [<][>][^][v][top][bottom][index][help] */
root/opal/datatype/opal_datatype_internal.h

INCLUDED FROM

DEFINITIONS
