root/opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/base/bfrop_base_fns.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. pmix_value_load
  2. pmix_value_unload
  3. pmix_value_xfer
  4. pmix_bfrops_base_value_load
  5. pmix_bfrops_base_value_unload
  6. pmix_bfrops_base_value_cmp
  7. pmix_bfrops_base_value_xfer
  8. pmix_bfrop_buffer_extend
  9. pmix_bfrop_too_small
  10. pmix_bfrop_store_data_type
  11. pmix_bfrop_get_data_type
  12. pmix_bfrops_base_data_type_string

   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/util/argv.h"
  31 #include "src/util/error.h"
  32 #include "src/include/pmix_globals.h"
  33 
  34 #include "src/mca/bfrops/base/base.h"
  35 
  36 /* define two public functions */
  37 PMIX_EXPORT void pmix_value_load(pmix_value_t *v, const void *data,
  38                                  pmix_data_type_t type)
  39 {
  40     pmix_bfrops_base_value_load(v, data, type);
  41 }
  42 
  43 PMIX_EXPORT pmix_status_t pmix_value_unload(pmix_value_t *kv,
  44                                             void **data,
  45                                             size_t *sz)
  46 {
  47     return pmix_bfrops_base_value_unload(kv, data, sz);
  48 }
  49 
  50 PMIX_EXPORT pmix_status_t pmix_value_xfer(pmix_value_t *dest,
  51                                           const pmix_value_t *src)
  52 {
  53     return pmix_bfrops_base_value_xfer(dest, src);
  54 }
  55 
  56 void pmix_bfrops_base_value_load(pmix_value_t *v, const void *data,
  57                                  pmix_data_type_t type)
  58 {
  59     pmix_byte_object_t *bo;
  60     pmix_proc_info_t *pi;
  61     pmix_envar_t *envar;
  62     pmix_data_array_t *darray;
  63     pmix_status_t rc;
  64     pmix_coord_t *coord;
  65     pmix_regattr_t *regattr;
  66 
  67     v->type = type;
  68     if (NULL == data) {
  69         /* just set the fields to zero */
  70         memset(&v->data, 0, sizeof(v->data));
  71         if (PMIX_BOOL == type) {
  72           v->data.flag = true; // existence of the attribute indicates true unless specified different
  73         }
  74     } else {
  75         switch(type) {
  76         case PMIX_UNDEF:
  77             break;
  78         case PMIX_BOOL:
  79             memcpy(&(v->data.flag), data, 1);
  80             break;
  81         case PMIX_BYTE:
  82             memcpy(&(v->data.byte), data, 1);
  83             break;
  84         case PMIX_STRING:
  85             v->data.string = strdup(data);
  86             break;
  87         case PMIX_SIZE:
  88             memcpy(&(v->data.size), data, sizeof(size_t));
  89             break;
  90         case PMIX_PID:
  91             memcpy(&(v->data.pid), data, sizeof(pid_t));
  92             break;
  93         case PMIX_INT:
  94             memcpy(&(v->data.integer), data, sizeof(int));
  95             break;
  96         case PMIX_INT8:
  97             memcpy(&(v->data.int8), data, 1);
  98             break;
  99         case PMIX_INT16:
 100             memcpy(&(v->data.int16), data, 2);
 101             break;
 102         case PMIX_INT32:
 103             memcpy(&(v->data.int32), data, 4);
 104             break;
 105         case PMIX_INT64:
 106             memcpy(&(v->data.int64), data, 8);
 107             break;
 108         case PMIX_UINT:
 109             memcpy(&(v->data.uint), data, sizeof(int));
 110             break;
 111         case PMIX_UINT8:
 112             memcpy(&(v->data.uint8), data, 1);
 113             break;
 114         case PMIX_UINT16:
 115             memcpy(&(v->data.uint16), data, 2);
 116             break;
 117         case PMIX_UINT32:
 118             memcpy(&(v->data.uint32), data, 4);
 119             break;
 120         case PMIX_UINT64:
 121             memcpy(&(v->data.uint64), data, 8);
 122             break;
 123         case PMIX_FLOAT:
 124             memcpy(&(v->data.fval), data, sizeof(float));
 125             break;
 126         case PMIX_DOUBLE:
 127             memcpy(&(v->data.dval), data, sizeof(double));
 128             break;
 129         case PMIX_TIMEVAL:
 130             memcpy(&(v->data.tv), data, sizeof(struct timeval));
 131             break;
 132         case PMIX_TIME:
 133             memcpy(&(v->data.time), data, sizeof(time_t));
 134             break;
 135         case PMIX_STATUS:
 136             memcpy(&(v->data.status), data, sizeof(pmix_status_t));
 137             break;
 138         case PMIX_PROC_RANK:
 139             memcpy(&(v->data.rank), data, sizeof(pmix_rank_t));
 140             break;
 141         case PMIX_PROC:
 142             PMIX_PROC_CREATE(v->data.proc, 1);
 143             if (NULL == v->data.proc) {
 144                 PMIX_ERROR_LOG(PMIX_ERR_NOMEM);
 145                 return;
 146             }
 147             memcpy(v->data.proc, data, sizeof(pmix_proc_t));
 148             break;
 149         case PMIX_BYTE_OBJECT:
 150             bo = (pmix_byte_object_t*)data;
 151             v->data.bo.bytes = (char*)malloc(bo->size);
 152             if (NULL == v->data.bo.bytes) {
 153                 PMIX_ERROR_LOG(PMIX_ERR_NOMEM);
 154                 return;
 155             }
 156             memcpy(v->data.bo.bytes, bo->bytes, bo->size);
 157             memcpy(&(v->data.bo.size), &bo->size, sizeof(size_t));
 158             break;
 159         case PMIX_PERSIST:
 160             memcpy(&(v->data.persist), data, sizeof(pmix_persistence_t));
 161             break;
 162         case PMIX_SCOPE:
 163             memcpy(&(v->data.scope), data, sizeof(pmix_scope_t));
 164             break;
 165         case PMIX_DATA_RANGE:
 166             memcpy(&(v->data.range), data, sizeof(pmix_data_range_t));
 167             break;
 168         case PMIX_PROC_STATE:
 169             memcpy(&(v->data.state), data, sizeof(pmix_proc_state_t));
 170             break;
 171         case PMIX_PROC_INFO:
 172             PMIX_PROC_INFO_CREATE(v->data.pinfo, 1);
 173             if (NULL == v->data.pinfo) {
 174                 PMIX_ERROR_LOG(PMIX_ERR_NOMEM);
 175                 return;
 176             }
 177             pi = (pmix_proc_info_t*)data;
 178             memcpy(&(v->data.pinfo->proc), &pi->proc, sizeof(pmix_proc_t));
 179             if (NULL != pi->hostname) {
 180                 v->data.pinfo->hostname = strdup(pi->hostname);
 181             }
 182             if (NULL != pi->executable_name) {
 183                 v->data.pinfo->executable_name = strdup(pi->executable_name);
 184             }
 185             memcpy(&(v->data.pinfo->pid), &pi->pid, sizeof(pid_t));
 186             memcpy(&(v->data.pinfo->exit_code), &pi->exit_code, sizeof(int));
 187             break;
 188         case PMIX_POINTER:
 189             v->data.ptr = (void*)data;
 190             break;
 191         case PMIX_ENVAR:
 192             envar = (pmix_envar_t*)data;
 193             if (NULL != envar->envar) {
 194                 v->data.envar.envar = strdup(envar->envar);
 195             }
 196             if (NULL != envar->value) {
 197                 v->data.envar.value = strdup(envar->value);
 198             }
 199             v->data.envar.separator = envar->separator;
 200             break;
 201         case PMIX_DATA_ARRAY:
 202             darray = (pmix_data_array_t*)data;
 203             rc = pmix_bfrops_base_copy_darray(&v->data.darray, darray, PMIX_DATA_ARRAY);
 204             if (PMIX_SUCCESS != rc) {
 205                 PMIX_ERROR_LOG(rc);
 206             }
 207             break;
 208         case PMIX_COORD:
 209             coord = (pmix_coord_t*)data;
 210             rc = pmix_bfrops_base_copy_coord(&v->data.coord, coord, PMIX_COORD);
 211             if (PMIX_SUCCESS != rc) {
 212                 PMIX_ERROR_LOG(rc);
 213             }
 214             break;
 215         case PMIX_REGATTR:
 216             regattr = (pmix_regattr_t*)data;
 217             rc = pmix_bfrops_base_copy_regattr((pmix_regattr_t**)&v->data.ptr, regattr, PMIX_REGATTR);
 218             if (PMIX_SUCCESS != rc) {
 219                 PMIX_ERROR_LOG(rc);
 220             }
 221             break;
 222 
 223         default:
 224             /* silence warnings */
 225             break;
 226         }
 227     }
 228     return;
 229 }
 230 
 231 pmix_status_t pmix_bfrops_base_value_unload(pmix_value_t *kv,
 232                                             void **data,
 233                                             size_t *sz)
 234 {
 235     pmix_status_t rc;
 236     pmix_envar_t *envar;
 237     pmix_data_array_t **darray;
 238     pmix_coord_t *coord;
 239     pmix_regattr_t *regattr, *r;
 240 
 241     rc = PMIX_SUCCESS;
 242     if (NULL == data ||
 243        (NULL == *data && PMIX_STRING != kv->type && PMIX_BYTE_OBJECT != kv->type)) {
 244         rc = PMIX_ERR_BAD_PARAM;
 245     } else {
 246         switch(kv->type) {
 247         case PMIX_UNDEF:
 248             rc = PMIX_ERR_UNKNOWN_DATA_TYPE;
 249             break;
 250         case PMIX_BOOL:
 251             memcpy(*data, &(kv->data.flag), 1);
 252             *sz = 1;
 253             break;
 254         case PMIX_BYTE:
 255             memcpy(*data, &(kv->data.byte), 1);
 256             *sz = 1;
 257             break;
 258         case PMIX_STRING:
 259             if (NULL != kv->data.string) {
 260                 *data = strdup(kv->data.string);
 261                 *sz = strlen(kv->data.string);
 262             }
 263             break;
 264         case PMIX_SIZE:
 265             memcpy(*data, &(kv->data.size), sizeof(size_t));
 266             *sz = sizeof(size_t);
 267             break;
 268         case PMIX_PID:
 269             memcpy(*data, &(kv->data.pid), sizeof(pid_t));
 270             *sz = sizeof(pid_t);
 271             break;
 272         case PMIX_INT:
 273             memcpy(*data, &(kv->data.integer), sizeof(int));
 274             *sz = sizeof(int);
 275             break;
 276         case PMIX_INT8:
 277             memcpy(*data, &(kv->data.int8), 1);
 278             *sz = 1;
 279             break;
 280         case PMIX_INT16:
 281             memcpy(*data, &(kv->data.int16), 2);
 282             *sz = 2;
 283             break;
 284         case PMIX_INT32:
 285             memcpy(*data, &(kv->data.int32), 4);
 286             *sz = 4;
 287             break;
 288         case PMIX_INT64:
 289             memcpy(*data, &(kv->data.int64), 8);
 290             *sz = 8;
 291             break;
 292         case PMIX_UINT:
 293             memcpy(*data, &(kv->data.uint), sizeof(int));
 294             *sz = sizeof(int);
 295             break;
 296         case PMIX_UINT8:
 297             memcpy(*data, &(kv->data.uint8), 1);
 298             *sz = 1;
 299             break;
 300         case PMIX_UINT16:
 301             memcpy(*data, &(kv->data.uint16), 2);
 302             *sz = 2;
 303             break;
 304         case PMIX_UINT32:
 305             memcpy(*data, &(kv->data.uint32), 4);
 306             *sz = 4;
 307             break;
 308         case PMIX_UINT64:
 309             memcpy(*data, &(kv->data.uint64), 8);
 310             *sz = 8;
 311             break;
 312         case PMIX_FLOAT:
 313             memcpy(*data, &(kv->data.fval), sizeof(float));
 314             *sz = sizeof(float);
 315             break;
 316         case PMIX_DOUBLE:
 317             memcpy(*data, &(kv->data.dval), sizeof(double));
 318             *sz = sizeof(double);
 319             break;
 320         case PMIX_TIMEVAL:
 321             memcpy(*data, &(kv->data.tv), sizeof(struct timeval));
 322             *sz = sizeof(struct timeval);
 323             break;
 324         case PMIX_TIME:
 325             memcpy(*data, &(kv->data.time), sizeof(time_t));
 326             *sz = sizeof(time_t);
 327             break;
 328         case PMIX_BYTE_OBJECT:
 329             if (NULL != kv->data.bo.bytes && 0 < kv->data.bo.size) {
 330                 *data = kv->data.bo.bytes;
 331                 *sz = kv->data.bo.size;
 332             } else {
 333                 *data = NULL;
 334                 *sz = 0;
 335             }
 336             break;
 337         case PMIX_PERSIST:
 338             memcpy(*data, &(kv->data.persist), sizeof(pmix_persistence_t));
 339             *sz = sizeof(pmix_persistence_t);
 340             break;
 341         case PMIX_SCOPE:
 342             memcpy(*data, &(kv->data.scope), sizeof(pmix_scope_t));
 343             *sz = sizeof(pmix_scope_t);
 344             break;
 345         case PMIX_DATA_RANGE:
 346             memcpy(*data, &(kv->data.range), sizeof(pmix_data_range_t));
 347             *sz = sizeof(pmix_data_range_t);
 348             break;
 349         case PMIX_PROC_STATE:
 350             memcpy(*data, &(kv->data.state), sizeof(pmix_proc_state_t));
 351             *sz = sizeof(pmix_proc_state_t);
 352             break;
 353         case PMIX_POINTER:
 354             *data = (void*)kv->data.ptr;
 355             *sz = sizeof(void*);
 356             break;
 357         case PMIX_DATA_ARRAY:
 358             darray = (pmix_data_array_t**)data;
 359             rc = pmix_bfrops_base_copy_darray(darray, kv->data.darray, PMIX_DATA_ARRAY);
 360             *sz = sizeof(pmix_data_array_t);
 361             break;
 362         case PMIX_ENVAR:
 363             PMIX_ENVAR_CREATE(envar, 1);
 364             if (NULL == envar) {
 365                 return PMIX_ERR_NOMEM;
 366             }
 367             if (NULL != kv->data.envar.envar) {
 368                 envar->envar = strdup(kv->data.envar.envar);
 369             }
 370             if (NULL != kv->data.envar.value) {
 371                 envar->value = strdup(kv->data.envar.value);
 372             }
 373             envar->separator = kv->data.envar.separator;
 374             *data = envar;
 375             *sz = sizeof(pmix_envar_t);
 376             break;
 377         case PMIX_COORD:
 378             coord = (pmix_coord_t*)malloc(sizeof(pmix_coord_t));
 379             if (NULL == coord) {
 380                 return PMIX_ERR_NOMEM;
 381             }
 382             memcpy(coord, kv->data.coord, sizeof(pmix_coord_t));
 383             *data = coord;
 384             break;
 385         case PMIX_REGATTR:
 386             PMIX_REGATTR_CREATE(regattr, 1);
 387             if (NULL == regattr) {
 388                 return PMIX_ERR_NOMEM;
 389             }
 390             r = (pmix_regattr_t*)kv->data.ptr;
 391             if (NULL != r->name) {
 392                 regattr->name = strdup(r->name);
 393             }
 394             PMIX_LOAD_KEY(regattr->string, r->string);
 395             regattr->type = r->type;
 396             if (NULL != r->info) {
 397                 PMIX_INFO_XFER(regattr->info, r->info);
 398             }
 399             regattr->ninfo = r->ninfo;
 400             regattr->description = pmix_argv_copy(r->description);
 401             *data = regattr;
 402             break;
 403         default:
 404             /* silence warnings */
 405             rc = PMIX_ERROR;
 406             break;
 407         }
 408     }
 409     return rc;
 410 }
 411 
 412 /* compare function for pmix_value_t */
 413 pmix_value_cmp_t pmix_bfrops_base_value_cmp(pmix_value_t *p,
 414                                             pmix_value_t *p1)
 415 {
 416     pmix_value_cmp_t rc = PMIX_VALUE1_GREATER;
 417     int ret;
 418 
 419     if (p->type != p1->type) {
 420         return rc;
 421     }
 422 
 423     switch (p->type) {
 424         case PMIX_UNDEF:
 425             rc = PMIX_EQUAL;
 426             break;
 427         case PMIX_BOOL:
 428             if (p->data.flag == p1->data.flag) {
 429                 rc = PMIX_EQUAL;
 430             }
 431             break;
 432         case PMIX_BYTE:
 433             if (p->data.byte == p1->data.byte) {
 434                 rc = PMIX_EQUAL;
 435             }
 436             break;
 437         case PMIX_SIZE:
 438             if (p->data.size == p1->data.size) {
 439                 rc = PMIX_EQUAL;
 440             }
 441             break;
 442         case PMIX_INT:
 443             if (p->data.integer == p1->data.integer) {
 444                 rc = PMIX_EQUAL;
 445             }
 446             break;
 447         case PMIX_INT8:
 448             if (p->data.int8 == p1->data.int8) {
 449                 rc = PMIX_EQUAL;
 450             }
 451             break;
 452         case PMIX_INT16:
 453             if (p->data.int16 == p1->data.int16) {
 454                 rc = PMIX_EQUAL;
 455             }
 456             break;
 457         case PMIX_INT32:
 458             if (p->data.int32 == p1->data.int32) {
 459                 rc = PMIX_EQUAL;
 460             }
 461             break;
 462         case PMIX_INT64:
 463             if (p->data.int64 == p1->data.int64) {
 464                 rc = PMIX_EQUAL;
 465             }
 466             break;
 467         case PMIX_UINT:
 468             if (p->data.uint == p1->data.uint) {
 469                 rc = PMIX_EQUAL;
 470             }
 471             break;
 472         case PMIX_UINT8:
 473             if (p->data.uint8 == p1->data.int8) {
 474                 rc = PMIX_EQUAL;
 475             }
 476             break;
 477         case PMIX_UINT16:
 478             if (p->data.uint16 == p1->data.uint16) {
 479                 rc = PMIX_EQUAL;
 480             }
 481             break;
 482         case PMIX_UINT32:
 483             if (p->data.uint32 == p1->data.uint32) {
 484                 rc = PMIX_EQUAL;
 485             }
 486             break;
 487         case PMIX_UINT64:
 488             if (p->data.uint64 == p1->data.uint64) {
 489                 rc = PMIX_EQUAL;
 490             }
 491             break;
 492         case PMIX_STRING:
 493             if (0 == strcmp(p->data.string, p1->data.string)) {
 494                 rc = PMIX_EQUAL;
 495             }
 496             break;
 497         case PMIX_COMPRESSED_STRING:
 498             if (p->data.bo.size > p1->data.bo.size) {
 499                 return PMIX_VALUE2_GREATER;
 500             } else {
 501                 return PMIX_VALUE1_GREATER;
 502             }
 503             break;
 504         case PMIX_STATUS:
 505             if (p->data.status == p1->data.status) {
 506                 rc = PMIX_EQUAL;
 507             }
 508             break;
 509         case PMIX_ENVAR:
 510             if (NULL != p->data.envar.envar) {
 511                 if (NULL == p1->data.envar.envar) {
 512                     return PMIX_VALUE1_GREATER;
 513                 }
 514                 ret = strcmp(p->data.envar.envar, p1->data.envar.envar);
 515                 if (ret < 0) {
 516                     return PMIX_VALUE2_GREATER;
 517                 } else if (0 < ret) {
 518                     return PMIX_VALUE1_GREATER;
 519                 }
 520             } else if (NULL != p1->data.envar.envar) {
 521                 /* we know value1->envar had to be NULL */
 522                 return PMIX_VALUE2_GREATER;
 523             }
 524 
 525             /* if both are NULL or are equal, then check value */
 526             if (NULL != p->data.envar.value) {
 527                 if (NULL == p1->data.envar.value) {
 528                     return PMIX_VALUE1_GREATER;
 529                 }
 530                 ret = strcmp(p->data.envar.value, p1->data.envar.value);
 531                 if (ret < 0) {
 532                     return PMIX_VALUE2_GREATER;
 533                 } else if (0 < ret) {
 534                     return PMIX_VALUE1_GREATER;
 535                 }
 536             } else if (NULL != p1->data.envar.value) {
 537                 /* we know value1->value had to be NULL */
 538                 return PMIX_VALUE2_GREATER;
 539             }
 540 
 541             /* finally, check separator */
 542             if (p->data.envar.separator < p1->data.envar.separator) {
 543                 return PMIX_VALUE2_GREATER;
 544             }
 545             if (p1->data.envar.separator < p->data.envar.separator) {
 546                 return PMIX_VALUE1_GREATER;
 547             }
 548             rc = PMIX_EQUAL;
 549             break;
 550         case PMIX_COORD:
 551             rc = memcmp(p->data.coord, p1->data.coord, sizeof(pmix_coord_t));
 552             if (0 > rc) {
 553                 rc = PMIX_VALUE2_GREATER;
 554             } else if (0 < rc) {
 555                 rc = PMIX_VALUE1_GREATER;
 556             } else {
 557                 rc = PMIX_EQUAL;
 558             }
 559             break;
 560         case PMIX_REGATTR:
 561             rc = memcmp(p->data.ptr, p1->data.ptr, sizeof(pmix_regattr_t));
 562             if (0 > rc) {
 563                 rc = PMIX_VALUE2_GREATER;
 564             } else if (0 < rc) {
 565                 rc = PMIX_VALUE1_GREATER;
 566             } else {
 567                 rc = PMIX_EQUAL;
 568             }
 569             break;
 570 
 571         default:
 572             pmix_output(0, "COMPARE-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
 573     }
 574     return rc;
 575 }
 576 
 577 /* Xfer FUNCTIONS FOR GENERIC PMIX TYPES */
 578 pmix_status_t pmix_bfrops_base_value_xfer(pmix_value_t *p,
 579                                           const pmix_value_t *src)
 580 {
 581     /* copy the right field */
 582     p->type = src->type;
 583     switch (src->type) {
 584     case PMIX_UNDEF:
 585     break;
 586     case PMIX_BOOL:
 587         p->data.flag = src->data.flag;
 588         break;
 589     case PMIX_BYTE:
 590         p->data.byte = src->data.byte;
 591         break;
 592     case PMIX_STRING:
 593         if (NULL != src->data.string) {
 594             p->data.string = strdup(src->data.string);
 595         } else {
 596             p->data.string = NULL;
 597         }
 598         break;
 599     case PMIX_SIZE:
 600         p->data.size = src->data.size;
 601         break;
 602     case PMIX_PID:
 603         p->data.pid = src->data.pid;
 604         break;
 605     case PMIX_INT:
 606         /* to avoid alignment issues */
 607         memcpy(&p->data.integer, &src->data.integer, sizeof(int));
 608         break;
 609     case PMIX_INT8:
 610         p->data.int8 = src->data.int8;
 611         break;
 612     case PMIX_INT16:
 613         /* to avoid alignment issues */
 614         memcpy(&p->data.int16, &src->data.int16, 2);
 615         break;
 616     case PMIX_INT32:
 617         /* to avoid alignment issues */
 618         memcpy(&p->data.int32, &src->data.int32, 4);
 619         break;
 620     case PMIX_INT64:
 621         /* to avoid alignment issues */
 622         memcpy(&p->data.int64, &src->data.int64, 8);
 623         break;
 624     case PMIX_UINT:
 625         /* to avoid alignment issues */
 626         memcpy(&p->data.uint, &src->data.uint, sizeof(unsigned int));
 627         break;
 628     case PMIX_UINT8:
 629         p->data.uint8 = src->data.uint8;
 630         break;
 631     case PMIX_UINT16:
 632         /* to avoid alignment issues */
 633         memcpy(&p->data.uint16, &src->data.uint16, 2);
 634         break;
 635     case PMIX_UINT32:
 636         /* to avoid alignment issues */
 637         memcpy(&p->data.uint32, &src->data.uint32, 4);
 638         break;
 639     case PMIX_UINT64:
 640         /* to avoid alignment issues */
 641         memcpy(&p->data.uint64, &src->data.uint64, 8);
 642         break;
 643     case PMIX_FLOAT:
 644         p->data.fval = src->data.fval;
 645         break;
 646     case PMIX_DOUBLE:
 647         p->data.dval = src->data.dval;
 648         break;
 649     case PMIX_TIMEVAL:
 650         memcpy(&p->data.tv, &src->data.tv, sizeof(struct timeval));
 651         break;
 652     case PMIX_TIME:
 653         memcpy(&p->data.time, &src->data.time, sizeof(time_t));
 654         break;
 655     case PMIX_STATUS:
 656         memcpy(&p->data.status, &src->data.status, sizeof(pmix_status_t));
 657         break;
 658     case PMIX_PROC:
 659         PMIX_PROC_CREATE(p->data.proc, 1);
 660         if (NULL == p->data.proc) {
 661             return PMIX_ERR_NOMEM;
 662         }
 663         memcpy(p->data.proc, src->data.proc, sizeof(pmix_proc_t));
 664         break;
 665     case PMIX_PROC_RANK:
 666         memcpy(&p->data.rank, &src->data.rank, sizeof(pmix_rank_t));
 667         break;
 668     case PMIX_BYTE_OBJECT:
 669     case PMIX_COMPRESSED_STRING:
 670         memset(&p->data.bo, 0, sizeof(pmix_byte_object_t));
 671         if (NULL != src->data.bo.bytes && 0 < src->data.bo.size) {
 672             p->data.bo.bytes = malloc(src->data.bo.size);
 673             memcpy(p->data.bo.bytes, src->data.bo.bytes, src->data.bo.size);
 674             p->data.bo.size = src->data.bo.size;
 675         } else {
 676             p->data.bo.bytes = NULL;
 677             p->data.bo.size = 0;
 678         }
 679         break;
 680     case PMIX_PERSIST:
 681         memcpy(&p->data.persist, &src->data.persist, sizeof(pmix_persistence_t));
 682         break;
 683     case PMIX_SCOPE:
 684         memcpy(&p->data.scope, &src->data.scope, sizeof(pmix_scope_t));
 685         break;
 686     case PMIX_DATA_RANGE:
 687         memcpy(&p->data.range, &src->data.range, sizeof(pmix_data_range_t));
 688         break;
 689     case PMIX_PROC_STATE:
 690         memcpy(&p->data.state, &src->data.state, sizeof(pmix_proc_state_t));
 691         break;
 692     case PMIX_PROC_INFO:
 693         return pmix_bfrops_base_copy_pinfo(&p->data.pinfo, src->data.pinfo, PMIX_PROC_INFO);
 694     case PMIX_DATA_ARRAY:
 695         return pmix_bfrops_base_copy_darray(&p->data.darray, src->data.darray, PMIX_DATA_ARRAY);
 696     case PMIX_POINTER:
 697         p->data.ptr = src->data.ptr;
 698         break;
 699     case PMIX_ENVAR:
 700         PMIX_ENVAR_CONSTRUCT(&p->data.envar);
 701         if (NULL != src->data.envar.envar) {
 702             p->data.envar.envar = strdup(src->data.envar.envar);
 703         }
 704         if (NULL != src->data.envar.value) {
 705             p->data.envar.value = strdup(src->data.envar.value);
 706         }
 707         p->data.envar.separator = src->data.envar.separator;
 708         break;
 709     case PMIX_COORD:
 710         pmix_bfrops_base_copy_coord(&p->data.coord, src->data.coord, PMIX_COORD);
 711         break;
 712     case PMIX_REGATTR:
 713         pmix_bfrops_base_copy_regattr((pmix_regattr_t**)&p->data.ptr, src->data.ptr, PMIX_REGATTR);
 714         break;
 715     default:
 716         pmix_output(0, "PMIX-XFER-VALUE: UNSUPPORTED TYPE %d", (int)src->type);
 717         return PMIX_ERROR;
 718     }
 719     return PMIX_SUCCESS;
 720 }
 721 
 722 
 723 /**
 724  * Internal function that resizes (expands) an inuse buffer if
 725  * necessary.
 726  */
 727 char* pmix_bfrop_buffer_extend(pmix_buffer_t *buffer, size_t bytes_to_add)
 728 {
 729     size_t required, to_alloc;
 730     size_t pack_offset, unpack_offset;
 731 
 732     /* Check to see if we have enough space already */
 733 
 734 
 735     if ((buffer->bytes_allocated - buffer->bytes_used) >= bytes_to_add) {
 736         return buffer->pack_ptr;
 737     }
 738 
 739     required = buffer->bytes_used + bytes_to_add;
 740     if (required >= pmix_bfrops_globals.threshold_size) {
 741         to_alloc = ((required + pmix_bfrops_globals.threshold_size - 1)
 742                     / pmix_bfrops_globals.threshold_size) * pmix_bfrops_globals.threshold_size;
 743     } else {
 744         to_alloc = buffer->bytes_allocated;
 745         if (0 == to_alloc) {
 746             to_alloc = pmix_bfrops_globals.initial_size;
 747         }
 748         while (to_alloc < required) {
 749             to_alloc <<= 1;
 750         }
 751     }
 752 
 753     if (NULL != buffer->base_ptr) {
 754         pack_offset = ((char*) buffer->pack_ptr) - ((char*) buffer->base_ptr);
 755         unpack_offset = ((char*) buffer->unpack_ptr) -
 756             ((char*) buffer->base_ptr);
 757         buffer->base_ptr = (char*)realloc(buffer->base_ptr, to_alloc);
 758         memset(buffer->base_ptr + pack_offset, 0, to_alloc - buffer->bytes_allocated);
 759     } else {
 760         pack_offset = 0;
 761         unpack_offset = 0;
 762         buffer->bytes_used = 0;
 763         buffer->base_ptr = (char*)malloc(to_alloc);
 764         memset(buffer->base_ptr, 0, to_alloc);
 765     }
 766 
 767     if (NULL == buffer->base_ptr) {
 768         return NULL;
 769     }
 770     buffer->pack_ptr = ((char*) buffer->base_ptr) + pack_offset;
 771     buffer->unpack_ptr = ((char*) buffer->base_ptr) + unpack_offset;
 772     buffer->bytes_allocated = to_alloc;
 773 
 774     /* All done */
 775     return buffer->pack_ptr;
 776 }
 777 
 778 /*
 779  * Internal function that checks to see if the specified number of bytes
 780  * remain in the buffer for unpacking
 781  */
 782 bool pmix_bfrop_too_small(pmix_buffer_t *buffer, size_t bytes_reqd)
 783 {
 784     size_t bytes_remaining_packed;
 785 
 786     if (buffer->pack_ptr < buffer->unpack_ptr) {
 787         return true;
 788     }
 789 
 790     bytes_remaining_packed = buffer->pack_ptr - buffer->unpack_ptr;
 791 
 792     if (bytes_remaining_packed < bytes_reqd) {
 793         /* don't error log this - it could be that someone is trying to
 794          * simply read until the buffer is empty
 795          */
 796         return true;
 797     }
 798 
 799     return false;
 800 }
 801 
 802 pmix_status_t pmix_bfrop_store_data_type(pmix_pointer_array_t *regtypes,
 803                                          pmix_buffer_t *buffer, pmix_data_type_t type)
 804 {
 805     pmix_status_t ret;
 806 
 807     PMIX_BFROPS_PACK_TYPE(ret, buffer, &type, 1, PMIX_UINT16, regtypes);
 808     return ret;
 809 }
 810 
 811 pmix_status_t pmix_bfrop_get_data_type(pmix_pointer_array_t *regtypes,
 812                                        pmix_buffer_t *buffer, pmix_data_type_t *type)
 813 {
 814     pmix_status_t ret;
 815     int32_t m = 1;
 816 
 817     PMIX_BFROPS_UNPACK_TYPE(ret, buffer, type, &m, PMIX_UINT16, regtypes);
 818     return ret;
 819 }
 820 
 821 const char* pmix_bfrops_base_data_type_string(pmix_pointer_array_t *regtypes,
 822                                               pmix_data_type_t type)
 823 {
 824     pmix_bfrop_type_info_t *info;
 825 
 826     /* Lookup the object for this type and call it */
 827     if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(regtypes, type))) {
 828         return NULL;
 829     }
 830 
 831     return info->odti_name;
 832 }

/* [<][>][^][v][top][bottom][index][help] */