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

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
pmix12_bfrop_pack
pmix12_bfrop_pack_buffer
pmix12_bfrop_pack_bool
pmix12_bfrop_pack_int
pmix12_bfrop_pack_sizet
pmix12_bfrop_pack_pid
pmix12_bfrop_pack_byte
pmix12_bfrop_pack_int16
pmix12_bfrop_pack_int32
pmix12_bfrop_pack_datatype
pmix12_bfrop_pack_int64
pmix12_bfrop_pack_string
pmix12_bfrop_pack_float
pmix12_bfrop_pack_double
pmix12_bfrop_pack_timeval
pmix12_bfrop_pack_time
pack_val
pmix12_bfrop_pack_value
pmix12_bfrop_pack_info
pmix12_bfrop_pack_pdata
pmix12_bfrop_pack_buf
pmix12_bfrop_pack_proc
pmix12_bfrop_pack_app
pmix12_bfrop_pack_kval
pmix12_bfrop_pack_array
pmix12_bfrop_pack_modex
pmix12_bfrop_pack_persist
pmix12_bfrop_pack_bo
pmix12_bfrop_pack_ptr
pmix12_bfrop_pack_scope
pmix12_bfrop_pack_status
pmix12_bfrop_pack_range
pmix12_bfrop_pack_cmd
pmix12_bfrop_pack_info_directives
pmix12_bfrop_pack_proc_state
pmix12_bfrop_pack_darray
pmix12_bfrop_pack_proc_info
pmix12_bfrop_pack_query
pmix12_bfrop_pack_rank
   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 "bfrop_v12.h"
  36 #include "internal.h"
  37 
  38 pmix_status_t pmix12_bfrop_pack(pmix_buffer_t *buffer,
  39                                 const void *src, int32_t num_vals,
  40                                 pmix_data_type_t type)
  41 {
  42     pmix_status_t rc;
  43     pmix_pointer_array_t *regtypes = &mca_bfrops_v12_component.types;
  44 
  45     /* check for error */
  46     if (NULL == buffer) {
  47         return PMIX_ERR_BAD_PARAM;
  48     }
  49 
  50     /* Pack the number of values */
  51     if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
  52         if (PMIX_SUCCESS != (rc = pmix12_bfrop_store_data_type(regtypes, buffer, PMIX_INT32))) {
  53             return rc;
  54         }
  55     }
  56     if (PMIX_SUCCESS != (rc = pmix12_bfrop_pack_int32(regtypes, buffer, &num_vals, 1, PMIX_INT32))) {
  57         return rc;
  58     }
  59 
  60     /* Pack the value(s) */
  61     return pmix12_bfrop_pack_buffer(regtypes, buffer, src, num_vals, type);
  62 }
  63 
  64 pmix_status_t pmix12_bfrop_pack_buffer(pmix_pointer_array_t *regtypes,
  65                                        pmix_buffer_t *buffer,
  66                                        const void *src, int32_t num_vals,
  67                                        pmix_data_type_t type)
  68 {
  69     pmix_status_t rc;
  70     pmix_bfrop_type_info_t *info;
  71     int v1type;
  72 
  73     pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_buffer( %p, %p, %lu, %d )\n",
  74                    (void*)buffer, src, (long unsigned int)num_vals, (int)type);
  75 
  76     /* some v1 types are simply declared differently */
  77     switch (type) {
  78         case PMIX_COMMAND:
  79             v1type = PMIX_UINT32;
  80             break;
  81         case PMIX_SCOPE:
  82         case PMIX_DATA_RANGE:
  83             v1type = PMIX_UINT;
  84             break;
  85         case PMIX_PROC_RANK:
  86         case PMIX_PERSIST:
  87             v1type = PMIX_INT;
  88             break;
  89         case PMIX_INFO_ARRAY:
  90             v1type = 22;
  91             break;
  92         default:
  93             v1type = type;
  94     }
  95 
  96     /* Pack the declared data type */
  97     if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
  98         if (PMIX_SUCCESS != (rc = pmix12_bfrop_store_data_type(regtypes, buffer, v1type))) {
  99             return rc;
 100         }
 101     }
 102     /* if it is an info array, we have to set the type back
 103      * so the pack routine will get the correct function */
 104     if (PMIX_INFO_ARRAY == type) {
 105         v1type = PMIX_INFO_ARRAY;
 106     }
 107 
 108     /* Lookup the pack function for this type and call it */
 109 
 110     if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v12_component.types, v1type))) {
 111         return PMIX_ERR_PACK_FAILURE;
 112     }
 113 
 114     return info->odti_pack_fn(regtypes, buffer, src, num_vals, v1type);
 115 }
 116 
 117 
 118 /* PACK FUNCTIONS FOR GENERIC SYSTEM TYPES */
 119 
 120 /*
 121  * BOOL
 122  */
 123 pmix_status_t pmix12_bfrop_pack_bool(pmix_pointer_array_t *regtypes,
 124                                      pmix_buffer_t *buffer, const void *src,
 125                                      int32_t num_vals, pmix_data_type_t type)
 126 {
 127     uint8_t *dst;
 128     int32_t i;
 129     bool *s = (bool*)src;
 130 
 131     pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_bool * %d\n", num_vals);
 132     /* check to see if buffer needs extending */
 133     if (NULL == (dst = (uint8_t*)pmix_bfrop_buffer_extend(buffer, num_vals))) {
 134         return PMIX_ERR_OUT_OF_RESOURCE;
 135     }
 136 
 137     /* store the data */
 138     for (i=0; i < num_vals; i++) {
 139         if (s[i]) {
 140             dst[i] = 1;
 141         } else {
 142             dst[i] = 0;
 143         }
 144     }
 145 
 146     /* update buffer pointers */
 147     buffer->pack_ptr += num_vals;
 148     buffer->bytes_used += num_vals;
 149 
 150     return PMIX_SUCCESS;
 151 }
 152 
 153 /*
 154  * INT
 155  */
 156 pmix_status_t pmix12_bfrop_pack_int(pmix_pointer_array_t *regtypes,
 157                                     pmix_buffer_t *buffer, const void *src,
 158                                     int32_t num_vals, pmix_data_type_t type)
 159 {
 160     pmix_status_t ret;
 161 
 162     /* System types need to always be described so we can properly
 163        unpack them */
 164     if (PMIX_SUCCESS != (ret = pmix12_bfrop_store_data_type(regtypes, buffer, BFROP_TYPE_INT))) {
 165         return ret;
 166     }
 167 
 168     /* Turn around and pack the real type */
 169     return pmix12_bfrop_pack_buffer(regtypes, buffer, src, num_vals, BFROP_TYPE_INT);
 170 }
 171 
 172 /*
 173  * SIZE_T
 174  */
 175 pmix_status_t pmix12_bfrop_pack_sizet(pmix_pointer_array_t *regtypes,
 176                                       pmix_buffer_t *buffer, const void *src,
 177                                       int32_t num_vals, pmix_data_type_t type)
 178 {
 179     pmix_status_t ret;
 180 
 181     /* System types need to always be described so we can properly
 182        unpack them. */
 183     if (PMIX_SUCCESS != (ret = pmix12_bfrop_store_data_type(regtypes, buffer, BFROP_TYPE_SIZE_T))) {
 184         return ret;
 185     }
 186 
 187     return pmix12_bfrop_pack_buffer(regtypes, buffer, src, num_vals, BFROP_TYPE_SIZE_T);
 188 }
 189 
 190 /*
 191  * PID_T
 192  */
 193 pmix_status_t pmix12_bfrop_pack_pid(pmix_pointer_array_t *regtypes,
 194                                     pmix_buffer_t *buffer, const void *src,
 195                                     int32_t num_vals, pmix_data_type_t type)
 196 {
 197     pmix_status_t ret;
 198 
 199     /* System types need to always be described so we can properly
 200        unpack them. */
 201     if (PMIX_SUCCESS != (ret = pmix12_bfrop_store_data_type(regtypes, buffer, BFROP_TYPE_PID_T))) {
 202         return ret;
 203     }
 204 
 205     /* Turn around and pack the real type */
 206     return pmix12_bfrop_pack_buffer(regtypes, buffer, src, num_vals, BFROP_TYPE_PID_T);
 207 }
 208 
 209 
 210 /* PACK FUNCTIONS FOR NON-GENERIC SYSTEM TYPES */
 211 
 212 /*
 213  * BYTE, CHAR, INT8
 214  */
 215 pmix_status_t pmix12_bfrop_pack_byte(pmix_pointer_array_t *regtypes,
 216                                      pmix_buffer_t *buffer, const void *src,
 217                                      int32_t num_vals, pmix_data_type_t type)
 218 {
 219     char *dst;
 220 
 221     pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_byte * %d\n", num_vals);
 222     /* check to see if buffer needs extending */
 223     if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, num_vals))) {
 224         return PMIX_ERR_OUT_OF_RESOURCE;
 225     }
 226 
 227     /* store the data */
 228     memcpy(dst, src, num_vals);
 229 
 230     /* update buffer pointers */
 231     buffer->pack_ptr += num_vals;
 232     buffer->bytes_used += num_vals;
 233 
 234     return PMIX_SUCCESS;
 235 }
 236 
 237 /*
 238  * INT16
 239  */
 240 pmix_status_t pmix12_bfrop_pack_int16(pmix_pointer_array_t *regtypes,
 241                                       pmix_buffer_t *buffer, const void *src,
 242                                       int32_t num_vals, pmix_data_type_t type)
 243 {
 244     int32_t i;
 245     uint16_t tmp, *srctmp = (uint16_t*) src;
 246     char *dst;
 247 
 248     pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_int16 * %d\n", num_vals);
 249     /* check to see if buffer needs extending */
 250     if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, num_vals*sizeof(tmp)))) {
 251         return PMIX_ERR_OUT_OF_RESOURCE;
 252     }
 253 
 254     for (i = 0; i < num_vals; ++i) {
 255         tmp = pmix_htons(srctmp[i]);
 256         memcpy(dst, &tmp, sizeof(tmp));
 257         dst += sizeof(tmp);
 258     }
 259     buffer->pack_ptr += num_vals * sizeof(tmp);
 260     buffer->bytes_used += num_vals * sizeof(tmp);
 261 
 262     return PMIX_SUCCESS;
 263 }
 264 
 265 /*
 266  * INT32
 267  */
 268 pmix_status_t pmix12_bfrop_pack_int32(pmix_pointer_array_t *regtypes,
 269                                       pmix_buffer_t *buffer, const void *src,
 270                                       int32_t num_vals, pmix_data_type_t type)
 271 {
 272     int32_t i;
 273     uint32_t tmp, *srctmp = (uint32_t*) src;
 274     char *dst;
 275 
 276     pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_int32 * %d\n", num_vals);
 277     /* check to see if buffer needs extending */
 278     if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, num_vals*sizeof(tmp)))) {
 279         return PMIX_ERR_OUT_OF_RESOURCE;
 280     }
 281 
 282     for (i = 0; i < num_vals; ++i) {
 283         tmp = htonl(srctmp[i]);
 284         memcpy(dst, &tmp, sizeof(tmp));
 285         dst += sizeof(tmp);
 286     }
 287     buffer->pack_ptr += num_vals * sizeof(tmp);
 288     buffer->bytes_used += num_vals * sizeof(tmp);
 289 
 290     return PMIX_SUCCESS;
 291 }
 292 
 293 pmix_status_t pmix12_bfrop_pack_datatype(pmix_pointer_array_t *regtypes,
 294                                          pmix_buffer_t *buffer, const void *src,
 295                                          int32_t num_vals, pmix_data_type_t type)
 296 {
 297     return pmix12_bfrop_pack_int32(regtypes, buffer, src, num_vals, type);
 298 }
 299 
 300 /*
 301  * INT64
 302  */
 303 pmix_status_t pmix12_bfrop_pack_int64(pmix_pointer_array_t *regtypes,
 304                                       pmix_buffer_t *buffer, const void *src,
 305                                       int32_t num_vals, pmix_data_type_t type)
 306 {
 307     int32_t i;
 308     uint64_t tmp, tmp2;
 309     char *dst;
 310     size_t bytes_packed = num_vals * sizeof(tmp);
 311 
 312     pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_int64 * %d\n", num_vals);
 313     /* check to see if buffer needs extending */
 314     if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, bytes_packed))) {
 315         return PMIX_ERR_OUT_OF_RESOURCE;
 316     }
 317 
 318     for (i = 0; i < num_vals; ++i) {
 319         memcpy(&tmp2, (char *)src+i*sizeof(uint64_t), sizeof(uint64_t));
 320         tmp = pmix_hton64(tmp2);
 321         memcpy(dst, &tmp, sizeof(tmp));
 322         dst += sizeof(tmp);
 323     }
 324     buffer->pack_ptr += bytes_packed;
 325     buffer->bytes_used += bytes_packed;
 326 
 327     return PMIX_SUCCESS;
 328 }
 329 
 330 /*
 331  * STRING
 332  */
 333 pmix_status_t pmix12_bfrop_pack_string(pmix_pointer_array_t *regtypes,
 334                                        pmix_buffer_t *buffer, const void *src,
 335                                        int32_t num_vals, pmix_data_type_t type)
 336 {
 337     int ret = PMIX_SUCCESS;
 338     int32_t i, len;
 339     char **ssrc = (char**) src;
 340 
 341     for (i = 0; i < num_vals; ++i) {
 342         if (NULL == ssrc[i]) {  /* got zero-length string/NULL pointer - store NULL */
 343             len = 0;
 344             if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int32(regtypes, buffer, &len, 1, PMIX_INT32))) {
 345                 return ret;
 346             }
 347         } else {
 348             len = (int32_t)strlen(ssrc[i]) + 1;
 349             if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int32(regtypes, buffer, &len, 1, PMIX_INT32))) {
 350                 return ret;
 351             }
 352             if (PMIX_SUCCESS != (ret =
 353                                  pmix12_bfrop_pack_byte(regtypes, buffer, ssrc[i], len, PMIX_BYTE))) {
 354                 return ret;
 355             }
 356         }
 357     }
 358 
 359     return PMIX_SUCCESS;
 360 }
 361 
 362 /* FLOAT */
 363 pmix_status_t pmix12_bfrop_pack_float(pmix_pointer_array_t *regtypes,
 364                                       pmix_buffer_t *buffer, const void *src,
 365                                       int32_t num_vals, pmix_data_type_t type)
 366 {
 367     pmix_status_t ret = PMIX_SUCCESS;
 368     int32_t i;
 369     float *ssrc = (float*)src;
 370     char *convert;
 371 
 372     for (i = 0; i < num_vals; ++i) {
 373         if (0 > asprintf(&convert, "%f", ssrc[i])) {
 374             return PMIX_ERR_NOMEM;
 375         }
 376         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &convert, 1, PMIX_STRING))) {
 377             free(convert);
 378             return ret;
 379         }
 380         free(convert);
 381     }
 382 
 383     return PMIX_SUCCESS;
 384 }
 385 
 386 /* DOUBLE */
 387 pmix_status_t pmix12_bfrop_pack_double(pmix_pointer_array_t *regtypes,
 388                                        pmix_buffer_t *buffer, const void *src,
 389                                        int32_t num_vals, pmix_data_type_t type)
 390 {
 391     pmix_status_t ret = PMIX_SUCCESS;
 392     int32_t i;
 393     double *ssrc = (double*)src;
 394     char *convert;
 395 
 396     for (i = 0; i < num_vals; ++i) {
 397         if (0 > asprintf(&convert, "%f", ssrc[i])) {
 398             return PMIX_ERR_NOMEM;
 399         }
 400         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &convert, 1, PMIX_STRING))) {
 401             free(convert);
 402             return ret;
 403         }
 404         free(convert);
 405     }
 406 
 407     return PMIX_SUCCESS;
 408 }
 409 
 410 /* TIMEVAL */
 411 pmix_status_t pmix12_bfrop_pack_timeval(pmix_pointer_array_t *regtypes,
 412                                         pmix_buffer_t *buffer, const void *src,
 413                                         int32_t num_vals, pmix_data_type_t type)
 414 {
 415     int64_t tmp[2];
 416     pmix_status_t ret = PMIX_SUCCESS;
 417     int32_t i;
 418     struct timeval *ssrc = (struct timeval *)src;
 419 
 420     for (i = 0; i < num_vals; ++i) {
 421         tmp[0] = (int64_t)ssrc[i].tv_sec;
 422         tmp[1] = (int64_t)ssrc[i].tv_usec;
 423         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int64(regtypes, buffer, tmp, 2, PMIX_INT64))) {
 424             return ret;
 425         }
 426     }
 427 
 428     return PMIX_SUCCESS;
 429 }
 430 
 431 /* TIME */
 432 pmix_status_t pmix12_bfrop_pack_time(pmix_pointer_array_t *regtypes,
 433                                      pmix_buffer_t *buffer, const void *src,
 434                                      int32_t num_vals, pmix_data_type_t type)
 435 {
 436     pmix_status_t ret = PMIX_SUCCESS;
 437     int32_t i;
 438     time_t *ssrc = (time_t *)src;
 439     uint64_t ui64;
 440 
 441     /* time_t is a system-dependent size, so cast it
 442      * to uint64_t as a generic safe size
 443      */
 444     for (i = 0; i < num_vals; ++i) {
 445         ui64 = (uint64_t)ssrc[i];
 446         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int64(regtypes, buffer, &ui64, 1, PMIX_UINT64))) {
 447             return ret;
 448         }
 449     }
 450 
 451     return PMIX_SUCCESS;
 452 }
 453 
 454 
 455 /* PACK FUNCTIONS FOR GENERIC PMIX TYPES */
 456 static pmix_status_t pack_val(pmix_pointer_array_t *regtypes,
 457                               pmix_buffer_t *buffer,
 458                               pmix_value_t *p)
 459 {
 460     pmix_status_t ret;
 461     pmix_info_array_t array;
 462     int rank;
 463 
 464     switch (p->type) {
 465     case PMIX_BOOL:
 466         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.flag, 1, PMIX_BOOL))) {
 467             return ret;
 468         }
 469         break;
 470     case PMIX_BYTE:
 471         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.byte, 1, PMIX_BYTE))) {
 472             return ret;
 473         }
 474         break;
 475     case PMIX_STRING:
 476         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.string, 1, PMIX_STRING))) {
 477             return ret;
 478         }
 479         break;
 480     case PMIX_SIZE:
 481         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.size, 1, PMIX_SIZE))) {
 482             return ret;
 483         }
 484         break;
 485     case PMIX_PID:
 486         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.pid, 1, PMIX_PID))) {
 487             return ret;
 488         }
 489         break;
 490     case PMIX_INT:
 491         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.integer, 1, PMIX_INT))) {
 492             return ret;
 493         }
 494         break;
 495     case PMIX_INT8:
 496         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.int8, 1, PMIX_INT8))) {
 497             return ret;
 498         }
 499         break;
 500     case PMIX_INT16:
 501         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.int16, 1, PMIX_INT16))) {
 502             return ret;
 503         }
 504         break;
 505     case PMIX_INT32:
 506         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.int32, 1, PMIX_INT32))) {
 507             return ret;
 508         }
 509         break;
 510     case PMIX_INT64:
 511         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.int64, 1, PMIX_INT64))) {
 512             return ret;
 513         }
 514         break;
 515     case PMIX_UINT:
 516         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint, 1, PMIX_UINT))) {
 517             return ret;
 518         }
 519         break;
 520     case PMIX_UINT8:
 521         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint8, 1, PMIX_UINT8))) {
 522             return ret;
 523         }
 524         break;
 525     case PMIX_UINT16:
 526         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint16, 1, PMIX_UINT16))) {
 527             return ret;
 528         }
 529         break;
 530     case PMIX_UINT32:
 531         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint32, 1, PMIX_UINT32))) {
 532             return ret;
 533         }
 534         break;
 535     case PMIX_UINT64:
 536         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint64, 1, PMIX_UINT64))) {
 537             return ret;
 538         }
 539         break;
 540     case PMIX_FLOAT:
 541         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.fval, 1, PMIX_FLOAT))) {
 542             return ret;
 543         }
 544         break;
 545     case PMIX_DOUBLE:
 546         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.dval, 1, PMIX_DOUBLE))) {
 547             return ret;
 548         }
 549         break;
 550     case PMIX_TIMEVAL:
 551         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.tv, 1, PMIX_TIMEVAL))) {
 552             return ret;
 553         }
 554         break;
 555     case PMIX_BYTE_OBJECT:
 556         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.bo, 1, PMIX_BYTE_OBJECT))) {
 557             return ret;
 558         }
 559         break;
 560     case PMIX_DATA_ARRAY:
 561         /* must convert this to an in info array for v1.2 */
 562         if (PMIX_INFO != p->data.darray->type) {
 563             return PMIX_ERR_NOT_SUPPORTED;
 564         }
 565         array.size = p->data.darray->size;
 566         array.array = (pmix_info_t*)p->data.darray->array;
 567         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &array, 1, PMIX_INFO_ARRAY))) {
 568             return ret;
 569         }
 570         break;
 571 
 572     case PMIX_PROC_RANK:
 573         /* must convert this to an int */
 574         rank = p->data.rank;
 575         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &rank, 1, PMIX_INT))) {
 576             return ret;
 577         }
 578         break;
 579 
 580     default:
 581         pmix_output(0, "PACK-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
 582         return PMIX_ERROR;
 583     }
 584     return PMIX_SUCCESS;
 585 }
 586 
 587 /*
 588  * PMIX_VALUE
 589  */
 590 pmix_status_t pmix12_bfrop_pack_value(pmix_pointer_array_t *regtypes,
 591                                       pmix_buffer_t *buffer, const void *src,
 592                                       int32_t num_vals, pmix_data_type_t type)
 593 {
 594     pmix_value_t *ptr;
 595     int32_t i;
 596     pmix_status_t ret;
 597     int v1type;
 598 
 599     ptr = (pmix_value_t *) src;
 600 
 601     for (i = 0; i < num_vals; ++i) {
 602         /* pack the type - unfortunately, v1.2 directly packed the int instead of
 603          * using the store_data_type function. This means we lose the translation!
 604          * So get it here */
 605         v1type = pmix12_v2_to_v1_datatype(ptr[i].type);
 606         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &v1type, 1, PMIX_INT))) {
 607             return ret;
 608         }
 609         /* now pack the right field */
 610         if (PMIX_SUCCESS != (ret = pack_val(regtypes, buffer, &ptr[i]))) {
 611             return ret;
 612         }
 613     }
 614 
 615     return PMIX_SUCCESS;
 616 }
 617 
 618 
 619 pmix_status_t pmix12_bfrop_pack_info(pmix_pointer_array_t *regtypes,
 620                                      pmix_buffer_t *buffer, const void *src,
 621                                      int32_t num_vals, pmix_data_type_t type)
 622 {
 623     pmix_info_t *info;
 624     int32_t i;
 625     pmix_status_t ret;
 626     char *foo;
 627     int v1type;
 628 
 629     info = (pmix_info_t *) src;
 630 
 631     for (i = 0; i < num_vals; ++i) {
 632         /* pack key */
 633         foo = info[i].key;
 634         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &foo, 1, PMIX_STRING))) {
 635             return ret;
 636         }
 637         /* pack the type - unfortunately, v1.2 directly packed the int instead of
 638          * using the store_data_type function. This means we lose the translation!
 639          * So get it here */
 640         v1type = pmix12_v2_to_v1_datatype(info[i].value.type);
 641         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &v1type, 1, PMIX_INT))) {
 642             return ret;
 643         }
 644         /* pack value */
 645         if (PMIX_SUCCESS != (ret = pack_val(regtypes, buffer, &info[i].value))) {
 646             return ret;
 647         }
 648     }
 649     return PMIX_SUCCESS;
 650 }
 651 
 652 pmix_status_t pmix12_bfrop_pack_pdata(pmix_pointer_array_t *regtypes,
 653                                       pmix_buffer_t *buffer, const void *src,
 654                                       int32_t num_vals, pmix_data_type_t type)
 655 {
 656     pmix_pdata_t *pdata;
 657     int32_t i;
 658     pmix_status_t ret;
 659     char *foo;
 660     int v1type;
 661 
 662     pdata = (pmix_pdata_t *) src;
 663 
 664     for (i = 0; i < num_vals; ++i) {
 665         /* pack the proc */
 666         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_proc(regtypes, buffer, &pdata[i].proc, 1, PMIX_PROC))) {
 667             return ret;
 668         }
 669         /* pack key */
 670         foo = pdata[i].key;
 671         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &foo, 1, PMIX_STRING))) {
 672             return ret;
 673         }
 674         /* pack the type - unfortunately, v1.2 directly packed the int instead of
 675          * using the store_data_type function. This means we lose the translation!
 676          * So get it here */
 677         v1type = pmix12_v2_to_v1_datatype(pdata[i].value.type);
 678         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &v1type, 1, PMIX_INT))) {
 679             return ret;
 680         }
 681         /* pack value */
 682         if (PMIX_SUCCESS != (ret = pack_val(regtypes, buffer, &pdata[i].value))) {
 683             return ret;
 684         }
 685     }
 686     return PMIX_SUCCESS;
 687 }
 688 
 689 pmix_status_t pmix12_bfrop_pack_buf(pmix_pointer_array_t *regtypes,
 690                                     pmix_buffer_t *buffer, const void *src,
 691                                     int32_t num_vals, pmix_data_type_t type)
 692 {
 693     pmix_buffer_t *ptr;
 694     int32_t i;
 695     pmix_status_t ret;
 696 
 697     ptr = (pmix_buffer_t *) src;
 698 
 699     for (i = 0; i < num_vals; ++i) {
 700         /* pack the number of bytes */
 701         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &ptr[i].bytes_used, 1, PMIX_SIZE))) {
 702             return ret;
 703         }
 704         /* pack the bytes */
 705         if (0 < ptr[i].bytes_used) {
 706             if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_byte(regtypes, buffer, ptr[i].base_ptr, ptr[i].bytes_used, PMIX_BYTE))) {
 707                 return ret;
 708             }
 709         }
 710     }
 711     return PMIX_SUCCESS;
 712 }
 713 
 714 pmix_status_t pmix12_bfrop_pack_proc(pmix_pointer_array_t *regtypes,
 715                                      pmix_buffer_t *buffer, const void *src,
 716                                      int32_t num_vals, pmix_data_type_t type)
 717 {
 718     pmix_proc_t *proc;
 719     int32_t i;
 720     pmix_status_t ret;
 721 
 722     proc = (pmix_proc_t *) src;
 723 
 724     for (i = 0; i < num_vals; ++i) {
 725         char *ptr = proc[i].nspace;
 726         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &ptr, 1, PMIX_STRING))) {
 727             return ret;
 728         }
 729         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &proc[i].rank, 1, PMIX_INT))) {
 730             return ret;
 731         }
 732     }
 733     return PMIX_SUCCESS;
 734 }
 735 
 736 pmix_status_t pmix12_bfrop_pack_app(pmix_pointer_array_t *regtypes,
 737                                     pmix_buffer_t *buffer, const void *src,
 738                                     int32_t num_vals, pmix_data_type_t type)
 739 {
 740     pmix_app_t *app;
 741     int32_t i, j, nvals;
 742     pmix_status_t ret;
 743     int argc;
 744 
 745     app = (pmix_app_t *) src;
 746 
 747     for (i = 0; i < num_vals; ++i) {
 748         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &app[i].cmd, 1, PMIX_STRING))) {
 749             return ret;
 750         }
 751         /* argv */
 752         argc = pmix_argv_count(app[i].argv);
 753         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &argc, 1, PMIX_INT))) {
 754             return ret;
 755         }
 756         for (j=0; j < argc; j++) {
 757             if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &app[i].argv[j], 1, PMIX_STRING))) {
 758                 return ret;
 759             }
 760         }
 761         /* env */
 762         nvals = pmix_argv_count(app[i].env);
 763         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int32(regtypes, buffer, &nvals, 1, PMIX_INT32))) {
 764             return ret;
 765         }
 766         for (j=0; j < nvals; j++) {
 767             if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &app[i].env[j], 1, PMIX_STRING))) {
 768                 return ret;
 769             }
 770         }
 771         /* maxprocs */
 772         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &app[i].maxprocs, 1, PMIX_INT))) {
 773             return ret;
 774         }
 775         /* info array */
 776         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &app[i].ninfo, 1, PMIX_SIZE))) {
 777             return ret;
 778         }
 779         if (0 < app[i].ninfo) {
 780             if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_info(regtypes, buffer, app[i].info, app[i].ninfo, PMIX_INFO))) {
 781                 return ret;
 782             }
 783         }
 784     }
 785     return PMIX_SUCCESS;
 786 }
 787 
 788 
 789 pmix_status_t pmix12_bfrop_pack_kval(pmix_pointer_array_t *regtypes,
 790                                      pmix_buffer_t *buffer, const void *src,
 791                                      int32_t num_vals, pmix_data_type_t type)
 792 {
 793     pmix_kval_t *ptr;
 794     int32_t i;
 795     pmix_status_t ret;
 796 
 797     ptr = (pmix_kval_t *) src;
 798 
 799     for (i = 0; i < num_vals; ++i) {
 800         /* pack the key */
 801         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &ptr[i].key, 1, PMIX_STRING))) {
 802             return ret;
 803         }
 804         /* pack the value */
 805         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_value(regtypes, buffer, ptr[i].value, 1, ptr[i].value->type))) {
 806             return ret;
 807         }
 808     }
 809 
 810     return PMIX_SUCCESS;
 811 }
 812 
 813 pmix_status_t pmix12_bfrop_pack_array(pmix_pointer_array_t *regtypes,
 814                                       pmix_buffer_t *buffer, const void *src,
 815                                       int32_t num_vals, pmix_data_type_t type)
 816 {
 817     pmix_info_array_t *ptr;
 818     int32_t i;
 819     pmix_status_t ret;
 820 
 821     ptr = (pmix_info_array_t *) src;
 822 
 823     for (i = 0; i < num_vals; ++i) {
 824         /* pack the size */
 825         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &ptr[i].size, 1, PMIX_SIZE))) {
 826             return ret;
 827         }
 828         if (0 < ptr[i].size) {
 829             /* pack the values */
 830             if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_info(regtypes, buffer, ptr[i].array, ptr[i].size, PMIX_INFO))) {
 831                 return ret;
 832             }
 833         }
 834     }
 835 
 836     return PMIX_SUCCESS;
 837 }
 838 
 839 pmix_status_t pmix12_bfrop_pack_modex(pmix_pointer_array_t *regtypes,
 840                                       pmix_buffer_t *buffer, const void *src,
 841                                       int32_t num_vals, pmix_data_type_t type)
 842 {
 843     pmix_modex_data_t *ptr;
 844     int32_t i;
 845     pmix_status_t ret;
 846 
 847     ptr = (pmix_modex_data_t *) src;
 848 
 849     for (i = 0; i < num_vals; ++i) {
 850         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &ptr[i].size, 1, PMIX_SIZE))) {
 851             return ret;
 852         }
 853         if( 0 < ptr[i].size){
 854             if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_byte(regtypes, buffer, ptr[i].blob, ptr[i].size, PMIX_UINT8))) {
 855                 return ret;
 856             }
 857         }
 858     }
 859     return PMIX_SUCCESS;
 860 }
 861 
 862 pmix_status_t pmix12_bfrop_pack_persist(pmix_pointer_array_t *regtypes,
 863                                         pmix_buffer_t *buffer, const void *src,
 864                                         int32_t num_vals, pmix_data_type_t type)
 865 {
 866     return pmix12_bfrop_pack_int(regtypes, buffer, src, num_vals, PMIX_INT);
 867 }
 868 
 869 pmix_status_t pmix12_bfrop_pack_bo(pmix_pointer_array_t *regtypes,
 870                                    pmix_buffer_t *buffer, const void *src,
 871                                    int32_t num_vals, pmix_data_type_t type)
 872 {
 873     pmix_status_t ret;
 874     int i;
 875     pmix_byte_object_t *bo;
 876 
 877     bo = (pmix_byte_object_t*)src;
 878     for (i=0; i < num_vals; i++) {
 879         if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &bo[i].size, 1, PMIX_SIZE))) {
 880             return ret;
 881         }
 882         if (0 < bo[i].size) {
 883             if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_byte(regtypes, buffer, bo[i].bytes, bo[i].size, PMIX_BYTE))) {
 884                 return ret;
 885             }
 886         }
 887     }
 888     return PMIX_SUCCESS;
 889 }
 890 
 891 pmix_status_t pmix12_bfrop_pack_ptr(pmix_pointer_array_t *regtypes,
 892                                     pmix_buffer_t *buffer, const void *src,
 893                                     int32_t num_vals, pmix_data_type_t type)
 894 {
 895     /* v1.x has no concept of packing a pointer, so just return */
 896     return PMIX_SUCCESS;
 897 }
 898 
 899 pmix_status_t pmix12_bfrop_pack_scope(pmix_pointer_array_t *regtypes,
 900                                       pmix_buffer_t *buffer, const void *src,
 901                                       int32_t num_vals, pmix_data_type_t type)
 902 {
 903     pmix_scope_t *scope = (pmix_scope_t*)src;
 904     unsigned int *v1scope;
 905     pmix_status_t ret;
 906     int i;
 907 
 908     /* v1.2 packed scope as PMIX_UINT, so we have to convert */
 909     v1scope = (unsigned int*)malloc(num_vals * sizeof(unsigned int));
 910     if (NULL == v1scope) {
 911         return PMIX_ERR_NOMEM;
 912     }
 913     for (i=0; i < num_vals; i++) {
 914         v1scope[i] = (unsigned int)scope[i];
 915     }
 916     ret = pmix12_bfrop_pack_int(regtypes, buffer, (void*)v1scope, num_vals, PMIX_UINT);
 917     free(v1scope);
 918     return ret;
 919 }
 920 
 921 pmix_status_t pmix12_bfrop_pack_status(pmix_pointer_array_t *regtypes,
 922                                        pmix_buffer_t *buffer, const void *src,
 923                                        int32_t num_vals, pmix_data_type_t type)
 924 {
 925     /* v1.2 declares pmix_status_t as an enum, which translates to int and
 926      * matches that of v2 */
 927     return pmix12_bfrop_pack_int(regtypes, buffer, src, num_vals, PMIX_INT);
 928 }
 929 
 930 pmix_status_t pmix12_bfrop_pack_range(pmix_pointer_array_t *regtypes,
 931                                       pmix_buffer_t *buffer, const void *src,
 932                                       int32_t num_vals, pmix_data_type_t type)
 933 {
 934     pmix_data_range_t *range = (pmix_data_range_t*)src;
 935     unsigned int *v1range;
 936     pmix_status_t ret;
 937     int i;
 938 
 939     /* v1.2 packed data range as PMIX_UINT, so we have to convert */
 940     v1range = (unsigned int*)malloc(num_vals * sizeof(unsigned int));
 941     if (NULL == v1range) {
 942         return PMIX_ERR_NOMEM;
 943     }
 944     for (i=0; i < num_vals; i++) {
 945         v1range[i] = (unsigned int)range[i];
 946     }
 947     ret = pmix12_bfrop_pack_int(regtypes, buffer, (void*)v1range, num_vals, PMIX_UINT);
 948     free(v1range);
 949     return ret;
 950 }
 951 
 952 pmix_status_t pmix12_bfrop_pack_cmd(pmix_pointer_array_t *regtypes,
 953                                     pmix_buffer_t *buffer, const void *src,
 954                                     int32_t num_vals, pmix_data_type_t type)
 955 {
 956     pmix_cmd_t *cmd = (pmix_cmd_t*)src;
 957     int *v1cmd;
 958     pmix_status_t ret;
 959     int i;
 960 
 961     /* v1.2 commands were enum (i.e., int), while they are uint8_t in v2 */
 962     v1cmd = (int*)malloc(num_vals * sizeof(int));
 963     if (NULL == v1cmd) {
 964         return PMIX_ERR_NOMEM;
 965     }
 966     for (i=0; i < num_vals; i++) {
 967         v1cmd[i] = cmd[i];
 968     }
 969     ret = pmix12_bfrop_pack_int(regtypes, buffer, (void*)v1cmd, num_vals, PMIX_INT);
 970     free(v1cmd);
 971     return ret;
 972 }
 973 
 974 pmix_status_t pmix12_bfrop_pack_info_directives(pmix_pointer_array_t *regtypes,
 975                                                 pmix_buffer_t *buffer, const void *src,
 976                                                 int32_t num_vals, pmix_data_type_t type)
 977 {
 978     /* v1.x has no concept of an info directive, so just return */
 979     return PMIX_SUCCESS;
 980 }
 981 
 982 pmix_status_t pmix12_bfrop_pack_proc_state(pmix_pointer_array_t *regtypes,
 983                                            pmix_buffer_t *buffer, const void *src,
 984                                            int32_t num_vals, pmix_data_type_t type)
 985 {
 986     /* v1.x has no concept of proc state, so just return */
 987     return PMIX_SUCCESS;
 988 }
 989 
 990 pmix_status_t pmix12_bfrop_pack_darray(pmix_pointer_array_t *regtypes,
 991                                        pmix_buffer_t *buffer, const void *src,
 992                                        int32_t num_vals, pmix_data_type_t type)
 993 {
 994     return PMIX_ERR_NOT_SUPPORTED;
 995 }
 996 
 997 pmix_status_t pmix12_bfrop_pack_proc_info(pmix_pointer_array_t *regtypes,
 998                                           pmix_buffer_t *buffer, const void *src,
 999                                           int32_t num_vals, pmix_data_type_t type)
1000 {
1001     return PMIX_ERR_NOT_SUPPORTED;
1002 
1003 }
1004 
1005 pmix_status_t pmix12_bfrop_pack_query(pmix_pointer_array_t *regtypes,
1006                                       pmix_buffer_t *buffer, const void *src,
1007                                       int32_t num_vals, pmix_data_type_t type)
1008 {
1009     return PMIX_ERR_NOT_SUPPORTED;
1010 }
1011 
1012 pmix_status_t pmix12_bfrop_pack_rank(pmix_pointer_array_t *regtypes,
1013                                      pmix_buffer_t *buffer, const void *src,
1014                                      int32_t num_vals, pmix_data_type_t type)
1015 {
1016     /* v1 rank is just an int, not a separate data type - it is defined
1017      * to be an unint32 in v2 */
1018     return pmix12_bfrop_pack_int(regtypes, buffer, src, num_vals, PMIX_INT);
1019 }
/* [<][>][^][v][top][bottom][index][help] */
root/opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v12/pack.c

DEFINITIONS
