opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v20/pack.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
pmix20_bfrop_pack
pmix20_bfrop_pack_buffer
pmix20_bfrop_pack_bool
pmix20_bfrop_pack_int
pmix20_bfrop_pack_sizet
pmix20_bfrop_pack_pid
pmix20_bfrop_pack_byte
pmix20_bfrop_pack_int16
pmix20_bfrop_pack_int32
pmix20_bfrop_pack_datatype
pmix20_bfrop_pack_int64
pmix20_bfrop_pack_string
pmix20_bfrop_pack_float
pmix20_bfrop_pack_double
pmix20_bfrop_pack_timeval
pmix20_bfrop_pack_time
pmix20_bfrop_pack_status
pack_val
pmix20_bfrop_pack_value
pmix20_bfrop_pack_info
pmix20_bfrop_pack_pdata
pmix20_bfrop_pack_buf
pmix20_bfrop_pack_proc
pmix20_bfrop_pack_app
pmix20_bfrop_pack_kval
pmix20_bfrop_pack_modex
pmix20_bfrop_pack_persist
pmix20_bfrop_pack_scope
pmix20_bfrop_pack_range
pmix20_bfrop_pack_cmd
pmix20_bfrop_pack_infodirs
pmix20_bfrop_pack_bo
pmix20_bfrop_pack_ptr
pmix20_bfrop_pack_pstate
pmix20_bfrop_pack_pinfo
pmix20_bfrop_pack_darray
pmix20_bfrop_pack_rank
pmix20_bfrop_pack_query
pmix20_bfrop_pack_alloc_directive
pmix20_bfrop_pack_array
   1 /*
   2  * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2007 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2011-2013 Cisco Systems, Inc.  All rights reserved.
  13  * Copyright (c) 2014-2018 Intel, Inc.  All rights reserved.
  14  * Copyright (c) 2015-2019 Research Organization for Information Science
  15  *                         and Technology (RIST).  All rights reserved.
  16  * Copyright (c) 2016-2019 Mellanox Technologies, Inc.
  17  *                         All rights reserved.
  18  * Copyright (c) 2016      IBM Corporation.  All rights reserved.
  19  * $COPYRIGHT$
  20  *
  21  * Additional copyrights may follow
  22  *
  23  * $HEADER$
  24  */
  25 
  26 #include <src/include/pmix_config.h>
  27 
  28 #ifdef HAVE_ARPA_INET_H
  29 #include <arpa/inet.h>
  30 #endif
  31 
  32 #include "src/util/argv.h"
  33 #include "src/util/error.h"
  34 #include "src/util/output.h"
  35 #include "src/mca/bfrops/base/base.h"
  36 #include "bfrop_pmix20.h"
  37 #include "internal.h"
  38 
  39 pmix_status_t pmix20_bfrop_pack(pmix_buffer_t *buffer,
  40                                 const void *src, int32_t num_vals,
  41                                 pmix_data_type_t type)
  42  {
  43     pmix_status_t rc;
  44     pmix_pointer_array_t *regtypes = &mca_bfrops_v20_component.types;
  45 
  46     /* check for error */
  47     if (NULL == buffer) {
  48         return PMIX_ERR_BAD_PARAM;
  49     }
  50 
  51     /* Pack the number of values */
  52     if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
  53         if (PMIX_SUCCESS != (rc = pmix20_bfrop_store_data_type(regtypes, buffer,
  54                                                                PMIX_INT32))) {
  55             return rc;
  56         }
  57     }
  58     if (PMIX_SUCCESS != (rc = pmix20_bfrop_pack_int32(regtypes, buffer,
  59                                                       &num_vals, 1, PMIX_INT32))) {
  60         return rc;
  61     }
  62 
  63     /* Pack the value(s) */
  64     return pmix20_bfrop_pack_buffer(regtypes, buffer, src, num_vals, type);
  65 }
  66 
  67 pmix_status_t pmix20_bfrop_pack_buffer(pmix_pointer_array_t *regtypes,
  68                                        pmix_buffer_t *buffer,
  69                                        const void *src, int32_t num_vals,
  70                                        pmix_data_type_t type)
  71 {
  72     pmix_data_type_t v20type;
  73     pmix_status_t rc;
  74     pmix_bfrop_type_info_t *info;
  75 
  76     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
  77                         "pmix20_bfrop_pack_buffer( %p, %p, %lu, %d )\n",
  78                         (void*)buffer, src, (long unsigned int)num_vals, (int)type);
  79 
  80     /* some v20 types are simply declared differently */
  81     switch (type) {
  82         case PMIX_COMMAND:
  83             v20type = PMIX_UINT32;
  84             break;
  85         default:
  86             v20type = type;
  87     }
  88 
  89     /* Pack the declared data type */
  90     if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
  91         if (PMIX_SUCCESS != (rc = pmix20_bfrop_store_data_type(regtypes, buffer, v20type))) {
  92             return rc;
  93         }
  94     }
  95 
  96     /* Lookup the pack function for this type and call it */
  97 
  98     if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v20_component.types, v20type))) {
  99         return PMIX_ERR_PACK_FAILURE;
 100     }
 101 
 102     return info->odti_pack_fn(regtypes, buffer, src, num_vals, v20type);
 103 }
 104 
 105 
 106 /* PACK FUNCTIONS FOR GENERIC SYSTEM TYPES */
 107 
 108 /*
 109  * BOOL
 110  */
 111 pmix_status_t pmix20_bfrop_pack_bool(pmix_pointer_array_t *regtypes,
 112                                      pmix_buffer_t *buffer, const void *src,
 113                                      int32_t num_vals, pmix_data_type_t type)
 114  {
 115     uint8_t *dst;
 116     int32_t i;
 117     bool *s = (bool*)src;
 118 
 119     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 120                         "pmix20_bfrop_pack_bool * %d\n", num_vals);
 121     /* check to see if buffer needs extending */
 122     if (NULL == (dst = (uint8_t*)pmix_bfrop_buffer_extend(buffer, num_vals))) {
 123         return PMIX_ERR_OUT_OF_RESOURCE;
 124     }
 125 
 126     /* store the data */
 127     for (i=0; i < num_vals; i++) {
 128         if (s[i]) {
 129             dst[i] = 1;
 130         } else {
 131             dst[i] = 0;
 132         }
 133     }
 134 
 135     /* update buffer pointers */
 136     buffer->pack_ptr += num_vals;
 137     buffer->bytes_used += num_vals;
 138 
 139     return PMIX_SUCCESS;
 140 }
 141 
 142 /*
 143  * INT
 144  */
 145 pmix_status_t pmix20_bfrop_pack_int(pmix_pointer_array_t *regtypes,
 146                                     pmix_buffer_t *buffer, const void *src,
 147                                     int32_t num_vals, pmix_data_type_t type)
 148  {
 149     pmix_status_t ret;
 150 
 151     /* System types need to always be described so we can properly
 152        unpack them */
 153     if (PMIX_SUCCESS != (ret = pmix20_bfrop_store_data_type(regtypes, buffer, BFROP_TYPE_INT))) {
 154         return ret;
 155     }
 156 
 157     /* Turn around and pack the real type */
 158     return pmix20_bfrop_pack_buffer(regtypes, buffer, src, num_vals, BFROP_TYPE_INT);
 159 }
 160 
 161 /*
 162  * SIZE_T
 163  */
 164 pmix_status_t pmix20_bfrop_pack_sizet(pmix_pointer_array_t *regtypes,
 165                                       pmix_buffer_t *buffer, const void *src,
 166                                       int32_t num_vals, pmix_data_type_t type)
 167  {
 168     pmix_status_t ret;
 169 
 170     /* System types need to always be described so we can properly
 171        unpack them. */
 172     if (PMIX_SUCCESS != (ret = pmix20_bfrop_store_data_type(regtypes, buffer, BFROP_TYPE_SIZE_T))) {
 173         return ret;
 174     }
 175 
 176     return pmix20_bfrop_pack_buffer(regtypes, buffer, src, num_vals, BFROP_TYPE_SIZE_T);
 177 }
 178 
 179 /*
 180  * PID_T
 181  */
 182 pmix_status_t pmix20_bfrop_pack_pid(pmix_pointer_array_t *regtypes,
 183                                     pmix_buffer_t *buffer, const void *src,
 184                                     int32_t num_vals, pmix_data_type_t type)
 185  {
 186     pmix_status_t ret;
 187 
 188     /* System types need to always be described so we can properly
 189        unpack them. */
 190     if (PMIX_SUCCESS != (ret = pmix20_bfrop_store_data_type(regtypes, buffer, BFROP_TYPE_PID_T))) {
 191         return ret;
 192     }
 193 
 194     /* Turn around and pack the real type */
 195     return pmix20_bfrop_pack_buffer(regtypes, buffer, src, num_vals, BFROP_TYPE_PID_T);
 196 }
 197 
 198 
 199 /* PACK FUNCTIONS FOR NON-GENERIC SYSTEM TYPES */
 200 
 201 /*
 202  * BYTE, CHAR, INT8
 203  */
 204 pmix_status_t pmix20_bfrop_pack_byte(pmix_pointer_array_t *regtypes,
 205                                      pmix_buffer_t *buffer, const void *src,
 206                                      int32_t num_vals, pmix_data_type_t type)
 207  {
 208     char *dst;
 209 
 210     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 211                         "pmix20_bfrop_pack_byte * %d\n", num_vals);
 212     /* check to see if buffer needs extending */
 213     if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, num_vals))) {
 214         return PMIX_ERR_OUT_OF_RESOURCE;
 215     }
 216 
 217     /* store the data */
 218     memcpy(dst, src, num_vals);
 219 
 220     /* update buffer pointers */
 221     buffer->pack_ptr += num_vals;
 222     buffer->bytes_used += num_vals;
 223 
 224     return PMIX_SUCCESS;
 225 }
 226 
 227 /*
 228  * INT16
 229  */
 230 pmix_status_t pmix20_bfrop_pack_int16(pmix_pointer_array_t *regtypes,
 231                                       pmix_buffer_t *buffer, const void *src,
 232                                       int32_t num_vals, pmix_data_type_t type)
 233  {
 234     int32_t i;
 235     uint16_t tmp, *srctmp = (uint16_t*) src;
 236     char *dst;
 237 
 238     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 239                         "pmix20_bfrop_pack_int16 * %d\n", num_vals);
 240     /* check to see if buffer needs extending */
 241     if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, num_vals*sizeof(tmp)))) {
 242         return PMIX_ERR_OUT_OF_RESOURCE;
 243     }
 244 
 245     for (i = 0; i < num_vals; ++i) {
 246         tmp = pmix_htons(srctmp[i]);
 247         memcpy(dst, &tmp, sizeof(tmp));
 248         dst += sizeof(tmp);
 249     }
 250     buffer->pack_ptr += num_vals * sizeof(tmp);
 251     buffer->bytes_used += num_vals * sizeof(tmp);
 252 
 253     return PMIX_SUCCESS;
 254 }
 255 
 256 /*
 257  * INT32
 258  */
 259 pmix_status_t pmix20_bfrop_pack_int32(pmix_pointer_array_t *regtypes,
 260                                       pmix_buffer_t *buffer, const void *src,
 261                                       int32_t num_vals, pmix_data_type_t type)
 262  {
 263     int32_t i;
 264     uint32_t tmp, *srctmp = (uint32_t*) src;
 265     char *dst;
 266 
 267     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 268                         "pmix20_bfrop_pack_int32 * %d\n", num_vals);
 269     /* check to see if buffer needs extending */
 270     if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, num_vals*sizeof(tmp)))) {
 271         return PMIX_ERR_OUT_OF_RESOURCE;
 272     }
 273 
 274     for (i = 0; i < num_vals; ++i) {
 275         tmp = htonl(srctmp[i]);
 276         memcpy(dst, &tmp, sizeof(tmp));
 277         dst += sizeof(tmp);
 278     }
 279     buffer->pack_ptr += num_vals * sizeof(tmp);
 280     buffer->bytes_used += num_vals * sizeof(tmp);
 281 
 282     return PMIX_SUCCESS;
 283 }
 284 
 285 pmix_status_t pmix20_bfrop_pack_datatype(pmix_pointer_array_t *regtypes,
 286                                          pmix_buffer_t *buffer, const void *src,
 287                                          int32_t num_vals, pmix_data_type_t type)
 288 {
 289     pmix_status_t ret;
 290 
 291     PMIX_BFROPS_PACK_TYPE(ret, buffer, src, num_vals, PMIX_INT16, regtypes);
 292     return ret;
 293 }
 294 
 295 /*
 296  * INT64
 297  */
 298 pmix_status_t pmix20_bfrop_pack_int64(pmix_pointer_array_t *regtypes,
 299                                       pmix_buffer_t *buffer, const void *src,
 300                                       int32_t num_vals, pmix_data_type_t type)
 301  {
 302     int32_t i;
 303     uint64_t tmp, tmp2;
 304     char *dst;
 305     size_t bytes_packed = num_vals * sizeof(tmp);
 306 
 307     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 308                         "pmix20_bfrop_pack_int64 * %d\n", num_vals);
 309     /* check to see if buffer needs extending */
 310     if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, bytes_packed))) {
 311         return PMIX_ERR_OUT_OF_RESOURCE;
 312     }
 313 
 314     for (i = 0; i < num_vals; ++i) {
 315         memcpy(&tmp2, (char *)src+i*sizeof(uint64_t), sizeof(uint64_t));
 316         tmp = pmix_hton64(tmp2);
 317         memcpy(dst, &tmp, sizeof(tmp));
 318         dst += sizeof(tmp);
 319     }
 320     buffer->pack_ptr += bytes_packed;
 321     buffer->bytes_used += bytes_packed;
 322 
 323     return PMIX_SUCCESS;
 324 }
 325 
 326 /*
 327  * STRING
 328  */
 329 pmix_status_t pmix20_bfrop_pack_string(pmix_pointer_array_t *regtypes,
 330                                        pmix_buffer_t *buffer, const void *src,
 331                                        int32_t num_vals, pmix_data_type_t type)
 332  {
 333     pmix_status_t ret = PMIX_SUCCESS;
 334     int32_t i, len;
 335     char **ssrc = (char**) src;
 336 
 337     for (i = 0; i < num_vals; ++i) {
 338         if (NULL == ssrc[i]) {  /* got zero-length string/NULL pointer - store NULL */
 339         len = 0;
 340         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int32(regtypes, buffer, &len, 1, PMIX_INT32))) {
 341             return ret;
 342         }
 343     } else {
 344         len = (int32_t)strlen(ssrc[i]) + 1;
 345         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int32(regtypes, buffer, &len, 1, PMIX_INT32))) {
 346             return ret;
 347         }
 348         if (PMIX_SUCCESS != (ret =
 349             pmix20_bfrop_pack_byte(regtypes, buffer, ssrc[i], len, PMIX_BYTE))) {
 350             return ret;
 351     }
 352 }
 353 }
 354 
 355 return PMIX_SUCCESS;
 356 }
 357 
 358 /* FLOAT */
 359 pmix_status_t pmix20_bfrop_pack_float(pmix_pointer_array_t *regtypes,
 360                                       pmix_buffer_t *buffer, const void *src,
 361                                       int32_t num_vals, pmix_data_type_t type)
 362 {
 363     pmix_status_t ret = PMIX_SUCCESS;
 364     int32_t i;
 365     float *ssrc = (float*)src;
 366     char *convert;
 367 
 368     for (i = 0; i < num_vals; ++i) {
 369         if (0 > asprintf(&convert, "%f", ssrc[i])) {
 370             return PMIX_ERR_NOMEM;
 371         }
 372         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &convert, 1, PMIX_STRING))) {
 373             free(convert);
 374             return ret;
 375         }
 376         free(convert);
 377     }
 378 
 379     return PMIX_SUCCESS;
 380 }
 381 
 382 /* DOUBLE */
 383 pmix_status_t pmix20_bfrop_pack_double(pmix_pointer_array_t *regtypes,
 384                                        pmix_buffer_t *buffer, const void *src,
 385                                        int32_t num_vals, pmix_data_type_t type)
 386 {
 387     pmix_status_t ret = PMIX_SUCCESS;
 388     int32_t i;
 389     double *ssrc = (double*)src;
 390     char *convert;
 391 
 392     for (i = 0; i < num_vals; ++i) {
 393         if (0 > asprintf(&convert, "%f", ssrc[i])) {
 394             return PMIX_ERR_NOMEM;
 395         }
 396         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &convert, 1, PMIX_STRING))) {
 397             free(convert);
 398             return ret;
 399         }
 400         free(convert);
 401     }
 402 
 403     return PMIX_SUCCESS;
 404 }
 405 
 406 /* TIMEVAL */
 407 pmix_status_t pmix20_bfrop_pack_timeval(pmix_pointer_array_t *regtypes,
 408                                         pmix_buffer_t *buffer, const void *src,
 409                                         int32_t num_vals, pmix_data_type_t type)
 410 {
 411     int64_t tmp[2];
 412     pmix_status_t ret = PMIX_SUCCESS;
 413     int32_t i;
 414     struct timeval *ssrc = (struct timeval *)src;
 415 
 416     for (i = 0; i < num_vals; ++i) {
 417         tmp[0] = (int64_t)ssrc[i].tv_sec;
 418         tmp[1] = (int64_t)ssrc[i].tv_usec;
 419         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int64(regtypes, buffer, tmp, 2, PMIX_INT64))) {
 420             return ret;
 421         }
 422     }
 423 
 424     return PMIX_SUCCESS;
 425 }
 426 
 427 /* TIME */
 428 pmix_status_t pmix20_bfrop_pack_time(pmix_pointer_array_t *regtypes,
 429                                      pmix_buffer_t *buffer, const void *src,
 430                                      int32_t num_vals, pmix_data_type_t type)
 431 {
 432     pmix_status_t ret = PMIX_SUCCESS;
 433     int32_t i;
 434     time_t *ssrc = (time_t *)src;
 435     uint64_t ui64;
 436 
 437     /* time_t is a system-dependent size, so cast it
 438      * to uint64_t as a generic safe size
 439      */
 440      for (i = 0; i < num_vals; ++i) {
 441         ui64 = (uint64_t)ssrc[i];
 442         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int64(regtypes, buffer, &ui64, 1, PMIX_UINT64))) {
 443             return ret;
 444         }
 445     }
 446 
 447     return PMIX_SUCCESS;
 448 }
 449 
 450 /* STATUS */
 451 pmix_status_t pmix20_bfrop_pack_status(pmix_pointer_array_t *regtypes,
 452                                        pmix_buffer_t *buffer, const void *src,
 453                                        int32_t num_vals, pmix_data_type_t type)
 454 {
 455     pmix_status_t ret = PMIX_SUCCESS;
 456     int32_t i;
 457     pmix_status_t *ssrc = (pmix_status_t *)src;
 458     int32_t status;
 459 
 460     for (i = 0; i < num_vals; ++i) {
 461         status = (int32_t)ssrc[i];
 462         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int32(regtypes, buffer, &status, 1, PMIX_INT32))) {
 463             return ret;
 464         }
 465     }
 466 
 467     return PMIX_SUCCESS;
 468 }
 469 
 470 
 471 /* PACK FUNCTIONS FOR GENERIC PMIX TYPES */
 472 static pmix_status_t pack_val(pmix_pointer_array_t *regtypes,
 473                               pmix_buffer_t *buffer,
 474                               pmix_value_t *p)
 475 {
 476     pmix_status_t ret;
 477 
 478     switch (p->type) {
 479         case PMIX_UNDEF:
 480             break;
 481         case PMIX_BOOL:
 482             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.flag, 1, PMIX_BOOL))) {
 483                 return ret;
 484             }
 485             break;
 486         case PMIX_BYTE:
 487             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.byte, 1, PMIX_BYTE))) {
 488                 return ret;
 489             }
 490             break;
 491         case PMIX_STRING:
 492             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.string, 1, PMIX_STRING))) {
 493                 return ret;
 494             }
 495             break;
 496         case PMIX_SIZE:
 497             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.size, 1, PMIX_SIZE))) {
 498                 return ret;
 499             }
 500             break;
 501         case PMIX_PID:
 502             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.pid, 1, PMIX_PID))) {
 503                 return ret;
 504             }
 505             break;
 506         case PMIX_INT:
 507             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.integer, 1, PMIX_INT))) {
 508                 return ret;
 509             }
 510             break;
 511         case PMIX_INT8:
 512             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.int8, 1, PMIX_INT8))) {
 513                 return ret;
 514             }
 515             break;
 516         case PMIX_INT16:
 517             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.int16, 1, PMIX_INT16))) {
 518                 return ret;
 519             }
 520             break;
 521         case PMIX_INT32:
 522             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.int32, 1, PMIX_INT32))) {
 523                 return ret;
 524             }
 525             break;
 526         case PMIX_INT64:
 527             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.int64, 1, PMIX_INT64))) {
 528                 return ret;
 529             }
 530             break;
 531         case PMIX_UINT:
 532             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.uint, 1, PMIX_UINT))) {
 533                 return ret;
 534             }
 535             break;
 536         case PMIX_UINT8:
 537             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.uint8, 1, PMIX_UINT8))) {
 538                 return ret;
 539             }
 540             break;
 541         case PMIX_UINT16:
 542             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.uint16, 1, PMIX_UINT16))) {
 543                 return ret;
 544             }
 545             break;
 546         case PMIX_UINT32:
 547             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.uint32, 1, PMIX_UINT32))) {
 548                 return ret;
 549             }
 550             break;
 551         case PMIX_UINT64:
 552             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.uint64, 1, PMIX_UINT64))) {
 553                 return ret;
 554             }
 555             break;
 556         case PMIX_FLOAT:
 557             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.fval, 1, PMIX_FLOAT))) {
 558                 return ret;
 559             }
 560             break;
 561         case PMIX_DOUBLE:
 562             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.dval, 1, PMIX_DOUBLE))) {
 563                 return ret;
 564             }
 565             break;
 566         case PMIX_TIMEVAL:
 567             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.tv, 1, PMIX_TIMEVAL))) {
 568                 return ret;
 569             }
 570             break;
 571         case PMIX_TIME:
 572             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.time, 1, PMIX_TIME))) {
 573                 return ret;
 574             }
 575             break;
 576         case PMIX_STATUS:
 577             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.status, 1, PMIX_STATUS))) {
 578                 return ret;
 579             }
 580             break;
 581         case PMIX_PROC:
 582             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, p->data.proc, 1, PMIX_PROC))) {
 583                 return ret;
 584             }
 585             break;
 586         case PMIX_PROC_RANK:
 587             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.rank, 1, PMIX_PROC_RANK))) {
 588                 return ret;
 589             }
 590             break;
 591         case PMIX_BYTE_OBJECT:
 592         case PMIX_COMPRESSED_STRING:
 593             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.bo, 1, PMIX_BYTE_OBJECT))) {
 594                 return ret;
 595             }
 596             break;
 597         case PMIX_PERSIST:
 598             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.persist, 1, PMIX_PERSIST))) {
 599                 return ret;
 600             }
 601             break;
 602         case PMIX_POINTER:
 603             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.ptr, 1, PMIX_POINTER))) {
 604                 return ret;
 605             }
 606             break;
 607         case PMIX_SCOPE:
 608             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.scope, 1, PMIX_SCOPE))) {
 609                 return ret;
 610             }
 611             break;
 612         case PMIX_DATA_RANGE:
 613             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.range, 1, PMIX_DATA_RANGE))) {
 614                 return ret;
 615             }
 616             break;
 617         case PMIX_PROC_STATE:
 618             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, &p->data.state, 1, PMIX_PROC_STATE))) {
 619                 return ret;
 620             }
 621             break;
 622         case PMIX_PROC_INFO:
 623             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, p->data.pinfo, 1, PMIX_PROC_INFO))) {
 624                 return ret;
 625             }
 626             break;
 627         case PMIX_DATA_ARRAY:
 628             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, p->data.darray, 1, PMIX_DATA_ARRAY))) {
 629                 return ret;
 630             }
 631             break;
 632         case PMIX_QUERY:
 633             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, p->data.darray, 1, PMIX_QUERY))) {
 634                 return ret;
 635             }
 636             break;
 637         default:
 638         pmix_output(0, "PACK-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
 639         return PMIX_ERROR;
 640     }
 641     return PMIX_SUCCESS;
 642 }
 643 
 644 /*
 645  * PMIX_VALUE
 646  */
 647  pmix_status_t pmix20_bfrop_pack_value(pmix_pointer_array_t *regtypes,
 648                                        pmix_buffer_t *buffer, const void *src,
 649                                      int32_t num_vals, pmix_data_type_t type)
 650  {
 651     pmix_value_t *ptr;
 652     int32_t i;
 653     pmix_status_t ret;
 654 
 655     ptr = (pmix_value_t *) src;
 656 
 657     for (i = 0; i < num_vals; ++i) {
 658         /* pack the type */
 659         if (PMIX_SUCCESS != (ret = pmix20_bfrop_store_data_type(regtypes, buffer, ptr[i].type))) {
 660             return ret;
 661         }
 662         /* now pack the right field */
 663         if (PMIX_SUCCESS != (ret = pack_val(regtypes, buffer, &ptr[i]))) {
 664             return ret;
 665         }
 666     }
 667 
 668     return PMIX_SUCCESS;
 669 }
 670 
 671 
 672 pmix_status_t pmix20_bfrop_pack_info(pmix_pointer_array_t *regtypes,
 673                                      pmix_buffer_t *buffer, const void *src,
 674                                      int32_t num_vals, pmix_data_type_t type)
 675 {
 676     pmix_info_t *info;
 677     int32_t i;
 678     pmix_status_t ret;
 679     char *foo;
 680 
 681     info = (pmix_info_t *) src;
 682 
 683     for (i = 0; i < num_vals; ++i) {
 684         /* pack key */
 685         foo = info[i].key;
 686         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &foo, 1, PMIX_STRING))) {
 687             return ret;
 688         }
 689         /* pack info directives flag */
 690         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_infodirs(regtypes, buffer, &info[i].flags, 1, PMIX_INFO_DIRECTIVES))) {
 691             return ret;
 692         }
 693         /* pack the type */
 694         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int(regtypes, buffer, &info[i].value.type, 1, PMIX_INT))) {
 695             return ret;
 696         }
 697         /* pack value */
 698         if (PMIX_SUCCESS != (ret = pack_val(regtypes, buffer, &info[i].value))) {
 699             return ret;
 700         }
 701     }
 702     return PMIX_SUCCESS;
 703 }
 704 
 705 pmix_status_t pmix20_bfrop_pack_pdata(pmix_pointer_array_t *regtypes,
 706                                       pmix_buffer_t *buffer, const void *src,
 707                                       int32_t num_vals, pmix_data_type_t type)
 708 {
 709     pmix_pdata_t *pdata;
 710     int32_t i;
 711     pmix_status_t ret;
 712     char *foo;
 713 
 714     pdata = (pmix_pdata_t *) src;
 715 
 716     for (i = 0; i < num_vals; ++i) {
 717         /* pack the proc */
 718         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_proc(regtypes, buffer, &pdata[i].proc, 1, PMIX_PROC))) {
 719             return ret;
 720         }
 721         /* pack key */
 722         foo = pdata[i].key;
 723         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &foo, 1, PMIX_STRING))) {
 724             return ret;
 725         }
 726         /* pack the type */
 727         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int(regtypes, buffer, &pdata[i].value.type, 1, PMIX_INT))) {
 728             return ret;
 729         }
 730         /* pack value */
 731         if (PMIX_SUCCESS != (ret = pack_val(regtypes, buffer, &pdata[i].value))) {
 732             return ret;
 733         }
 734     }
 735     return PMIX_SUCCESS;
 736 }
 737 
 738 pmix_status_t pmix20_bfrop_pack_buf(pmix_pointer_array_t *regtypes,
 739                                     pmix_buffer_t *buffer, const void *src,
 740                                     int32_t num_vals, pmix_data_type_t type)
 741 {
 742     pmix_buffer_t *ptr;
 743     int32_t i;
 744     pmix_status_t ret;
 745 
 746     ptr = (pmix_buffer_t *) src;
 747 
 748     for (i = 0; i < num_vals; ++i) {
 749         /* pack the number of bytes */
 750         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_sizet(regtypes, buffer, &ptr[i].bytes_used, 1, PMIX_SIZE))) {
 751             return ret;
 752         }
 753         /* pack the bytes */
 754         if (0 < ptr[i].bytes_used) {
 755             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_byte(regtypes, buffer, ptr[i].base_ptr, ptr[i].bytes_used, PMIX_BYTE))) {
 756                 return ret;
 757             }
 758         }
 759     }
 760     return PMIX_SUCCESS;
 761 }
 762 
 763 pmix_status_t pmix20_bfrop_pack_proc(pmix_pointer_array_t *regtypes,
 764                                      pmix_buffer_t *buffer, const void *src,
 765                                      int32_t num_vals, pmix_data_type_t type)
 766 {
 767     pmix_proc_t *proc;
 768     int32_t i;
 769     pmix_status_t ret;
 770 
 771     proc = (pmix_proc_t *) src;
 772 
 773     for (i = 0; i < num_vals; ++i) {
 774         char *ptr = proc[i].nspace;
 775         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &ptr, 1, PMIX_STRING))) {
 776             return ret;
 777         }
 778         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_rank(regtypes, buffer, &proc[i].rank, 1, PMIX_PROC_RANK))) {
 779             return ret;
 780         }
 781     }
 782     return PMIX_SUCCESS;
 783 }
 784 
 785 pmix_status_t pmix20_bfrop_pack_app(pmix_pointer_array_t *regtypes,
 786                                     pmix_buffer_t *buffer, const void *src,
 787                                     int32_t num_vals, pmix_data_type_t type)
 788 {
 789     pmix_app_t *app;
 790     int32_t i, j, nvals;
 791     pmix_status_t ret;
 792 
 793     app = (pmix_app_t *) src;
 794 
 795     for (i = 0; i < num_vals; ++i) {
 796         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &app[i].cmd, 1, PMIX_STRING))) {
 797             return ret;
 798         }
 799         /* argv */
 800         nvals = pmix_argv_count(app[i].argv);
 801         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int(regtypes, buffer, &nvals, 1, PMIX_INT32))) {
 802             return ret;
 803         }
 804         for (j=0; j < nvals; j++) {
 805             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &app[i].argv[j], 1, PMIX_STRING))) {
 806                 return ret;
 807             }
 808         }
 809         /* env */
 810         nvals = pmix_argv_count(app[i].env);
 811         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int32(regtypes, buffer, &nvals, 1, PMIX_INT32))) {
 812             return ret;
 813         }
 814         for (j=0; j < nvals; j++) {
 815             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &app[i].env[j], 1, PMIX_STRING))) {
 816                 return ret;
 817             }
 818         }
 819         /* cwd */
 820         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &app[i].cwd, 1, PMIX_STRING))) {
 821             return ret;
 822         }
 823         /* maxprocs */
 824         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int(regtypes, buffer, &app[i].maxprocs, 1, PMIX_INT))) {
 825             return ret;
 826         }
 827         /* info array */
 828         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_sizet(regtypes, buffer, &app[i].ninfo, 1, PMIX_SIZE))) {
 829             return ret;
 830         }
 831         if (0 < app[i].ninfo) {
 832             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_info(regtypes, buffer, app[i].info, app[i].ninfo, PMIX_INFO))) {
 833                 return ret;
 834             }
 835         }
 836     }
 837     return PMIX_SUCCESS;
 838 }
 839 
 840 
 841 pmix_status_t pmix20_bfrop_pack_kval(pmix_pointer_array_t *regtypes,
 842                                      pmix_buffer_t *buffer, const void *src,
 843                                      int32_t num_vals, pmix_data_type_t type)
 844 {
 845     pmix_kval_t *ptr;
 846     int32_t i;
 847     pmix_status_t ret;
 848     char *st;
 849 
 850     ptr = (pmix_kval_t *) src;
 851 
 852     for (i = 0; i < num_vals; ++i) {
 853         /* pack the key */
 854         st = ptr[i].key;
 855         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &st, 1, PMIX_STRING))) {
 856             return ret;
 857         }
 858         /* pack the value */
 859         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_value(regtypes, buffer, ptr[i].value, 1, PMIX_VALUE))) {
 860             return ret;
 861         }
 862     }
 863 
 864     return PMIX_SUCCESS;
 865 }
 866 
 867 pmix_status_t pmix20_bfrop_pack_modex(pmix_pointer_array_t *regtypes,
 868                                       pmix_buffer_t *buffer, const void *src,
 869                                       int32_t num_vals, pmix_data_type_t type)
 870 {
 871     pmix_modex_data_t *ptr;
 872     int32_t i;
 873     pmix_status_t ret;
 874 
 875     ptr = (pmix_modex_data_t *) src;
 876 
 877     for (i = 0; i < num_vals; ++i) {
 878         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_sizet(regtypes, buffer, &ptr[i].size, 1, PMIX_SIZE))) {
 879             return ret;
 880         }
 881         if( 0 < ptr[i].size){
 882             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_byte(regtypes, buffer, ptr[i].blob, ptr[i].size, PMIX_UINT8))) {
 883                 return ret;
 884             }
 885         }
 886     }
 887     return PMIX_SUCCESS;
 888 }
 889 
 890 pmix_status_t pmix20_bfrop_pack_persist(pmix_pointer_array_t *regtypes,
 891                                         pmix_buffer_t *buffer, const void *src,
 892                                         int32_t num_vals, pmix_data_type_t type)
 893 {
 894     return pmix20_bfrop_pack_byte(regtypes, buffer, src, num_vals, PMIX_UINT8);
 895 }
 896 
 897 pmix_status_t pmix20_bfrop_pack_scope(pmix_pointer_array_t *regtypes,
 898                                       pmix_buffer_t *buffer, const void *src,
 899                                       int32_t num_vals, pmix_data_type_t type)
 900 {
 901     return pmix20_bfrop_pack_byte(regtypes, buffer, src, num_vals, PMIX_UINT8);
 902 }
 903 
 904 pmix_status_t pmix20_bfrop_pack_range(pmix_pointer_array_t *regtypes,
 905                                       pmix_buffer_t *buffer, const void *src,
 906                                       int32_t num_vals, pmix_data_type_t type)
 907 {
 908     return pmix20_bfrop_pack_byte(regtypes, buffer, src, num_vals, PMIX_UINT8);
 909 }
 910 
 911 pmix_status_t pmix20_bfrop_pack_cmd(pmix_pointer_array_t *regtypes,
 912                                     pmix_buffer_t *buffer, const void *src,
 913                                     int32_t num_vals, pmix_data_type_t type)
 914 {
 915     return pmix20_bfrop_pack_byte(regtypes, buffer, src, num_vals, PMIX_UINT8);
 916 }
 917 
 918 pmix_status_t pmix20_bfrop_pack_infodirs(pmix_pointer_array_t *regtypes,
 919                                          pmix_buffer_t *buffer, const void *src,
 920                                          int32_t num_vals, pmix_data_type_t type)
 921 {
 922     return pmix20_bfrop_pack_int32(regtypes, buffer, src, num_vals, PMIX_UINT32);
 923 }
 924 
 925 pmix_status_t pmix20_bfrop_pack_bo(pmix_pointer_array_t *regtypes,
 926                                    pmix_buffer_t *buffer, const void *src,
 927                                    int32_t num_vals, pmix_data_type_t type)
 928 {
 929     pmix_status_t ret;
 930     int i;
 931     pmix_byte_object_t *bo;
 932 
 933     bo = (pmix_byte_object_t*)src;
 934     for (i=0; i < num_vals; i++) {
 935         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_sizet(regtypes, buffer, &bo[i].size, 1, PMIX_SIZE))) {
 936             return ret;
 937         }
 938         if (0 < bo[i].size) {
 939             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_byte(regtypes, buffer, bo[i].bytes, bo[i].size, PMIX_BYTE))) {
 940                 return ret;
 941             }
 942         }
 943     }
 944     return PMIX_SUCCESS;
 945 }
 946 
 947 pmix_status_t pmix20_bfrop_pack_ptr(pmix_pointer_array_t *regtypes,
 948                                     pmix_buffer_t *buffer, const void *src,
 949                                     int32_t num_vals, pmix_data_type_t type)
 950 {
 951     uint8_t foo=1;
 952     /* it obviously makes no sense to pack a pointer and
 953      * send it somewhere else, so we just pack a sentinel */
 954     return pmix20_bfrop_pack_byte(regtypes, buffer, &foo, 1, PMIX_UINT8);
 955 }
 956 
 957 pmix_status_t pmix20_bfrop_pack_pstate(pmix_pointer_array_t *regtypes,
 958                                        pmix_buffer_t *buffer, const void *src,
 959                                        int32_t num_vals, pmix_data_type_t type)
 960 {
 961     return pmix20_bfrop_pack_byte(regtypes, buffer, src, num_vals, PMIX_UINT8);
 962 }
 963 
 964 pmix_status_t pmix20_bfrop_pack_pinfo(pmix_pointer_array_t *regtypes,
 965                                       pmix_buffer_t *buffer, const void *src,
 966                                       int32_t num_vals, pmix_data_type_t type)
 967 {
 968     pmix_proc_info_t *pinfo = (pmix_proc_info_t*)src;
 969     pmix_status_t ret;
 970     int32_t i;
 971 
 972     for (i=0; i < num_vals; i++) {
 973         /* pack the proc identifier */
 974         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_proc(regtypes, buffer, &pinfo[i].proc, 1, PMIX_PROC))) {
 975             return ret;
 976         }
 977         /* pack the hostname and exec */
 978         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &pinfo[i].hostname, 1, PMIX_STRING))) {
 979             return ret;
 980         }
 981         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, &pinfo[i].executable_name, 1, PMIX_STRING))) {
 982             return ret;
 983         }
 984         /* pack the pid and state */
 985         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_pid(regtypes, buffer, &pinfo[i].pid, 1, PMIX_PID))) {
 986             return ret;
 987         }
 988         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_pstate(regtypes, buffer, &pinfo[i].state, 1, PMIX_PROC_STATE))) {
 989             return ret;
 990         }
 991     }
 992     return PMIX_SUCCESS;
 993 }
 994 
 995 pmix_status_t pmix20_bfrop_pack_darray(pmix_pointer_array_t *regtypes,
 996                                        pmix_buffer_t *buffer, const void *src,
 997                                        int32_t num_vals, pmix_data_type_t type)
 998 {
 999     pmix_data_array_t *p = (pmix_data_array_t*)src;
1000     pmix_status_t ret;
1001     int32_t i;
1002 
1003     for (i=0; i < num_vals; i++) {
1004         /* pack the actual type in the array */
1005         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_datatype(regtypes, buffer, &p[i].type, 1, PMIX_DATA_TYPE))) {
1006             return ret;
1007         }
1008         /* pack the number of array elements */
1009         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_sizet(regtypes, buffer, &p[i].size, 1, PMIX_SIZE))) {
1010             return ret;
1011         }
1012         if (0 == p[i].size || PMIX_UNDEF == p[i].type) {
1013             /* nothing left to do */
1014             continue;
1015         }
1016         /* pack the actual elements */
1017         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_buffer(regtypes, buffer, p[i].array, p[i].size, p[i].type))) {
1018             return ret;
1019         }
1020     }
1021     return PMIX_SUCCESS;
1022 }
1023 
1024 pmix_status_t pmix20_bfrop_pack_rank(pmix_pointer_array_t *regtypes,
1025                                      pmix_buffer_t *buffer, const void *src,
1026                                      int32_t num_vals, pmix_data_type_t type)
1027 {
1028     return pmix20_bfrop_pack_int32(regtypes, buffer, src, num_vals, PMIX_UINT32);
1029 }
1030 
1031 pmix_status_t pmix20_bfrop_pack_query(pmix_pointer_array_t *regtypes,
1032                                       pmix_buffer_t *buffer, const void *src,
1033                                       int32_t num_vals, pmix_data_type_t type)
1034 {
1035     pmix_query_t *pq = (pmix_query_t*)src;
1036     pmix_status_t ret;
1037     int32_t i;
1038     int32_t nkeys;
1039 
1040     for (i=0; i < num_vals; i++) {
1041         /* pack the number of keys */
1042         nkeys = pmix_argv_count(pq[i].keys);
1043         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_int32(regtypes, buffer, &nkeys, 1, PMIX_INT32))) {
1044             return ret;
1045         }
1046         if (0 < nkeys) {
1047             /* pack the keys */
1048             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_string(regtypes, buffer, pq[i].keys, nkeys, PMIX_STRING))) {
1049                 return ret;
1050             }
1051         }
1052         /* pack the number of qualifiers */
1053         if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_sizet(regtypes, buffer, &pq[i].nqual, 1, PMIX_SIZE))) {
1054             return ret;
1055         }
1056         if (0 < pq[i].nqual) {
1057             /* pack any provided qualifiers */
1058             if (PMIX_SUCCESS != (ret = pmix20_bfrop_pack_info(regtypes, buffer, pq[i].qualifiers, pq[i].nqual, PMIX_INFO))) {
1059                 return ret;
1060             }
1061         }
1062     }
1063     return PMIX_SUCCESS;
1064 }
1065 
1066 pmix_status_t pmix20_bfrop_pack_alloc_directive(pmix_pointer_array_t *regtypes,
1067                                                 pmix_buffer_t *buffer, const void *src,
1068                                                 int32_t num_vals, pmix_data_type_t type)
1069 {
1070     return pmix20_bfrop_pack_byte(regtypes, buffer, src, num_vals, PMIX_UINT8);
1071 }
1072 
1073 /**** DEPRECATED ****/
1074 pmix_status_t pmix20_bfrop_pack_array(pmix_pointer_array_t *regtypes,
1075                                       pmix_buffer_t *buffer, const void *src,
1076                                       int32_t num_vals, pmix_data_type_t type)
1077 {
1078     pmix_info_array_t *ptr;
1079     int32_t i;
1080     pmix_status_t ret;
1081 
1082     ptr = (pmix_info_array_t *) src;
1083 
1084     for (i = 0; i < num_vals; ++i) {
1085         /* pack the size */
1086         if (PMIX_SUCCESS != (ret = pmix_bfrops_base_pack_sizet(regtypes, buffer, &ptr[i].size, 1, PMIX_SIZE))) {
1087             return ret;
1088         }
1089         if (0 < ptr[i].size) {
1090             /* pack the values */
1091             if (PMIX_SUCCESS != (ret = pmix_bfrops_base_pack_info(regtypes, buffer, ptr[i].array, ptr[i].size, PMIX_INFO))) {
1092                 return ret;
1093             }
1094         }
1095     }
1096 
1097     return PMIX_SUCCESS;
1098 }
1099 /********************/
1100
/* [<][>][^][v][top][bottom][index][help] */
root/opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v20/pack.c

DEFINITIONS
