root/opal/dss/dss_copy.c

DEFINITIONS

1. opal_dss_copy
2. opal_dss_std_copy
3. opal_dss_copy_null
4. opal_dss_copy_string
5. opal_dss_copy_byte_object
6. opal_dss_copy_pstat
7. opal_dss_copy_node_stat
8. opal_dss_copy_value
9. opal_dss_copy_buffer_contents
10. opal_dss_copy_name
11. opal_dss_copy_jobid
12. opal_dss_copy_vpid
13. opal_dss_copy_envar

   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) 2014-2015 Research Organization for Information Science
  14  *                         and Technology (RIST). All rights reserved.
  15  * $COPYRIGHT$
  16  *
  17  * Additional copyrights may follow
  18  *
  19  * $HEADER$
  20  */
  21 
  22 #include "opal_config.h"
  23 
  24 #include "opal/util/output.h"
  25 #include "opal/dss/dss_internal.h"
  26 #include "opal/util/error.h"
  27 
  28 int opal_dss_copy(void **dest, void *src, opal_data_type_t type)
  29 {
  30     opal_dss_type_info_t *info;
  31 
  32     /* check for error */
  33     if (NULL == dest) {
  34         return OPAL_ERR_BAD_PARAM;
  35     }
  36     if (NULL == src && (OPAL_NULL != type && OPAL_STRING != type)) {
  37         return OPAL_ERR_BAD_PARAM;
  38     }
  39 
  40    /* Lookup the copy function for this type and call it */
  41 
  42     if (NULL == (info = (opal_dss_type_info_t*)opal_pointer_array_get_item(&opal_dss_types, type))) {
  43         return OPAL_ERR_UNKNOWN_DATA_TYPE;
  44     }
  45 
  46     return info->odti_copy_fn(dest, src, type);
  47 }
  48 
  49 /*
  50  * STANDARD COPY FUNCTION - WORKS FOR EVERYTHING NON-STRUCTURED
  51  */
  52 int opal_dss_std_copy(void **dest, void *src, opal_data_type_t type)
  53 {
  54     size_t datasize;
  55     uint8_t *val = NULL;
  56 
  57     switch(type) {
  58     case OPAL_BOOL:
  59         datasize = sizeof(bool);
  60         break;
  61 
  62     case OPAL_INT:
  63     case OPAL_UINT:
  64     case OPAL_STATUS:
  65         datasize = sizeof(int);
  66         break;
  67 
  68     case OPAL_SIZE:
  69         datasize = sizeof(size_t);
  70         break;
  71 
  72     case OPAL_PID:
  73         datasize = sizeof(pid_t);
  74         break;
  75 
  76     case OPAL_BYTE:
  77     case OPAL_INT8:
  78     case OPAL_UINT8:
  79         datasize = 1;
  80         break;
  81 
  82     case OPAL_INT16:
  83     case OPAL_UINT16:
  84         datasize = 2;
  85         break;
  86 
  87     case OPAL_INT32:
  88     case OPAL_UINT32:
  89         datasize = 4;
  90         break;
  91 
  92     case OPAL_INT64:
  93     case OPAL_UINT64:
  94         datasize = 8;
  95         break;
  96 
  97     case OPAL_DATA_TYPE:
  98         datasize = sizeof(opal_data_type_t);
  99         break;
 100 
 101     case OPAL_FLOAT:
 102         datasize = sizeof(float);
 103         break;
 104 
 105     case OPAL_TIMEVAL:
 106         datasize = sizeof(struct timeval);
 107         break;
 108 
 109     case OPAL_TIME:
 110         datasize = sizeof(time_t);
 111         break;
 112 
 113     case OPAL_NAME:
 114         datasize = sizeof(opal_process_name_t);
 115         break;
 116 
 117     default:
 118         return OPAL_ERR_UNKNOWN_DATA_TYPE;
 119     }
 120 
 121     val = (uint8_t*)malloc(datasize);
 122     if (NULL == val) {
 123         return OPAL_ERR_OUT_OF_RESOURCE;
 124     }
 125 
 126     memcpy(val, src, datasize);
 127     *dest = val;
 128 
 129     return OPAL_SUCCESS;
 130 }
 131 
 132 /* COPY FUNCTIONS FOR NON-STANDARD SYSTEM TYPES */
 133 
 134 /*
 135  * NULL
 136  */
 137 int opal_dss_copy_null(char **dest, char *src, opal_data_type_t type)
 138 {
 139     char *val;
 140 
 141     *dest = (char*)malloc(sizeof(char));
 142     if (NULL == *dest) {
 143         return OPAL_ERR_OUT_OF_RESOURCE;
 144     }
 145 
 146     val = *dest;  /* save the address of the value */
 147 
 148     /* set the dest to null */
 149     *val = 0x00;
 150 
 151     return OPAL_SUCCESS;
 152 }
 153 
 154 /*
 155  * STRING
 156  */
 157 int opal_dss_copy_string(char **dest, char *src, opal_data_type_t type)
 158 {
 159     if (NULL == src) {  /* got zero-length string/NULL pointer - store NULL */
 160         *dest = NULL;
 161     } else {
 162         *dest = strdup(src);
 163     }
 164 
 165     return OPAL_SUCCESS;
 166 }
 167 
 168 /* COPY FUNCTIONS FOR GENERIC OPAL TYPES */
 169 
 170 /*
 171  * OPAL_BYTE_OBJECT
 172  */
 173 int opal_dss_copy_byte_object(opal_byte_object_t **dest, opal_byte_object_t *src,
 174                               opal_data_type_t type)
 175 {
 176     /* allocate space for the new object */
 177     *dest = (opal_byte_object_t*)malloc(sizeof(opal_byte_object_t));
 178     if (NULL == *dest) {
 179         return OPAL_ERR_OUT_OF_RESOURCE;
 180     }
 181 
 182     (*dest)->size = src->size;
 183 
 184     /* allocate the required space for the bytes */
 185     if (NULL == src->bytes) {
 186         (*dest)->bytes = NULL;
 187     } else {
 188         (*dest)->bytes = (uint8_t*)malloc(src->size);
 189         if (NULL == (*dest)->bytes) {
 190             OBJ_RELEASE(*dest);
 191             return OPAL_ERR_OUT_OF_RESOURCE;
 192         }
 193         /* copy the data across */
 194         memcpy((*dest)->bytes, src->bytes, src->size);
 195     }
 196 
 197     return OPAL_SUCCESS;
 198 }
 199 
 200 /* OPAL_PSTAT */
 201 int opal_dss_copy_pstat(opal_pstats_t **dest, opal_pstats_t *src,
 202                         opal_data_type_t type)
 203 {
 204     opal_pstats_t *p;
 205 
 206     /* create the new object */
 207     *dest = OBJ_NEW(opal_pstats_t);
 208     if (NULL == *dest) {
 209         return OPAL_ERR_OUT_OF_RESOURCE;
 210     }
 211     p = *dest;
 212 
 213     /* copy the individual fields */
 214     memcpy(p->node, src->node, sizeof(src->node));
 215     p->rank = src->rank;
 216     p->pid = src->pid;
 217     memcpy(p->cmd, src->cmd, sizeof(src->cmd));
 218     p->state[0] = src->state[0];
 219     p->time = src->time;
 220     p->priority = src->priority;
 221     p->num_threads = src->num_threads;
 222     p->pss = src->pss;
 223     p->vsize = src->vsize;
 224     p->rss = src->rss;
 225     p->peak_vsize = src->peak_vsize;
 226     p->processor = src->processor;
 227     p->sample_time.tv_sec = src->sample_time.tv_sec;
 228     p->sample_time.tv_usec = src->sample_time.tv_usec;
 229     return OPAL_SUCCESS;
 230 }
 231 
 232 /* OPAL_NODE_STAT */
 233 int opal_dss_copy_node_stat(opal_node_stats_t **dest, opal_node_stats_t *src,
 234                             opal_data_type_t type)
 235 {
 236     opal_node_stats_t *p;
 237 
 238     /* create the new object */
 239     *dest = OBJ_NEW(opal_node_stats_t);
 240     if (NULL == *dest) {
 241         return OPAL_ERR_OUT_OF_RESOURCE;
 242     }
 243     p = *dest;
 244 
 245     /* copy the individual fields */
 246     p->la = src->la;
 247     p->la5 = src->la5;
 248     p->la15 = src->la15;
 249     p->total_mem = src->total_mem;
 250     p->free_mem = src->free_mem;
 251     p->sample_time.tv_sec = src->sample_time.tv_sec;
 252     p->sample_time.tv_usec = src->sample_time.tv_usec;
 253     return OPAL_SUCCESS;
 254 }
 255 
 256 /* OPAL_VALUE */
 257 int opal_dss_copy_value(opal_value_t **dest, opal_value_t *src,
 258                         opal_data_type_t type)
 259 {
 260     opal_value_t *p;
 261 
 262     /* create the new object */
 263     *dest = OBJ_NEW(opal_value_t);
 264     if (NULL == *dest) {
 265         return OPAL_ERR_OUT_OF_RESOURCE;
 266     }
 267     p = *dest;
 268 
 269     /* copy the type and key */
 270     if (NULL != src->key) {
 271         p->key = strdup(src->key);
 272     }
 273     p->type = src->type;
 274 
 275     /* copy the right field */
 276     switch (src->type) {
 277     case OPAL_BYTE:
 278         p->data.byte = src->data.byte;
 279         break;
 280     case OPAL_STRING:
 281         if (NULL != src->data.string) {
 282             p->data.string = strdup(src->data.string);
 283         } else {
 284             p->data.string = NULL;
 285         }
 286         break;
 287     case OPAL_PID:
 288         p->data.pid = src->data.pid;
 289         break;
 290     case OPAL_INT:
 291         /* to avoid alignment issues */
 292         memcpy(&p->data.integer, &src->data.integer, sizeof(int));
 293         break;
 294     case OPAL_INT8:
 295         p->data.int8 = src->data.int8;
 296         break;
 297     case OPAL_INT16:
 298         /* to avoid alignment issues */
 299         memcpy(&p->data.int16, &src->data.int16, 2);
 300         break;
 301     case OPAL_INT32:
 302         /* to avoid alignment issues */
 303         memcpy(&p->data.int32, &src->data.int32, 4);
 304         break;
 305     case OPAL_INT64:
 306         /* to avoid alignment issues */
 307         memcpy(&p->data.int64, &src->data.int64, 8);
 308         break;
 309     case OPAL_UINT:
 310         /* to avoid alignment issues */
 311         memcpy(&p->data.uint, &src->data.uint, sizeof(unsigned int));
 312         break;
 313     case OPAL_UINT8:
 314         p->data.uint8 = src->data.uint8;
 315         break;
 316     case OPAL_UINT16:
 317         /* to avoid alignment issues */
 318         memcpy(&p->data.uint16, &src->data.uint16, 2);
 319         break;
 320     case OPAL_UINT32:
 321         /* to avoid alignment issues */
 322         memcpy(&p->data.uint32, &src->data.uint32, 4);
 323         break;
 324     case OPAL_UINT64:
 325         /* to avoid alignment issues */
 326         memcpy(&p->data.uint64, &src->data.uint64, 8);
 327         break;
 328     case OPAL_BYTE_OBJECT:
 329         if (NULL != src->data.bo.bytes && 0 < src->data.bo.size) {
 330             p->data.bo.bytes = malloc(src->data.bo.size);
 331             memcpy(p->data.bo.bytes, src->data.bo.bytes, src->data.bo.size);
 332             p->data.bo.size = src->data.bo.size;
 333         } else {
 334             p->data.bo.bytes = NULL;
 335             p->data.bo.size = 0;
 336         }
 337         break;
 338     case OPAL_NAME:
 339         memcpy(&p->data.name, &src->data.name, sizeof(opal_process_name_t));
 340         break;
 341     case OPAL_ENVAR:
 342         OBJ_CONSTRUCT(&p->data.envar, opal_envar_t);
 343         if (NULL != src->data.envar.envar) {
 344             p->data.envar.envar = strdup(src->data.envar.envar);
 345         }
 346         if (NULL != src->data.envar.value) {
 347             p->data.envar.value = strdup(src->data.envar.value);
 348         }
 349         p->data.envar.separator = src->data.envar.separator;
 350         break;
 351     default:
 352         opal_output(0, "COPY-OPAL-VALUE: UNSUPPORTED TYPE %d", (int)src->type);
 353         return OPAL_ERROR;
 354     }
 355 
 356     return OPAL_SUCCESS;
 357 }
 358 
 359 int opal_dss_copy_buffer_contents(opal_buffer_t **dest, opal_buffer_t *src,
 360                                   opal_data_type_t type)
 361 {
 362     *dest = OBJ_NEW(opal_buffer_t);
 363     opal_dss.copy_payload(*dest, src);
 364     return OPAL_SUCCESS;
 365 }
 366 
 367 /* PROCESS NAME */
 368 int opal_dss_copy_name(opal_process_name_t **dest, opal_process_name_t *src, opal_data_type_t type)
 369 {
 370     opal_process_name_t *val;
 371 
 372     val = (opal_process_name_t*)malloc(sizeof(opal_process_name_t));
 373     if (NULL == val) {
 374         OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
 375         return OPAL_ERR_OUT_OF_RESOURCE;
 376     }
 377 
 378     val->jobid = src->jobid;
 379     val->vpid = src->vpid;
 380 
 381     *dest = val;
 382     return OPAL_SUCCESS;
 383 }
 384 
 385 /*
 386  * JOBID
 387  */
 388 int opal_dss_copy_jobid(opal_jobid_t **dest, opal_jobid_t *src, opal_data_type_t type)
 389 {
 390     opal_jobid_t *val;
 391 
 392     val = (opal_jobid_t*)malloc(sizeof(opal_jobid_t));
 393     if (NULL == val) {
 394         OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
 395         return OPAL_ERR_OUT_OF_RESOURCE;
 396     }
 397 
 398     *val = *src;
 399     *dest = val;
 400 
 401     return OPAL_SUCCESS;
 402 }
 403 
 404 /*
 405  * VPID
 406  */
 407 int opal_dss_copy_vpid(opal_vpid_t **dest, opal_vpid_t *src, opal_data_type_t type)
 408 {
 409     opal_vpid_t *val;
 410 
 411     val = (opal_vpid_t*)malloc(sizeof(opal_vpid_t));
 412     if (NULL == val) {
 413         OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
 414         return OPAL_ERR_OUT_OF_RESOURCE;
 415     }
 416 
 417     *val = *src;
 418     *dest = val;
 419 
 420     return OPAL_SUCCESS;
 421 }
 422 
 423 int opal_dss_copy_envar(opal_envar_t **dest, opal_envar_t *src, opal_data_type_t type)
 424 {
 425     opal_envar_t *val;
 426 
 427     val = OBJ_NEW(opal_envar_t);
 428     if (NULL == val) {
 429         OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
 430         return OPAL_ERR_OUT_OF_RESOURCE;
 431     }
 432 
 433     if (NULL != src->envar) {
 434         val->envar = strdup(src->envar);
 435     }
 436     if (NULL != src->value) {
 437         val->value = strdup(src->value);
 438     }
 439     val->separator = src->separator;
 440     *dest = val;
 441 
 442     return OPAL_SUCCESS;
 443 }