opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/base/bfrop_base

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

DEFINITIONS
