adding external32size field to supplement remote_sizes[]

markalle · markalle · commit cc098ba84f15 · 2020-07-22T03:21:57.000-04:00
opal datatypes map MPI_LONG and MPI_INT8_T to the same
OPAL_DATATYPE_INT8.  This makes the remote_sizes[] array
indexed by the predefined OPAL_DATATYPE_* entries inadequate
to identify the external32 size for entries in a datatype's
description[].

A datatype's desc[] entries have elem.common with info about
the predefined OMPI type that makes up the description.  This
PR adds an elem.external32size.

Details for setting that field::
* the OPAL datatype initializers (in OPAL_DATATYPE_INIT_DESC_PREDEFINED)
  create opal_datatype-&gt;desc.desc as an offset into
  opal_datatype_predefined_elem_desc, using the same offsets for
  multiple items.  With the addition of an external32size field
  that data diverges for the different OMPI types that are using the
  same OPAL construction, so it had to be copied into its own space
  for the predefined datatypes, see the malloc/memcpy in
  opal_datatype_set_external32_size().
* the field is initialized for the predefined OMPI datatypes using
  opal_datatype_set_external32_size() performed by OMPI, then in
  opal_datatype_add() when description[] entries are being added
  it's always either pulling from the .external32size set in
  one of those base datatypes, or it's using that field out of
  a previously created description[] entry.

Details for using that field:
* Not all the OMPI types will have an elem.external32size set,
  so I didn't remove remote_sizes[], rather a non-zero external32size
  is used first, and if unavailable then the remote_sizes[] of the
  elem.common.type is used.  This is found in opal_datatype_pack/unpack.c

There's a similar issue in opal_datatype_compute_remote_size()
that used a ptypes[] array that counted the number of each predefined
OPAL_DATATYPE_* contained in the datatype.  This was used to count
a total remote_size.  It doesn't have enough info for the same reason,
so I expanded the ptypes into a struct with two entries
    .bdt_count[]  for counting the number of each predefined OPAL_DATATYPE_*
    .external32size for counting the total bytes represented by the
        external32 size for the entries put in bdt_count[]

Signed-off-by: Mark Allen &lt;markalle@us.ibm.com&gt;
diff --git a/ompi/datatype/ompi_datatype.h b/ompi/datatype/ompi_datatype.h
@@ -388,6 +388,8 @@ OMPI_DECLSPEC int ompi_datatype_unpack_external( const char datarep[], const voi
 OMPI_DECLSPEC int ompi_datatype_pack_external_size( const char datarep[], int incount,
                                                     ompi_datatype_t *datatype, MPI_Aint *size);
 
+OMPI_DECLSPEC int ompi_set_external32_sizes(void);
+
 #define OMPI_DATATYPE_RETAIN(ddt)                                       \
     {                                                                   \
         if( !ompi_datatype_is_predefined((ddt)) ) {                     \
diff --git a/ompi/datatype/ompi_datatype_external32.c b/ompi/datatype/ompi_datatype_external32.c
@@ -97,3 +97,39 @@ int32_t ompi_datatype_default_convertors_fini( void )
 
     return OMPI_SUCCESS;
 }
+
+int
+ompi_set_external32_sizes() {
+    opal_datatype_set_external32_size(&MPI_PACKED->super, 1);
+    opal_datatype_set_external32_size(&MPI_BYTE->super, 1);
+    opal_datatype_set_external32_size(&MPI_CHAR->super, 1);
+    opal_datatype_set_external32_size(&MPI_UNSIGNED_CHAR->super, 1);
+    opal_datatype_set_external32_size(&MPI_SIGNED_CHAR->super, 1);
+    opal_datatype_set_external32_size(&MPI_WCHAR->super, 2);
+    opal_datatype_set_external32_size(&MPI_SHORT->super, 2);
+    opal_datatype_set_external32_size(&MPI_UNSIGNED_SHORT->super, 2);
+    opal_datatype_set_external32_size(&MPI_INT->super, 4);
+    opal_datatype_set_external32_size(&MPI_UNSIGNED->super, 4);
+    opal_datatype_set_external32_size(&MPI_LONG->super, 4);
+    opal_datatype_set_external32_size(&MPI_UNSIGNED_LONG->super, 4);
+    opal_datatype_set_external32_size(&MPI_FLOAT->super, 4);
+    opal_datatype_set_external32_size(&MPI_DOUBLE->super, 8);
+    opal_datatype_set_external32_size(&MPI_LONG_DOUBLE->super, 16);
+    opal_datatype_set_external32_size(&MPI_CHARACTER->super, 1);
+    opal_datatype_set_external32_size(&MPI_LOGICAL->super, 4);
+    opal_datatype_set_external32_size(&MPI_INTEGER->super, 4);
+    opal_datatype_set_external32_size(&MPI_REAL->super, 4);
+    opal_datatype_set_external32_size(&MPI_DOUBLE_PRECISION->super, 8);
+    opal_datatype_set_external32_size(&MPI_COMPLEX->super, 2*4);
+    opal_datatype_set_external32_size(&MPI_DOUBLE_COMPLEX->super, 2*8);
+    opal_datatype_set_external32_size(&MPI_INTEGER1->super, 1);
+    opal_datatype_set_external32_size(&MPI_INTEGER2->super, 2);
+    opal_datatype_set_external32_size(&MPI_INTEGER4->super, 4);
+    opal_datatype_set_external32_size(&MPI_INTEGER8->super, 8);
+    opal_datatype_set_external32_size(&MPI_LONG_LONG_INT->super, 8);
+    opal_datatype_set_external32_size(&MPI_UNSIGNED_LONG_LONG->super, 8);
+    opal_datatype_set_external32_size(&MPI_REAL4->super, 4);
+    opal_datatype_set_external32_size(&MPI_REAL8->super, 8);
+    opal_datatype_set_external32_size(&MPI_REAL16->super, 16);
+    return 0;
+}
diff --git a/ompi/datatype/ompi_datatype_get_elements.c b/ompi/datatype/ompi_datatype_get_elements.c
@@ -49,10 +49,10 @@ int ompi_datatype_get_elements (ompi_datatype_t *datatype, size_t ucount, size_t
        there are no leftover bytes */
     if (!ompi_datatype_is_predefined(datatype)) {
         if (0 != internal_count) {
-            opal_datatype_compute_ptypes(&datatype->super);
+            opal_datatype_compute_ptypes(&datatype->super, opal_convertor_get_remote_sizes(ompi_mpi_external32_convertor));
             /* count the basic elements in the datatype */
             for (i = OPAL_DATATYPE_FIRST_TYPE, total = 0 ; i < OPAL_DATATYPE_MAX_PREDEFINED ; ++i) {
-                total += datatype->super.ptypes[i];
+                total += datatype->super.ptypes->bdt_count[i];
             }
             internal_count = total * internal_count;
         }
diff --git a/ompi/datatype/ompi_datatype_internal.h b/ompi/datatype/ompi_datatype_internal.h
@@ -494,7 +494,7 @@ extern const ompi_datatype_t* ompi_datatype_basicDatatypes[OMPI_DATATYPE_MPI_MAX
         .name = OPAL_DATATYPE_INIT_NAME(TYPE ## SIZE),                               \
         .desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(TYPE ## SIZE),                    \
         .opt_desc = OPAL_DATATYPE_INIT_DESC_PREDEFINED(TYPE ## SIZE),                \
-        .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY(TYPE ## SIZE)                      \
+        .ptypes = OPAL_DATATYPE_INIT_PTYPES_ARRAY(TYPE ## SIZE, SIZE)                \
     }
 
 #define OMPI_DATATYPE_INIT_PREDEFINED_BASIC_TYPE_FORTRAN( TYPE, NAME, SIZE, ALIGN, FLAGS ) \
@@ -571,8 +571,20 @@ extern const ompi_datatype_t* ompi_datatype_basicDatatypes[OMPI_DATATYPE_MPI_MAX
 #define OMPI_DATATYPE_INITIALIZER_UNSIGNED            OPAL_DATATYPE_INITIALIZER_UINT8
 #endif
 
-#define OMPI_DATATYPE_INITIALIZER_LONG                OPAL_DATATYPE_INITIALIZER_LONG
-#define OMPI_DATATYPE_INITIALIZER_UNSIGNED_LONG       OPAL_DATATYPE_INITIALIZER_ULONG
+//#define OMPI_DATATYPE_INITIALIZER_LONG                OPAL_DATATYPE_INITIALIZER_LONG
+//#define OMPI_DATATYPE_INITIALIZER_UNSIGNED_LONG       OPAL_DATATYPE_INITIALIZER_ULONG
+#if 1
+#if SIZEOF_LONG == 4
+#define OMPI_DATATYPE_INITIALIZER_LONG                OPAL_DATATYPE_INITIALIZER_INT4
+#define OMPI_DATATYPE_INITIALIZER_UNSIGNED_LONG       OPAL_DATATYPE_INITIALIZER_UINT4
+#elif SIZEOF_LONG == 8
+#define OMPI_DATATYPE_INITIALIZER_LONG                OPAL_DATATYPE_INITIALIZER_INT8
+#define OMPI_DATATYPE_INITIALIZER_UNSIGNED_LONG       OPAL_DATATYPE_INITIALIZER_UINT8
+#elif SIZEOF_LONG == 16
+#define OMPI_DATATYPE_INITIALIZER_LONG                OPAL_DATATYPE_INITIALIZER_INT16
+#define OMPI_DATATYPE_INITIALIZER_UNSIGNED_LONG       OPAL_DATATYPE_INITIALIZER_UINT16
+#endif
+#endif
 
 #if SIZEOF_LONG_LONG == 4
 #define OMPI_DATATYPE_INITIALIZER_LONG_LONG_INT       OPAL_DATATYPE_INITIALIZER_INT4
diff --git a/ompi/datatype/ompi_datatype_module.c b/ompi/datatype/ompi_datatype_module.c
@@ -663,6 +663,9 @@ int32_t ompi_datatype_init( void )
         }
     }
     ompi_datatype_default_convertors_init();
+
+    ompi_set_external32_sizes();
+
     return OMPI_SUCCESS;
 }
 
diff --git a/opal/datatype/Makefile.am b/opal/datatype/Makefile.am
@@ -66,7 +66,8 @@ libdatatype_la_SOURCES = \
         opal_datatype_pack.c \
         opal_datatype_position.c \
         opal_datatype_resize.c \
-        opal_datatype_unpack.c
+        opal_datatype_unpack.c \
+        opal_datatype_setexternal32.c
 
 libdatatype_la_LIBADD = libdatatype_reliable.la
 
diff --git a/opal/datatype/opal_convertor.c b/opal/datatype/opal_convertor.c
@@ -461,21 +461,27 @@ opal_datatype_compute_remote_size( const opal_datatype_t* pData,
     size_t length = 0;
 
     if (opal_datatype_is_predefined(pData)) {
+        if (pData->desc.desc->elem.common.external32size != 0) {
+            return pData->desc.desc->elem.common.external32size;
+        }
         return sizes[pData->desc.desc->elem.common.type];
     }
 
     if( OPAL_UNLIKELY(NULL == pData->ptypes) ) {
         /* Allocate and fill the array of types used in the datatype description */
-        opal_datatype_compute_ptypes( (opal_datatype_t*)pData );
+        opal_datatype_compute_ptypes( (opal_datatype_t*)pData , sizes );
     }
+    return pData->ptypes->external32size;
 
+#if 0
     for( int i = OPAL_DATATYPE_FIRST_TYPE; typeMask && (i < OPAL_DATATYPE_MAX_PREDEFINED); i++ ) {
         if( typeMask & ((uint32_t)1 << i) ) {
             length += (pData->ptypes[i] * sizes[i]);
             typeMask ^= ((uint32_t)1 << i);
         }
     }
     return length;
+#endif
 }
 
 /**
@@ -772,3 +778,9 @@ void opal_datatype_dump_stack( const dt_stack_t* pStack, int stack_pos,
     }
     opal_output( 0, "\n" );
 }
+
+size_t*
+opal_convertor_get_remote_sizes(opal_convertor_t* pConvertor)
+{
+    return pConvertor->master->remote_sizes;
+}
diff --git a/opal/datatype/opal_convertor.h b/opal/datatype/opal_convertor.h
@@ -397,6 +397,9 @@ OPAL_DECLSPEC int
 opal_convertor_generic_simple_position( opal_convertor_t* pConvertor,
                                         size_t* position );
 
+OPAL_DECLSPEC size_t*
+opal_convertor_get_remote_sizes(opal_convertor_t* pConvertor);
+
 END_C_DECLS
 
 #endif  /* OPAL_CONVERTOR_H_HAS_BEEN_INCLUDED */
diff --git a/opal/datatype/opal_datatype.h b/opal/datatype/opal_datatype.h
@@ -101,6 +101,18 @@ struct dt_type_desc_t {
 };
 typedef struct dt_type_desc_t dt_type_desc_t;
 
+/*
+ *  ptypes structure
+ *
+ *  There used to just be a ptypes[] array that was a count of how
+ *  many of each base OPAL_DATATYPE_ was in a given datatype.  This
+ *  keeps that but adds another field for the total external32size
+ *  of all those types combined.
+ */
+typedef struct {
+    size_t bdt_count[OPAL_DATATYPE_MAX_SUPPORTED];
+    size_t external32size;
+} ptypes_t;
 
 /*
  * The datatype description.
@@ -127,7 +139,7 @@ struct opal_datatype_t {
     dt_type_desc_t     opt_desc; /**< short description of the data used when conversion is useless
                                       or in the send case (without conversion) */
 
-    size_t             *ptypes;  /**< array of basic predefined types that facilitate the computing
+    ptypes_t           *ptypes;  /**< array of basic predefined types that facilitate the computing
                                       of the remote size in heterogeneous environments. The length of the
                                       array is dependent on the maximum number of predefined datatypes of
                                       all language interfaces (because Fortran is not known at the OPAL
@@ -316,7 +328,7 @@ OPAL_DECLSPEC int32_t
 opal_datatype_copy_content_same_ddt( const opal_datatype_t* pData, int32_t count,
                                      char* pDestBuf, char* pSrcBuf );
 
-OPAL_DECLSPEC int opal_datatype_compute_ptypes( opal_datatype_t* datatype );
+OPAL_DECLSPEC int opal_datatype_compute_ptypes( opal_datatype_t* datatype, const size_t* sizes );
 
 /* Compute the span in memory of count datatypes. This function help with temporary
  * memory allocations for receiving already typed data (such as those used for reduce
@@ -341,6 +353,13 @@ opal_datatype_span( const opal_datatype_t* pData, size_t count,
     return true_extent + extent * (count - 1);
 }
 
+/*
+ * For use with the bottom level MPI datatypes
+ * Set the .external32size field in the datatype's
+ * description[].elem.common entry
+ */
+int opal_datatype_set_external32_size(opal_datatype_t *pData, int e32sz);
+
 #if OPAL_ENABLE_DEBUG
 /*
  * Set a breakpoint to this function in your favorite debugger
diff --git a/opal/datatype/opal_datatype_add.c b/opal/datatype/opal_datatype_add.c
@@ -279,11 +279,14 @@ int32_t opal_datatype_add( opal_datatype_t* pdtBase, const opal_datatype_t* pdtA
      * predefined non contiguous datatypes (like MPI_SHORT_INT).
      */
     if( (pdtAdd->flags & (OPAL_DATATYPE_FLAG_PREDEFINED | OPAL_DATATYPE_FLAG_DATA)) == (OPAL_DATATYPE_FLAG_PREDEFINED | OPAL_DATATYPE_FLAG_DATA) ) {
-        if( NULL != pdtBase->ptypes )
-            pdtBase->ptypes[pdtAdd->id] += count;
+        if( NULL != pdtBase->ptypes ) {
+            pdtBase->ptypes->bdt_count[pdtAdd->id] += count;
+            pdtBase->ptypes->external32size += count * pdtAdd->desc.desc->elem.common.external32size;
+        }
 
         pLast->elem.common.flags     = pdtAdd->flags & ~(OPAL_DATATYPE_FLAG_COMMITTED);
         pLast->elem.common.type      = pdtAdd->id;
+        pLast->elem.common.external32size = pdtAdd->desc.desc->elem.common.external32size;
         pLast->elem.disp             = disp;
         pLast->elem.extent           = (ptrdiff_t)count * extent;
         /* assume predefined datatypes without extent, aka. contiguous */
@@ -305,7 +308,12 @@ int32_t opal_datatype_add( opal_datatype_t* pdtBase, const opal_datatype_t* pdtA
         pdtBase->flags |= (pdtAdd->flags & OPAL_DATATYPE_FLAG_USER_UB);
         if( (NULL != pdtBase->ptypes) && (NULL != pdtAdd->ptypes) ) {
             for( i = OPAL_DATATYPE_FIRST_TYPE; i < OPAL_DATATYPE_MAX_PREDEFINED; i++ )
-                if( pdtAdd->ptypes[i] != 0 ) pdtBase->ptypes[i] += (count * pdtAdd->ptypes[i]);
+                if( pdtAdd->ptypes->bdt_count[i] != 0 ) pdtBase->ptypes->bdt_count[i] += (count * pdtAdd->ptypes->bdt_count[i]); 
+            pdtBase->ptypes->external32size += pdtAdd->ptypes->external32size;
+        } else if (NULL != pdtBase->ptypes) {
+            /* (We had ptypes data but didn't update it, must invalidate) */
+            free(pdtBase->ptypes);
+            pdtBase->ptypes = NULL;
         }
         if( 1 == pdtAdd->desc.used ) {
             pLast->elem        = pdtAdd->desc.desc[0].elem;
diff --git a/opal/datatype/opal_datatype_dump.c b/opal/datatype/opal_datatype_dump.c
@@ -50,7 +50,7 @@ int opal_datatype_contain_basic_datatypes( const opal_datatype_t* pData, char* p
                 index += snprintf( ptr + index, length - index, "%s:* ", opal_datatype_basicDatatypes[i]->name );
             } else {
                 index += snprintf( ptr + index, length - index, "%s:%" PRIsize_t " ", opal_datatype_basicDatatypes[i]->name,
-                                   pData->ptypes[i]);
+                                   pData->ptypes->bdt_count[i]);
             }
         }
         mask <<= 1;
diff --git a/opal/datatype/opal_datatype_get_count.c b/opal/datatype/opal_datatype_get_count.c
@@ -150,16 +150,23 @@ int32_t opal_datatype_set_element_count( const opal_datatype_t* datatype, size_t
  * when we use get_element_count). Thus, we will pay the cost once per
  * datatype, but we will only update this array if/when needed.
  */
-int opal_datatype_compute_ptypes( opal_datatype_t* datatype )
+int opal_datatype_compute_ptypes( opal_datatype_t* datatype , const size_t *sizes )
 {
     dt_stack_t* pStack;   /* pointer to the position on the stack */
     uint32_t pos_desc;    /* actual position in the description of the derived datatype */
     ssize_t nbElems = 0, stack_pos = 0;
     dt_elem_desc_t* pElems;
 
     if( NULL != datatype->ptypes ) return 0;
-    datatype->ptypes = (size_t*)calloc(OPAL_DATATYPE_MAX_SUPPORTED, sizeof(size_t));
+    datatype->ptypes = (ptypes_t*)calloc(1, sizeof(ptypes_t));
 
+/*
+ *  The ptypes.bdt_count[] entries don't have enough information to later figure out
+ *  what the remote size of the packed data would be.  If the datatype is
+ *  2 MPI_LONG, those counts will only tell us it's 2 OPAL_DATATYPE_UINT8_T.
+ *  So the new field .external32size represents the total external32size of all
+ *  the entries that were entered into bdt_count[]
+ */
     DUMP( "opal_datatype_compute_ptypes( %p )\n", (void*)datatype );
     pStack = (dt_stack_t*)alloca( sizeof(dt_stack_t) * (datatype->loops + 2) );
     pStack->count    = 1;
@@ -188,11 +195,18 @@ int opal_datatype_compute_ptypes( opal_datatype_t* datatype )
         }
         while( pElems[pos_desc].elem.common.flags & OPAL_DATATYPE_FLAG_DATA ) {
             /* now here we have a basic datatype */
-            datatype->ptypes[pElems[pos_desc].elem.common.type] += (size_t)pElems[pos_desc].elem.count * pElems[pos_desc].elem.blocklen;
-            nbElems += (size_t)pElems[pos_desc].elem.count * pElems[pos_desc].elem.blocklen;
+            size_t mycount = (size_t)pElems[pos_desc].elem.count * pElems[pos_desc].elem.blocklen;
+            datatype->ptypes->bdt_count[pElems[pos_desc].elem.common.type] += mycount;
+            nbElems += mycount;
+
+            size_t _r_blength = sizes[pElems[pos_desc].elem.common.type];
+            if (pElems[pos_desc].elem.common.external32size != 0) {
+                _r_blength = pElems[pos_desc].elem.common.external32size;
+            }
+            datatype->ptypes->external32size += _r_blength * mycount;
 
             DUMP( "  compute_ptypes-add: type %d count %"PRIsize_t" (total type %u total %lld)\n",
-                  pElems[pos_desc].elem.common.type, datatype->ptypes[pElems[pos_desc].elem.common.type],
+                  pElems[pos_desc].elem.common.type, datatype->ptypes->bdt_count[pElems[pos_desc].elem.common.type],
                   pElems[pos_desc].elem.count, nbElems );
             pos_desc++;  /* advance to the next data */
         }
diff --git a/opal/datatype/opal_datatype_internal.h b/opal/datatype/opal_datatype_internal.h
@@ -149,6 +149,7 @@ BEGIN_C_DECLS
 struct ddt_elem_id_description {
     uint16_t   flags;  /**< flags for the record */
     uint16_t   type;   /**< the basic data type id */
+    signed char external32size;
 };
 typedef struct ddt_elem_id_description ddt_elem_id_description;
 
@@ -254,7 +255,10 @@ struct opal_datatype_t;
  */
 
 #define OPAL_DATATYPE_INIT_PTYPES_ARRAY_UNAVAILABLE NULL
-#define OPAL_DATATYPE_INIT_PTYPES_ARRAY(NAME) (size_t[OPAL_DATATYPE_MAX_PREDEFINED]){ [OPAL_DATATYPE_ ## NAME] = 1, [OPAL_DATATYPE_MAX_PREDEFINED-1] = 0 }
+#define OPAL_DATATYPE_INIT_PTYPES_ARRAY(NAME, SZ) &(ptypes_t) { \
+        .bdt_count = { [OPAL_DATATYPE_ ## NAME] = 1, [OPAL_DATATYPE_MAX_PREDEFINED-1] = 0}, \
+        .external32size = (SZ) /* opal_datatype_set_external32_size can reset */ \
+    }
 
 #define OPAL_DATATYPE_INIT_NAME(NAME) "OPAL_" #NAME
 
@@ -266,6 +270,7 @@ struct opal_datatype_t;
 #define OPAL_DATATYPE_INIT_DESC_PREDEFINED(NAME)                                     \
     {                                                                                \
         .length = 1, .used = 1,                                                      \
+        /*.desc = &(opal_datatype_predefined_elem_desc[2 * OPAL_DATATYPE_ ## NAME]) */   \
         .desc = &(opal_datatype_predefined_elem_desc[2 * OPAL_DATATYPE_ ## NAME])    \
     }
 #define OPAL_DATATYPE_INIT_DESC_NULL  {.length = 0, .used = 0, .desc = NULL}
diff --git a/opal/datatype/opal_datatype_pack.c b/opal/datatype/opal_datatype_pack.c
@@ -400,6 +400,9 @@ pack_predefined_heterogeneous( opal_convertor_t* CONVERTOR,
     size_t _r_blength;
 
     _r_blength = master->remote_sizes[_elem->common.type];
+    if (_elem->common.external32size != 0) {
+        _r_blength = _elem->common.external32size;
+    }
     if( (_count * _r_blength) > *(SPACE) ) {
         _count = (*(SPACE) / _r_blength);
         if( 0 == _count ) return;  /* nothing to do */
diff --git a/opal/datatype/opal_datatype_setexternal32.c b/opal/datatype/opal_datatype_setexternal32.c
@@ -0,0 +1,46 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2020      IBM Corporation.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+
+#include <stddef.h>
+
+#include "opal/runtime/opal.h"
+#include "opal/util/arch.h"
+#include "opal/util/output.h"
+#include "opal/datatype/opal_datatype_internal.h"
+#include "opal/datatype/opal_datatype.h"
+#include "opal/datatype/opal_convertor_internal.h"
+#include "opal/mca/base/mca_base_var.h"
+
+int
+opal_datatype_set_external32_size(opal_datatype_t *pData, int e32sz)
+{
+    dt_elem_desc_t* p, *popt;
+    p = pData->desc.desc;
+    popt = pData->opt_desc.desc;
+
+    dt_elem_desc_t *new = malloc(2 * sizeof(dt_elem_desc_t));
+    if (!new) { return -1; }
+
+    memcpy(new, p, 2 * sizeof(dt_elem_desc_t));
+    pData->desc.desc = new;
+    if (popt == p) {
+        pData->opt_desc.desc = new;
+    }
+
+    pData->desc.desc[0].elem.common.external32size = e32sz;
+
+    if (pData->ptypes) {
+        pData->ptypes->external32size = e32sz;
+    }
+
+    return OPAL_SUCCESS;
+}
diff --git a/opal/datatype/opal_datatype_unpack.c b/opal/datatype/opal_datatype_unpack.c
@@ -489,6 +489,9 @@ opal_unpack_general_function( opal_convertor_t* pConvertor,
                 size_t elements_done;
                 elements_done = pElem->elem.count * pElem->elem.blocklen - count_desc;
                 size_t _r_blength = master->remote_sizes[type];
+                if (pElem->elem.common.external32size != 0) {
+                    _r_blength = pElem->elem.common.external32size;
+                }
                 rc = master->pFunctions[type]( pConvertor, COPY_TO_VECTOR,
                                                (char*)conv_ptr,
                                                &pElem->elem,

Original file line number	Diff line number	Diff line change
`@@ -49,10 +49,10 @@ int ompi_datatype_get_elements (ompi_datatype_t *datatype, size_t ucount, size_t`
`49`	`49`	`there are no leftover bytes */`
`50`	`50`	`if (!ompi_datatype_is_predefined(datatype)) {`
`51`	`51`	`if (0 != internal_count) {`
`52`		`- opal_datatype_compute_ptypes(&datatype->super);`
	`52`	`+ opal_datatype_compute_ptypes(&datatype->super, opal_convertor_get_remote_sizes(ompi_mpi_external32_convertor));`
`53`	`53`	`/* count the basic elements in the datatype */`
`54`	`54`	`for (i = OPAL_DATATYPE_FIRST_TYPE, total = 0 ; i < OPAL_DATATYPE_MAX_PREDEFINED ; ++i) {`
`55`		`- total += datatype->super.ptypes[i];`
	`55`	`+ total += datatype->super.ptypes->bdt_count[i];`
`56`	`56`	`}`
`57`	`57`	`internal_count = total * internal_count;`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -663,6 +663,9 @@ int32_t ompi_datatype_init( void )`
`663`	`663`	`}`
`664`	`664`	`}`
`665`	`665`	`ompi_datatype_default_convertors_init();`
	`666`	`+`
	`667`	`+ ompi_set_external32_sizes();`
	`668`	`+`
`666`	`669`	`return OMPI_SUCCESS;`
`667`	`670`	`}`
`668`	`671`
Original file line number	Diff line number	Diff line change
`@@ -461,21 +461,27 @@ opal_datatype_compute_remote_size( const opal_datatype_t* pData,`
`461`	`461`	`size_t length = 0;`
`462`	`462`
`463`	`463`	`if (opal_datatype_is_predefined(pData)) {`
	`464`	`+ if (pData->desc.desc->elem.common.external32size != 0) {`
	`465`	`+ return pData->desc.desc->elem.common.external32size;`
	`466`	`+ }`
`464`	`467`	`return sizes[pData->desc.desc->elem.common.type];`
`465`	`468`	`}`
`466`	`469`
`467`	`470`	`if( OPAL_UNLIKELY(NULL == pData->ptypes) ) {`
`468`	`471`	`/* Allocate and fill the array of types used in the datatype description */`
`469`		`- opal_datatype_compute_ptypes( (opal_datatype_t*)pData );`
	`472`	`+ opal_datatype_compute_ptypes( (opal_datatype_t*)pData , sizes );`
`470`	`473`	`}`
	`474`	`+ return pData->ptypes->external32size;`
`471`	`475`
	`476`	`+#if 0`
`472`	`477`	`for( int i = OPAL_DATATYPE_FIRST_TYPE; typeMask && (i < OPAL_DATATYPE_MAX_PREDEFINED); i++ ) {`
`473`	`478`	`if( typeMask & ((uint32_t)1 << i) ) {`
`474`	`479`	`length += (pData->ptypes[i] * sizes[i]);`
`475`	`480`	`typeMask ^= ((uint32_t)1 << i);`
`476`	`481`	`}`
`477`	`482`	`}`
`478`	`483`	`return length;`
	`484`	`+#endif`
`479`	`485`	`}`
`480`	`486`
`481`	`487`	`/**`
`@@ -772,3 +778,9 @@ void opal_datatype_dump_stack( const dt_stack_t* pStack, int stack_pos,`
`772`	`778`	`}`
`773`	`779`	`opal_output( 0, "\n" );`
`774`	`780`	`}`
	`781`	`+`
	`782`	`+size_t*`
	`783`	`+opal_convertor_get_remote_sizes(opal_convertor_t* pConvertor)`
	`784`	`+{`
	`785`	`+ return pConvertor->master->remote_sizes;`
	`786`	`+}`