Update to PMIx v2.0.0rc1
Signed-off-by: Ralph Castain <rhc@open-mpi.org>
Этот коммит содержится в:
Ralph Castain
родитель
36457cbce6
Коммит
9f1f9d6606
@ -30,7 +30,7 @@ greek=
|
||||
# command, or with the date (if "git describe" fails) in the form of
|
||||
# "date<date>".
|
||||
|
||||
repo_rev=git217c369
|
||||
repo_rev=git1ce71dd
|
||||
|
||||
# If tarball_version is not empty, it is used as the version string in
|
||||
# the tarball filename, regardless of all other versions listed in
|
||||
@ -44,7 +44,7 @@ tarball_version=
|
||||
|
||||
# The date when this release was created
|
||||
|
||||
date="May 25, 2017"
|
||||
date="May 28, 2017"
|
||||
|
||||
# The shared library version of each of PMIx's public libraries.
|
||||
# These versions are maintained in accordance with the "Library
|
||||
|
||||
@ -690,6 +690,44 @@ typedef struct pmix_byte_object {
|
||||
} pmix_byte_object_t;
|
||||
|
||||
|
||||
/**** PMIX DATA BUFFER ****/
|
||||
typedef struct pmix_data_buffer {
|
||||
/** Start of my memory */
|
||||
char *base_ptr;
|
||||
/** Where the next data will be packed to (within the allocated
|
||||
memory starting at base_ptr) */
|
||||
char *pack_ptr;
|
||||
/** Where the next data will be unpacked from (within the
|
||||
allocated memory starting as base_ptr) */
|
||||
char *unpack_ptr;
|
||||
/** Number of bytes allocated (starting at base_ptr) */
|
||||
size_t bytes_allocated;
|
||||
/** Number of bytes used by the buffer (i.e., amount of data --
|
||||
including overhead -- packed in the buffer) */
|
||||
size_t bytes_used;
|
||||
} pmix_data_buffer_t;
|
||||
#define PMIX_DATA_BUFFER_CREATE(m) \
|
||||
do { \
|
||||
(m) = (pmix_data_buffer_t*)calloc(1, sizeof(pmix_data_buffer_t)); \
|
||||
} while (0)
|
||||
#define PMIX_DATA_BUFFER_RELEASE(m) \
|
||||
do { \
|
||||
if (NULL != (m)->base_ptr) { \
|
||||
free((m)->base_ptr); \
|
||||
} \
|
||||
free((m)); \
|
||||
(m) = NULL; \
|
||||
} while (0)
|
||||
#define PMIX_DATA_BUFFER_CONSTRUCT(m) \
|
||||
memset((m), 0, sizeof(pmix_data_buffer_t))
|
||||
#define PMIX_DATA_BUFFER_DESTRUCT(m) \
|
||||
do { \
|
||||
if (NULL != (m)->base_ptr) { \
|
||||
free((m)->base_ptr); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
|
||||
/**** PMIX PROC OBJECT ****/
|
||||
typedef struct pmix_proc {
|
||||
char nspace[PMIX_MAX_NSLEN+1];
|
||||
@ -700,9 +738,10 @@ typedef struct pmix_proc {
|
||||
(m) = (pmix_proc_t*)calloc((n) , sizeof(pmix_proc_t)); \
|
||||
} while (0)
|
||||
|
||||
#define PMIX_PROC_RELEASE(m) \
|
||||
do { \
|
||||
PMIX_PROC_FREE((m)); \
|
||||
#define PMIX_PROC_RELEASE(m) \
|
||||
do { \
|
||||
free((m)); \
|
||||
(m) = NULL; \
|
||||
} while (0)
|
||||
|
||||
#define PMIX_PROC_CONSTRUCT(m) \
|
||||
@ -957,7 +996,6 @@ pmix_status_t pmix_setenv(const char *name, const char *value,
|
||||
#define PMIX_SETENV(a, b, c) \
|
||||
pmix_setenv((a), (b), true, (c))
|
||||
|
||||
|
||||
/**** PMIX INFO STRUCT ****/
|
||||
struct pmix_info_t {
|
||||
char key[PMIX_MAX_KEYLEN+1]; // ensure room for the NULL terminator
|
||||
@ -1492,6 +1530,209 @@ pmix_status_t PMIx_Store_internal(const pmix_proc_t *proc,
|
||||
const char *key, pmix_value_t *val);
|
||||
|
||||
|
||||
/**
|
||||
* Top-level interface function to pack one or more values into a
|
||||
* buffer.
|
||||
*
|
||||
* The pack function packs one or more values of a specified type into
|
||||
* the specified buffer. The buffer must have already been
|
||||
* initialized via the PMIX_DATA_BUFFER_CREATE or PMIX_DATA_BUFFER_CONSTRUCT
|
||||
* call - otherwise, the pack_value function will return an error.
|
||||
* Providing an unsupported type flag will likewise be reported as an error.
|
||||
*
|
||||
* Note that any data to be packed that is not hard type cast (i.e.,
|
||||
* not type cast to a specific size) may lose precision when unpacked
|
||||
* by a non-homogeneous recipient. The PACK function will do its best to deal
|
||||
* with heterogeneity issues between the packer and unpacker in such
|
||||
* cases. Sending a number larger than can be handled by the recipient
|
||||
* will return an error code (generated upon unpacking) -
|
||||
* the error cannot be detected during packing.
|
||||
*
|
||||
* @param *buffer A pointer to the buffer into which the value is to
|
||||
* be packed.
|
||||
*
|
||||
* @param *src A void* pointer to the data that is to be packed. Note
|
||||
* that strings are to be passed as (char **) - i.e., the caller must
|
||||
* pass the address of the pointer to the string as the void*. This
|
||||
* allows PMIx to use a single pack function, but still allow
|
||||
* the caller to pass multiple strings in a single call.
|
||||
*
|
||||
* @param num_values An int32_t indicating the number of values that are
|
||||
* to be packed, beginning at the location pointed to by src. A string
|
||||
* value is counted as a single value regardless of length. The values
|
||||
* must be contiguous in memory. Arrays of pointers (e.g., string
|
||||
* arrays) should be contiguous, although (obviously) the data pointed
|
||||
* to need not be contiguous across array entries.
|
||||
*
|
||||
* @param type The type of the data to be packed - must be one of the
|
||||
* PMIX defined data types.
|
||||
*
|
||||
* @retval PMIX_SUCCESS The data was packed as requested.
|
||||
*
|
||||
* @retval PMIX_ERROR(s) An appropriate PMIX error code indicating the
|
||||
* problem encountered. This error code should be handled
|
||||
* appropriately.
|
||||
*
|
||||
* @code
|
||||
* pmix_data_buffer_t *buffer;
|
||||
* int32_t src;
|
||||
*
|
||||
* PMIX_DATA_BUFFER_CREATE(buffer);
|
||||
* status_code = PMIx_Data_pack(buffer, &src, 1, PMIX_INT32);
|
||||
* @endcode
|
||||
*/
|
||||
pmix_status_t PMIx_Data_pack(pmix_data_buffer_t *buffer,
|
||||
void *src, int32_t num_vals,
|
||||
pmix_data_type_t type);
|
||||
|
||||
/**
|
||||
* Unpack values from a buffer.
|
||||
*
|
||||
* The unpack function unpacks the next value (or values) of a
|
||||
* specified type from the specified buffer.
|
||||
*
|
||||
* The buffer must have already been initialized via an PMIX_DATA_BUFFER_CREATE or
|
||||
* PMIX_DATA_BUFFER_CONSTRUCT call (and assumedly filled with some data) -
|
||||
* otherwise, the unpack_value function will return an
|
||||
* error. Providing an unsupported type flag will likewise be reported
|
||||
* as an error, as will specifying a data type that DOES NOT match the
|
||||
* type of the next item in the buffer. An attempt to read beyond the
|
||||
* end of the stored data held in the buffer will also return an
|
||||
* error.
|
||||
*
|
||||
* NOTE: it is possible for the buffer to be corrupted and that
|
||||
* PMIx will *think* there is a proper variable type at the
|
||||
* beginning of an unpack region - but that the value is bogus (e.g., just
|
||||
* a byte field in a string array that so happens to have a value that
|
||||
* matches the specified data type flag). Therefore, the data type error check
|
||||
* is NOT completely safe. This is true for ALL unpack functions.
|
||||
*
|
||||
*
|
||||
* Unpacking values is a "nondestructive" process - i.e., the values are
|
||||
* not removed from the buffer. It is therefore possible for the caller
|
||||
* to re-unpack a value from the same buffer by resetting the unpack_ptr.
|
||||
*
|
||||
* Warning: The caller is responsible for providing adequate memory
|
||||
* storage for the requested data. As noted below, the user
|
||||
* must provide a parameter indicating the maximum number of values that
|
||||
* can be unpacked into the allocated memory. If more values exist in the
|
||||
* buffer than can fit into the memory storage, then the function will unpack
|
||||
* what it can fit into that location and return an error code indicating
|
||||
* that the buffer was only partially unpacked.
|
||||
*
|
||||
* Note that any data that was not hard type cast (i.e., not type cast
|
||||
* to a specific size) when packed may lose precision when unpacked by
|
||||
* a non-homogeneous recipient. PMIx will do its best to deal with
|
||||
* heterogeneity issues between the packer and unpacker in such
|
||||
* cases. Sending a number larger than can be handled by the recipient
|
||||
* will return an error code generated upon unpacking - these errors
|
||||
* cannot be detected during packing.
|
||||
*
|
||||
* @param *buffer A pointer to the buffer from which the value will be
|
||||
* extracted.
|
||||
*
|
||||
* @param *dest A void* pointer to the memory location into which the
|
||||
* data is to be stored. Note that these values will be stored
|
||||
* contiguously in memory. For strings, this pointer must be to (char
|
||||
* **) to provide a means of supporting multiple string
|
||||
* operations. The unpack function will allocate memory for each
|
||||
* string in the array - the caller must only provide adequate memory
|
||||
* for the array of pointers.
|
||||
*
|
||||
* @param type The type of the data to be unpacked - must be one of
|
||||
* the BFROP defined data types.
|
||||
*
|
||||
* @retval *max_num_values The number of values actually unpacked. In
|
||||
* most cases, this should match the maximum number provided in the
|
||||
* parameters - but in no case will it exceed the value of this
|
||||
* parameter. Note that if you unpack fewer values than are actually
|
||||
* available, the buffer will be in an unpackable state - the function will
|
||||
* return an error code to warn of this condition.
|
||||
*
|
||||
* @note The unpack function will return the actual number of values
|
||||
* unpacked in this location.
|
||||
*
|
||||
* @retval PMIX_SUCCESS The next item in the buffer was successfully
|
||||
* unpacked.
|
||||
*
|
||||
* @retval PMIX_ERROR(s) The unpack function returns an error code
|
||||
* under one of several conditions: (a) the number of values in the
|
||||
* item exceeds the max num provided by the caller; (b) the type of
|
||||
* the next item in the buffer does not match the type specified by
|
||||
* the caller; or (c) the unpack failed due to either an error in the
|
||||
* buffer or an attempt to read past the end of the buffer.
|
||||
*
|
||||
* @code
|
||||
* pmix_data_buffer_t *buffer;
|
||||
* int32_t dest;
|
||||
* char **string_array;
|
||||
* int32_t num_values;
|
||||
*
|
||||
* num_values = 1;
|
||||
* status_code = PMIx_Data_unpack(buffer, (void*)&dest, &num_values, PMIX_INT32);
|
||||
*
|
||||
* num_values = 5;
|
||||
* string_array = malloc(num_values*sizeof(char *));
|
||||
* status_code = PMIx_Data_unpack(buffer, (void*)(string_array), &num_values, PMIX_STRING);
|
||||
*
|
||||
* @endcode
|
||||
*/
|
||||
pmix_status_t PMIx_Data_unpack(pmix_data_buffer_t *buffer, void *dest,
|
||||
int32_t *max_num_values,
|
||||
pmix_data_type_t type);
|
||||
|
||||
/**
|
||||
* Copy a data value from one location to another.
|
||||
*
|
||||
* Since registered data types can be complex structures, the system
|
||||
* needs some way to know how to copy the data from one location to
|
||||
* another (e.g., for storage in the registry). This function, which
|
||||
* can call other copy functions to build up complex data types, defines
|
||||
* the method for making a copy of the specified data type.
|
||||
*
|
||||
* @param **dest The address of a pointer into which the
|
||||
* address of the resulting data is to be stored.
|
||||
*
|
||||
* @param *src A pointer to the memory location from which the
|
||||
* data is to be copied.
|
||||
*
|
||||
* @param type The type of the data to be copied - must be one of
|
||||
* the PMIx defined data types.
|
||||
*
|
||||
* @retval PMIX_SUCCESS The value was successfully copied.
|
||||
*
|
||||
* @retval PMIX_ERROR(s) An appropriate error code.
|
||||
*
|
||||
*/
|
||||
pmix_status_t PMIx_Data_copy(void **dest, void *src, pmix_data_type_t type);
|
||||
|
||||
/**
|
||||
* Print a data value.
|
||||
*
|
||||
* Since registered data types can be complex structures, the system
|
||||
* needs some way to know how to print them (i.e., convert them to a string
|
||||
* representation). Provided for debug purposes.
|
||||
*
|
||||
* @retval PMIX_SUCCESS The value was successfully printed.
|
||||
*
|
||||
* @retval PMIX_ERROR(s) An appropriate error code.
|
||||
*/
|
||||
pmix_status_t PMIx_Data_print(char **output, char *prefix,
|
||||
void *src, pmix_data_type_t type);
|
||||
|
||||
/**
|
||||
* Copy a payload from one buffer to another
|
||||
*
|
||||
* This function will append a copy of the payload in one buffer into
|
||||
* another buffer.
|
||||
* NOTE: This is NOT a destructive procedure - the
|
||||
* source buffer's payload will remain intact, as will any pre-existing
|
||||
* payload in the destination's buffer.
|
||||
*/
|
||||
pmix_status_t PMIx_Data_copy_payload(pmix_data_buffer_t *dest,
|
||||
pmix_data_buffer_t *src);
|
||||
|
||||
|
||||
/* Key-Value pair management macros */
|
||||
// TODO: add all possible types/fields here.
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
* Copyright (c) 2014-2017 Intel, Inc. All rights reserved.
|
||||
* Copyright (c) 2015 Research Organization for Information Science
|
||||
* and Technology (RIST). All rights reserved.
|
||||
* Copyright (c) 2016 IBM Corporation. All rights reserved.
|
||||
* Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
|
||||
* $COPYRIGHT$
|
||||
*
|
||||
* Additional copyrights may follow
|
||||
@ -46,7 +46,7 @@ pmix_pointer_array_t pmix_bfrop_types = {{0}};
|
||||
pmix_data_type_t pmix_bfrop_num_reg_types = PMIX_UNDEF;
|
||||
static pmix_bfrop_buffer_type_t pmix_default_buf_type = PMIX_BFROP_BUFFER_NON_DESC;
|
||||
|
||||
pmix_bfrop_t pmix_bfrop = {
|
||||
PMIX_EXPORT pmix_bfrop_t pmix_bfrop = {
|
||||
pmix_bfrop_pack,
|
||||
pmix_bfrop_unpack,
|
||||
pmix_bfrop_copy,
|
||||
@ -149,7 +149,7 @@ PMIX_EXPORT PMIX_CLASS_INSTANCE(pmix_regex_value_t,
|
||||
pmix_list_item_t,
|
||||
rvcon, rvdes);
|
||||
|
||||
pmix_status_t pmix_bfrop_open(void)
|
||||
PMIX_EXPORT pmix_status_t pmix_bfrop_open(void)
|
||||
{
|
||||
pmix_status_t rc;
|
||||
|
||||
@ -445,7 +445,7 @@ pmix_status_t pmix_bfrop_open(void)
|
||||
}
|
||||
|
||||
|
||||
pmix_status_t pmix_bfrop_close(void)
|
||||
PMIX_EXPORT pmix_status_t pmix_bfrop_close(void)
|
||||
{
|
||||
int32_t i;
|
||||
|
||||
|
||||
@ -14,4 +14,5 @@ sources += \
|
||||
common/pmix_strings.c \
|
||||
common/pmix_log.c \
|
||||
common/pmix_jobdata.c \
|
||||
common/pmix_control.c
|
||||
common/pmix_control.c \
|
||||
common/pmix_data.c
|
||||
|
||||
159
opal/mca/pmix/pmix2x/pmix/src/common/pmix_data.c
Обычный файл
159
opal/mca/pmix/pmix2x/pmix/src/common/pmix_data.c
Обычный файл
@ -0,0 +1,159 @@
|
||||
/*
|
||||
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
|
||||
* University Research and Technology
|
||||
* Corporation. All rights reserved.
|
||||
* Copyright (c) 2004-2005 The University of Tennessee and The University
|
||||
* of Tennessee Research Foundation. All rights
|
||||
* reserved.
|
||||
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
||||
* University of Stuttgart. All rights reserved.
|
||||
* Copyright (c) 2004-2005 The Regents of the University of California.
|
||||
* All rights reserved.
|
||||
* Copyright (c) 2007-2012 Los Alamos National Security, LLC.
|
||||
* All rights reserved.
|
||||
* Copyright (c) 2014-2017 Intel, Inc. All rights reserved.
|
||||
* $COPYRIGHT$
|
||||
*
|
||||
* Additional copyrights may follow
|
||||
*
|
||||
* $HEADER$
|
||||
*/
|
||||
|
||||
#include <src/include/pmix_config.h>
|
||||
|
||||
|
||||
#ifdef HAVE_STRING_H
|
||||
#include <string.h>
|
||||
#endif
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#ifdef HAVE_STDLIB_H
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#include <pmix_common.h>
|
||||
#include <pmix_rename.h>
|
||||
|
||||
#include "src/buffer_ops/buffer_ops.h"
|
||||
|
||||
#define PMIX_EMBED_DATA_BUFFER(b, db) \
|
||||
do { \
|
||||
(b)->base_ptr = (db)->base_ptr; \
|
||||
(b)->pack_ptr = (db)->pack_ptr; \
|
||||
(b)->unpack_ptr = (db)->unpack_ptr; \
|
||||
(b)->bytes_allocated = (db)->bytes_allocated; \
|
||||
(b)->bytes_used = (db)->bytes_used; \
|
||||
(db)->base_ptr = NULL; \
|
||||
(db)->pack_ptr = NULL; \
|
||||
(db)->unpack_ptr = NULL; \
|
||||
(db)->bytes_allocated = 0; \
|
||||
(db)->bytes_used = 0; \
|
||||
} while (0)
|
||||
|
||||
#define PMIX_EXTRACT_DATA_BUFFER(b, db) \
|
||||
do { \
|
||||
(db)->base_ptr = (b)->base_ptr; \
|
||||
(db)->pack_ptr = (b)->pack_ptr; \
|
||||
(db)->unpack_ptr = (b)->unpack_ptr; \
|
||||
(db)->bytes_allocated = (b)->bytes_allocated; \
|
||||
(db)->bytes_used = (b)->bytes_used; \
|
||||
(b)->base_ptr = NULL; \
|
||||
(b)->pack_ptr = NULL; \
|
||||
(b)->unpack_ptr = NULL; \
|
||||
(b)->bytes_allocated = 0; \
|
||||
(b)->bytes_used = 0; \
|
||||
} while (0)
|
||||
|
||||
PMIX_EXPORT pmix_status_t PMIx_Data_pack(pmix_data_buffer_t *buffer,
|
||||
void *src, int32_t num_vals,
|
||||
pmix_data_type_t type)
|
||||
{
|
||||
pmix_status_t rc;
|
||||
pmix_buffer_t buf;
|
||||
|
||||
/* setup the host */
|
||||
PMIX_CONSTRUCT(&buf, pmix_buffer_t);
|
||||
|
||||
/* embed the data buffer into a buffer */
|
||||
PMIX_EMBED_DATA_BUFFER(&buf, buffer);
|
||||
|
||||
/* pack the value */
|
||||
rc = pmix_bfrop.pack(&buf, src, num_vals, type);
|
||||
|
||||
/* extract the data buffer - the pointers may have changed */
|
||||
PMIX_EXTRACT_DATA_BUFFER(&buf, buffer);
|
||||
|
||||
/* no need to cleanup as all storage was xfered */
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
PMIX_EXPORT pmix_status_t PMIx_Data_unpack(pmix_data_buffer_t *buffer, void *dest,
|
||||
int32_t *max_num_values,
|
||||
pmix_data_type_t type)
|
||||
{
|
||||
pmix_status_t rc;
|
||||
pmix_buffer_t buf;
|
||||
|
||||
/* setup the host */
|
||||
PMIX_CONSTRUCT(&buf, pmix_buffer_t);
|
||||
|
||||
/* embed the data buffer into a buffer */
|
||||
PMIX_EMBED_DATA_BUFFER(&buf, buffer);
|
||||
|
||||
/* unpack the value */
|
||||
rc = pmix_bfrop.unpack(&buf, dest, max_num_values, type);
|
||||
|
||||
/* extract the data buffer - the pointers may have changed */
|
||||
PMIX_EXTRACT_DATA_BUFFER(&buf, buffer);
|
||||
|
||||
/* no need to cleanup as all storage was xfered */
|
||||
return rc;
|
||||
}
|
||||
|
||||
PMIX_EXPORT pmix_status_t PMIx_Data_copy(void **dest, void *src,
|
||||
pmix_data_type_t type)
|
||||
{
|
||||
pmix_status_t rc;
|
||||
|
||||
/* copy the value */
|
||||
rc = pmix_bfrop.copy(dest, src, type);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
PMIX_EXPORT pmix_status_t PMIx_Data_print(char **output, char *prefix,
|
||||
void *src, pmix_data_type_t type)
|
||||
{
|
||||
pmix_status_t rc;
|
||||
|
||||
/* print the value */
|
||||
rc = pmix_bfrop.print(output, prefix, src, type);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
PMIX_EXPORT pmix_status_t PMIx_Data_copy_payload(pmix_data_buffer_t *dest,
|
||||
pmix_data_buffer_t *src)
|
||||
{
|
||||
pmix_status_t rc;
|
||||
pmix_buffer_t buf1, buf2;
|
||||
|
||||
/* setup the hosts */
|
||||
PMIX_CONSTRUCT(&buf1, pmix_buffer_t);
|
||||
PMIX_CONSTRUCT(&buf2, pmix_buffer_t);
|
||||
|
||||
/* embed the data buffer into a buffer */
|
||||
PMIX_EMBED_DATA_BUFFER(&buf1, dest);
|
||||
PMIX_EMBED_DATA_BUFFER(&buf2, src);
|
||||
|
||||
/* copy payload */
|
||||
rc = pmix_bfrop.copy_payload(&buf1, &buf2);
|
||||
|
||||
/* extract the dest data buffer - the pointers may have changed */
|
||||
PMIX_EXTRACT_DATA_BUFFER(&buf1, dest);
|
||||
PMIX_EXTRACT_DATA_BUFFER(&buf2, src);
|
||||
|
||||
/* no need to cleanup as all storage was xfered */
|
||||
return rc;
|
||||
}
|
||||
@ -20,6 +20,8 @@
|
||||
#include "src/util/argv.h"
|
||||
#include "src/util/compress.h"
|
||||
#include "src/util/hash.h"
|
||||
#include "src/util/show_help.h"
|
||||
#include "src/runtime/pmix_rte.h"
|
||||
#include "src/include/pmix_jobdata.h"
|
||||
|
||||
#if defined(PMIX_ENABLE_DSTORE) && (PMIX_ENABLE_DSTORE == 1)
|
||||
@ -77,6 +79,7 @@ static inline int _rank_key_dstore_store(void *cbdata)
|
||||
pmix_job_data_caddy_t *cb = (pmix_job_data_caddy_t*)cbdata;
|
||||
pmix_rank_t rank;
|
||||
pmix_kval_t *kv = NULL;
|
||||
bool flag = true;
|
||||
|
||||
if (NULL == cb->bufs) {
|
||||
rc = PMIX_ERR_BAD_PARAM;
|
||||
@ -93,9 +96,22 @@ static inline int _rank_key_dstore_store(void *cbdata)
|
||||
tmp = &(PMIX_VALUE_ARRAY_GET_ITEM(cb->bufs, pmix_buffer_t, i));
|
||||
rank = 0 == i ? PMIX_RANK_WILDCARD : i - 1;
|
||||
PMIX_UNLOAD_BUFFER(tmp, kv->value->data.bo.bytes, kv->value->data.bo.size);
|
||||
if (PMIX_SUCCESS != (rc = cb->dstore_fn(cb->nsptr->nspace, rank, kv))) {
|
||||
PMIX_ERROR_LOG(rc);
|
||||
goto exit;
|
||||
if (NULL == kv->value->data.bo.bytes) {
|
||||
if (flag && !pmix_suppress_missing_data_warning) {
|
||||
/* this occurs if the host RM did _not_ provide us with
|
||||
* data for every process in the job, in non-compliance
|
||||
* with the PMIx standard. Warn the user that their job
|
||||
* may not scale as desired, and give them a way to turn
|
||||
* that warning off in case the RM just can't do it */
|
||||
pmix_show_help("help-pmix-runtime.txt", "missingdata", true);
|
||||
/* only show this once */
|
||||
flag = false;
|
||||
}
|
||||
} else {
|
||||
if (PMIX_SUCCESS != (rc = cb->dstore_fn(cb->nsptr->nspace, rank, kv))) {
|
||||
PMIX_ERROR_LOG(rc);
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -181,6 +181,9 @@ void pmix_event_timeout_cb(int fd, short flags, void *arg);
|
||||
PMIX_INFO_FREE(ch->info, ch->ninfo); \
|
||||
ch->info = info; \
|
||||
ch->ninfo = ninfo; \
|
||||
/* reset the timer */ \
|
||||
pmix_event_del(&ch->ev); \
|
||||
pmix_event_add(&ch->ev, &pmix_globals.event_window); \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
|
||||
@ -3,6 +3,8 @@
|
||||
* Copyright (c) 2014-2017 Intel, Inc. All rights reserved.
|
||||
* Copyright (c) 2017 Research Organization for Information Science
|
||||
* and Technology (RIST). All rights reserved.
|
||||
* Copyright (c) 2017 IBM Corporation. All rights reserved.
|
||||
*
|
||||
* $COPYRIGHT$
|
||||
*
|
||||
* Additional copyrights may follow
|
||||
@ -848,6 +850,23 @@ pmix_status_t pmix_server_notify_client_of_event(pmix_status_t status,
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
* If the range is PMIX_RANGE_NAMESPACE, then they should not have set a
|
||||
* PMIX_EVENT_CUSTOM_RANGE info object or at least we should ignore it
|
||||
*/
|
||||
if (PMIX_RANGE_NAMESPACE == cd->range) {
|
||||
if (cd->targets) {
|
||||
PMIX_PROC_FREE(cd->targets, cd->ntargets);
|
||||
}
|
||||
PMIX_PROC_CREATE(cd->targets, 1);
|
||||
cd->ntargets = 1;
|
||||
cd->targets[0].rank = PMIX_RANK_WILDCARD;
|
||||
if (NULL == source) {
|
||||
strncpy(cd->targets[0].nspace, "UNDEF", PMIX_MAX_NSLEN);
|
||||
} else {
|
||||
strncpy(cd->targets[0].nspace, source->nspace, PMIX_MAX_NSLEN);
|
||||
}
|
||||
}
|
||||
|
||||
/* pack the command */
|
||||
if (PMIX_SUCCESS != (rc = pmix_bfrop.pack(cd->buf, &cmd, 1, PMIX_CMD))) {
|
||||
|
||||
@ -63,7 +63,7 @@ AC_DEFUN([MCA_pmix_pdl_pdlopen_CONFIG],[
|
||||
])
|
||||
|
||||
AS_IF([test "$pmix_pdl_pdlopen_happy" = "yes"],
|
||||
[pdl_pdlopen_ADD_LIBS=$pmix_pdl_pdlopen_LIBS
|
||||
[pmix_pdl_pdlopen_ADD_LIBS=$pmix_pdl_pdlopen_LIBS
|
||||
$1],
|
||||
[$2])
|
||||
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
# All rights reserved.
|
||||
# Copyright (c) 2011 Oak Ridge National Labs. All rights reserved.
|
||||
# Copyright (c) 2014 Cisco Systems, Inc. All rights reserved.
|
||||
# Copyright (c) 2017 Intel, Inc. All rights reserved.
|
||||
# $COPYRIGHT$
|
||||
#
|
||||
# Additional copyrights may follow
|
||||
@ -31,38 +32,11 @@ PMIX developer):
|
||||
%s failed
|
||||
--> Returned value %d instead of PMIX_SUCCESS
|
||||
#
|
||||
[pmix_cr_init:no-crs]
|
||||
It looks like pmix_cr_init failed. This usually means that the CRS component
|
||||
could not be activated on this machine. Check the installation of your
|
||||
checkpointer, MCA parameters, and configuration. If all of that seems
|
||||
correct, then copy this error message with the additional information below
|
||||
to the PMIX users list.
|
||||
Function: %s
|
||||
Return value: %d
|
||||
#
|
||||
# Just want a clean printout for sys limit as the
|
||||
# message was already generated by show-help
|
||||
[pmix_init:syslimit]
|
||||
%s
|
||||
#
|
||||
[pmix_init:warn-fork]
|
||||
A process has executed an operation involving a call to the
|
||||
"fork()" system call to create a child process. PMIX is currently
|
||||
operating in a condition that could result in memory corruption or
|
||||
other system errors; your job may hang, crash, or produce silent
|
||||
data corruption. The use of fork() (or system() or other calls that
|
||||
create child processes) is strongly discouraged.
|
||||
[missingdata]
|
||||
PMIx has detected that the host RM failed to provide all the job-level
|
||||
information specified by the PMIx standard. This is not necessarily
|
||||
a fatal situation, but may negatively impact your launch performance.
|
||||
|
||||
The process that invoked fork was:
|
||||
|
||||
Local host: %s (PID %d)
|
||||
|
||||
If you are *absolutely sure* that your application will successfully
|
||||
and correctly survive a call to fork(), you may disable this warning
|
||||
by setting the mpi_warn_on_fork MCA parameter to 0.
|
||||
#
|
||||
[mpi-params:leave-pinned-and-pipeline-selected]
|
||||
WARNING: Cannot set both the MCA parameters pmix_leave_pinned (a.k.a.,
|
||||
mpi_leave_pinned) and pmix_leave_pinned_pipeline (a.k.a.,
|
||||
mpi_leave_pinned_pipeline) to "true". Defaulting to mpi_leave_pinned
|
||||
ONLY.
|
||||
If you feel you have received this warning in error, or wish to ignore
|
||||
it in the future, you can disable it by setting the PMIx MCA parameter
|
||||
"pmix_suppress_missing_data_warning=1"
|
||||
|
||||
@ -43,7 +43,8 @@ bool pmix_timing_overhead = true;
|
||||
|
||||
static bool pmix_register_done = false;
|
||||
char *pmix_net_private_ipv4 = NULL;
|
||||
int pmix_event_caching_window;
|
||||
int pmix_event_caching_window = 1;
|
||||
bool pmix_suppress_missing_data_warning = false;
|
||||
|
||||
pmix_status_t pmix_register_params(void)
|
||||
{
|
||||
@ -91,14 +92,20 @@ pmix_status_t pmix_register_params(void)
|
||||
return ret;
|
||||
}
|
||||
|
||||
pmix_event_caching_window = 3;
|
||||
(void) pmix_mca_base_var_register ("pmix", "pmix", NULL, "event_caching_window",
|
||||
"Time (in seconds) to cache events before reporting them - this "
|
||||
"allows for event aggregation",
|
||||
"Time (in seconds) to aggregate events before reporting them - this "
|
||||
"suppresses event cascades when processes abnormally terminate",
|
||||
PMIX_MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
|
||||
PMIX_INFO_LVL_9, PMIX_MCA_BASE_VAR_SCOPE_ALL,
|
||||
PMIX_INFO_LVL_1, PMIX_MCA_BASE_VAR_SCOPE_ALL,
|
||||
&pmix_event_caching_window);
|
||||
|
||||
(void) pmix_mca_base_var_register ("pmix", "pmix", NULL, "suppress_missing_data_warning",
|
||||
"Suppress warning that PMIx is missing job-level data that "
|
||||
"is supposed to be provided by the host RM.",
|
||||
PMIX_MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
|
||||
PMIX_INFO_LVL_1, PMIX_MCA_BASE_VAR_SCOPE_ALL,
|
||||
&pmix_suppress_missing_data_warning);
|
||||
|
||||
return PMIX_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
@ -47,6 +47,7 @@ extern bool pmix_timing_overhead;
|
||||
extern int pmix_initialized;
|
||||
extern char *pmix_net_private_ipv4;
|
||||
extern int pmix_event_caching_window;
|
||||
extern bool pmix_suppress_missing_data_warning;
|
||||
|
||||
/** version string of pmix */
|
||||
extern const char pmix_version_string[];
|
||||
|
||||
@ -123,8 +123,12 @@ int main(int argc, char **argv)
|
||||
|
||||
/* rank=0 dies */
|
||||
if (4 < nprocs) {
|
||||
/* have two exit */
|
||||
if (myproc.rank < 2) {
|
||||
/* have one exit */
|
||||
if (0 == myproc.rank) {
|
||||
pmix_output(0, "Client ns %s rank %d: bye-bye!", myproc.nspace, myproc.rank);
|
||||
exit(1);
|
||||
} else if (1 == myproc.rank) {
|
||||
usleep(500000);
|
||||
pmix_output(0, "Client ns %s rank %d: bye-bye!", myproc.nspace, myproc.rank);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
Загрузка…
Ссылка в новой задаче
Block a user