Update the datatype dump to match the actual types.

Update the comments to better reflect what is going on.
Minor indentations.

Signed-off-by: George Bosilca <bosilca@icl.utk.edu>

Author: bosilca

ompi/datatype/ompi_datatype_module.c

@@ -3,7 +3,7 @@
  * Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
  *                         University Research and Technology
  *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2017 The University of Tennessee and The University
+ * 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,
@@ -759,14 +759,14 @@ void ompi_datatype_dump( const ompi_datatype_t* pData )
     length = length * 100 + 500;
     buffer = (char*)malloc( length );
     index += snprintf( buffer, length - index,
-                       "Datatype %p[%s] id %d size %ld align %d opal_id %d length %d used %d\n"
-                       "true_lb %ld true_ub %ld (true_extent %ld) lb %ld ub %ld (extent %ld)\n"
-                       "nbElems %d loops %d flags %X (",
-                     (void*)pData, pData->name, pData->id,
-                     (long)pData->super.size, (int)pData->super.align, pData->super.id, (int)pData->super.desc.length, (int)pData->super.desc.used,
-                     (long)pData->super.true_lb, (long)pData->super.true_ub, (long)(pData->super.true_ub - pData->super.true_lb),
-                     (long)pData->super.lb, (long)pData->super.ub, (long)(pData->super.ub - pData->super.lb),
-                     (int)pData->super.nbElems, (int)pData->super.loops, (int)pData->super.flags );
+                       "Datatype %p[%s] id %d size %" PRIsize_t " align %u opal_id %u length %" PRIsize_t " used %" PRIsize_t "\n"
+                       "true_lb %td true_ub %td (true_extent %td) lb %td ub %td (extent %td)\n"
+                       "nbElems %" PRIsize_t " loops %u flags %X (",
+                       (void*)pData, pData->name, pData->id,
+                       pData->super.size, pData->super.align, (uint32_t)pData->super.id, pData->super.desc.length, pData->super.desc.used,
+                       pData->super.true_lb, pData->super.true_ub, pData->super.true_ub - pData->super.true_lb,
+                       pData->super.lb, pData->super.ub, pData->super.ub - pData->super.lb,
+                       pData->super.nbElems, pData->super.loops, (int)pData->super.flags );
     /* dump the flags */
     if( ompi_datatype_is_predefined(pData) ) {
         index += snprintf( buffer + index, length - index, "predefined " );

opal/datatype/opal_convertor.c

@@ -3,7 +3,7 @@
  * Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
  *                         University Research and Technology
  *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2017 The University of Tennessee and The University
+ * Copyright (c) 2004-2018 The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
  * Copyright (c) 2004-2006 High Performance Computing Center Stuttgart,
@@ -699,12 +699,12 @@ int opal_convertor_clone( const opal_convertor_t* source,
 
 void opal_convertor_dump( opal_convertor_t* convertor )
 {
-    opal_output( 0, "Convertor %p count %" PRIsize_t" stack position %d bConverted %" PRIsize_t "\n"
-                 "\tlocal_size %ld remote_size %ld flags %X stack_size %d pending_length %" PRIsize_t "\n"
+    opal_output( 0, "Convertor %p count %" PRIsize_t " stack position %u bConverted %" PRIsize_t "\n"
+                 "\tlocal_size %" PRIsize_t " remote_size %" PRIsize_t " flags %X stack_size %u pending_length %" PRIsize_t "\n"
                  "\tremote_arch %u local_arch %u\n",
                  (void*)convertor,
                  convertor->count, convertor->stack_pos, convertor->bConverted,
-                 (unsigned long)convertor->local_size, (unsigned long)convertor->remote_size,
+                 convertor->local_size, convertor->remote_size,
                  convertor->flags, convertor->stack_size, convertor->partial_length,
                  convertor->remoteArch, opal_local_arch );
     if( convertor->flags & CONVERTOR_RECV ) opal_output( 0, "unpack ");

opal/datatype/opal_convertor_raw.c

@@ -32,13 +32,13 @@
 
 /**
  * This function always work in local representation. This means no representation
- * conversion (i.e. no heterogeneity) has to be taken into account, and that all
+ * conversion (i.e. no heterogeneity) is taken into account, and that all
  * length we're working on are local.
  */
 int32_t
 opal_convertor_raw( opal_convertor_t* pConvertor,
-		    struct iovec* iov, uint32_t* iov_count,
-		    size_t* length )
+                    struct iovec* iov, uint32_t* iov_count,
+                    size_t* length )
 {
     const opal_datatype_t *pData = pConvertor->pDesc;
     dt_stack_t* pStack;       /* pointer to the position on the stack */
@@ -77,9 +77,9 @@ opal_convertor_raw( opal_convertor_t* pConvertor,
     description = pConvertor->use_desc->desc;
 
     /* For the first step we have to add both displacement to the source. After in the
-    * main while loop we will set back the source_base to the correct value. This is
-    * due to the fact that the convertor can stop in the middle of a data with a count
-    */
+     * main while loop we will set back the source_base to the correct value. This is
+     * due to the fact that the convertor can stop in the middle of a data with a count
+     */
     pStack = pConvertor->pStack + pConvertor->stack_pos;
     pos_desc     = pStack->index;
     source_base  = pConvertor->pBaseBuf + pStack->disp;
@@ -101,9 +101,9 @@ opal_convertor_raw( opal_convertor_t* pConvertor,
                     blength *= count_desc;
                     /* now here we have a basic datatype */
                     OPAL_DATATYPE_SAFEGUARD_POINTER( source_base, blength, pConvertor->pBaseBuf,
-                                                pConvertor->pDesc, pConvertor->count );
+                                                     pConvertor->pDesc, pConvertor->count );
                     DO_DEBUG( opal_output( 0, "raw 1. iov[%d] = {base %p, length %" PRIsize_t "}\n",
-                                           index, (void*)source_base, (unsigned long)blength ); );
+                                           index, (void*)source_base, blength ); );
                     iov[index].iov_base = (IOVBASE_TYPE *) source_base;
                     iov[index].iov_len  = blength;
                     source_base += blength;
@@ -114,9 +114,9 @@ opal_convertor_raw( opal_convertor_t* pConvertor,
             } else {
                 for(size_t i = count_desc; (i > 0) && (index < *iov_count); i--, index++ ) {
                     OPAL_DATATYPE_SAFEGUARD_POINTER( source_base, blength, pConvertor->pBaseBuf,
-                                                pConvertor->pDesc, pConvertor->count );
+                                                     pConvertor->pDesc, pConvertor->count );
                     DO_DEBUG( opal_output( 0, "raw 2. iov[%d] = {base %p, length %" PRIsize_t "}\n",
-                                           index, (void*)source_base, (unsigned long)blength ); );
+                                           index, (void*)source_base, blength ); );
                     iov[index].iov_base = (IOVBASE_TYPE *) source_base;
                     iov[index].iov_len  = blength;
                     source_base += pElem->elem.extent;
@@ -141,8 +141,8 @@ opal_convertor_raw( opal_convertor_t* pConvertor,
             if( --(pStack->count) == 0 ) { /* end of loop */
                 if( pConvertor->stack_pos == 0 ) {
                     /* we lie about the size of the next element in order to
-                    * make sure we exit the main loop.
-                    */
+                     * make sure we exit the main loop.
+                     */
                     *iov_count = index;
                     goto complete_loop;  /* completed */
                 }
@@ -174,7 +174,7 @@ opal_convertor_raw( opal_convertor_t* pConvertor,
                 source_base += offset;
                 for(size_t i = MIN(count_desc, *iov_count - index); i > 0; i--, index++ ) {
                     OPAL_DATATYPE_SAFEGUARD_POINTER( source_base, end_loop->size, pConvertor->pBaseBuf,
-                                                pConvertor->pDesc, pConvertor->count );
+                                                     pConvertor->pDesc, pConvertor->count );
                     iov[index].iov_base = (IOVBASE_TYPE *) source_base;
                     iov[index].iov_len  = end_loop->size;
                     source_base += pElem->loop.extent;
@@ -198,14 +198,14 @@ opal_convertor_raw( opal_convertor_t* pConvertor,
             PUSH_STACK( pStack, pConvertor->stack_pos, pos_desc, OPAL_DATATYPE_LOOP, count_desc,
                         pStack->disp + local_disp);
             pos_desc++;
-          update_loop_description:  /* update the current state */
+        update_loop_description:  /* update the current state */
             source_base = pConvertor->pBaseBuf + pStack->disp;
             UPDATE_INTERNAL_COUNTERS( description, pos_desc, pElem, count_desc );
             DDT_DUMP_STACK( pConvertor->pStack, pConvertor->stack_pos, pElem, "advance loop" );
             continue;
         }
     }
-complete_loop:
+ complete_loop:
     pConvertor->bConverted += raw_data;  /* update the already converted bytes */
     *length = raw_data;
     *iov_count = index;

opal/datatype/opal_datatype_dump.c

@@ -3,7 +3,7 @@
  * Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
  *                         University Research and Technology
  *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2017 The University of Tennessee and The University
+ * 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,
@@ -64,7 +64,7 @@ int opal_datatype_dump_data_flags( unsigned short usflags, char* ptr, size_t len
     int index = 0;
     if( length < 22 ) return 0;
     index = snprintf( ptr, 22, "-----------[---][---]" );  /* set everything to - */
-    if( usflags & OPAL_DATATYPE_FLAG_COMMITTED )   ptr[1]  = 'c';
+    if( usflags & OPAL_DATATYPE_FLAG_COMMITTED )  ptr[1]  = 'c';
     if( usflags & OPAL_DATATYPE_FLAG_CONTIGUOUS ) ptr[2]  = 'C';
     if( usflags & OPAL_DATATYPE_FLAG_OVERLAP )    ptr[3]  = 'o';
     if( usflags & OPAL_DATATYPE_FLAG_USER_LB )    ptr[4]  = 'l';
@@ -90,17 +90,17 @@ int opal_datatype_dump_data_desc( dt_elem_desc_t* pDesc, int nbElems, char* ptr,
         index += snprintf( ptr + index, length - index, "%15s ", opal_datatype_basicDatatypes[pDesc->elem.common.type]->name );
         if( length <= (size_t)index ) break;
         if( OPAL_DATATYPE_LOOP == pDesc->elem.common.type )
-            index += snprintf( ptr + index, length - index, "%d times the next %d elements extent %d\n",
-                               (int)pDesc->loop.loops, (int)pDesc->loop.items,
-                               (int)pDesc->loop.extent );
+            index += snprintf( ptr + index, length - index, "%u times the next %u elements extent %td\n",
+                               pDesc->loop.loops, pDesc->loop.items,
+                               pDesc->loop.extent );
         else if( OPAL_DATATYPE_END_LOOP == pDesc->elem.common.type )
-            index += snprintf( ptr + index, length - index, "prev %d elements first elem displacement %ld size of data %d\n",
-                           (int)pDesc->end_loop.items, (long)pDesc->end_loop.first_elem_disp,
-                           (int)pDesc->end_loop.size );
+            index += snprintf( ptr + index, length - index, "prev %u elements first elem displacement %td size of data %" PRIsize_t "\n",
+                               pDesc->end_loop.items, pDesc->end_loop.first_elem_disp,
+                               pDesc->end_loop.size );
         else
-            index += snprintf( ptr + index, length - index, "count %" PRIsize_t " disp 0x%lx (%ld) blen %d extent %ld (size %ld)\n",
-                               pDesc->elem.count, (long)pDesc->elem.disp, (long)pDesc->elem.disp, (int)pDesc->elem.blocklen,
-                               pDesc->elem.extent, (long)(pDesc->elem.count * opal_datatype_basicDatatypes[pDesc->elem.common.type]->size) );
+            index += snprintf( ptr + index, length - index, "count %" PRIsize_t " disp 0x%tx (%td) blen %u extent %td (size %zd)\n",
+                               pDesc->elem.count, pDesc->elem.disp, pDesc->elem.disp, pDesc->elem.blocklen,
+                               pDesc->elem.extent, (pDesc->elem.count * pDesc->elem.blocklen * opal_datatype_basicDatatypes[pDesc->elem.common.type]->size) );
         pDesc++;
 
         if( length <= (size_t)index ) break;
@@ -118,13 +118,13 @@ void opal_datatype_dump( const opal_datatype_t* pData )
     length = pData->opt_desc.used + pData->desc.used;
     length = length * 100 + 500;
     buffer = (char*)malloc( length );
-    index += snprintf( buffer, length - index, "Datatype %p[%s] size %ld align %d id %d length %d used %d\n"
-                                               "true_lb %ld true_ub %ld (true_extent %ld) lb %ld ub %ld (extent %ld)\n"
-                                               "nbElems %" PRIsize_t " loops %d flags %X (",
-                     (void*)pData, pData->name, (long)pData->size, (int)pData->align, pData->id, (int)pData->desc.length, (int)pData->desc.used,
-                     (long)pData->true_lb, (long)pData->true_ub, (long)(pData->true_ub - pData->true_lb),
-                     (long)pData->lb, (long)pData->ub, (long)(pData->ub - pData->lb),
-                     pData->nbElems, (int)pData->loops, (int)pData->flags );
+    index += snprintf( buffer, length - index, "Datatype %p[%s] size %" PRIsize_t " align %u id %u length %" PRIsize_t " used %" PRIsize_t "\n"
+                                               "true_lb %td true_ub %td (true_extent %td) lb %td ub %td (extent %td)\n"
+                                               "nbElems %" PRIsize_t " loops %u flags %X (",
+                       (void*)pData, pData->name, pData->size, pData->align, (uint32_t)pData->id, pData->desc.length, pData->desc.used,
+                       pData->true_lb, pData->true_ub, pData->true_ub - pData->true_lb,
+                       pData->lb, pData->ub, pData->ub - pData->lb,
+                       pData->nbElems, pData->loops, (int)pData->flags );
     /* dump the flags */
     if( pData->flags == OPAL_DATATYPE_FLAG_PREDEFINED )
         index += snprintf( buffer + index, length - index, "predefined " );