root/opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v12/copy.c

DEFINITIONS

1. pmix12_bfrop_copy
2. pmix12_bfrop_copy_payload
3. pmix12_bfrop_std_copy
4. pmix12_bfrop_copy_string
5. pmix12_bfrop_value_cmp
6. pmix12_bfrop_value_xfer
7. pmix12_bfrop_copy_value
8. pmix12_bfrop_copy_info
9. pmix12_bfrop_copy_buf
10. pmix12_bfrop_copy_app
11. pmix12_bfrop_copy_kval
12. pmix12_bfrop_copy_array
13. pmix12_bfrop_copy_proc
14. pmix12_bfrop_copy_modex
15. pmix12_bfrop_copy_persist
16. pmix12_bfrop_copy_bo
17. pmix12_bfrop_copy_pdata
18. pmix12_bfrop_copy_darray
19. pmix12_bfrop_copy_proc_info
20. pmix12_bfrop_copy_query

   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-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) 2014-2018 Intel, Inc.  All rights reserved.
  13  * Copyright (c) 2015      Research Organization for Information Science
  14  *                         and Technology (RIST). All rights reserved.
  15  * Copyright (c) 2016      IBM Corporation.  All rights reserved.
  16  * $COPYRIGHT$
  17  *
  18  * Additional copyrights may follow
  19  *
  20  * $HEADER$
  21  */
  22 
  23 #include <src/include/pmix_config.h>
  24 
  25 
  26 #include "src/util/argv.h"
  27 #include "src/util/error.h"
  28 #include "src/util/output.h"
  29 #include "src/mca/bfrops/base/base.h"
  30 #include "bfrop_v12.h"
  31 #include "internal.h"
  32 
  33 pmix_status_t pmix12_bfrop_copy(void **dest, void *src, pmix_data_type_t type)
  34 {
  35     pmix_bfrop_type_info_t *info;
  36 
  37     /* check for error */
  38     if (NULL == dest) {
  39         PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
  40         return PMIX_ERR_BAD_PARAM;
  41     }
  42     if (NULL == src) {
  43         PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
  44         return PMIX_ERR_BAD_PARAM;
  45     }
  46 
  47    /* Lookup the copy function for this type and call it */
  48 
  49     if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v12_component.types, type))) {
  50         PMIX_ERROR_LOG(PMIX_ERR_UNKNOWN_DATA_TYPE);
  51         return PMIX_ERR_UNKNOWN_DATA_TYPE;
  52     }
  53 
  54     return info->odti_copy_fn(dest, src, type);
  55 }
  56 
  57 pmix_status_t pmix12_bfrop_copy_payload(pmix_buffer_t *dest, pmix_buffer_t *src)
  58 {
  59     size_t to_copy = 0;
  60     char *ptr;
  61     /* deal with buffer type */
  62     if( NULL == dest->base_ptr ){
  63         /* destination buffer is empty - derive src buffer type */
  64         dest->type = src->type;
  65     } else if( dest->type != src->type ){
  66         /* buffer types mismatch */
  67         PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
  68         return PMIX_ERR_BAD_PARAM;
  69     }
  70 
  71     to_copy = src->pack_ptr - src->unpack_ptr;
  72     if( NULL == (ptr = pmix_bfrop_buffer_extend(dest, to_copy)) ){
  73         PMIX_ERROR_LOG(PMIX_ERR_OUT_OF_RESOURCE);
  74         return PMIX_ERR_OUT_OF_RESOURCE;
  75     }
  76     memcpy(ptr,src->unpack_ptr, to_copy);
  77     dest->bytes_used += to_copy;
  78     dest->pack_ptr += to_copy;
  79     return PMIX_SUCCESS;
  80 }
  81 
  82 
  83 /*
  84  * STANDARD COPY FUNCTION - WORKS FOR EVERYTHING NON-STRUCTURED
  85  */
  86 pmix_status_t pmix12_bfrop_std_copy(void **dest, void *src, pmix_data_type_t type)
  87 {
  88     size_t datasize;
  89     uint8_t *val = NULL;
  90 
  91     switch(type) {
  92     case PMIX_BOOL:
  93         datasize = sizeof(bool);
  94         break;
  95 
  96     case PMIX_INT:
  97     case PMIX_UINT:
  98         datasize = sizeof(int);
  99         break;
 100 
 101     case PMIX_SIZE:
 102         datasize = sizeof(size_t);
 103         break;
 104 
 105     case PMIX_PID:
 106         datasize = sizeof(pid_t);
 107         break;
 108 
 109     case PMIX_BYTE:
 110     case PMIX_INT8:
 111     case PMIX_UINT8:
 112         datasize = 1;
 113         break;
 114 
 115     case PMIX_INT16:
 116     case PMIX_UINT16:
 117         datasize = 2;
 118         break;
 119 
 120     case PMIX_INT32:
 121     case PMIX_UINT32:
 122         datasize = 4;
 123         break;
 124 
 125     case PMIX_INT64:
 126     case PMIX_UINT64:
 127         datasize = 8;
 128         break;
 129 
 130     case PMIX_FLOAT:
 131         datasize = sizeof(float);
 132         break;
 133 
 134     case PMIX_TIMEVAL:
 135         datasize = sizeof(struct timeval);
 136         break;
 137 
 138     case PMIX_TIME:
 139         datasize = sizeof(time_t);
 140         break;
 141 
 142     default:
 143         return PMIX_ERR_UNKNOWN_DATA_TYPE;
 144     }
 145 
 146     val = (uint8_t*)malloc(datasize);
 147     if (NULL == val) {
 148         return PMIX_ERR_OUT_OF_RESOURCE;
 149     }
 150 
 151     memcpy(val, src, datasize);
 152     *dest = val;
 153 
 154     return PMIX_SUCCESS;
 155 }
 156 
 157 /* COPY FUNCTIONS FOR NON-STANDARD SYSTEM TYPES */
 158 
 159 /*
 160  * STRING
 161  */
 162 pmix_status_t pmix12_bfrop_copy_string(char **dest, char *src, pmix_data_type_t type)
 163 {
 164     if (NULL == src) {  /* got zero-length string/NULL pointer - store NULL */
 165         *dest = NULL;
 166     } else {
 167         *dest = strdup(src);
 168     }
 169 
 170     return PMIX_SUCCESS;
 171 }
 172 /* compare function for pmix_value_t*/
 173 pmix_value_cmp_t pmix12_bfrop_value_cmp(pmix_value_t *p, pmix_value_t *p1)
 174 {
 175     bool rc = false;
 176     switch (p->type) {
 177         case PMIX_BOOL:
 178             rc = (p->data.flag == p1->data.flag);
 179             break;
 180         case PMIX_BYTE:
 181             rc = (p->data.byte == p1->data.byte);
 182             break;
 183         case PMIX_SIZE:
 184             rc = (p->data.size == p1->data.size);
 185             break;
 186         case PMIX_INT:
 187             rc = (p->data.integer == p1->data.integer);
 188             break;
 189         case PMIX_INT8:
 190             rc = (p->data.int8 == p1->data.int8);
 191             break;
 192         case PMIX_INT16:
 193             rc = (p->data.int16 == p1->data.int16);
 194             break;
 195         case PMIX_INT32:
 196             rc = (p->data.int32 == p1->data.int32);
 197             break;
 198         case PMIX_INT64:
 199             rc = (p->data.int64 == p1->data.int64);
 200             break;
 201         case PMIX_UINT:
 202             rc = (p->data.uint == p1->data.uint);
 203             break;
 204         case PMIX_UINT8:
 205             rc = (p->data.uint8 == p1->data.int8);
 206             break;
 207         case PMIX_UINT16:
 208             rc = (p->data.uint16 == p1->data.uint16);
 209             break;
 210         case PMIX_UINT32:
 211             rc = (p->data.uint32 == p1->data.uint32);
 212             break;
 213         case PMIX_UINT64:
 214             rc = (p->data.uint64 == p1->data.uint64);
 215             break;
 216         case PMIX_STRING:
 217             rc = strcmp(p->data.string, p1->data.string);
 218             break;
 219         default:
 220             pmix_output(0, "COMPARE-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
 221     }
 222     if (rc) {
 223         return PMIX_EQUAL;
 224     }
 225     return PMIX_VALUE1_GREATER;
 226 }
 227 /* COPY FUNCTIONS FOR GENERIC PMIX TYPES */
 228 pmix_status_t pmix12_bfrop_value_xfer(pmix_value_t *p, const pmix_value_t *src)
 229 {
 230     /* copy the right field */
 231     p->type = src->type;
 232     switch (src->type) {
 233     case PMIX_BOOL:
 234         p->data.flag = src->data.flag;
 235         break;
 236     case PMIX_BYTE:
 237         p->data.byte = src->data.byte;
 238         break;
 239     case PMIX_STRING:
 240         if (NULL != src->data.string) {
 241             p->data.string = strdup(src->data.string);
 242         } else {
 243             p->data.string = NULL;
 244         }
 245         break;
 246     case PMIX_SIZE:
 247         p->data.size = src->data.size;
 248         break;
 249     case PMIX_PID:
 250         p->data.pid = src->data.pid;
 251         break;
 252     case PMIX_INT:
 253         /* to avoid alignment issues */
 254         memcpy(&p->data.integer, &src->data.integer, sizeof(int));
 255         break;
 256     case PMIX_INT8:
 257         p->data.int8 = src->data.int8;
 258         break;
 259     case PMIX_INT16:
 260         /* to avoid alignment issues */
 261         memcpy(&p->data.int16, &src->data.int16, 2);
 262         break;
 263     case PMIX_INT32:
 264         /* to avoid alignment issues */
 265         memcpy(&p->data.int32, &src->data.int32, 4);
 266         break;
 267     case PMIX_INT64:
 268         /* to avoid alignment issues */
 269         memcpy(&p->data.int64, &src->data.int64, 8);
 270         break;
 271     case PMIX_UINT:
 272         /* to avoid alignment issues */
 273         memcpy(&p->data.uint, &src->data.uint, sizeof(unsigned int));
 274         break;
 275     case PMIX_UINT8:
 276         p->data.uint8 = src->data.uint8;
 277         break;
 278     case PMIX_UINT16:
 279         /* to avoid alignment issues */
 280         memcpy(&p->data.uint16, &src->data.uint16, 2);
 281         break;
 282     case PMIX_UINT32:
 283         /* to avoid alignment issues */
 284         memcpy(&p->data.uint32, &src->data.uint32, 4);
 285         break;
 286     case PMIX_UINT64:
 287         /* to avoid alignment issues */
 288         memcpy(&p->data.uint64, &src->data.uint64, 8);
 289         break;
 290     case PMIX_FLOAT:
 291         p->data.fval = src->data.fval;
 292         break;
 293     case PMIX_DOUBLE:
 294         p->data.dval = src->data.dval;
 295         break;
 296     case PMIX_TIMEVAL:
 297         p->data.tv.tv_sec = src->data.tv.tv_sec;
 298         p->data.tv.tv_usec = src->data.tv.tv_usec;
 299         break;
 300     case PMIX_INFO_ARRAY:
 301         return PMIX_ERR_NOT_SUPPORTED;
 302     case PMIX_BYTE_OBJECT:
 303         if (NULL != src->data.bo.bytes && 0 < src->data.bo.size) {
 304             p->data.bo.bytes = malloc(src->data.bo.size);
 305             memcpy(p->data.bo.bytes, src->data.bo.bytes, src->data.bo.size);
 306             p->data.bo.size = src->data.bo.size;
 307         } else {
 308             p->data.bo.bytes = NULL;
 309             p->data.bo.size = 0;
 310         }
 311         break;
 312     default:
 313         pmix_output(0, "COPY-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)src->type);
 314         return PMIX_ERROR;
 315     }
 316     return PMIX_SUCCESS;
 317 }
 318 
 319 /* PMIX_VALUE */
 320 pmix_status_t pmix12_bfrop_copy_value(pmix_value_t **dest, pmix_value_t *src,
 321                                      pmix_data_type_t type)
 322 {
 323     pmix_value_t *p;
 324 
 325     /* create the new object */
 326     *dest = (pmix_value_t*)malloc(sizeof(pmix_value_t));
 327     if (NULL == *dest) {
 328         return PMIX_ERR_OUT_OF_RESOURCE;
 329     }
 330     p = *dest;
 331 
 332     /* copy the type */
 333     p->type = src->type;
 334     /* copy the data */
 335     return pmix_value_xfer(p, src);
 336 }
 337 
 338 pmix_status_t pmix12_bfrop_copy_info(pmix_info_t **dest, pmix_info_t *src,
 339                                     pmix_data_type_t type)
 340 {
 341     *dest = (pmix_info_t*)malloc(sizeof(pmix_info_t));
 342     pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
 343     return pmix_value_xfer(&(*dest)->value, &src->value);
 344 }
 345 
 346 pmix_status_t pmix12_bfrop_copy_buf(pmix_buffer_t **dest, pmix_buffer_t *src,
 347                                    pmix_data_type_t type)
 348 {
 349     *dest = PMIX_NEW(pmix_buffer_t);
 350     pmix_bfrops_base_copy_payload(*dest, src);
 351     return PMIX_SUCCESS;
 352 }
 353 
 354 pmix_status_t pmix12_bfrop_copy_app(pmix_app_t **dest, pmix_app_t *src,
 355                                    pmix_data_type_t type)
 356 {
 357     size_t j;
 358 
 359     *dest = (pmix_app_t*)malloc(sizeof(pmix_app_t));
 360     (*dest)->cmd = strdup(src->cmd);
 361     (*dest)->argv = pmix_argv_copy(src->argv);
 362     (*dest)->env = pmix_argv_copy(src->env);
 363     (*dest)->maxprocs = src->maxprocs;
 364     (*dest)->ninfo = src->ninfo;
 365     (*dest)->info = (pmix_info_t*)malloc(src->ninfo * sizeof(pmix_info_t));
 366     for (j=0; j < src->ninfo; j++) {
 367         pmix_strncpy((*dest)->info[j].key, src->info[j].key, PMIX_MAX_KEYLEN);
 368         pmix_value_xfer(&(*dest)->info[j].value, &src->info[j].value);
 369     }
 370     return PMIX_SUCCESS;
 371 }
 372 
 373 pmix_status_t pmix12_bfrop_copy_kval(pmix_kval_t **dest, pmix_kval_t *src,
 374                                     pmix_data_type_t type)
 375 {
 376     pmix_kval_t *p;
 377 
 378     /* create the new object */
 379     *dest = PMIX_NEW(pmix_kval_t);
 380     if (NULL == *dest) {
 381         return PMIX_ERR_OUT_OF_RESOURCE;
 382     }
 383     p = *dest;
 384 
 385     /* copy the type */
 386     p->value->type = src->value->type;
 387     /* copy the data */
 388     return pmix_value_xfer(p->value, src->value);
 389 }
 390 
 391 pmix_status_t pmix12_bfrop_copy_array(pmix_info_array_t **dest,
 392                                      pmix_info_array_t *src,
 393                                      pmix_data_type_t type)
 394 {
 395     pmix_info_t *d1, *s1;
 396 
 397     *dest = (pmix_info_array_t*)malloc(sizeof(pmix_info_array_t));
 398     (*dest)->size = src->size;
 399     (*dest)->array = (pmix_info_t*)malloc(src->size * sizeof(pmix_info_t));
 400     d1 = (pmix_info_t*)(*dest)->array;
 401     s1 = (pmix_info_t*)src->array;
 402     memcpy(d1, s1, src->size * sizeof(pmix_info_t));
 403     return PMIX_SUCCESS;
 404 }
 405 
 406 pmix_status_t pmix12_bfrop_copy_proc(pmix_proc_t **dest, pmix_proc_t *src,
 407                                     pmix_data_type_t type)
 408 {
 409     *dest = (pmix_proc_t*)malloc(sizeof(pmix_proc_t));
 410     if (NULL == *dest) {
 411         return PMIX_ERR_OUT_OF_RESOURCE;
 412     }
 413     pmix_strncpy((*dest)->nspace, src->nspace, PMIX_MAX_NSLEN);
 414     (*dest)->rank = src->rank;
 415     return PMIX_SUCCESS;
 416 }
 417 
 418 pmix_status_t pmix12_bfrop_copy_modex(pmix_modex_data_t **dest,
 419                                      pmix_modex_data_t *src,
 420                                      pmix_data_type_t type)
 421 {
 422     *dest = (pmix_modex_data_t*)malloc(sizeof(pmix_modex_data_t));
 423     if (NULL == *dest) {
 424         return PMIX_ERR_OUT_OF_RESOURCE;
 425     }
 426     (*dest)->blob = NULL;
 427     (*dest)->size = 0;
 428     if (NULL != src->blob) {
 429         (*dest)->blob = (uint8_t*)malloc(src->size * sizeof(uint8_t));
 430         if (NULL == (*dest)->blob) {
 431             return PMIX_ERR_OUT_OF_RESOURCE;
 432         }
 433         memcpy((*dest)->blob, src->blob, src->size * sizeof(uint8_t));
 434         (*dest)->size = src->size;
 435     }
 436     return PMIX_SUCCESS;
 437 }
 438 
 439 pmix_status_t pmix12_bfrop_copy_persist(pmix_persistence_t **dest,
 440                                        pmix_persistence_t *src,
 441                                        pmix_data_type_t type)
 442 {
 443     *dest = (pmix_persistence_t*)malloc(sizeof(pmix_persistence_t));
 444     if (NULL == *dest) {
 445         return PMIX_ERR_OUT_OF_RESOURCE;
 446     }
 447     memcpy(*dest, src, sizeof(pmix_persistence_t));
 448     return PMIX_SUCCESS;
 449 }
 450 
 451 pmix_status_t pmix12_bfrop_copy_bo(pmix_byte_object_t **dest,
 452                                   pmix_byte_object_t *src,
 453                                   pmix_data_type_t type)
 454 {
 455     *dest = (pmix_byte_object_t*)malloc(sizeof(pmix_byte_object_t));
 456     if (NULL == *dest) {
 457         return PMIX_ERR_OUT_OF_RESOURCE;
 458     }
 459     (*dest)->bytes = (char*)malloc(src->size);
 460     memcpy((*dest)->bytes, src->bytes, src->size);
 461     (*dest)->size = src->size;
 462     return PMIX_SUCCESS;
 463 }
 464 
 465 pmix_status_t pmix12_bfrop_copy_pdata(pmix_pdata_t **dest,
 466                                      pmix_pdata_t *src,
 467                                      pmix_data_type_t type)
 468 {
 469     *dest = (pmix_pdata_t*)malloc(sizeof(pmix_pdata_t));
 470     pmix_strncpy((*dest)->proc.nspace, src->proc.nspace, PMIX_MAX_NSLEN);
 471     (*dest)->proc.rank = src->proc.rank;
 472     pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
 473     return pmix_value_xfer(&(*dest)->value, &src->value);
 474 }
 475 
 476 pmix_status_t pmix12_bfrop_copy_darray(pmix_pdata_t **dest, pmix_data_array_t *src,
 477                                       pmix_data_type_t type)
 478 {
 479     return PMIX_ERR_NOT_SUPPORTED;
 480 }
 481 
 482 pmix_status_t pmix12_bfrop_copy_proc_info(pmix_pdata_t **dest, pmix_proc_info_t *src,
 483                                       pmix_data_type_t type)
 484 {
 485     return PMIX_ERR_NOT_SUPPORTED;
 486 }
 487 
 488 pmix_status_t pmix12_bfrop_copy_query(pmix_pdata_t **dest, pmix_query_t *src,
 489                                       pmix_data_type_t type)
 490 {
 491     return PMIX_ERR_NOT_SUPPORTED;
 492 }