opal/dss/dss

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
opal_dss_pack
opal_dss_pack_buffer
opal_dss_pack_bool
opal_dss_pack_int
opal_dss_pack_sizet
opal_dss_pack_pid
opal_dss_pack_null
opal_dss_pack_byte
opal_dss_pack_int16
opal_dss_pack_int32
opal_dss_pack_int64
opal_dss_pack_string
opal_dss_pack_float
opal_dss_pack_double
opal_dss_pack_timeval
opal_dss_pack_time
opal_dss_pack_data_type
opal_dss_pack_byte_object
opal_dss_pack_pstat
pack_disk_stats
pack_net_stats
opal_dss_pack_node_stat
opal_dss_pack_value
opal_dss_pack_buffer_contents
opal_dss_pack_name
opal_dss_pack_jobid
opal_dss_pack_vpid
opal_dss_pack_status
opal_dss_pack_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-2007 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2011-2013 Cisco Systems, Inc.  All rights reserved.
  13  * Copyright (c) 2014-2018 Intel, Inc. All rights reserved.
  14  * Copyright (c) 2014      Research Organization for Information Science
  15  *                         and Technology (RIST). All rights reserved.
  16  * Copyright (c) 2018      Amazon.com, Inc. or its affiliates.  All Rights reserved.
  17  * $COPYRIGHT$
  18  *
  19  * Additional copyrights may follow
  20  *
  21  * $HEADER$
  22  */
  23 
  24 #include "opal_config.h"
  25 
  26 #include "opal/types.h"
  27 #include "opal/util/error.h"
  28 #include "opal/util/output.h"
  29 #include "opal/util/printf.h"
  30 #include "opal/dss/dss_internal.h"
  31 
  32 int opal_dss_pack(opal_buffer_t *buffer,
  33                   const void *src, int32_t num_vals,
  34                   opal_data_type_t type)
  35 {
  36     int rc;
  37 
  38     /* check for error */
  39     if (NULL == buffer) {
  40         return OPAL_ERR_BAD_PARAM;
  41     }
  42 
  43     /* Pack the number of values */
  44     if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
  45         if (OPAL_SUCCESS != (rc = opal_dss_store_data_type(buffer, OPAL_INT32))) {
  46             return rc;
  47         }
  48     }
  49     if (OPAL_SUCCESS != (rc = opal_dss_pack_int32(buffer, &num_vals, 1, OPAL_INT32))) {
  50         return rc;
  51     }
  52 
  53     /* Pack the value(s) */
  54     return opal_dss_pack_buffer(buffer, src, num_vals, type);
  55 }
  56 
  57 int opal_dss_pack_buffer(opal_buffer_t *buffer,
  58                          const void *src, int32_t num_vals,
  59                          opal_data_type_t type)
  60 {
  61     int rc;
  62     opal_dss_type_info_t *info;
  63 
  64     OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_pack_buffer( %p, %p, %lu, %d )\n",
  65                    (void*)buffer, src, (long unsigned int)num_vals, (int)type ) );
  66 
  67     /* Pack the declared data type */
  68     if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
  69         if (OPAL_SUCCESS != (rc = opal_dss_store_data_type(buffer, type))) {
  70             return rc;
  71         }
  72     }
  73 
  74     /* Lookup the pack function for this type and call it */
  75 
  76     if (NULL == (info = (opal_dss_type_info_t*)opal_pointer_array_get_item(&opal_dss_types, type))) {
  77         return OPAL_ERR_PACK_FAILURE;
  78     }
  79 
  80     return info->odti_pack_fn(buffer, src, num_vals, type);
  81 }
  82 
  83 
  84 /* PACK FUNCTIONS FOR GENERIC SYSTEM TYPES */
  85 
  86 /*
  87  * BOOL
  88  */
  89 int opal_dss_pack_bool(opal_buffer_t *buffer, const void *src,
  90                        int32_t num_vals, opal_data_type_t type)
  91 {
  92     int ret;
  93 
  94     /* System types need to always be described so we can properly
  95        unpack them.  If we aren't fully described, then add the
  96        description for this type... */
  97     if (OPAL_DSS_BUFFER_FULLY_DESC != buffer->type) {
  98         if (OPAL_SUCCESS != (ret = opal_dss_store_data_type(buffer, DSS_TYPE_BOOL))) {
  99             return ret;
 100         }
 101     }
 102 
 103     /* Turn around and pack the real type */
 104     return opal_dss_pack_buffer(buffer, src, num_vals, DSS_TYPE_BOOL);
 105 }
 106 
 107 /*
 108  * INT
 109  */
 110 int opal_dss_pack_int(opal_buffer_t *buffer, const void *src,
 111                       int32_t num_vals, opal_data_type_t type)
 112 {
 113     int ret;
 114 
 115     /* System types need to always be described so we can properly
 116        unpack them.  If we aren't fully described, then add the
 117        description for this type... */
 118     if (OPAL_DSS_BUFFER_FULLY_DESC != buffer->type) {
 119         if (OPAL_SUCCESS != (ret = opal_dss_store_data_type(buffer, DSS_TYPE_INT))) {
 120             return ret;
 121         }
 122     }
 123 
 124     /* Turn around and pack the real type */
 125     return opal_dss_pack_buffer(buffer, src, num_vals, DSS_TYPE_INT);
 126 }
 127 
 128 /*
 129  * SIZE_T
 130  */
 131 int opal_dss_pack_sizet(opal_buffer_t *buffer, const void *src,
 132                         int32_t num_vals, opal_data_type_t type)
 133 {
 134     int ret;
 135 
 136     /* System types need to always be described so we can properly
 137        unpack them.  If we aren't fully described, then add the
 138        description for this type... */
 139     if (OPAL_DSS_BUFFER_FULLY_DESC != buffer->type) {
 140         if (OPAL_SUCCESS != (ret = opal_dss_store_data_type(buffer, DSS_TYPE_SIZE_T))) {
 141             return ret;
 142         }
 143     }
 144 
 145     return opal_dss_pack_buffer(buffer, src, num_vals, DSS_TYPE_SIZE_T);
 146 }
 147 
 148 /*
 149  * PID_T
 150  */
 151 int opal_dss_pack_pid(opal_buffer_t *buffer, const void *src,
 152                       int32_t num_vals, opal_data_type_t type)
 153 {
 154     int ret;
 155 
 156     /* System types need to always be described so we can properly
 157        unpack them.  If we aren't fully described, then add the
 158        description for this type... */
 159     if (OPAL_DSS_BUFFER_FULLY_DESC != buffer->type) {
 160         if (OPAL_SUCCESS != (ret = opal_dss_store_data_type(buffer, DSS_TYPE_PID_T))) {
 161             return ret;
 162         }
 163     }
 164 
 165     /* Turn around and pack the real type */
 166     return opal_dss_pack_buffer(buffer, src, num_vals, DSS_TYPE_PID_T);
 167 }
 168 
 169 
 170 /* PACK FUNCTIONS FOR NON-GENERIC SYSTEM TYPES */
 171 
 172 /*
 173  * NULL
 174  */
 175 int opal_dss_pack_null(opal_buffer_t *buffer, const void *src,
 176                        int32_t num_vals, opal_data_type_t type)
 177 {
 178     char null=0x00;
 179     char *dst;
 180 
 181     OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_pack_null * %d\n", num_vals ) );
 182     /* check to see if buffer needs extending */
 183     if (NULL == (dst = opal_dss_buffer_extend(buffer, num_vals))) {
 184         return OPAL_ERR_OUT_OF_RESOURCE;
 185     }
 186 
 187     /* store the nulls */
 188     memset(dst, (int)null, num_vals);
 189 
 190     /* update buffer pointers */
 191     buffer->pack_ptr += num_vals;
 192     buffer->bytes_used += num_vals;
 193 
 194     return OPAL_SUCCESS;
 195 }
 196 
 197 /*
 198  * BYTE, CHAR, INT8
 199  */
 200 int opal_dss_pack_byte(opal_buffer_t *buffer, const void *src,
 201                        int32_t num_vals, opal_data_type_t type)
 202 {
 203     char *dst;
 204 
 205     OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_pack_byte * %d\n", num_vals ) );
 206     /* check to see if buffer needs extending */
 207     if (NULL == (dst = opal_dss_buffer_extend(buffer, num_vals))) {
 208         return OPAL_ERR_OUT_OF_RESOURCE;
 209     }
 210 
 211     /* store the data */
 212     memcpy(dst, src, num_vals);
 213 
 214     /* update buffer pointers */
 215     buffer->pack_ptr += num_vals;
 216     buffer->bytes_used += num_vals;
 217 
 218     return OPAL_SUCCESS;
 219 }
 220 
 221 /*
 222  * INT16
 223  */
 224 int opal_dss_pack_int16(opal_buffer_t *buffer, const void *src,
 225                         int32_t num_vals, opal_data_type_t type)
 226 {
 227     int32_t i;
 228     uint16_t tmp, *srctmp = (uint16_t*) src;
 229     char *dst;
 230 
 231     OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_pack_int16 * %d\n", num_vals ) );
 232     /* check to see if buffer needs extending */
 233     if (NULL == (dst = opal_dss_buffer_extend(buffer, num_vals*sizeof(tmp)))) {
 234         return OPAL_ERR_OUT_OF_RESOURCE;
 235     }
 236 
 237     for (i = 0; i < num_vals; ++i) {
 238         tmp = htons(srctmp[i]);
 239         memcpy(dst, &tmp, sizeof(tmp));
 240         dst += sizeof(tmp);
 241     }
 242     buffer->pack_ptr += num_vals * sizeof(tmp);
 243     buffer->bytes_used += num_vals * sizeof(tmp);
 244 
 245     return OPAL_SUCCESS;
 246 }
 247 
 248 /*
 249  * INT32
 250  */
 251 int opal_dss_pack_int32(opal_buffer_t *buffer, const void *src,
 252                         int32_t num_vals, opal_data_type_t type)
 253 {
 254     int32_t i;
 255     uint32_t tmp, *srctmp = (uint32_t*) src;
 256     char *dst;
 257 
 258     OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_pack_int32 * %d\n", num_vals ) );
 259     /* check to see if buffer needs extending */
 260     if (NULL == (dst = opal_dss_buffer_extend(buffer, num_vals*sizeof(tmp)))) {
 261         return OPAL_ERR_OUT_OF_RESOURCE;
 262     }
 263 
 264     for (i = 0; i < num_vals; ++i) {
 265         tmp = htonl(srctmp[i]);
 266         memcpy(dst, &tmp, sizeof(tmp));
 267         dst += sizeof(tmp);
 268     }
 269     buffer->pack_ptr += num_vals * sizeof(tmp);
 270     buffer->bytes_used += num_vals * sizeof(tmp);
 271 
 272     return OPAL_SUCCESS;
 273 }
 274 
 275 /*
 276  * INT64
 277  */
 278 int opal_dss_pack_int64(opal_buffer_t *buffer, const void *src,
 279                         int32_t num_vals, opal_data_type_t type)
 280 {
 281     int32_t i;
 282     uint64_t tmp, *srctmp = (uint64_t*) src;
 283     char *dst;
 284     size_t bytes_packed = num_vals * sizeof(tmp);
 285 
 286     OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_pack_int64 * %d\n", num_vals ) );
 287     /* check to see if buffer needs extending */
 288     if (NULL == (dst = opal_dss_buffer_extend(buffer, bytes_packed))) {
 289         return OPAL_ERR_OUT_OF_RESOURCE;
 290     }
 291 
 292     for (i = 0; i < num_vals; ++i) {
 293         tmp = hton64(srctmp[i]);
 294         memcpy(dst, &tmp, sizeof(tmp));
 295         dst += sizeof(tmp);
 296     }
 297     buffer->pack_ptr += bytes_packed;
 298     buffer->bytes_used += bytes_packed;
 299 
 300     return OPAL_SUCCESS;
 301 }
 302 
 303 /*
 304  * STRING
 305  */
 306 int opal_dss_pack_string(opal_buffer_t *buffer, const void *src,
 307                          int32_t num_vals, opal_data_type_t type)
 308 {
 309     int ret = OPAL_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             if (OPAL_SUCCESS != (ret = opal_dss_pack_int32(buffer, &len, 1, OPAL_INT32))) {
 317                 return ret;
 318             }
 319         } else {
 320             len = (int32_t)strlen(ssrc[i]) + 1;
 321             if (OPAL_SUCCESS != (ret = opal_dss_pack_int32(buffer, &len, 1, OPAL_INT32))) {
 322                 return ret;
 323             }
 324             if (OPAL_SUCCESS != (ret =
 325                 opal_dss_pack_byte(buffer, ssrc[i], len, OPAL_BYTE))) {
 326                 return ret;
 327             }
 328         }
 329     }
 330 
 331     return OPAL_SUCCESS;
 332 }
 333 
 334 /* FLOAT */
 335 int opal_dss_pack_float(opal_buffer_t *buffer, const void *src,
 336                         int32_t num_vals, opal_data_type_t type)
 337 {
 338     int ret = OPAL_SUCCESS;
 339     int32_t i;
 340     float *ssrc = (float*)src;
 341     char *convert;
 342 
 343     for (i = 0; i < num_vals; ++i) {
 344         opal_asprintf(&convert, "%f", ssrc[i]);
 345         if (OPAL_SUCCESS != (ret = opal_dss_pack_string(buffer, &convert, 1, OPAL_STRING))) {
 346             free(convert);
 347             return ret;
 348         }
 349         free(convert);
 350     }
 351 
 352     return OPAL_SUCCESS;
 353 }
 354 
 355 /* DOUBLE */
 356 int opal_dss_pack_double(opal_buffer_t *buffer, const void *src,
 357                          int32_t num_vals, opal_data_type_t type)
 358 {
 359     int ret = OPAL_SUCCESS;
 360     int32_t i;
 361     double *ssrc = (double*)src;
 362     char *convert;
 363 
 364     for (i = 0; i < num_vals; ++i) {
 365         opal_asprintf(&convert, "%f", ssrc[i]);
 366         if (OPAL_SUCCESS != (ret = opal_dss_pack_string(buffer, &convert, 1, OPAL_STRING))) {
 367             free(convert);
 368             return ret;
 369         }
 370         free(convert);
 371     }
 372 
 373     return OPAL_SUCCESS;
 374 }
 375 
 376 /* TIMEVAL */
 377 int opal_dss_pack_timeval(opal_buffer_t *buffer, const void *src,
 378                           int32_t num_vals, opal_data_type_t type)
 379 {
 380     int64_t tmp[2];
 381     int ret = OPAL_SUCCESS;
 382     int32_t i;
 383     struct timeval *ssrc = (struct timeval *)src;
 384 
 385     for (i = 0; i < num_vals; ++i) {
 386         tmp[0] = (int64_t)ssrc[i].tv_sec;
 387         tmp[1] = (int64_t)ssrc[i].tv_usec;
 388         if (OPAL_SUCCESS != (ret = opal_dss_pack_int64(buffer, tmp, 2, OPAL_INT64))) {
 389             return ret;
 390         }
 391     }
 392 
 393     return OPAL_SUCCESS;
 394 }
 395 
 396 /* TIME */
 397 int opal_dss_pack_time(opal_buffer_t *buffer, const void *src,
 398                        int32_t num_vals, opal_data_type_t type)
 399 {
 400     int ret = OPAL_SUCCESS;
 401     int32_t i;
 402     time_t *ssrc = (time_t *)src;
 403     uint64_t ui64;
 404 
 405     /* time_t is a system-dependent size, so cast it
 406      * to uint64_t as a generic safe size
 407      */
 408     for (i = 0; i < num_vals; ++i) {
 409         ui64 = (uint64_t)ssrc[i];
 410         if (OPAL_SUCCESS != (ret = opal_dss_pack_int64(buffer, &ui64, 1, OPAL_UINT64))) {
 411             return ret;
 412         }
 413     }
 414 
 415     return OPAL_SUCCESS;
 416 }
 417 
 418 
 419 /* PACK FUNCTIONS FOR GENERIC OPAL TYPES */
 420 
 421 /*
 422  * OPAL_DATA_TYPE
 423  */
 424 int opal_dss_pack_data_type(opal_buffer_t *buffer, const void *src, int32_t num_vals,
 425                             opal_data_type_t type)
 426 {
 427     int ret;
 428 
 429     /* Turn around and pack the real type */
 430     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, src, num_vals, OPAL_DATA_TYPE_T))) {
 431     }
 432 
 433     return ret;
 434 }
 435 
 436 /*
 437  * OPAL_BYTE_OBJECT
 438  */
 439 int opal_dss_pack_byte_object(opal_buffer_t *buffer, const void *src, int32_t num,
 440                              opal_data_type_t type)
 441 {
 442     opal_byte_object_t **sbyteptr;
 443     int32_t i, n;
 444     int ret;
 445 
 446     sbyteptr = (opal_byte_object_t **) src;
 447 
 448     for (i = 0; i < num; ++i) {
 449         n = sbyteptr[i]->size;
 450         if (OPAL_SUCCESS != (ret = opal_dss_pack_int32(buffer, &n, 1, OPAL_INT32))) {
 451             return ret;
 452         }
 453         if (0 < n) {
 454             if (OPAL_SUCCESS != (ret =
 455                 opal_dss_pack_byte(buffer, sbyteptr[i]->bytes, n, OPAL_BYTE))) {
 456                 return ret;
 457             }
 458         }
 459     }
 460 
 461     return OPAL_SUCCESS;
 462 }
 463 
 464 /*
 465  * OPAL_PSTAT
 466  */
 467 int opal_dss_pack_pstat(opal_buffer_t *buffer, const void *src,
 468                         int32_t num_vals, opal_data_type_t type)
 469 {
 470     opal_pstats_t **ptr;
 471     int32_t i;
 472     int ret;
 473     char *cptr;
 474 
 475     ptr = (opal_pstats_t **) src;
 476 
 477     for (i = 0; i < num_vals; ++i) {
 478         cptr = ptr[i]->node;
 479         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &cptr, 1, OPAL_STRING))) {
 480             return ret;
 481         }
 482         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->rank, 1, OPAL_INT32))) {
 483             return ret;
 484         }
 485         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->pid, 1, OPAL_PID))) {
 486             return ret;
 487         }
 488         cptr = ptr[i]->cmd;
 489         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &cptr, 1, OPAL_STRING))) {
 490             return ret;
 491         }
 492         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->state[0], 1, OPAL_BYTE))) {
 493             return ret;
 494         }
 495         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->time, 1, OPAL_TIMEVAL))) {
 496             return ret;
 497         }
 498         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->priority, 1, OPAL_INT32))) {
 499             return ret;
 500         }
 501         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->num_threads, 1, OPAL_INT16))) {
 502             return ret;
 503         }
 504         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->pss, 1, OPAL_FLOAT))) {
 505             return ret;
 506         }
 507         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->vsize, 1, OPAL_FLOAT))) {
 508             return ret;
 509         }
 510         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->rss, 1, OPAL_FLOAT))) {
 511             return ret;
 512         }
 513         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->peak_vsize, 1, OPAL_FLOAT))) {
 514             return ret;
 515         }
 516         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->processor, 1, OPAL_INT16))) {
 517             return ret;
 518         }
 519         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->sample_time, 1, OPAL_TIMEVAL))) {
 520             return ret;
 521         }
 522     }
 523 
 524     return OPAL_SUCCESS;
 525 }
 526 
 527 static int pack_disk_stats(opal_buffer_t *buffer, opal_diskstats_t *dk)
 528 {
 529     uint64_t i64;
 530     int ret;
 531 
 532     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &dk->disk, 1, OPAL_STRING))) {
 533         return ret;
 534     }
 535     i64 = (uint64_t)dk->num_reads_completed;
 536     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 537         return ret;
 538     }
 539     i64 = (uint64_t)dk->num_reads_merged;
 540     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 541         return ret;
 542     }
 543     i64 = (uint64_t)dk->num_sectors_read;
 544     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 545         return ret;
 546     }
 547     i64 = (uint64_t)dk->milliseconds_reading;
 548     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 549         return ret;
 550     }
 551     i64 = (uint64_t)dk->num_writes_completed;
 552     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 553         return ret;
 554     }
 555     i64 = (uint64_t)dk->num_writes_merged;
 556     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 557         return ret;
 558     }
 559     i64 = (uint64_t)dk->num_sectors_written;
 560     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 561         return ret;
 562     }
 563     i64 = (uint64_t)dk->milliseconds_writing;
 564     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 565         return ret;
 566     }
 567     i64 = (uint64_t)dk->num_ios_in_progress;
 568     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 569         return ret;
 570     }
 571     i64 = (uint64_t)dk->milliseconds_io;
 572     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 573         return ret;
 574     }
 575     i64 = (uint64_t)dk->weighted_milliseconds_io;
 576     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 577         return ret;
 578     }
 579     return OPAL_SUCCESS;
 580 }
 581 
 582 static int pack_net_stats(opal_buffer_t *buffer, opal_netstats_t *ns)
 583 {
 584     uint64_t i64;
 585     int ret;
 586 
 587     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ns->net_interface, 1, OPAL_STRING))) {
 588         return ret;
 589     }
 590     i64 = (uint64_t)ns->num_bytes_recvd;
 591     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 592         return ret;
 593     }
 594     i64 = (uint64_t)ns->num_packets_recvd;
 595     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 596         return ret;
 597     }
 598     i64 = (uint64_t)ns->num_recv_errs;
 599     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 600         return ret;
 601     }
 602     i64 = (uint64_t)ns->num_bytes_sent;
 603     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 604         return ret;
 605     }
 606     i64 = (uint64_t)ns->num_packets_sent;
 607     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 608         return ret;
 609     }
 610     i64 = (uint64_t)ns->num_send_errs;
 611     if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &i64, 1, OPAL_UINT64))) {
 612         return ret;
 613     }
 614     return OPAL_SUCCESS;
 615 }
 616 
 617 /*
 618  * OPAL_NODE_STAT
 619  */
 620 int opal_dss_pack_node_stat(opal_buffer_t *buffer, const void *src,
 621                             int32_t num_vals, opal_data_type_t type)
 622 {
 623     opal_node_stats_t **ptr;
 624     int32_t i, j;
 625     int ret;
 626     opal_diskstats_t *ds;
 627     opal_netstats_t *ns;
 628 
 629     ptr = (opal_node_stats_t **) src;
 630 
 631     for (i = 0; i < num_vals; ++i) {
 632         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->la, 1, OPAL_FLOAT))) {
 633             return ret;
 634         }
 635         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->la5, 1, OPAL_FLOAT))) {
 636             return ret;
 637         }
 638         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->la15, 1, OPAL_FLOAT))) {
 639             return ret;
 640         }
 641         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->total_mem, 1, OPAL_FLOAT))) {
 642             return ret;
 643         }
 644         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->free_mem, 1, OPAL_FLOAT))) {
 645             return ret;
 646         }
 647         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->buffers, 1, OPAL_FLOAT))) {
 648             return ret;
 649         }
 650         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->cached, 1, OPAL_FLOAT))) {
 651             return ret;
 652         }
 653         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->swap_cached, 1, OPAL_FLOAT))) {
 654             return ret;
 655         }
 656         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->swap_total, 1, OPAL_FLOAT))) {
 657             return ret;
 658         }
 659         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->swap_free, 1, OPAL_FLOAT))) {
 660             return ret;
 661         }
 662         if (OPAL_SUCCESS != (ret = opal_dss_pack_float(buffer, &ptr[i]->mapped, 1, OPAL_FLOAT))) {
 663             return ret;
 664         }
 665         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->sample_time, 1, OPAL_TIMEVAL))) {
 666             return ret;
 667         }
 668         /* pack the number of disk stat objects on the list */
 669         j = opal_list_get_size(&ptr[i]->diskstats);
 670         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &j, 1, OPAL_INT32))) {
 671             return ret;
 672         }
 673         if (0 < j) {
 674             /* pack them */
 675             OPAL_LIST_FOREACH(ds, &ptr[i]->diskstats, opal_diskstats_t) {
 676                 if (OPAL_SUCCESS != (ret = pack_disk_stats(buffer, ds))) {
 677                     return ret;
 678                 }
 679             }
 680         }
 681         /* pack the number of net stat objects on the list */
 682         j = opal_list_get_size(&ptr[i]->netstats);
 683         if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &j, 1, OPAL_INT32))) {
 684             return ret;
 685         }
 686         if (0 < j) {
 687             /* pack them */
 688             OPAL_LIST_FOREACH(ns, &ptr[i]->netstats, opal_netstats_t) {
 689                 if (OPAL_SUCCESS != (ret = pack_net_stats(buffer, ns))) {
 690                     return ret;
 691                 }
 692             }
 693         }
 694     }
 695 
 696     return OPAL_SUCCESS;
 697 }
 698 
 699 /*
 700  * OPAL_VALUE
 701  */
 702 int opal_dss_pack_value(opal_buffer_t *buffer, const void *src,
 703                         int32_t num_vals, opal_data_type_t type)
 704 {
 705     opal_value_t **ptr;
 706     int32_t i, n;
 707     int ret;
 708 
 709     ptr = (opal_value_t **) src;
 710 
 711     for (i = 0; i < num_vals; ++i) {
 712         /* pack the key and type */
 713         if (OPAL_SUCCESS != (ret = opal_dss_pack_string(buffer, &ptr[i]->key, 1, OPAL_STRING))) {
 714             return ret;
 715         }
 716         if (OPAL_SUCCESS != (ret = opal_dss_pack_data_type(buffer, &ptr[i]->type, 1, OPAL_DATA_TYPE))) {
 717             return ret;
 718         }
 719         /* now pack the right field */
 720         switch (ptr[i]->type) {
 721         case OPAL_BOOL:
 722             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.flag, 1, OPAL_BOOL))) {
 723                 return ret;
 724             }
 725             break;
 726         case OPAL_BYTE:
 727             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.byte, 1, OPAL_BYTE))) {
 728                 return ret;
 729             }
 730             break;
 731         case OPAL_STRING:
 732             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.string, 1, OPAL_STRING))) {
 733                 return ret;
 734             }
 735             break;
 736         case OPAL_SIZE:
 737             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.size, 1, OPAL_SIZE))) {
 738                 return ret;
 739             }
 740             break;
 741         case OPAL_PID:
 742             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.pid, 1, OPAL_PID))) {
 743                 return ret;
 744             }
 745             break;
 746         case OPAL_INT:
 747             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.integer, 1, OPAL_INT))) {
 748                 return ret;
 749             }
 750             break;
 751         case OPAL_INT8:
 752             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.int8, 1, OPAL_INT8))) {
 753                 return ret;
 754             }
 755             break;
 756         case OPAL_INT16:
 757             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.int16, 1, OPAL_INT16))) {
 758                 return ret;
 759             }
 760             break;
 761         case OPAL_INT32:
 762             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.int32, 1, OPAL_INT32))) {
 763                 return ret;
 764             }
 765             break;
 766         case OPAL_INT64:
 767             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.int64, 1, OPAL_INT64))) {
 768                 return ret;
 769             }
 770             break;
 771         case OPAL_UINT:
 772             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.uint, 1, OPAL_UINT))) {
 773                 return ret;
 774             }
 775             break;
 776         case OPAL_UINT8:
 777         case OPAL_PERSIST:
 778         case OPAL_SCOPE:
 779         case OPAL_DATA_RANGE:
 780         case OPAL_PROC_STATE:
 781             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.uint8, 1, OPAL_UINT8))) {
 782                 return ret;
 783             }
 784             break;
 785         case OPAL_UINT16:
 786             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.uint16, 1, OPAL_UINT16))) {
 787                 return ret;
 788             }
 789             break;
 790         case OPAL_UINT32:
 791         case OPAL_INFO_DIRECTIVES:
 792             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.uint32, 1, OPAL_UINT32))) {
 793                 return ret;
 794             }
 795             break;
 796         case OPAL_UINT64:
 797             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.uint64, 1, OPAL_UINT64))) {
 798                 return ret;
 799             }
 800             break;
 801         case OPAL_BYTE_OBJECT:
 802             /* have to pack by hand so we can match unpack without allocation */
 803             n = ptr[i]->data.bo.size;
 804             if (OPAL_SUCCESS != (ret = opal_dss_pack_int32(buffer, &n, 1, OPAL_INT32))) {
 805                 return ret;
 806             }
 807             if (0 < n) {
 808                 if (OPAL_SUCCESS != (ret = opal_dss_pack_byte(buffer, ptr[i]->data.bo.bytes, n, OPAL_BYTE))) {
 809                     return ret;
 810                 }
 811             }
 812             break;
 813         case OPAL_FLOAT:
 814             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.fval, 1, OPAL_FLOAT))) {
 815                 return ret;
 816             }
 817             break;
 818         case OPAL_DOUBLE:
 819             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.dval, 1, OPAL_DOUBLE))) {
 820                 return ret;
 821             }
 822             break;
 823         case OPAL_TIMEVAL:
 824             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.tv, 1, OPAL_TIMEVAL))) {
 825                 return ret;
 826             }
 827             break;
 828         case OPAL_PTR:
 829             /* just ignore these values */
 830             break;
 831         case OPAL_NAME:
 832             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.name, 1, OPAL_NAME))) {
 833                 return ret;
 834             }
 835             break;
 836         case OPAL_STATUS:
 837             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.status, 1, OPAL_INT))) {
 838                 return ret;
 839             }
 840             break;
 841         case OPAL_ENVAR:
 842             if (OPAL_SUCCESS != (ret = opal_dss_pack_buffer(buffer, &ptr[i]->data.envar, 1, OPAL_ENVAR))) {
 843                 return ret;
 844             }
 845             break;
 846         default:
 847             opal_output(0, "PACK-OPAL-VALUE: UNSUPPORTED TYPE %d FOR KEY %s", (int)ptr[i]->type, ptr[i]->key);
 848             return OPAL_ERROR;
 849         }
 850     }
 851 
 852     return OPAL_SUCCESS;
 853 }
 854 
 855 
 856 /*
 857  * BUFFER CONTENTS
 858  */
 859 int opal_dss_pack_buffer_contents(opal_buffer_t *buffer, const void *src,
 860                                   int32_t num_vals, opal_data_type_t type)
 861 {
 862     opal_buffer_t **ptr;
 863     int32_t i;
 864     int ret;
 865 
 866     ptr = (opal_buffer_t **) src;
 867 
 868     for (i = 0; i < num_vals; ++i) {
 869         /* pack the number of bytes */
 870         OPAL_OUTPUT((opal_dss_verbose, "opal_dss_pack_buffer_contents: bytes_used %u\n", (unsigned)ptr[i]->bytes_used));
 871         if (OPAL_SUCCESS != (ret = opal_dss_pack_sizet(buffer, &ptr[i]->bytes_used, 1, OPAL_SIZE))) {
 872             return ret;
 873         }
 874         /* pack the bytes */
 875         if (0 < ptr[i]->bytes_used) {
 876             if (OPAL_SUCCESS != (ret = opal_dss_pack_byte(buffer, ptr[i]->base_ptr, ptr[i]->bytes_used, OPAL_BYTE))) {
 877                 return ret;
 878             }
 879         } else {
 880             ptr[i]->base_ptr = NULL;
 881         }
 882     }
 883     return OPAL_SUCCESS;
 884 }
 885 
 886 /*
 887  * NAME
 888  */
 889 int opal_dss_pack_name(opal_buffer_t *buffer, const void *src,
 890                            int32_t num_vals, opal_data_type_t type)
 891 {
 892     int rc;
 893     int32_t i;
 894     opal_process_name_t* proc;
 895     opal_jobid_t *jobid;
 896     opal_vpid_t *vpid;
 897 
 898     /* collect all the jobids in a contiguous array */
 899     jobid = (opal_jobid_t*)malloc(num_vals * sizeof(opal_jobid_t));
 900     if (NULL == jobid) {
 901         OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
 902         return OPAL_ERR_OUT_OF_RESOURCE;
 903     }
 904     proc = (opal_process_name_t*)src;
 905     for (i=0; i < num_vals; i++) {
 906         jobid[i] = proc->jobid;
 907         proc++;
 908     }
 909     /* now pack them in one shot */
 910     if (OPAL_SUCCESS != (rc =
 911                          opal_dss_pack_jobid(buffer, jobid, num_vals, OPAL_JOBID))) {
 912         OPAL_ERROR_LOG(rc);
 913         free(jobid);
 914         return rc;
 915     }
 916     free(jobid);
 917 
 918     /* collect all the vpids in a contiguous array */
 919     vpid = (opal_vpid_t*)malloc(num_vals * sizeof(opal_vpid_t));
 920     if (NULL == vpid) {
 921         OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
 922         return OPAL_ERR_OUT_OF_RESOURCE;
 923     }
 924     proc = (opal_process_name_t*)src;
 925     for (i=0; i < num_vals; i++) {
 926         vpid[i] = proc->vpid;
 927         proc++;
 928     }
 929     /* now pack them in one shot */
 930     if (OPAL_SUCCESS != (rc =
 931                          opal_dss_pack_vpid(buffer, vpid, num_vals, OPAL_VPID))) {
 932         OPAL_ERROR_LOG(rc);
 933         free(vpid);
 934         return rc;
 935     }
 936     free(vpid);
 937 
 938     return OPAL_SUCCESS;
 939 }
 940 
 941 /*
 942  * JOBID
 943  */
 944 int opal_dss_pack_jobid(opal_buffer_t *buffer, const void *src,
 945                             int32_t num_vals, opal_data_type_t type)
 946 {
 947     int ret;
 948 
 949     /* Turn around and pack the real type */
 950     if (OPAL_SUCCESS != (
 951                          ret = opal_dss_pack_buffer(buffer, src, num_vals, OPAL_JOBID_T))) {
 952         OPAL_ERROR_LOG(ret);
 953     }
 954 
 955     return ret;
 956 }
 957 
 958 /*
 959  * VPID
 960  */
 961 int opal_dss_pack_vpid(opal_buffer_t *buffer, const void *src,
 962                            int32_t num_vals, opal_data_type_t type)
 963 {
 964     int ret;
 965 
 966     /* Turn around and pack the real type */
 967     if (OPAL_SUCCESS != (
 968                          ret = opal_dss_pack_buffer(buffer, src, num_vals, OPAL_VPID_T))) {
 969         OPAL_ERROR_LOG(ret);
 970     }
 971 
 972     return ret;
 973 }
 974 
 975 /*
 976  * STATUS
 977  */
 978 int opal_dss_pack_status(opal_buffer_t *buffer, const void *src,
 979                          int32_t num_vals, opal_data_type_t type)
 980 {
 981     int ret;
 982 
 983     /* Turn around and pack the real type */
 984     ret = opal_dss_pack_buffer(buffer, src, num_vals, OPAL_INT);
 985     if (OPAL_SUCCESS != ret) {
 986         OPAL_ERROR_LOG(ret);
 987     }
 988 
 989     return ret;
 990 }
 991 
 992 int opal_dss_pack_envar(opal_buffer_t *buffer, const void *src,
 993                         int32_t num_vals, opal_data_type_t type)
 994 {
 995     int ret;
 996     int32_t n;
 997     opal_envar_t *ptr = (opal_envar_t*)src;
 998 
 999     for (n=0; n < num_vals; n++) {
1000         if (OPAL_SUCCESS != (ret = opal_dss_pack_string(buffer, &ptr[n].envar, 1, OPAL_STRING))) {
1001             return ret;
1002         }
1003         if (OPAL_SUCCESS != (ret = opal_dss_pack_string(buffer, &ptr[n].value, 1, OPAL_STRING))) {
1004             return ret;
1005         }
1006         if (OPAL_SUCCESS != (ret = opal_dss_pack_byte(buffer, &ptr[n].separator, 1, OPAL_BYTE))) {
1007             return ret;
1008         }
1009     }
1010     return OPAL_SUCCESS;
1011 }
/* [<][>][^][v][top][bottom][index][help] */
root/opal/dss/dss_pack.c

DEFINITIONS
