ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Reset OMPI master to PMIx master

Просмотр исходного кода 
Track PMIx master instead of the reference server - fixes problem of external PMIx master builds.

Signed-off-by: Ralph Castain <rhc@open-mpi.org>
Этот коммит содержится в:
Ralph Castain 2018-03-25 08:36:46 -07:00
родитель 77ff99e9ee
Коммит e443adc7a1
45 изменённых файлов: 1438 добавлений и 1128 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

4
opal/mca/pmix/pmix3x/pmix/VERSION
Просмотреть файл

@ -30,7 +30,7 @@ greek=
# command, or with the date (if "git describe" fails) in the form of
# "date<date>".
repo_rev=git36e7e24
repo_rev=gitf0b8151
# 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="Feb 09, 2018"
date="Mar 24, 2018"
# The shared library version of each of PMIx's public libraries.
# These versions are maintained in accordance with the "Library

18
opal/mca/pmix/pmix3x/pmix/config/pmix.m4
Просмотреть файл

@ -12,12 +12,12 @@ dnl Copyright (c) 2004-2005 The Regents of the University of California.
dnl All rights reserved.
dnl Copyright (c) 2006-2016 Cisco Systems, Inc. All rights reserved.
dnl Copyright (c) 2007 Sun Microsystems, Inc. All rights reserved.
dnl Copyright (c) 2009 IBM Corporation. All rights reserved.
dnl Copyright (c) 2009-2018 IBM Corporation. All rights reserved.
dnl Copyright (c) 2009 Los Alamos National Security, LLC. All rights
dnl reserved.
dnl Copyright (c) 2009-2011 Oak Ridge National Labs. All rights reserved.
dnl Copyright (c) 2011-2013 NVIDIA Corporation. All rights reserved.
dnl Copyright (c) 2013-2017 Intel, Inc. All rights reserved.
dnl Copyright (c) 2013-2018 Intel, Inc. All rights reserved.
dnl Copyright (c) 2015-2017 Research Organization for Information Science
dnl and Technology (RIST). All rights reserved.
dnl Copyright (c) 2016 Mellanox Technologies, Inc.
@ -109,12 +109,6 @@ AC_DEFUN([PMIX_SETUP_CORE],[
AC_DEFINE_UNQUOTED([PMIX_MINOR_VERSION], [$PMIX_MINOR_VERSION],
[The library minor version is always available, contrary to VERSION])
pmixmajor=${PMIX_MAJOR_VERSION}L
pmixminor=${PMIX_MINOR_VERSION}L
AC_SUBST(pmixmajor)
AC_SUBST(pmixminor)
AC_CONFIG_FILES(pmix_config_prefix[include/pmix_version.h])
PMIX_RELEASE_VERSION="`$PMIX_top_srcdir/config/pmix_get_version.sh $PMIX_top_srcdir/VERSION --release`"
if test "$?" != "0"; then
AC_MSG_ERROR([Cannot continue])
@ -123,6 +117,14 @@ AC_DEFUN([PMIX_SETUP_CORE],[
AC_DEFINE_UNQUOTED([PMIX_RELEASE_VERSION], [$PMIX_RELEASE_VERSION],
[The library release version is always available, contrary to VERSION])
pmixmajor=${PMIX_MAJOR_VERSION}L
pmixminor=${PMIX_MINOR_VERSION}L
pmixrelease=${PMIX_RELEASE_VERSION}L
AC_SUBST(pmixmajor)
AC_SUBST(pmixminor)
AC_SUBST(pmixrelease)
AC_CONFIG_FILES(pmix_config_prefix[include/pmix_version.h])
PMIX_GREEK_VERSION="`$PMIX_top_srcdir/config/pmix_get_version.sh $PMIX_top_srcdir/VERSION --greek`"
if test "$?" != "0"; then
AC_MSG_ERROR([Cannot continue])

6
opal/mca/pmix/pmix3x/pmix/contrib/perf_tools/pmi_intra_perf.c
Просмотреть файл

@ -302,6 +302,12 @@ int main(int argc, char **argv)
commit_time, fence_time);
}
/*
* The barrier ensures that all procs finished key fetching
* we had issues with dstor/lockless case evaluation
*/
pmi_fence( 0 );
/* Out of the perf path - send our results to rank 0 using same PMI */
char key[128];
sprintf(key, "PMIX_PERF_get_total_time.%d", rank);

2
opal/mca/pmix/pmix3x/pmix/include/pmix.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
* Copyright (c) 2013-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2013-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2016 Research Organization for Information Science
* and Technology (RIST). All rights reserved.
*

62
opal/mca/pmix/pmix3x/pmix/include/pmix_common.h.in
Просмотреть файл

@ -154,13 +154,24 @@ typedef uint32_t pmix_rank_t;
#define PMIX_GRPID "pmix.egid" // (uint32_t) effective group id
#define PMIX_DSTPATH "pmix.dstpath" // (char*) path to dstore files
#define PMIX_VERSION_INFO "pmix.version" // (char*) PMIx version of contactor
#define PMIX_REQUESTOR_IS_TOOL "pmix.req.tool" // (bool) requesting process is a tool
#define PMIX_REQUESTOR_IS_CLIENT "pmix.req.client" // (bool) requesting process is a client process
/* model attributes */
#define PMIX_PROGRAMMING_MODEL "pmix.pgm.model" // (char*) programming model being initialized (e.g., "MPI" or "OpenMP")
#define PMIX_MODEL_LIBRARY_NAME "pmix.mdl.name" // (char*) programming model implementation ID (e.g., "OpenMPI" or "MPICH")
#define PMIX_MODEL_LIBRARY_VERSION "pmix.mld.vrs" // (char*) programming model version string (e.g., "2.1.1")
#define PMIX_THREADING_MODEL "pmix.threads" // (char*) threading model used (e.g., "pthreads")
#define PMIX_REQUESTOR_IS_TOOL "pmix.req.tool" // (bool) requesting process is a tool
#define PMIX_REQUESTOR_IS_CLIENT "pmix.req.client" // (bool) requesting process is a client process
#define PMIX_MODEL_NUM_THREADS "pmix.mdl.nthrds" // (uint64_t) number of active threads being used by the model
#define PMIX_MODEL_NUM_CPUS "pmix.mdl.ncpu" // (uint64_t) number of cpus being used by the model
#define PMIX_MODEL_CPU_TYPE "pmix.mdl.cputype" // (char*) granularity - "hwthread", "core", etc.
#define PMIX_MODEL_PHASE_NAME "pmix.mdl.phase" // (char*) user-assigned name for a phase in the application execution - e.g.,
// "cfd reduction"
#define PMIX_MODEL_PHASE_TYPE "pmix.mdl.ptype" // (char*) type of phase being executed - e.g., "matrix multiply"
#define PMIX_MODEL_AFFINITY_POLICY "pmix.mdl.tap" // (char*) thread affinity policy - e.g.:
// "master" (thread co-located with master thread),
// "close" (thread located on cpu close to master thread)
// "spread" (threads load-balanced across available cpus)
/* attributes for the USOCK rendezvous socket */
#define PMIX_USOCK_DISABLE "pmix.usock.disable" // (bool) disable legacy usock support
@ -422,8 +433,7 @@ typedef uint32_t pmix_rank_t;
#define PMIX_DEBUG_WAIT_FOR_NOTIFY "pmix.dbg.notify" // (bool) block at desired point until receiving debugger release notification
#define PMIX_DEBUG_JOB "pmix.dbg.job" // (char*) nspace of the job to be debugged - the RM/PMIx server are
#define PMIX_DEBUG_WAITING_FOR_NOTIFY "pmix.dbg.waiting" // (bool) job to be debugged is waiting for a release
#define PMIX_DEBUG_JOB_DIRECTIVES "pmix.dbg.jdirs" // (pmix_data_array_t) array of job-level directives
#define PMIX_DEBUG_APP_DIRECTIVES "pmix.dbg.adirs" // (pmix_data_array_t) array of app-level directives
/* Resource Manager identification */
#define PMIX_RM_NAME "pmix.rm.name" // (char*) string name of the resource manager
@ -432,7 +442,6 @@ typedef uint32_t pmix_rank_t;
/* environmental variable operation attributes */
#define PMIX_SET_ENVAR "pmix.envar.set" // (pmix_envar_t*) set the envar to the given value,
// overwriting any pre-existing one
#define PMIX_ADD_ENVAR "pmix.envar.add" // (pmix_envar_t*) add envar, but do not overwrite any existing one
#define PMIX_UNSET_ENVAR "pmix.envar.unset" // (char*) unset the envar, if present
#define PMIX_PREPEND_ENVAR "pmix.envar.prepnd" // (pmix_envar_t*) prepend the given value to the
// specified envar using the separator
@ -511,7 +520,7 @@ typedef uint32_t pmix_rank_t;
// generating the event
/* security attributes */
#define PMIX_CRED_TYPE "pmix.sec.ctype" // (char*) when passed in PMIx_Get_credential, a prioritized,
#define PMIX_CRED_TYPE "pmix.sec.ctype" // when passed in PMIx_Get_credential, a prioritized,
// comma-delimited list of desired credential types for use
// in environments where multiple authentication mechanisms
// may be available. When returned in a callback function, a
@ -538,12 +547,6 @@ typedef uint32_t pmix_rank_t;
// the tool's stdin and forward it to the procs specified in
// the PMIx_IOF_push call
/* Attributes for controlling contents of application setup data */
#define PMIX_SETUP_APP_ENVARS "pmix.setup.env" // (bool) harvest and include relevant envars
#define PMIX_SETUP_APP_NONENVARS "pmix.setup.nenv" // (bool) include all non-envar data
#define PMIX_SETUP_APP_ALL "pmix.setup.all" // (bool) include all relevant data
/**** PROCESS STATE DEFINITIONS ****/
typedef uint8_t pmix_proc_state_t;
#define PMIX_PROC_STATE_UNDEF 0 /* undefined process state */
@ -573,13 +576,11 @@ typedef uint8_t pmix_proc_state_t;
#define PMIX_PROC_STATE_ABORTED_BY_SIG (PMIX_PROC_STATE_ERROR + 4) /* process aborted by signal */
#define PMIX_PROC_STATE_TERM_WO_SYNC (PMIX_PROC_STATE_ERROR + 5) /* process exit'd w/o calling PMIx_Finalize */
#define PMIX_PROC_STATE_COMM_FAILED (PMIX_PROC_STATE_ERROR + 6) /* process communication has failed */
#define PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED (PMIX_PROC_STATE_ERROR + 7) /* process exceeded a sensor limit */
#define PMIX_PROC_STATE_CALLED_ABORT (PMIX_PROC_STATE_ERROR + 8) /* process called "PMIx_Abort" */
#define PMIX_PROC_STATE_HEARTBEAT_FAILED (PMIX_PROC_STATE_ERROR + 9) /* process failed to send heartbeat w/in time limit */
#define PMIX_PROC_STATE_MIGRATING (PMIX_PROC_STATE_ERROR + 10) /* process failed and is waiting for resources before restarting */
#define PMIX_PROC_STATE_CANNOT_RESTART (PMIX_PROC_STATE_ERROR + 11) /* process failed and cannot be restarted */
#define PMIX_PROC_STATE_TERM_NON_ZERO (PMIX_PROC_STATE_ERROR + 12) /* process exited with a non-zero status, indicating abnormal */
#define PMIX_PROC_STATE_FAILED_TO_LAUNCH (PMIX_PROC_STATE_ERROR + 13) /* unable to launch process */
#define PMIX_PROC_STATE_CALLED_ABORT (PMIX_PROC_STATE_ERROR + 7) /* process called "PMIx_Abort" */
#define PMIX_PROC_STATE_MIGRATING (PMIX_PROC_STATE_ERROR + 8) /* process failed and is waiting for resources before restarting */
#define PMIX_PROC_STATE_CANNOT_RESTART (PMIX_PROC_STATE_ERROR + 9) /* process failed and cannot be restarted */
#define PMIX_PROC_STATE_TERM_NON_ZERO (PMIX_PROC_STATE_ERROR + 10) /* process exited with a non-zero status, indicating abnormal */
#define PMIX_PROC_STATE_FAILED_TO_LAUNCH (PMIX_PROC_STATE_ERROR + 11) /* unable to launch process */
/**** PMIX ERROR CONSTANTS ****/
@ -682,7 +683,9 @@ typedef int pmix_status_t;
#define PMIX_GDS_ACTION_COMPLETE (PMIX_ERR_OP_BASE - 18)
#define PMIX_PROC_HAS_CONNECTED (PMIX_ERR_OP_BASE - 19)
#define PMIX_CONNECT_REQUESTED (PMIX_ERR_OP_BASE - 20)
#define PMIX_LAUNCH_DIRECTIVE (PMIX_ERR_OP_BASE - 21)
#define PMIX_MODEL_RESOURCES (PMIX_ERR_OP_BASE - 21) // model resource usage has changed
#define PMIX_OPENMP_PARALLEL_ENTERED (PMIX_ERR_OP_BASE - 22) // an OpenMP parallel region has been entered
#define PMIX_OPENMP_PARALLEL_EXITED (PMIX_ERR_OP_BASE - 23) // an OpenMP parallel region has completed
/* define a starting point for system error constants so
* we avoid renumbering when making additions */
@ -1105,17 +1108,6 @@ typedef struct pmix_data_array {
size_t size;
void *array;
} pmix_data_array_t;
#define PMIX_DATA_ARRAY_CONSTRUCT(m, n, t) \
do { \
(m)->type = (t); \
(m)->size = (n); \
} while(0)
#define PMIX_DATA_ARRAY_CREATE(m, n, t) \
do { \
(m) = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t)); \
PMIX_DATA_ARRAY_CONSTRUCT((m), (n), (t)); \
} while(0)
typedef struct pmix_info_array {
size_t size;
@ -1360,16 +1352,12 @@ struct pmix_info_t {
#define PMIX_INFO_LOAD(m, k, v, t) \
do { \
if (NULL != (k)) { \
(void)strncpy((m)->key, (k), PMIX_MAX_KEYLEN); \
} \
pmix_value_load(&((m)->value), (v), (t)); \
} while (0)
#define PMIX_INFO_XFER(d, s) \
do { \
if (NULL != (s)->key) { \
(void)strncpy((d)->key, (s)->key, PMIX_MAX_KEYLEN); \
} \
(d)->flags = (s)->flags; \
pmix_value_xfer(&(d)->value, &(s)->value); \
} while(0)
@ -1392,9 +1380,7 @@ struct pmix_info_t {
(r) = PMIX_ERR_NOMEM; \
break; \
} \
if (NULL != _info[_n].key) { \
_kv->key = strdup(_info[_n].key); \
} \
PMIX_VALUE_XFER((r), _kv->value, &_info[_n].value);\
if (PMIX_SUCCESS != (r)) { \
PMIX_RELEASE(_kv); \

3
opal/mca/pmix/pmix3x/pmix/include/pmix_version.h.in
Просмотреть файл

@ -1,6 +1,7 @@
/*
* Copyright (c) 2016 Mellanox Technologies, Inc.
* All rights reserved.
* Copyright (c) 2018 IBM Corporation. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
@ -15,5 +16,5 @@
/* define PMIx version */
#define PMIX_VERSION_MAJOR @pmixmajor@
#define PMIX_VERSION_MINOR @pmixminor@
#define PMIX_VERSION_RELEASE @pmixrelease@
#endif

2
opal/mca/pmix/pmix3x/pmix/src/class/pmix_hotel.c
Просмотреть файл

@ -2,7 +2,7 @@
/*
* Copyright (c) 2012-2016 Cisco Systems, Inc. All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, LLC. All rights reserved
* Copyright (c) 2015-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow

2
opal/mca/pmix/pmix3x/pmix/src/class/pmix_hotel.h
Просмотреть файл

@ -2,7 +2,7 @@
/*
* Copyright (c) 2012-2016 Cisco Systems, Inc. All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, LLC. All rights reserved
* Copyright (c) 2015-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow

112
opal/mca/pmix/pmix3x/pmix/src/client/pmix_client.c
Просмотреть файл

@ -1175,27 +1175,11 @@ static void _commitfn(int sd, short args, void *cbdata)
return rc;
}
static void _resolve_peers(int sd, short args, void *cbdata)
{
pmix_cb_t *cb = (pmix_cb_t*)cbdata;
pmix_status_t rc;
cb->status = pmix_preg.resolve_peers(cb->key, cb->pname.nspace,
&cb->procs, &cb->nprocs);
/* post the data so the receiving thread can acquire it */
PMIX_POST_OBJECT(cb);
PMIX_WAKEUP_THREAD(&cb->lock);
}
/* need to thread-shift this request */
PMIX_EXPORT pmix_status_t PMIx_Resolve_peers(const char *nodename,
const char *nspace,
pmix_proc_t **procs, size_t *nprocs)
{
pmix_cb_t *cb;
pmix_status_t rc;
pmix_proc_t proc;
PMIX_ACQUIRE_THREAD(&pmix_global_lock);
if (pmix_globals.init_cntr <= 0) {
PMIX_RELEASE_THREAD(&pmix_global_lock);
@ -1203,71 +1187,16 @@ PMIX_EXPORT pmix_status_t PMIx_Resolve_peers(const char *nodename,
}
PMIX_RELEASE_THREAD(&pmix_global_lock);
/* set default */
*procs = NULL;
*nprocs = 0;
cb = PMIX_NEW(pmix_cb_t);
cb->key = (char*)nodename;
cb->pname.nspace = strdup(nspace);
PMIX_THREADSHIFT(cb, _resolve_peers);
/* wait for the result */
PMIX_WAIT_THREAD(&cb->lock);
/* if the nspace wasn't found, then we need to
* ask the server for that info */
if (PMIX_ERR_INVALID_NAMESPACE == cb->status) {
(void)strncpy(proc.nspace, nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
/* any key will suffice as it will bring down
* the entire data blob */
rc = PMIx_Get(&proc, PMIX_UNIV_SIZE, NULL, 0, NULL);
if (PMIX_SUCCESS != rc) {
PMIX_RELEASE(cb);
return rc;
}
/* retry the fetch */
cb->lock.active = true;
PMIX_THREADSHIFT(cb, _resolve_peers);
PMIX_WAIT_THREAD(&cb->lock);
}
*procs = cb->procs;
*nprocs = cb->nprocs;
rc = cb->status;
PMIX_RELEASE(cb);
return rc;
}
static void _resolve_nodes(int fd, short args, void *cbdata)
{
pmix_cb_t *cb = (pmix_cb_t*)cbdata;
char *regex, **names;
/* get a regular expression describing the PMIX_NODE_MAP */
cb->status = pmix_preg.resolve_nodes(cb->pname.nspace, &regex);
if (PMIX_SUCCESS == cb->status) {
/* parse it into an argv array of names */
cb->status = pmix_preg.parse_nodes(regex, &names);
if (PMIX_SUCCESS == cb->status) {
/* assemble it into a comma-delimited list */
cb->key = pmix_argv_join(names, ',');
pmix_argv_free(names);
} else {
free(regex);
}
}
/* post the data so the receiving thread can acquire it */
PMIX_POST_OBJECT(cb);
PMIX_WAKEUP_THREAD(&cb->lock);
return pmix_preg.resolve_peers(nodename, nspace, procs, nprocs);
}
/* need to thread-shift this request */
PMIX_EXPORT pmix_status_t PMIx_Resolve_nodes(const char *nspace, char **nodelist)
{
pmix_cb_t *cb;
pmix_status_t rc;
pmix_proc_t proc;
PMIX_ACQUIRE_THREAD(&pmix_global_lock);
if (pmix_globals.init_cntr <= 0) {
PMIX_RELEASE_THREAD(&pmix_global_lock);
@ -1275,35 +1204,8 @@ PMIX_EXPORT pmix_status_t PMIx_Resolve_nodes(const char *nspace, char **nodelist
}
PMIX_RELEASE_THREAD(&pmix_global_lock);
cb = PMIX_NEW(pmix_cb_t);
cb->pname.nspace = strdup(nspace);
/* set default */
*nodelist = NULL;
PMIX_THREADSHIFT(cb, _resolve_nodes);
/* wait for the result */
PMIX_WAIT_THREAD(&cb->lock);
/* if the nspace wasn't found, then we need to
* ask the server for that info */
if (PMIX_ERR_INVALID_NAMESPACE == cb->status) {
(void)strncpy(proc.nspace, nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
/* any key will suffice as it will bring down
* the entire data blob */
rc = PMIx_Get(&proc, PMIX_UNIV_SIZE, NULL, 0, NULL);
if (PMIX_SUCCESS != rc) {
PMIX_RELEASE(cb);
return rc;
}
/* retry the fetch */
cb->lock.active = true;
PMIX_THREADSHIFT(cb, _resolve_nodes);
PMIX_WAIT_THREAD(&cb->lock);
}
/* the string we want is in the key field */
*nodelist = cb->key;
rc = cb->status;
PMIX_RELEASE(cb);
return rc;
return pmix_preg.resolve_nodes(nspace, nodelist);
}

3
opal/mca/pmix/pmix3x/pmix/src/common/pmix_query.c
Просмотреть файл

@ -63,7 +63,6 @@ static void query_cbfunc(struct pmix_peer_t *peer,
PMIX_BFROPS_UNPACK(rc, peer, buf, &results->status, &cnt, PMIX_STATUS);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
results->status = rc;
goto complete;
}
if (PMIX_SUCCESS != results->status) {
@ -75,7 +74,6 @@ static void query_cbfunc(struct pmix_peer_t *peer,
PMIX_BFROPS_UNPACK(rc, peer, buf, &results->ninfo, &cnt, PMIX_SIZE);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
results->status = rc;
goto complete;
}
if (0 < results->ninfo) {
@ -84,7 +82,6 @@ static void query_cbfunc(struct pmix_peer_t *peer,
PMIX_BFROPS_UNPACK(rc, peer, buf, results->info, &cnt, PMIX_INFO);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
results->status = rc;
goto complete;
}
}

4
opal/mca/pmix/pmix3x/pmix/src/common/pmix_strings.c
Просмотреть файл

@ -71,12 +71,8 @@ PMIX_EXPORT const char* PMIx_Proc_state_string(pmix_proc_state_t state)
return "PROC TERMINATED WITHOUT CALLING PMIx_Finalize";
case PMIX_PROC_STATE_COMM_FAILED:
return "PROC LOST COMMUNICATION";
case PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED:
return "PROC SENSOR BOUND EXCEEDED";
case PMIX_PROC_STATE_CALLED_ABORT:
return "PROC CALLED PMIx_Abort";
case PMIX_PROC_STATE_HEARTBEAT_FAILED:
return "PROC FAILED TO REPORT HEARTBEAT";
case PMIX_PROC_STATE_MIGRATING:
return "PROC WAITING TO MIGRATE";
case PMIX_PROC_STATE_CANNOT_RESTART:

2
opal/mca/pmix/pmix3x/pmix/src/include/pmix_globals.c
Просмотреть файл

@ -109,7 +109,6 @@ static void nscon(pmix_nspace_t *p)
PMIX_CONSTRUCT(&p->epilog.cleanup_dirs, pmix_list_t);
PMIX_CONSTRUCT(&p->epilog.cleanup_files, pmix_list_t);
PMIX_CONSTRUCT(&p->epilog.ignores, pmix_list_t);
PMIX_CONSTRUCT(&p->setup_data, pmix_list_t);
}
static void nsdes(pmix_nspace_t *p)
{
@ -126,7 +125,6 @@ static void nsdes(pmix_nspace_t *p)
PMIX_LIST_DESTRUCT(&p->epilog.cleanup_dirs);
PMIX_LIST_DESTRUCT(&p->epilog.cleanup_files);
PMIX_LIST_DESTRUCT(&p->epilog.ignores);
PMIX_LIST_DESTRUCT(&p->setup_data);
}
PMIX_EXPORT PMIX_CLASS_INSTANCE(pmix_nspace_t,
pmix_list_item_t,

2
opal/mca/pmix/pmix3x/pmix/src/include/pmix_globals.h
Просмотреть файл

@ -168,8 +168,6 @@ typedef struct {
pmix_personality_t compat;
pmix_epilog_t epilog; // things to do upon termination of all local clients
// from this nspace
pmix_list_t setup_data; // list of pmix_kval_t containing info structs having blobs
// for setting up the local node for this nspace/application
} pmix_nspace_t;
PMIX_CLASS_DECLARATION(pmix_nspace_t);

2
opal/mca/pmix/pmix3x/pmix/src/include/types.h
Просмотреть файл

@ -9,7 +9,7 @@
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2014-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2014-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2015 Mellanox Technologies, Inc.
* All rights reserved.
* $COPYRIGHT$

2
opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/base/base.h
Просмотреть файл

@ -11,7 +11,7 @@
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, Inc. All rights reserved.
* Copyright (c) 2014-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2014-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2015 Research Organization for Information Science
* and Technology (RIST). All rights reserved.
* $COPYRIGHT$

29
opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/base/bfrop_base_copy.c
Просмотреть файл

@ -9,7 +9,7 @@
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2014-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2014-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2015 Research Organization for Information Science
* and Technology (RIST). All rights reserved.
* $COPYRIGHT$
@ -367,23 +367,18 @@ pmix_status_t pmix_bfrops_base_copy_pinfo(pmix_proc_info_t **dest,
pmix_proc_info_t *src,
pmix_data_type_t type)
{
pmix_proc_info_t *p;
PMIX_PROC_INFO_CREATE(p, 1);
if (NULL == p) {
return PMIX_ERR_NOMEM;
}
memcpy(&p->proc, &src->proc, sizeof(pmix_proc_t));
*dest = (pmix_proc_info_t*)malloc(sizeof(pmix_proc_info_t));
(void)strncpy((*dest)->proc.nspace, src->proc.nspace, PMIX_MAX_NSLEN);
(*dest)->proc.rank = src->proc.rank;
if (NULL != src->hostname) {
p->hostname = strdup(src->hostname);
(*dest)->hostname = strdup(src->hostname);
}
if (NULL != src->executable_name) {
p->executable_name = strdup(src->executable_name);
(*dest)->executable_name = strdup(src->executable_name);
}
memcpy(&p->pid, &src->pid, sizeof(pid_t));
memcpy(&p->exit_code, &src->exit_code, sizeof(int));
memcpy(&p->state, &src->state, sizeof(pmix_proc_state_t));
*dest = p;
(*dest)->pid = src->pid;
(*dest)->exit_code = src->exit_code;
(*dest)->state = src->state;
return PMIX_SUCCESS;
}
@ -624,7 +619,7 @@ pmix_status_t pmix_bfrops_base_copy_darray(pmix_data_array_t **dest,
p1 = (pmix_info_t*)p->array;
s1 = (pmix_info_t*)src->array;
for (n=0; n < src->size; n++) {
PMIX_INFO_XFER(&p1[n], &s1[n]);
PMIX_INFO_LOAD(&p1[n], s1[n].key, &s1[n].value.data.flag, s1[n].value.type);
}
break;
case PMIX_PDATA:
@ -636,7 +631,7 @@ pmix_status_t pmix_bfrops_base_copy_darray(pmix_data_array_t **dest,
pd = (pmix_pdata_t*)p->array;
sd = (pmix_pdata_t*)src->array;
for (n=0; n < src->size; n++) {
PMIX_PDATA_XFER(&pd[n], &sd[n]);
PMIX_PDATA_LOAD(&pd[n], &sd[n].proc, sd[n].key, &sd[n].value.data.flag, sd[n].value.type);
}
break;
case PMIX_BUFFER:
@ -906,7 +901,7 @@ pmix_status_t pmix_bfrops_base_copy_envar(pmix_envar_t **dest,
pmix_envar_t *src,
pmix_data_type_t type)
{
PMIX_ENVAR_CREATE(*dest, 1);
*dest = (pmix_envar_t*)malloc(sizeof(pmix_envar_t));
if (NULL == (*dest)) {
return PMIX_ERR_NOMEM;
}

422
opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/base/bfrop_base_fns.c
Просмотреть файл

@ -9,7 +9,7 @@
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2015-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
@ -50,8 +50,6 @@ void pmix_bfrops_base_value_load(pmix_value_t *v, const void *data,
pmix_byte_object_t *bo;
pmix_proc_info_t *pi;
pmix_envar_t *envar;
pmix_data_array_t *darray;
pmix_status_t rc;
v->type = type;
if (NULL == data) {
@ -187,14 +185,6 @@ void pmix_bfrops_base_value_load(pmix_value_t *v, const void *data,
}
v->data.envar.separator = envar->separator;
break;
case PMIX_DATA_ARRAY:
darray = (pmix_data_array_t*)data;
rc = pmix_bfrops_base_copy_darray(&v->data.darray, darray, PMIX_DATA_ARRAY);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
}
break;
default:
/* silence warnings */
break;
@ -209,7 +199,6 @@ pmix_status_t pmix_bfrops_base_value_unload(pmix_value_t *kv,
{
pmix_status_t rc;
pmix_envar_t *envar;
pmix_data_array_t **darray;
rc = PMIX_SUCCESS;
if (NULL == data ||
@ -327,11 +316,6 @@ pmix_status_t pmix_bfrops_base_value_unload(pmix_value_t *kv,
memcpy(*data, &(kv->data.ptr), sizeof(void*));
*sz = sizeof(void*);
break;
case PMIX_DATA_ARRAY:
darray = (pmix_data_array_t**)data;
rc = pmix_bfrops_base_copy_darray(darray, kv->data.darray, PMIX_DATA_ARRAY);
*sz = sizeof(pmix_data_array_t);
break;
case PMIX_ENVAR:
PMIX_ENVAR_CREATE(envar, 1);
if (NULL == envar) {
@ -630,9 +614,409 @@ pmix_status_t pmix_bfrops_base_value_xfer(pmix_value_t *p,
memcpy(&p->data.state, &src->data.state, sizeof(pmix_proc_state_t));
break;
case PMIX_PROC_INFO:
return pmix_bfrops_base_copy_pinfo(&p->data.pinfo, src->data.pinfo, PMIX_PROC_INFO);
PMIX_PROC_INFO_CREATE(p->data.pinfo, 1);
if (NULL != src->data.pinfo->hostname) {
p->data.pinfo->hostname = strdup(src->data.pinfo->hostname);
}
if (NULL != src->data.pinfo->executable_name) {
p->data.pinfo->executable_name = strdup(src->data.pinfo->executable_name);
}
memcpy(&p->data.pinfo->pid, &src->data.pinfo->pid, sizeof(pid_t));
memcpy(&p->data.pinfo->exit_code, &src->data.pinfo->exit_code, sizeof(int));
memcpy(&p->data.pinfo->state, &src->data.pinfo->state, sizeof(pmix_proc_state_t));
break;
case PMIX_DATA_ARRAY:
return pmix_bfrops_base_copy_darray(&p->data.darray, src->data.darray, PMIX_DATA_ARRAY);
p->data.darray = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
p->data.darray->type = src->data.darray->type;
p->data.darray->size = src->data.darray->size;
if (0 == p->data.darray->size || NULL == src->data.darray->array) {
p->data.darray->array = NULL;
p->data.darray->size = 0;
break;
}
/* allocate space and do the copy */
switch (src->data.darray->type) {
case PMIX_UINT8:
case PMIX_INT8:
case PMIX_BYTE:
p->data.darray->array = (char*)malloc(src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size);
break;
case PMIX_UINT16:
case PMIX_INT16:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint16_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint16_t));
break;
case PMIX_UINT32:
case PMIX_INT32:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint32_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint32_t));
break;
case PMIX_UINT64:
case PMIX_INT64:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint64_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint64_t));
break;
case PMIX_BOOL:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(bool));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(bool));
break;
case PMIX_SIZE:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(size_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(size_t));
break;
case PMIX_PID:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(pid_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pid_t));
break;
case PMIX_STRING:
p->data.darray->array = (char**)malloc(src->data.darray->size * sizeof(char*));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
prarray = (char**)p->data.darray->array;
strarray = (char**)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != strarray[n]) {
prarray[n] = strdup(strarray[n]);
}
}
break;
case PMIX_INT:
case PMIX_UINT:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(int));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(int));
break;
case PMIX_FLOAT:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(float));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(float));
break;
case PMIX_DOUBLE:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(double));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(double));
break;
case PMIX_TIMEVAL:
p->data.darray->array = (struct timeval*)malloc(src->data.darray->size * sizeof(struct timeval));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(struct timeval));
break;
case PMIX_TIME:
p->data.darray->array = (time_t*)malloc(src->data.darray->size * sizeof(time_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(time_t));
break;
case PMIX_STATUS:
p->data.darray->array = (pmix_status_t*)malloc(src->data.darray->size * sizeof(pmix_status_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_status_t));
break;
case PMIX_VALUE:
PMIX_VALUE_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pv = (pmix_value_t*)p->data.darray->array;
sv = (pmix_value_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (PMIX_SUCCESS != (rc = pmix_value_xfer(&pv[n], &sv[n]))) {
PMIX_VALUE_FREE(pv, src->data.darray->size);
return rc;
}
}
break;
case PMIX_PROC:
PMIX_PROC_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_proc_t));
break;
case PMIX_APP:
PMIX_APP_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pa = (pmix_app_t*)p->data.darray->array;
sa = (pmix_app_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != sa[n].cmd) {
pa[n].cmd = strdup(sa[n].cmd);
}
if (NULL != sa[n].argv) {
pa[n].argv = pmix_argv_copy(sa[n].argv);
}
if (NULL != sa[n].env) {
pa[n].env = pmix_argv_copy(sa[n].env);
}
if (NULL != sa[n].cwd) {
pa[n].cwd = strdup(sa[n].cwd);
}
pa[n].maxprocs = sa[n].maxprocs;
if (0 < sa[n].ninfo && NULL != sa[n].info) {
PMIX_INFO_CREATE(pa[n].info, sa[n].ninfo);
if (NULL == pa[n].info) {
PMIX_APP_FREE(pa, src->data.darray->size);
return PMIX_ERR_NOMEM;
}
pa[n].ninfo = sa[n].ninfo;
for (m=0; m < pa[n].ninfo; m++) {
PMIX_INFO_XFER(&pa[n].info[m], &sa[n].info[m]);
}
}
}
break;
case PMIX_INFO:
PMIX_INFO_CREATE(p->data.darray->array, src->data.darray->size);
p1 = (pmix_info_t*)p->data.darray->array;
s1 = (pmix_info_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
PMIX_INFO_XFER(&p1[n], &s1[n]);
}
break;
case PMIX_PDATA:
PMIX_PDATA_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pd = (pmix_pdata_t*)p->data.darray->array;
sd = (pmix_pdata_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
PMIX_PDATA_XFER(&pd[n], &sd[n]);
}
break;
case PMIX_BUFFER:
p->data.darray->array = (pmix_buffer_t*)malloc(src->data.darray->size * sizeof(pmix_buffer_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pb = (pmix_buffer_t*)p->data.darray->array;
sb = (pmix_buffer_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
PMIX_CONSTRUCT(&pb[n], pmix_buffer_t);
pmix_bfrops_base_copy_payload(&pb[n], &sb[n]);
}
break;
case PMIX_BYTE_OBJECT:
case PMIX_COMPRESSED_STRING:
p->data.darray->array = (pmix_byte_object_t*)malloc(src->data.darray->size * sizeof(pmix_byte_object_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pbo = (pmix_byte_object_t*)p->data.darray->array;
sbo = (pmix_byte_object_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != sbo[n].bytes && 0 < sbo[n].size) {
pbo[n].size = sbo[n].size;
pbo[n].bytes = (char*)malloc(pbo[n].size);
memcpy(pbo[n].bytes, sbo[n].bytes, pbo[n].size);
} else {
pbo[n].bytes = NULL;
pbo[n].size = 0;
}
}
break;
case PMIX_KVAL:
p->data.darray->array = (pmix_kval_t*)calloc(src->data.darray->size , sizeof(pmix_kval_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pk = (pmix_kval_t*)p->data.darray->array;
sk = (pmix_kval_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != sk[n].key) {
pk[n].key = strdup(sk[n].key);
}
if (NULL != sk[n].value) {
PMIX_VALUE_CREATE(pk[n].value, 1);
if (NULL == pk[n].value) {
free(p->data.darray->array);
return PMIX_ERR_NOMEM;
}
if (PMIX_SUCCESS != (rc = pmix_value_xfer(pk[n].value, sk[n].value))) {
return rc;
}
}
}
break;
case PMIX_MODEX:
PMIX_MODEX_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pm = (pmix_modex_data_t*)p->data.darray->array;
sm = (pmix_modex_data_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
memcpy(&pm[n], &sm[n], sizeof(pmix_modex_data_t));
if (NULL != sm[n].blob && 0 < sm[n].size) {
pm[n].blob = (uint8_t*)malloc(sm[n].size);
if (NULL == pm[n].blob) {
return PMIX_ERR_NOMEM;
}
memcpy(pm[n].blob, sm[n].blob, sm[n].size);
pm[n].size = sm[n].size;
} else {
pm[n].blob = NULL;
pm[n].size = 0;
}
}
break;
case PMIX_PERSIST:
p->data.darray->array = (pmix_persistence_t*)malloc(src->data.darray->size * sizeof(pmix_persistence_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_persistence_t));
break;
case PMIX_POINTER:
p->data.darray->array = (char**)malloc(src->data.darray->size * sizeof(char*));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
prarray = (char**)p->data.darray->array;
strarray = (char**)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
prarray[n] = strarray[n];
}
break;
case PMIX_SCOPE:
p->data.darray->array = (pmix_scope_t*)malloc(src->data.darray->size * sizeof(pmix_scope_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_scope_t));
break;
case PMIX_DATA_RANGE:
p->data.darray->array = (pmix_data_range_t*)malloc(src->data.darray->size * sizeof(pmix_data_range_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_data_range_t));
break;
case PMIX_COMMAND:
p->data.darray->array = (pmix_cmd_t*)malloc(src->data.darray->size * sizeof(pmix_cmd_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_cmd_t));
break;
case PMIX_INFO_DIRECTIVES:
p->data.darray->array = (pmix_info_directives_t*)malloc(src->data.darray->size * sizeof(pmix_info_directives_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_info_directives_t));
break;
case PMIX_PROC_INFO:
PMIX_PROC_INFO_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pi = (pmix_proc_info_t*)p->data.darray->array;
si = (pmix_proc_info_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
memcpy(&pi[n].proc, &si[n].proc, sizeof(pmix_proc_t));
if (NULL != si[n].hostname) {
pi[n].hostname = strdup(si[n].hostname);
} else {
pi[n].hostname = NULL;
}
if (NULL != si[n].executable_name) {
pi[n].executable_name = strdup(si[n].executable_name);
} else {
pi[n].executable_name = NULL;
}
pi[n].pid = si[n].pid;
pi[n].exit_code = si[n].exit_code;
pi[n].state = si[n].state;
}
break;
case PMIX_DATA_ARRAY:
PMIX_ERROR_LOG(PMIX_ERR_NOT_SUPPORTED);
return PMIX_ERR_NOT_SUPPORTED; // don't support iterative arrays
case PMIX_QUERY:
PMIX_QUERY_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pq = (pmix_query_t*)p->data.darray->array;
sq = (pmix_query_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != sq[n].keys) {
pq[n].keys = pmix_argv_copy(sq[n].keys);
}
if (NULL != sq[n].qualifiers && 0 < sq[n].nqual) {
PMIX_INFO_CREATE(pq[n].qualifiers, sq[n].nqual);
if (NULL == pq[n].qualifiers) {
PMIX_QUERY_FREE(pq, src->data.darray->size);
return PMIX_ERR_NOMEM;
}
for (m=0; m < sq[n].nqual; m++) {
PMIX_INFO_XFER(&pq[n].qualifiers[m], &sq[n].qualifiers[m]);
}
pq[n].nqual = sq[n].nqual;
} else {
pq[n].qualifiers = NULL;
pq[n].nqual = 0;
}
}
break;
case PMIX_ENVAR:
PMIX_ENVAR_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pe = (pmix_envar_t*)p->data.darray->array;
se = (pmix_envar_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != se[n].envar) {
pe[n].envar = strdup(se[n].envar);
}
if (NULL != se[n].value) {
pe[n].value = strdup(se[n].value);
}
pe[n].separator = se[n].separator;
}
break;
default:
return PMIX_ERR_UNKNOWN_DATA_TYPE;
}
break;
case PMIX_POINTER:
memcpy(&p->data.ptr, &src->data.ptr, sizeof(void*));
break;

2
opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/base/bfrop_base_pack.c
Просмотреть файл

@ -1310,5 +1310,5 @@ pmix_status_t pmix_bfrops_base_pack_envar(pmix_buffer_t *buffer, const void *src
return ret;
}
}
return PMIX_SUCCESS;
return pmix_bfrops_base_pack_int16(buffer, src, num_vals, PMIX_UINT16);
}

2
opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/base/bfrop_base_print.c
Просмотреть файл

@ -10,7 +10,7 @@
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, Inc. All rights reserved.
* Copyright (c) 2014-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2014-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2016 Mellanox Technologies, Inc.
* All rights reserved.
*

9
opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/base/bfrop_base_unpack.c
Просмотреть файл

@ -10,7 +10,7 @@
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, Inc. All rights reserved.
* Copyright (c) 2014-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2014-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2015 Research Organization for Information Science
* and Technology (RIST). All rights reserved.
* Copyright (c) 2016 Mellanox Technologies, Inc.
@ -111,7 +111,6 @@ pmix_status_t pmix_bfrops_base_unpack(pmix_pointer_array_t *regtypes,
}
if (PMIX_INT32 != local_type) { /* if the length wasn't first, then error */
*num_vals = 0;
PMIX_ERROR_LOG(PMIX_ERR_UNPACK_FAILURE);
return PMIX_ERR_UNPACK_FAILURE;
}
}
@ -754,13 +753,13 @@ pmix_status_t pmix_bfrops_base_unpack_val(pmix_buffer_t *buffer,
return ret;
}
break;
case PMIX_ALLOC_DIRECTIVE:
if (PMIX_SUCCESS != (ret = pmix_bfrops_base_unpack_alloc_directive(buffer, &val->data.adir, &m, PMIX_ALLOC_DIRECTIVE))) {
case PMIX_QUERY:
if (PMIX_SUCCESS != (ret = pmix_bfrops_base_unpack_query(buffer, val->data.darray, &m, PMIX_QUERY))) {
return ret;
}
break;
case PMIX_ENVAR:
if (PMIX_SUCCESS != (ret = pmix_bfrops_base_unpack_envar(buffer, &val->data.envar, &m, PMIX_ENVAR))) {
if (PMIX_SUCCESS != (ret = pmix_bfrops_base_unpack_envar(buffer, val->data.darray, &m, PMIX_ENVAR))) {
return ret;
}
break;

24
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/test/Makefile.am → opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/v3/Makefile.am
Просмотреть файл

@ -11,9 +11,7 @@
# Copyright (c) 2004-2005 The Regents of the University of California.
# All rights reserved.
# Copyright (c) 2012 Los Alamos National Security, Inc. All rights reserved.
# Copyright (c) 2013-2018 Intel, Inc. All rights reserved.
# Copyright (c) 2017 Research Organization for Information Science
# and Technology (RIST). All rights reserved.
# Copyright (c) 2013-2017 Intel, Inc. All rights reserved.
# $COPYRIGHT$
#
# Additional copyrights may follow
@ -21,22 +19,22 @@
# $HEADER$
#
headers = pnet_test.h
headers = bfrop_pmix3.h
sources = \
pnet_test_component.c \
pnet_test.c
bfrop_pmix3_component.c \
bfrop_pmix3.c
# Make the output library in this directory, and name it either
# mca_<type>_<name>.la (for DSO builds) or libmca_<type>_<name>.la
# (for static builds).
if MCA_BUILD_pmix_pnet_test_DSO
if MCA_BUILD_pmix_bfrops_v3_DSO
lib =
lib_sources =
component = mca_pnet_test.la
component = mca_bfrops_v3.la
component_sources = $(headers) $(sources)
else
lib = libmca_pnet_test.la
lib = libmca_bfrops_v3.la
lib_sources = $(headers) $(sources)
component =
component_sources =
@ -44,9 +42,9 @@ endif
mcacomponentdir = $(pmixlibdir)
mcacomponent_LTLIBRARIES = $(component)
mca_pnet_test_la_SOURCES = $(component_sources)
mca_pnet_test_la_LDFLAGS = -module -avoid-version
mca_bfrops_v3_la_SOURCES = $(component_sources)
mca_bfrops_v3_la_LDFLAGS = -module -avoid-version
noinst_LTLIBRARIES = $(lib)
libmca_pnet_test_la_SOURCES = $(lib_sources)
libmca_pnet_test_la_LDFLAGS = -module -avoid-version
libmca_bfrops_v3_la_SOURCES = $(lib_sources)
libmca_bfrops_v3_la_LDFLAGS = -module -avoid-version

464
opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/v3/bfrop_pmix3.c Обычный файл
Просмотреть файл

@ -0,0 +1,464 @@
/*
* Copyright (c) 2004-2010 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2011 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) 2010-2011 Oak Ridge National Labs. All rights reserved.
* Copyright (c) 2011-2014 Cisco Systems, Inc. All rights reserved.
* Copyright (c) 2011-2013 Los Alamos National Security, LLC. All rights
* reserved.
* Copyright (c) 2013-2018 Intel, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*
*/
#include <src/include/pmix_config.h>
#include "src/mca/bfrops/base/base.h"
#include "bfrop_pmix3.h"
static pmix_status_t init(void);
static void finalize(void);
static pmix_status_t pmix3_pack(pmix_buffer_t *buffer,
const void *src, int num_vals,
pmix_data_type_t type);
static pmix_status_t pmix3_unpack(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type);
static pmix_status_t pmix3_copy(void **dest, void *src,
pmix_data_type_t type);
static pmix_status_t pmix3_print(char **output, char *prefix,
void *src, pmix_data_type_t type);
static pmix_status_t register_type(const char *name,
pmix_data_type_t type,
pmix_bfrop_pack_fn_t pack,
pmix_bfrop_unpack_fn_t unpack,
pmix_bfrop_copy_fn_t copy,
pmix_bfrop_print_fn_t print);
static const char* data_type_string(pmix_data_type_t type);
pmix_bfrops_module_t pmix_bfrops_pmix3_module = {
.version = "v3",
.init = init,
.finalize = finalize,
.pack = pmix3_pack,
.unpack = pmix3_unpack,
.copy = pmix3_copy,
.print = pmix3_print,
.copy_payload = pmix_bfrops_base_copy_payload,
.value_xfer = pmix_bfrops_base_value_xfer,
.value_load = pmix_bfrops_base_value_load,
.value_unload = pmix_bfrops_base_value_unload,
.value_cmp = pmix_bfrops_base_value_cmp,
.register_type = register_type,
.data_type_string = data_type_string
};
static pmix_status_t init(void)
{
/* some standard types don't require anything special */
PMIX_REGISTER_TYPE("PMIX_BOOL", PMIX_BOOL,
pmix_bfrops_base_pack_bool,
pmix_bfrops_base_unpack_bool,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_bool,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_BYTE", PMIX_BYTE,
pmix_bfrops_base_pack_byte,
pmix_bfrops_base_unpack_byte,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_byte,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_STRING", PMIX_STRING,
pmix_bfrops_base_pack_string,
pmix_bfrops_base_unpack_string,
pmix_bfrops_base_copy_string,
pmix_bfrops_base_print_string,
&mca_bfrops_v3_component.types);
/* Register the rest of the standard generic types to point to internal functions */
PMIX_REGISTER_TYPE("PMIX_SIZE", PMIX_SIZE,
pmix_bfrops_base_pack_sizet,
pmix_bfrops_base_unpack_sizet,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_size,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_PID", PMIX_PID,
pmix_bfrops_base_pack_pid,
pmix_bfrops_base_unpack_pid,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_pid,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_INT", PMIX_INT,
pmix_bfrops_base_pack_int,
pmix_bfrops_base_unpack_int,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_int,
&mca_bfrops_v3_component.types);
/* Register all the standard fixed types to point to base functions */
PMIX_REGISTER_TYPE("PMIX_INT8", PMIX_INT8,
pmix_bfrops_base_pack_byte,
pmix_bfrops_base_unpack_byte,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_int8,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_INT16", PMIX_INT16,
pmix_bfrops_base_pack_int16,
pmix_bfrops_base_unpack_int16,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_int16,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_INT32", PMIX_INT32,
pmix_bfrops_base_pack_int32,
pmix_bfrops_base_unpack_int32,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_int32,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_INT64", PMIX_INT64,
pmix_bfrops_base_pack_int64,
pmix_bfrops_base_unpack_int64,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_int64,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_UINT", PMIX_UINT,
pmix_bfrops_base_pack_int,
pmix_bfrops_base_unpack_int,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_uint,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_UINT8", PMIX_UINT8,
pmix_bfrops_base_pack_byte,
pmix_bfrops_base_unpack_byte,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_uint8,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_UINT16", PMIX_UINT16,
pmix_bfrops_base_pack_int16,
pmix_bfrops_base_unpack_int16,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_uint16,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_UINT32", PMIX_UINT32,
pmix_bfrops_base_pack_int32,
pmix_bfrops_base_unpack_int32,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_uint32,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_UINT64", PMIX_UINT64,
pmix_bfrops_base_pack_int64,
pmix_bfrops_base_unpack_int64,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_uint64,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_FLOAT", PMIX_FLOAT,
pmix_bfrops_base_pack_float,
pmix_bfrops_base_unpack_float,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_float,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_DOUBLE", PMIX_DOUBLE,
pmix_bfrops_base_pack_double,
pmix_bfrops_base_unpack_double,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_double,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_TIMEVAL", PMIX_TIMEVAL,
pmix_bfrops_base_pack_timeval,
pmix_bfrops_base_unpack_timeval,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_timeval,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_TIME", PMIX_TIME,
pmix_bfrops_base_pack_time,
pmix_bfrops_base_unpack_time,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_time,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_STATUS", PMIX_STATUS,
pmix_bfrops_base_pack_status,
pmix_bfrops_base_unpack_status,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_status,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_VALUE", PMIX_VALUE,
pmix_bfrops_base_pack_value,
pmix_bfrops_base_unpack_value,
pmix_bfrops_base_copy_value,
pmix_bfrops_base_print_value,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_PROC", PMIX_PROC,
pmix_bfrops_base_pack_proc,
pmix_bfrops_base_unpack_proc,
pmix_bfrops_base_copy_proc,
pmix_bfrops_base_print_proc,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_APP", PMIX_APP,
pmix_bfrops_base_pack_app,
pmix_bfrops_base_unpack_app,
pmix_bfrops_base_copy_app,
pmix_bfrops_base_print_app,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_INFO", PMIX_INFO,
pmix_bfrops_base_pack_info,
pmix_bfrops_base_unpack_info,
pmix_bfrops_base_copy_info,
pmix_bfrops_base_print_info,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_PDATA", PMIX_PDATA,
pmix_bfrops_base_pack_pdata,
pmix_bfrops_base_unpack_pdata,
pmix_bfrops_base_copy_pdata,
pmix_bfrops_base_print_pdata,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_BUFFER", PMIX_BUFFER,
pmix_bfrops_base_pack_buf,
pmix_bfrops_base_unpack_buf,
pmix_bfrops_base_copy_buf,
pmix_bfrops_base_print_buf,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_BYTE_OBJECT", PMIX_BYTE_OBJECT,
pmix_bfrops_base_pack_bo,
pmix_bfrops_base_unpack_bo,
pmix_bfrops_base_copy_bo,
pmix_bfrops_base_print_bo,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_KVAL", PMIX_KVAL,
pmix_bfrops_base_pack_kval,
pmix_bfrops_base_unpack_kval,
pmix_bfrops_base_copy_kval,
pmix_bfrops_base_print_kval,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_MODEX", PMIX_MODEX,
pmix_bfrops_base_pack_modex,
pmix_bfrops_base_unpack_modex,
pmix_bfrops_base_copy_modex,
pmix_bfrops_base_print_modex,
&mca_bfrops_v3_component.types);
/* these are fixed-sized values and can be done by base */
PMIX_REGISTER_TYPE("PMIX_PERSIST", PMIX_PERSIST,
pmix_bfrops_base_pack_persist,
pmix_bfrops_base_unpack_persist,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_persist,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_POINTER", PMIX_POINTER,
pmix_bfrops_base_pack_ptr,
pmix_bfrops_base_unpack_ptr,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_ptr,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_SCOPE", PMIX_SCOPE,
pmix_bfrops_base_pack_scope,
pmix_bfrops_base_unpack_scope,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_std_copy,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_DATA_RANGE", PMIX_DATA_RANGE,
pmix_bfrops_base_pack_range,
pmix_bfrops_base_unpack_range,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_ptr,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_COMMAND", PMIX_COMMAND,
pmix_bfrops_base_pack_cmd,
pmix_bfrops_base_unpack_cmd,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_cmd,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_INFO_DIRECTIVES", PMIX_INFO_DIRECTIVES,
pmix_bfrops_base_pack_info_directives,
pmix_bfrops_base_unpack_info_directives,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_info_directives,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_DATA_TYPE", PMIX_DATA_TYPE,
pmix_bfrops_base_pack_datatype,
pmix_bfrops_base_unpack_datatype,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_datatype,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_PROC_STATE", PMIX_PROC_STATE,
pmix_bfrops_base_pack_pstate,
pmix_bfrops_base_unpack_pstate,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_pstate,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_PROC_INFO", PMIX_PROC_INFO,
pmix_bfrops_base_pack_pinfo,
pmix_bfrops_base_unpack_pinfo,
pmix_bfrops_base_copy_pinfo,
pmix_bfrops_base_print_pinfo,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_DATA_ARRAY", PMIX_DATA_ARRAY,
pmix_bfrops_base_pack_darray,
pmix_bfrops_base_unpack_darray,
pmix_bfrops_base_copy_darray,
pmix_bfrops_base_print_darray,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_PROC_RANK", PMIX_PROC_RANK,
pmix_bfrops_base_pack_rank,
pmix_bfrops_base_unpack_rank,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_rank,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_QUERY", PMIX_QUERY,
pmix_bfrops_base_pack_query,
pmix_bfrops_base_unpack_query,
pmix_bfrops_base_copy_query,
pmix_bfrops_base_print_query,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_COMPRESSED_STRING",
PMIX_COMPRESSED_STRING,
pmix_bfrops_base_pack_bo,
pmix_bfrops_base_unpack_bo,
pmix_bfrops_base_copy_bo,
pmix_bfrops_base_print_bo,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_ALLOC_DIRECTIVE",
PMIX_ALLOC_DIRECTIVE,
pmix_bfrops_base_pack_alloc_directive,
pmix_bfrops_base_unpack_alloc_directive,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_alloc_directive,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_IOF_CHANNEL",
PMIX_IOF_CHANNEL,
pmix_bfrops_base_pack_iof_channel,
pmix_bfrops_base_unpack_iof_channel,
pmix_bfrops_base_std_copy,
pmix_bfrops_base_print_iof_channel,
&mca_bfrops_v3_component.types);
PMIX_REGISTER_TYPE("PMIX_ENVAR",
PMIX_ENVAR,
pmix_bfrops_base_pack_envar,
pmix_bfrops_base_unpack_envar,
pmix_bfrops_base_copy_envar,
pmix_bfrops_base_print_envar,
&mca_bfrops_v3_component.types);
/**** DEPRECATED ****/
PMIX_REGISTER_TYPE("PMIX_INFO_ARRAY", PMIX_INFO_ARRAY,
pmix_bfrops_base_pack_array,
pmix_bfrops_base_unpack_array,
pmix_bfrops_base_copy_array,
pmix_bfrops_base_print_array,
&mca_bfrops_v3_component.types);
/********************/
return PMIX_SUCCESS;
}
static void finalize(void)
{
int n;
pmix_bfrop_type_info_t *info;
for (n=0; n < mca_bfrops_v3_component.types.size; n++) {
if (NULL != (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v3_component.types, n))) {
PMIX_RELEASE(info);
pmix_pointer_array_set_item(&mca_bfrops_v3_component.types, n, NULL);
}
}
}
static pmix_status_t pmix3_pack(pmix_buffer_t *buffer,
const void *src, int num_vals,
pmix_data_type_t type)
{
/* kick the process off by passing this in to the base */
return pmix_bfrops_base_pack(&mca_bfrops_v3_component.types,
buffer, src, num_vals, type);
}
static pmix_status_t pmix3_unpack(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
/* kick the process off by passing this in to the base */
return pmix_bfrops_base_unpack(&mca_bfrops_v3_component.types,
buffer, dest, num_vals, type);
}
static pmix_status_t pmix3_copy(void **dest, void *src,
pmix_data_type_t type)
{
return pmix_bfrops_base_copy(&mca_bfrops_v3_component.types,
dest, src, type);
}
static pmix_status_t pmix3_print(char **output, char *prefix,
void *src, pmix_data_type_t type)
{
return pmix_bfrops_base_print(&mca_bfrops_v3_component.types,
output, prefix, src, type);
}
static pmix_status_t register_type(const char *name, pmix_data_type_t type,
pmix_bfrop_pack_fn_t pack,
pmix_bfrop_unpack_fn_t unpack,
pmix_bfrop_copy_fn_t copy,
pmix_bfrop_print_fn_t print)
{
PMIX_REGISTER_TYPE(name, type,
pack, unpack,
copy, print,
&mca_bfrops_v3_component.types);
return PMIX_SUCCESS;
}
static const char* data_type_string(pmix_data_type_t type)
{
return pmix_bfrops_base_data_type_string(&mca_bfrops_v3_component.types, type);
}

34
opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/v3/bfrop_pmix3.h Обычный файл
Просмотреть файл

@ -0,0 +1,34 @@
/*
* Copyright (c) 2004-2008 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2006 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) 2016-2017 Intel, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#ifndef PMIX_BFROPS_PMIX3_H
#define PMIX_BFROPS_PMIX3_H
#include "src/mca/bfrops/bfrops.h"
BEGIN_C_DECLS
/* the component must be visible data for the linker to find it */
PMIX_EXPORT extern pmix_bfrops_base_component_t mca_bfrops_v3_component;
extern pmix_bfrops_module_t pmix_bfrops_pmix3_module;
END_C_DECLS
#endif /* PMIX_BFROPS_PMIX3_H */

99
opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/v3/bfrop_pmix3_component.c Обычный файл
Просмотреть файл

@ -0,0 +1,99 @@
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/*
* Copyright (c) 2004-2008 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennbfropsee and The University
* of Tennbfropsee 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) 2015 Los Alamos National Security, LLC. All rights
* reserved.
* Copyright (c) 2016-2017 Intel, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*
* These symbols are in a file by themselves to provide nice linker
* semantics. Since linkers generally pull in symbols by object
* files, keeping these symbols as the only symbols in this file
* prevents utility programs such as "ompi_info" from having to import
* entire components just to query their version and parameters.
*/
#include <src/include/pmix_config.h>
#include <pmix_common.h>
#include "src/include/types.h"
#include "src/include/pmix_globals.h"
#include "src/util/error.h"
#include "src/server/pmix_server_ops.h"
#include "src/mca/bfrops/base/base.h"
#include "bfrop_pmix3.h"
extern pmix_bfrops_module_t pmix_bfrops_pmix3_module;
static pmix_status_t component_open(void);
static pmix_status_t component_query(pmix_mca_base_module_t **module, int *priority);
static pmix_status_t component_close(void);
static pmix_bfrops_module_t* assign_module(void);
/*
* Instantiate the public struct with all of our public information
* and pointers to our public functions in it
*/
pmix_bfrops_base_component_t mca_bfrops_v3_component = {
.base = {
PMIX_BFROPS_BASE_VERSION_1_0_0,
/* Component name and version */
.pmix_mca_component_name = "v3",
PMIX_MCA_BASE_MAKE_VERSION(component, PMIX_MAJOR_VERSION, PMIX_MINOR_VERSION,
PMIX_RELEASE_VERSION),
/* Component open and close functions */
.pmix_mca_open_component = component_open,
.pmix_mca_close_component = component_close,
.pmix_mca_query_component = component_query,
},
.priority = 40,
.assign_module = assign_module
};
pmix_status_t component_open(void)
{
/* setup the types array */
PMIX_CONSTRUCT(&mca_bfrops_v3_component.types, pmix_pointer_array_t);
pmix_pointer_array_init(&mca_bfrops_v3_component.types, 32, INT_MAX, 16);
return PMIX_SUCCESS;
}
pmix_status_t component_query(pmix_mca_base_module_t **module, int *priority)
{
*priority = mca_bfrops_v3_component.priority;
*module = (pmix_mca_base_module_t *)&pmix_bfrops_pmix3_module;
return PMIX_SUCCESS;
}
pmix_status_t component_close(void)
{
PMIX_DESTRUCT(&mca_bfrops_v3_component.types);
return PMIX_SUCCESS;
}
static pmix_bfrops_module_t* assign_module(void)
{
pmix_output_verbose(10, pmix_bfrops_base_framework.framework_output,
"bfrops:pmix3x assigning module");
return &pmix_bfrops_pmix3_module;
}

16
opal/mca/pmix/pmix3x/pmix/src/mca/gds/hash/gds_hash.c
Просмотреть файл

@ -333,8 +333,7 @@ static pmix_status_t store_map(pmix_hash_table_t *ht,
}
/* store the comma-delimited list of nodes hosting
* procs in this nspace in case someone using PMIx v2
* requests it */
* procs in this nspace */
kp2 = PMIX_NEW(pmix_kval_t);
kp2->key = strdup(PMIX_NODE_LIST);
kp2->value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
@ -398,19 +397,6 @@ pmix_status_t hash_cache_job_info(struct pmix_nspace_t *ns,
ht = &trk->internal;
for (n=0; n < ninfo; n++) {
if (0 == strcmp(info[n].key, PMIX_NODE_MAP)) {
/* store the node map itself since that is
* what v3 uses */
kp2 = PMIX_NEW(pmix_kval_t);
kp2->key = strdup(PMIX_NODE_MAP);
kp2->value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
kp2->value->type = PMIX_STRING;
kp2->value->data.string = strdup(info[n].value.data.string);
if (PMIX_SUCCESS != (rc = pmix_hash_store(ht, PMIX_RANK_WILDCARD, kp2))) {
PMIX_ERROR_LOG(rc);
PMIX_RELEASE(kp2);
return rc;
}
/* parse the regex to get the argv array of node names */
if (PMIX_SUCCESS != (rc = pmix_preg.parse_nodes(info[n].value.data.string, &nodes))) {
PMIX_ERROR_LOG(rc);

4
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/base/base.h
Просмотреть файл

@ -78,9 +78,7 @@ typedef struct pmix_pnet_globals_t pmix_pnet_globals_t;
PMIX_EXPORT extern pmix_pnet_globals_t pmix_pnet_globals;
PMIX_EXPORT pmix_status_t pmix_pnet_base_setup_app(char *nspace,
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist);
PMIX_EXPORT pmix_status_t pmix_pnet_base_setup_app(char *nspace, pmix_list_t *ilist);
PMIX_EXPORT pmix_status_t pmix_pnet_base_setup_local_network(char *nspace,
pmix_info_t info[],
size_t ninfo);

86
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/base/pnet_base_fns.c
Просмотреть файл

@ -18,58 +18,27 @@
#include "src/class/pmix_list.h"
#include "src/util/error.h"
#include "src/server/pmix_server_ops.h"
#include "src/mca/pnet/base/base.h"
/* NOTE: a tool (e.g., prun) may call this function to
* harvest local envars for inclusion in a call to
* PMIx_Spawn */
pmix_status_t pmix_pnet_base_setup_app(char *nspace,
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist)
pmix_status_t pmix_pnet_base_setup_app(char *nspace, pmix_list_t *ilist)
{
pmix_pnet_base_active_module_t *active;
pmix_status_t rc;
pmix_nspace_t *nptr, *ns;
if (!pmix_pnet_globals.initialized) {
return PMIX_ERR_INIT;
}
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet: setup_app called");
/* protect against bozo inputs */
if (NULL == nspace || NULL == ilist) {
return PMIX_ERR_BAD_PARAM;
}
nptr = NULL;
if (PMIX_PROC_IS_SERVER(pmix_globals.mypeer)) {
/* find this nspace - note that it may not have
* been registered yet */
PMIX_LIST_FOREACH(ns, &pmix_server_globals.nspaces, pmix_nspace_t) {
if (0 == strcmp(ns->nspace, nspace)) {
nptr = ns;
break;
}
}
if (NULL == nptr) {
/* add it */
nptr = PMIX_NEW(pmix_nspace_t);
if (NULL == nptr) {
return PMIX_ERR_NOMEM;
}
nptr->nspace = strdup(nspace);
pmix_list_append(&pmix_server_globals.nspaces, &nptr->super);
}
}
PMIX_LIST_FOREACH(active, &pmix_pnet_globals.actives, pmix_pnet_base_active_module_t) {
if (NULL != active->module->setup_app) {
if (PMIX_SUCCESS != (rc = active->module->setup_app(nptr, info, ninfo, ilist))) {
if (PMIX_SUCCESS != (rc = active->module->setup_app(nspace, ilist))) {
return rc;
}
}
@ -78,48 +47,25 @@ pmix_status_t pmix_pnet_base_setup_app(char *nspace,
return PMIX_SUCCESS;
}
/* can only be called by a server */
pmix_status_t pmix_pnet_base_setup_local_network(char *nspace,
pmix_info_t info[],
size_t ninfo)
{
pmix_pnet_base_active_module_t *active;
pmix_status_t rc;
pmix_nspace_t *nptr, *ns;
if (!pmix_pnet_globals.initialized) {
return PMIX_ERR_INIT;
}
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet: setup_local_network called");
/* protect against bozo inputs */
if (NULL == nspace) {
return PMIX_ERR_BAD_PARAM;
}
/* find this proc's nspace object */
nptr = NULL;
PMIX_LIST_FOREACH(ns, &pmix_server_globals.nspaces, pmix_nspace_t) {
if (0 == strcmp(ns->nspace, nspace)) {
nptr = ns;
break;
}
}
if (NULL == nptr) {
/* add it */
nptr = PMIX_NEW(pmix_nspace_t);
if (NULL == nptr) {
return PMIX_ERR_NOMEM;
}
nptr->nspace = strdup(nspace);
pmix_list_append(&pmix_server_globals.nspaces, &nptr->super);
}
PMIX_LIST_FOREACH(active, &pmix_pnet_globals.actives, pmix_pnet_base_active_module_t) {
if (NULL != active->module->setup_local_network) {
if (PMIX_SUCCESS != (rc = active->module->setup_local_network(nptr, info, ninfo))) {
if (PMIX_SUCCESS != (rc = active->module->setup_local_network(nspace, info, ninfo))) {
return rc;
}
}
@ -128,43 +74,23 @@ pmix_status_t pmix_pnet_base_setup_local_network(char *nspace,
return PMIX_SUCCESS;
}
/* can only be called by a server */
pmix_status_t pmix_pnet_base_setup_fork(const pmix_proc_t *proc, char ***env)
pmix_status_t pmix_pnet_base_setup_fork(const pmix_proc_t *peer, char ***env)
{
pmix_pnet_base_active_module_t *active;
pmix_status_t rc;
pmix_nspace_t *nptr, *ns;
if (!pmix_pnet_globals.initialized) {
return PMIX_ERR_INIT;
}
/* protect against bozo inputs */
if (NULL == proc || NULL == env) {
if (NULL == peer || NULL == env) {
return PMIX_ERR_BAD_PARAM;
}
/* find this proc's nspace object */
nptr = NULL;
PMIX_LIST_FOREACH(ns, &pmix_server_globals.nspaces, pmix_nspace_t) {
if (0 == strcmp(ns->nspace, proc->nspace)) {
nptr = ns;
break;
}
}
if (NULL == nptr) {
/* add it */
nptr = PMIX_NEW(pmix_nspace_t);
if (NULL == nptr) {
return PMIX_ERR_NOMEM;
}
nptr->nspace = strdup(proc->nspace);
pmix_list_append(&pmix_server_globals.nspaces, &nptr->super);
}
PMIX_LIST_FOREACH(active, &pmix_pnet_globals.actives, pmix_pnet_base_active_module_t) {
if (NULL != active->module->setup_fork) {
if (PMIX_SUCCESS != (rc = active->module->setup_fork(nptr, env))) {
if (PMIX_SUCCESS != (rc = active->module->setup_fork(peer, env))) {
return rc;
}
}

2
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/base/pnet_base_frame.c
Просмотреть файл

@ -45,7 +45,7 @@
/* Instantiate the global vars */
pmix_pnet_globals_t pmix_pnet_globals = {{{0}}};
pmix_pnet_API_module_t pmix_pnet = {
pmix_pnet_module_t pmix_pnet = {
.setup_app = pmix_pnet_base_setup_app,
.setup_local_network = pmix_pnet_base_setup_local_network,
.setup_fork = pmix_pnet_base_setup_fork,

157
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/opa/pnet_opa.c
Просмотреть файл

@ -1,5 +1,5 @@
/*
* Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2015-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2016 IBM Corporation. All rights reserved.
*
* $COPYRIGHT$
@ -37,21 +37,17 @@
#include "src/util/error.h"
#include "src/util/output.h"
#include "src/util/pmix_environ.h"
#include "src/mca/preg/preg.h"
#include "src/mca/pnet/pnet.h"
#include "src/mca/pnet/base/base.h"
#include "pnet_opa.h"
static pmix_status_t opa_init(void);
static void opa_finalize(void);
static pmix_status_t setup_app(pmix_nspace_t *nptr,
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist);
static pmix_status_t setup_local_network(pmix_nspace_t *nptr,
static pmix_status_t setup_app(char *nspace, pmix_list_t *ilist);
static pmix_status_t setup_local_network(char *nspace,
pmix_info_t info[],
size_t ninfo);
static pmix_status_t setup_fork(pmix_nspace_t *nptr, char ***env);
static pmix_status_t setup_fork(const pmix_proc_t *peer, char ***env);
static void child_finalized(pmix_peer_t *peer);
static void local_app_finalized(char *nspace);
@ -67,14 +63,14 @@ pmix_pnet_module_t pmix_opa_module = {
static pmix_status_t opa_init(void)
{
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
pmix_output_verbose(2, pmix_globals.debug_output,
"pnet: opa init");
return PMIX_SUCCESS;
}
static void opa_finalize(void)
{
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
pmix_output_verbose(2, pmix_globals.debug_output,
"pnet: opa finalize");
}
@ -161,40 +157,14 @@ static char* transports_print(uint64_t *unique_key)
return string_key;
}
/* NOTE: if there is any binary data to be transferred, then
* this function MUST pack it for transport as the host will
* not know how to do so */
static pmix_status_t setup_app(pmix_nspace_t *nptr,
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist)
static pmix_status_t setup_app(char *nspace, pmix_list_t *ilist)
{
uint64_t unique_key[2];
char *string_key, *cs_env;
int fd_rand;
size_t n, bytes_read, len;
pmix_kval_t *kv, *next;
int i, j;
bool envars, seckeys;
size_t bytes_read;
pmix_kval_t *kv;
if (NULL == info) {
envars = true;
seckeys = true;
} else {
envars = false;
seckeys = false;
for (n=0; n < ninfo; n++) {
if (0 == strncmp(info[n].key, PMIX_SETUP_APP_ENVARS, PMIX_MAX_KEYLEN)) {
envars = PMIX_INFO_TRUE(&info[n]);
} else if (0 == strncmp(info[n].key, PMIX_SETUP_APP_ALL, PMIX_MAX_KEYLEN)) {
envars = PMIX_INFO_TRUE(&info[n]);
seckeys = PMIX_INFO_TRUE(&info[n]);
} else if (0 == strncmp(info[n].key, PMIX_SETUP_APP_NONENVARS, PMIX_MAX_KEYLEN)) {
seckeys = PMIX_INFO_TRUE(&info[n]);
}
}
}
if (seckeys) {
/* put the number here - or else create an appropriate string. this just needs to
* eventually be a string variable
*/
@ -213,7 +183,7 @@ static pmix_status_t setup_app(pmix_nspace_t *nptr,
return PMIX_ERR_OUT_OF_RESOURCE;
}
if (PMIX_SUCCESS != pmix_mca_base_var_env_name("opa_precondition_transports", &cs_env)) {
if (PMIX_SUCCESS != pmix_mca_base_var_env_name("pmix_precondition_transports", &cs_env)) {
PMIX_ERROR_LOG(PMIX_ERR_OUT_OF_RESOURCE);
free(string_key);
return PMIX_ERR_OUT_OF_RESOURCE;
@ -233,118 +203,29 @@ static pmix_status_t setup_app(pmix_nspace_t *nptr,
PMIX_RELEASE(kv);
return PMIX_ERR_OUT_OF_RESOURCE;
}
kv->value->type = PMIX_ENVAR;
PMIX_ENVAR_LOAD(&kv->value->data.envar, cs_env, string_key, ':');
kv->value->type = PMIX_STRING;
if (0 > asprintf(&kv->value->data.string, "%s=%s", cs_env, string_key)) {
free(string_key);
free(cs_env);
PMIX_RELEASE(kv);
return PMIX_ERR_OUT_OF_RESOURCE;
}
pmix_list_append(ilist, &kv->super);
free(cs_env);
free(string_key);
}
if (envars) {
/* harvest envars to pass along */
if (NULL != mca_pnet_opa_component.include) {
for (j=0; NULL != mca_pnet_opa_component.include[j]; j++) {
len = strlen(mca_pnet_opa_component.include[j]);
if ('*' == mca_pnet_opa_component.include[j][len-1]) {
--len;
}
for (i = 0; NULL != environ[i]; ++i) {
if (0 == strncmp(environ[i], mca_pnet_opa_component.include[j], len)) {
cs_env = strdup(environ[i]);
kv = PMIX_NEW(pmix_kval_t);
if (NULL == kv) {
return PMIX_ERR_OUT_OF_RESOURCE;
}
kv->key = strdup(PMIX_SET_ENVAR);
kv->value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
if (NULL == kv->value) {
PMIX_RELEASE(kv);
return PMIX_ERR_OUT_OF_RESOURCE;
}
kv->value->type = PMIX_ENVAR;
string_key = strchr(cs_env, '=');
*string_key = '\0';
++string_key;
PMIX_ENVAR_LOAD(&kv->value->data.envar, cs_env, string_key, ':');
pmix_list_append(ilist, &kv->super);
free(cs_env);
}
}
}
}
/* now check the exclusions and remove any that match */
if (NULL != mca_pnet_opa_component.exclude) {
for (j=0; NULL != mca_pnet_opa_component.exclude[j]; j++) {
len = strlen(mca_pnet_opa_component.exclude[j]);
if ('*' == mca_pnet_opa_component.exclude[j][len-1]) {
--len;
}
PMIX_LIST_FOREACH_SAFE(kv, next, ilist, pmix_kval_t) {
if (0 == strncmp(kv->value->data.envar.envar, mca_pnet_opa_component.exclude[j], len)) {
pmix_list_remove_item(ilist, &kv->super);
PMIX_RELEASE(kv);
}
}
}
}
}
return PMIX_SUCCESS;
}
static pmix_status_t setup_local_network(pmix_nspace_t *nptr,
static pmix_status_t setup_local_network(char *nspace,
pmix_info_t info[],
size_t ninfo)
{
size_t n;
pmix_status_t rc;
pmix_kval_t *kv;
char *nodestring, **nodes;
pmix_proc_t *procs;
size_t nprocs;
if (NULL != info) {
for (n=0; n < ninfo; n++) {
if (0 == strncmp(info[n].key, PMIX_PNET_OPA_BLOB, PMIX_MAX_KEYLEN)) {
/* the byte object contains a packed blob that needs to be
* cached until we determine we have local procs for this
* nspace, and then delivered to the local OPA driver when
* we have a means for doing so */
kv = PMIX_NEW(pmix_kval_t);
if (NULL == kv) {
return PMIX_ERR_NOMEM;
}
kv->key = strdup(info[n].key);
kv->value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
if (NULL == kv->value) {
PMIX_RELEASE(kv);
return PMIX_ERR_NOMEM;
}
pmix_value_xfer(kv->value, &info[n].value);
pmix_list_append(&nptr->setup_data, &kv->super);
}
}
}
return PMIX_SUCCESS;
}
static pmix_status_t setup_fork(pmix_nspace_t *nptr, char ***env)
static pmix_status_t setup_fork(const pmix_proc_t *peer, char ***env)
{
pmix_kval_t *kv, *next;
/* if there are any cached nspace prep blobs, execute them,
* ensuring that we only do so once per nspace - note that
* we don't expect to find any envars here, though we could
* have included some if we needed to set them per-client */
PMIX_LIST_FOREACH_SAFE(kv, next, &nptr->setup_data, pmix_kval_t) {
if (0 == strcmp(kv->key, PMIX_PNET_OPA_BLOB)) {
pmix_list_remove_item(&nptr->setup_data, &kv->super);
/* deliver to the local lib */
PMIX_RELEASE(kv);
}
}
return PMIX_SUCCESS;
}

13
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/opa/pnet_opa.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
* Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2015-2016 Intel, Inc. All rights reserved.
*
* $COPYRIGHT$
*
@ -18,19 +18,10 @@
BEGIN_C_DECLS
typedef struct {
pmix_pnet_base_component_t super;
char **include;
char **exclude;
} pmix_pnet_opa_component_t;
/* the component must be visible data for the linker to find it */
PMIX_EXPORT extern pmix_pnet_opa_component_t mca_pnet_opa_component;
PMIX_EXPORT extern pmix_pnet_base_component_t mca_pnet_opa_component;
extern pmix_pnet_module_t pmix_opa_module;
/* define a key for any blob we need to send in a launch msg */
#define PMIX_PNET_OPA_BLOB "pmix.pnet.opa.blob"
END_C_DECLS
#endif

49
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/opa/pnet_opa_component.c
Просмотреть файл

@ -12,7 +12,7 @@
* All rights reserved.
* Copyright (c) 2015 Los Alamos National Security, LLC. All rights
* reserved.
* Copyright (c) 2016-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2016 Intel, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
@ -29,21 +29,19 @@
#include <src/include/pmix_config.h>
#include "pmix_common.h"
#include "src/util/argv.h"
#include "src/mca/pnet/pnet.h"
#include "pnet_opa.h"
static pmix_status_t component_open(void);
static pmix_status_t component_close(void);
static pmix_status_t component_query(pmix_mca_base_module_t **module, int *priority);
static pmix_status_t component_register(void);
/*
* Instantiate the public struct with all of our public information
* and pointers to our public functions in it
*/
pmix_pnet_opa_component_t mca_pnet_opa_component = {
.super = {
pmix_pnet_base_component_t mca_pnet_opa_component = {
.base = {
PMIX_PNET_BASE_VERSION_1_0_0,
@ -57,57 +55,22 @@ pmix_pnet_opa_component_t mca_pnet_opa_component = {
/* Component open and close functions */
.pmix_mca_open_component = component_open,
.pmix_mca_close_component = component_close,
.pmix_mca_register_component_params = component_register,
.pmix_mca_query_component = component_query,
},
.data = {
/* The component is checkpoint ready */
PMIX_MCA_BASE_METADATA_PARAM_CHECKPOINT
}
},
.include = NULL,
.exclude = NULL
};
static char *includeparam;
static char *excludeparam;
static pmix_status_t component_register(void)
{
pmix_mca_base_component_t *component = &mca_pnet_opa_component.super.base;
includeparam = "HFI_*,PSM2_*";
(void)pmix_mca_base_component_var_register(component, "include_envars",
"Comma-delimited list of envars to harvest (\'*\' and \'?\' supported)",
PMIX_MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
PMIX_INFO_LVL_2,
PMIX_MCA_BASE_VAR_SCOPE_LOCAL,
&includeparam);
if (NULL != includeparam) {
mca_pnet_opa_component.include = pmix_argv_split(includeparam, ',');
}
excludeparam = NULL;
(void)pmix_mca_base_component_var_register(component, "exclude_envars",
"Comma-delimited list of envars to exclude (\'*\' and \'?\' supported)",
PMIX_MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
PMIX_INFO_LVL_2,
PMIX_MCA_BASE_VAR_SCOPE_LOCAL,
&excludeparam);
if (NULL != excludeparam) {
mca_pnet_opa_component.exclude = pmix_argv_split(excludeparam, ',');
}
return PMIX_SUCCESS;
}
static pmix_status_t component_open(void)
static int component_open(void)
{
return PMIX_SUCCESS;
}
static pmix_status_t component_query(pmix_mca_base_module_t **module, int *priority)
static int component_query(pmix_mca_base_module_t **module, int *priority)
{
*priority = 10;
*module = (pmix_mca_base_module_t *)&pmix_opa_module;
@ -115,7 +78,7 @@ static pmix_status_t component_query(pmix_mca_base_module_t **module, int *prior
}
static pmix_status_t component_close(void)
static int component_close(void)
{
return PMIX_SUCCESS;
}

53
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/pnet.h
Просмотреть файл

@ -56,15 +56,13 @@ typedef void (*pmix_pnet_base_module_fini_fn_t)(void);
* tokens required for application processes to communicate with
* each other
*/
typedef pmix_status_t (*pmix_pnet_base_module_setup_app_fn_t)(pmix_nspace_t *nptr,
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist);
typedef pmix_status_t (*pmix_pnet_base_module_setup_app_fn_t)(char *nspace, pmix_list_t *ilist);
/**
* Give the local network library an opportunity to setup address information
* for the application by passing in the layout type and a regex describing
* the layout */
typedef pmix_status_t (*pmix_pnet_base_module_setup_local_net_fn_t)(pmix_nspace_t *nptr,
typedef pmix_status_t (*pmix_pnet_base_module_setup_local_net_fn_t)(char *nspace,
pmix_info_t info[],
size_t ninfo);
@ -72,7 +70,7 @@ typedef pmix_status_t (*pmix_pnet_base_module_setup_local_net_fn_t)(pmix_nspace_
* Give the local network library an opportunity to add any envars to the
* environment of a local application process prior to fork/exec
*/
typedef pmix_status_t (*pmix_pnet_base_module_setup_fork_fn_t)(pmix_nspace_t *nptr, char ***env);
typedef pmix_status_t (*pmix_pnet_base_module_setup_fork_fn_t)(const pmix_proc_t *peer, char ***env);
/**
* Provide an opportunity for the local network library to cleanup when a
@ -101,51 +99,8 @@ typedef struct {
pmix_pnet_base_module_local_app_finalized_fn_t local_app_finalized;
} pmix_pnet_module_t;
/* define a few API versions of the functions */
/**
* Provide an opportunity for the network to define values that
* are to be passed to an application. This can include security
* tokens required for application processes to communicate with
* each other
*/
typedef pmix_status_t (*pmix_pnet_base_API_setup_app_fn_t)(char *nspace,
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist);
/**
* Give the local network library an opportunity to setup address information
* for the application by passing in the layout type and a regex describing
* the layout */
typedef pmix_status_t (*pmix_pnet_base_API_setup_local_net_fn_t)(char *nspace,
pmix_info_t info[],
size_t ninfo);
/**
* Give the local network library an opportunity to add any envars to the
* environment of a local application process prior to fork/exec
*/
typedef pmix_status_t (*pmix_pnet_base_API_setup_fork_fn_t)(const pmix_proc_t *peer, char ***env);
/**
* Base structure for a PNET API
*/
typedef struct {
char *name;
/* init/finalize */
pmix_pnet_base_module_init_fn_t init;
pmix_pnet_base_module_fini_fn_t finalize;
pmix_pnet_base_API_setup_app_fn_t setup_app;
pmix_pnet_base_API_setup_local_net_fn_t setup_local_network;
pmix_pnet_base_API_setup_fork_fn_t setup_fork;
pmix_pnet_base_module_child_finalized_fn_t child_finalized;
pmix_pnet_base_module_local_app_finalized_fn_t local_app_finalized;
} pmix_pnet_API_module_t;
/* declare the global APIs */
PMIX_EXPORT extern pmix_pnet_API_module_t pmix_pnet;
PMIX_EXPORT extern pmix_pnet_module_t pmix_pnet;
/*
* the standard component data structure

221
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/test/pnet_test.c
Просмотреть файл

@ -1,221 +0,0 @@
/*
* Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2016 IBM Corporation. All rights reserved.
*
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include <src/include/pmix_config.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#include <time.h>
#include <pmix_common.h>
#include "src/mca/base/pmix_mca_base_var.h"
#include "src/include/pmix_socket_errno.h"
#include "src/include/pmix_globals.h"
#include "src/class/pmix_list.h"
#include "src/util/alfg.h"
#include "src/util/argv.h"
#include "src/util/error.h"
#include "src/util/output.h"
#include "src/util/pmix_environ.h"
#include "src/mca/preg/preg.h"
#include "src/mca/pnet/pnet.h"
#include "src/mca/pnet/base/base.h"
#include "pnet_test.h"
static pmix_status_t test_init(void);
static void test_finalize(void);
static pmix_status_t setup_app(pmix_nspace_t *nptr,
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist);
static pmix_status_t setup_local_network(pmix_nspace_t *nptr,
pmix_info_t info[],
size_t ninfo);
static pmix_status_t setup_fork(pmix_nspace_t *nptr, char ***env);
static void child_finalized(pmix_peer_t *peer);
static void local_app_finalized(char *nspace);
pmix_pnet_module_t pmix_test_module = {
.init = test_init,
.finalize = test_finalize,
.setup_app = setup_app,
.setup_local_network = setup_local_network,
.setup_fork = setup_fork,
.child_finalized = child_finalized,
.local_app_finalized = local_app_finalized
};
static pmix_status_t test_init(void)
{
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet: test init");
return PMIX_SUCCESS;
}
static void test_finalize(void)
{
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet: test finalize");
}
/* NOTE: if there is any binary data to be transferred, then
* this function MUST pack it for transport as the host will
* not know how to do so */
static pmix_status_t setup_app(pmix_nspace_t *nptr,
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist)
{
uint64_t unique_key[2];
char *string_key, *cs_env;
int fd_rand;
size_t n, bytes_read, len;
pmix_kval_t *kv, *next;
int i, j;
bool envars, seckeys;
if (NULL == info) {
envars = true;
seckeys = true;
} else {
envars = false;
seckeys = false;
for (n=0; n < ninfo; n++) {
if (0 == strncmp(info[n].key, PMIX_SETUP_APP_ENVARS, PMIX_MAX_KEYLEN)) {
envars = PMIX_INFO_TRUE(&info[n]);
} else if (0 == strncmp(info[n].key, PMIX_SETUP_APP_ALL, PMIX_MAX_KEYLEN)) {
envars = PMIX_INFO_TRUE(&info[n]);
seckeys = PMIX_INFO_TRUE(&info[n]);
} else if (0 == strncmp(info[n].key, PMIX_SETUP_APP_NONENVARS, PMIX_MAX_KEYLEN)) {
seckeys = PMIX_INFO_TRUE(&info[n]);
}
}
}
if (seckeys) {
kv = PMIX_NEW(pmix_kval_t);
if (NULL == kv) {
return PMIX_ERR_NOMEM;
}
kv->key = strdup(PMIX_SET_ENVAR);
kv->value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
if (NULL == kv->value) {
PMIX_RELEASE(kv);
return PMIX_ERR_NOMEM;
}
kv->value->type = PMIX_ENVAR;
PMIX_ENVAR_LOAD(&kv->value->data.envar, "PMIX_TEST_SECKEY", "1", ':');
pmix_list_append(ilist, &kv->super);
}
if (envars) {
kv = PMIX_NEW(pmix_kval_t);
if (NULL == kv) {
return PMIX_ERR_NOMEM;
}
kv->key = strdup(PMIX_SET_ENVAR);
kv->value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
if (NULL == kv->value) {
PMIX_RELEASE(kv);
return PMIX_ERR_NOMEM;
}
kv->value->type = PMIX_ENVAR;
PMIX_ENVAR_LOAD(&kv->value->data.envar, "PMIX_TEST_ENVAR", "1", ':');
pmix_list_append(ilist, &kv->super);
}
/* provide a blob so setup_local_network will get called */
kv = PMIX_NEW(pmix_kval_t);
if (NULL == kv) {
return PMIX_ERR_NOMEM;
}
kv->key = strdup("pmix-pnet-test-blob");
kv->value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
if (NULL == kv->value) {
PMIX_RELEASE(kv);
return PMIX_ERR_NOMEM;
}
kv->value->type = PMIX_STRING;
kv->value->data.string = strdup("foobar");
pmix_list_append(ilist, &kv->super);
return PMIX_SUCCESS;
}
static pmix_status_t setup_local_network(pmix_nspace_t *nptr,
pmix_info_t info[],
size_t ninfo)
{
size_t n, m;
pmix_status_t rc;
pmix_kval_t *kv;
char *nodestring, **nodes;
pmix_proc_t *procs;
size_t nprocs;
/* get the list of nodes in this job - returns a regex */
pmix_output(0, "pnet:setup_local_network NSPACE %s", (NULL == nptr) ? "NULL" : nptr->nspace);
pmix_preg.resolve_nodes(nptr->nspace, &nodestring);
if (NULL == nodestring) {
return PMIX_SUCCESS;
}
pmix_preg.parse_nodes(nodestring, &nodes); // get an argv array of node names
pmix_output(0, "pnet:setup_local_network NODES %s", (NULL == nodes) ? "NULL" : "NON-NULL");
if (NULL == nodes) {
free(nodestring);
return PMIX_SUCCESS;
}
for (n=0; NULL != nodes[n]; n++) {
pmix_output(0, "pnet:setup_local_network NODE: %s", nodes[n]);
}
for (n=0; NULL != nodes[n]; n++) {
/* get an array of pmix_proc_t containing the names of the procs on that node */
pmix_preg.resolve_peers(nodes[n], nptr->nspace, &procs, &nprocs);
if (NULL == procs) {
continue;
}
for (m=0; m < nprocs; m++) {
pmix_output(0, "pnet:setup_local_network NODE %s: peer %s:%d", nodes[n], procs[m].nspace, procs[m].rank);
}
/* do stuff */
free(procs);
}
return PMIX_SUCCESS;
}
static pmix_status_t setup_fork(pmix_nspace_t *nptr, char ***env)
{
return PMIX_SUCCESS;
}
static void child_finalized(pmix_peer_t *peer)
{
}
static void local_app_finalized(char *nspace)
{
}

36
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/test/pnet_test.h
Просмотреть файл

@ -1,36 +0,0 @@
/*
* Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
*
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#ifndef PMIX_PNET_test_H
#define PMIX_PNET_test_H
#include <src/include/pmix_config.h>
#include "src/mca/pnet/pnet.h"
BEGIN_C_DECLS
typedef struct {
pmix_pnet_base_component_t super;
char **include;
char **exclude;
} pmix_pnet_test_component_t;
/* the component must be visible data for the linker to find it */
PMIX_EXPORT extern pmix_pnet_test_component_t mca_pnet_test_component;
extern pmix_pnet_module_t pmix_test_module;
/* define a key for any blob we need to send in a launch msg */
#define PMIX_PNET_TEST_BLOB "pmix.pnet.test.blob"
END_C_DECLS
#endif

101
opal/mca/pmix/pmix3x/pmix/src/mca/pnet/test/pnet_test_component.c
Просмотреть файл

@ -1,101 +0,0 @@
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/*
* Copyright (c) 2004-2008 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) 2015 Los Alamos National Security, LLC. All rights
* reserved.
* Copyright (c) 2016-2018 Intel, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*
* These symbols are in a file by themselves to provide nice linker
* semantics. Since linkers generally pull in symbols by object
* files, keeping these symbols as the only symbols in this file
* prevents utility programs such as "ompi_info" from having to import
* entire components just to query their version and parameters.
*/
#include <src/include/pmix_config.h>
#include "pmix_common.h"
#include "src/util/argv.h"
#include "src/mca/pnet/pnet.h"
#include "pnet_test.h"
static pmix_status_t component_open(void);
static pmix_status_t component_close(void);
static pmix_status_t component_query(pmix_mca_base_module_t **module, int *priority);
/*
* Instantiate the public struct with all of our public information
* and pointers to our public functions in it
*/
pmix_pnet_test_component_t mca_pnet_test_component = {
.super = {
.base = {
PMIX_PNET_BASE_VERSION_1_0_0,
/* Component name and version */
.pmix_mca_component_name = "test",
PMIX_MCA_BASE_MAKE_VERSION(component,
PMIX_MAJOR_VERSION,
PMIX_MINOR_VERSION,
PMIX_RELEASE_VERSION),
/* Component open and close functions */
.pmix_mca_open_component = component_open,
.pmix_mca_close_component = component_close,
.pmix_mca_query_component = component_query,
},
.data = {
/* The component is checkpoint ready */
PMIX_MCA_BASE_METADATA_PARAM_CHECKPOINT
}
},
.include = NULL,
.exclude = NULL
};
static pmix_status_t component_open(void)
{
int index;
const pmix_mca_base_var_storage_t *value=NULL;
/* we only allow ourselves to be considered IF the user
* specifically requested so */
if (0 > (index = pmix_mca_base_var_find("pmix", "pnet", NULL, NULL))) {
return PMIX_ERROR;
}
pmix_mca_base_var_get_value(index, &value, NULL, NULL);
if (NULL != value && NULL != value->stringval && '\0' != value->stringval[0]) {
if (NULL != strstr(value->stringval, "test")) {
return PMIX_SUCCESS;
}
}
return PMIX_ERROR;
}
static pmix_status_t component_query(pmix_mca_base_module_t **module, int *priority)
{
*priority = 0;
*module = (pmix_mca_base_module_t *)&pmix_test_module;
return PMIX_SUCCESS;
}
static pmix_status_t component_close(void)
{
return PMIX_SUCCESS;
}

198
opal/mca/pmix/pmix3x/pmix/src/mca/preg/native/preg_native.c
Просмотреть файл

@ -1,5 +1,5 @@
/*
* Copyright (c) 2015-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2016 IBM Corporation. All rights reserved.
* Copyright (c) 2018 Research Organization for Information Science
* and Technology (RIST). All rights reserved.
@ -501,32 +501,27 @@ static pmix_status_t parse_procs(const char *regexp,
return rc;
}
static pmix_status_t resolve_peers(const char *nodename,
const char *nspace,
pmix_proc_t **procs, size_t *nprocs)
static void _resolve_peers(int sd, short args, void *cbdata)
{
pmix_cb_t cb;
pmix_cb_t *cb = (pmix_cb_t*)cbdata;
pmix_status_t rc;
pmix_kval_t *kv;
pmix_proc_t proc;
char **ptr;
pmix_info_t *info;
pmix_proc_t *p=NULL;
size_t ninfo, np=0, n, j;
pmix_proc_t *procs;
size_t ninfo, nprocs, n, j;
PMIX_CONSTRUCT(&cb, pmix_cb_t);
cb.key = strdup(nodename);
/* this data isn't going anywhere, so we don't require a copy */
cb.copy = false;
cb->copy = false;
/* scope is irrelevant as the info we seek must be local */
cb.scope = PMIX_SCOPE_UNDEF;
cb->scope = PMIX_SCOPE_UNDEF;
/* let the proc point to the nspace */
(void)strncpy(proc.nspace, nspace, PMIX_MAX_NSLEN);
(void)strncpy(proc.nspace, cb->pname.nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
cb.proc = &proc;
cb->proc = &proc;
PMIX_GDS_FETCH_KV(rc, pmix_client_globals.myserver, &cb);
PMIX_GDS_FETCH_KV(rc, pmix_client_globals.myserver, cb);
if (PMIX_SUCCESS != rc) {
if (PMIX_ERR_INVALID_NAMESPACE != rc) {
PMIX_ERROR_LOG(rc);
@ -534,12 +529,12 @@ static pmix_status_t resolve_peers(const char *nodename,
goto complete;
}
/* should just be the one value on the list */
if (1 != pmix_list_get_size(&cb.kvs)) {
if (1 != pmix_list_get_size(&cb->kvs)) {
PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
rc = PMIX_ERR_BAD_PARAM;
goto complete;
}
kv = (pmix_kval_t*)pmix_list_get_first(&cb.kvs);
kv = (pmix_kval_t*)pmix_list_get_first(&cb->kvs);
/* the hostname used as a key with wildcard rank will return
* a pmix_data_array_t of pmix_info_t structs */
if (NULL == kv->value ||
@ -557,87 +552,123 @@ static pmix_status_t resolve_peers(const char *nodename,
if (0 == strncmp(info[n].key, PMIX_LOCAL_PEERS, PMIX_MAX_KEYLEN)) {
/* split the string */
ptr = pmix_argv_split(info[n].value.data.string, ',');
np = pmix_argv_count(ptr);
PMIX_PROC_CREATE(p, np);
if (NULL == p) {
nprocs = pmix_argv_count(ptr);
PMIX_PROC_CREATE(procs, nprocs);
if (NULL == procs) {
rc = PMIX_ERR_NOMEM;
pmix_argv_free(ptr);
goto complete;
}
for (j=0; j < np; j++) {
(void)strncpy(p[j].nspace, nspace, PMIX_MAX_NSLEN);
p[j].rank = strtoul(ptr[j], NULL, 10);
for (j=0; j < nprocs; j++) {
(void)strncpy(procs[j].nspace, cb->pname.nspace, PMIX_MAX_NSLEN);
procs[j].rank = strtoul(ptr[j], NULL, 10);
}
cb->procs = procs;
cb->nprocs = nprocs;
rc = PMIX_SUCCESS;
pmix_argv_free(ptr);
break;
goto complete;
}
}
complete:
if (NULL != cb.info) {
PMIX_INFO_FREE(cb.info, cb.ninfo);
cb->status = rc;
if (NULL != cb->info) {
PMIX_INFO_FREE(cb->info, cb->ninfo);
}
if (NULL != cb.key) {
free(cb.key);
cb.key = NULL;
}
PMIX_DESTRUCT(&cb);
*procs = p;
*nprocs = np;
cb->pstatus = rc;
/* post the data so the receiving thread can acquire it */
PMIX_POST_OBJECT(cb);
PMIX_WAKEUP_THREAD(&cb->lock);
return;
}
static pmix_status_t resolve_peers(const char *nodename,
const char *nspace,
pmix_proc_t **procs, size_t *nprocs)
{
pmix_cb_t *cb;
pmix_status_t rc;
pmix_proc_t proc;
cb = PMIX_NEW(pmix_cb_t);
cb->key = (char*)nodename;
cb->pname.nspace = strdup(nspace);
PMIX_THREADSHIFT(cb, _resolve_peers);
/* wait for the result */
PMIX_WAIT_THREAD(&cb->lock);
/* if the nspace wasn't found, then we need to
* ask the server for that info */
if (PMIX_ERR_INVALID_NAMESPACE == cb->status) {
(void)strncpy(proc.nspace, nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
/* any key will suffice as it will bring down
* the entire data blob */
rc = PMIx_Get(&proc, PMIX_UNIV_SIZE, NULL, 0, NULL);
if (PMIX_SUCCESS != rc) {
PMIX_RELEASE(cb);
return rc;
}
/* retry the fetch */
cb->lock.active = true;
PMIX_THREADSHIFT(cb, _resolve_peers);
PMIX_WAIT_THREAD(&cb->lock);
}
*procs = cb->procs;
*nprocs = cb->nprocs;
rc = cb->status;
PMIX_RELEASE(cb);
return rc;
}
static pmix_status_t resolve_nodes(const char *nspace,
char **nodelist)
static void _resolve_nodes(int sd, short args, void *cbdata)
{
pmix_cb_t cb;
pmix_cb_t *cb = (pmix_cb_t*)cbdata;
pmix_status_t rc;
pmix_kval_t *kv;
pmix_proc_t proc;
PMIX_CONSTRUCT(&cb, pmix_cb_t);
/* setup default answer */
*nodelist = NULL;
/* create a pmix_info_t so we can pass the nspace
* into the fetch as a qualifier */
PMIX_INFO_CREATE(cb.info, 1);
if (NULL == cb.info) {
PMIX_DESTRUCT(&cb);
return PMIX_ERR_NOMEM;
PMIX_INFO_CREATE(cb->info, 1);
if (NULL == cb->info) {
cb->status = PMIX_ERR_NOMEM;
PMIX_POST_OBJECT(cb);
PMIX_WAKEUP_THREAD(&cb->lock);
return;
}
cb.ninfo = 1;
PMIX_INFO_LOAD(&cb.info[0], PMIX_NSPACE, nspace, PMIX_STRING);
cb->ninfo = 1;
PMIX_INFO_LOAD(&cb->info[0], PMIX_NSPACE, cb->pname.nspace, PMIX_STRING);
/* tell the GDS what we want */
cb.key = PMIX_NODE_MAP;
cb->key = PMIX_NODE_LIST;
/* this data isn't going anywhere, so we don't require a copy */
cb.copy = false;
cb->copy = false;
/* scope is irrelevant as the info we seek must be local */
cb.scope = PMIX_SCOPE_UNDEF;
cb->scope = PMIX_SCOPE_UNDEF;
/* put the nspace in the proc field */
(void)strncpy(proc.nspace, nspace, PMIX_MAX_NSLEN);
(void)strncpy(proc.nspace, cb->pname.nspace, PMIX_MAX_NSLEN);
/* the info will be associated with PMIX_RANK_WILDCARD */
proc.rank = PMIX_RANK_WILDCARD;
cb.proc = &proc;
cb->proc = &proc;
PMIX_GDS_FETCH_KV(rc, pmix_client_globals.myserver, &cb);
PMIX_GDS_FETCH_KV(rc, pmix_client_globals.myserver, cb);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
goto complete;
}
/* should just be the one value on the list */
if (1 != pmix_list_get_size(&cb.kvs)) {
if (1 != pmix_list_get_size(&cb->kvs)) {
PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
rc = PMIX_ERR_BAD_PARAM;
goto complete;
}
kv = (pmix_kval_t*)pmix_list_get_first(&cb.kvs);
/* the PMIX_NODE_MAP key is supposed to return
* a regex string - check that it did */
kv = (pmix_kval_t*)pmix_list_get_first(&cb->kvs);
/* the PMIX_NODE_LIST key is supposed to return a comma-delimited
* string of nodes in this - check that it did */
if (NULL == kv->value ||
PMIX_STRING != kv->value->type) {
PMIX_ERROR_LOG(PMIX_ERR_DATA_VALUE_NOT_FOUND);
@ -646,14 +677,59 @@ static pmix_status_t resolve_nodes(const char *nspace,
}
/* return the string */
if (NULL != kv->value->data.string) {
*nodelist = strdup(kv->value->data.string);
cb->key = strdup(kv->value->data.string);
}
complete:
if (NULL != cb.info) {
PMIX_INFO_FREE(cb.info, cb.ninfo);
cb->status = rc;
if (NULL != cb->info) {
PMIX_INFO_FREE(cb->info, cb->ninfo);
}
/* post the data so the receiving thread can acquire it */
PMIX_POST_OBJECT(cb);
PMIX_WAKEUP_THREAD(&cb->lock);
return;
}
static pmix_status_t resolve_nodes(const char *nspace,
char **nodelist)
{
pmix_cb_t *cb;
pmix_status_t rc;
pmix_proc_t proc;
cb = PMIX_NEW(pmix_cb_t);
cb->pname.nspace = (char*)nspace;
PMIX_THREADSHIFT(cb, _resolve_nodes);
/* wait for the result */
PMIX_WAIT_THREAD(&cb->lock);
/* if the nspace wasn't found, then we need to
* ask the server for that info */
if (PMIX_ERR_INVALID_NAMESPACE == cb->status) {
(void)strncpy(proc.nspace, nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
/* any key will suffice as it will bring down
* the entire data blob */
rc = PMIx_Get(&proc, PMIX_UNIV_SIZE, NULL, 0, NULL);
if (PMIX_SUCCESS != rc) {
PMIX_RELEASE(cb);
return rc;
}
/* retry the fetch */
cb->lock.active = true;
PMIX_THREADSHIFT(cb, _resolve_nodes);
PMIX_WAIT_THREAD(&cb->lock);
}
/* the string we want is in the key field */
*nodelist = cb->key;
rc = cb->status;
PMIX_RELEASE(cb);
return rc;
}
static pmix_status_t pmix_regex_extract_nodes(char *regexp, char ***names)

42
opal/mca/pmix/pmix3x/pmix/src/server/pmix_server.c
Просмотреть файл

@ -1331,20 +1331,19 @@ static void _setup_op(pmix_status_t rc, void *cbdata)
static void _setup_app(int sd, short args, void *cbdata)
{
pmix_setup_caddy_t *cd = (pmix_setup_caddy_t*)cbdata;
pmix_buffer_t buffer;
pmix_byte_object_t blob;
pmix_setup_caddy_t *fcd = NULL;
pmix_status_t rc;
pmix_list_t ilist;
pmix_kval_t *kv;
size_t n;
PMIX_ACQUIRE_OBJECT(cd);
PMIX_CONSTRUCT(&ilist, pmix_list_t);
/* pass to the network libraries */
if (PMIX_SUCCESS != (rc = pmix_pnet.setup_app(cd->nspace,
cd->info, cd->ninfo,
&ilist))) {
if (PMIX_SUCCESS != (rc = pmix_pnet.setup_app(cd->nspace, &ilist))) {
goto depart;
}
@ -1356,20 +1355,31 @@ static void _setup_app(int sd, short args, void *cbdata)
goto depart;
}
/* if anything came back, construct an info array */
if (0 < (fcd->ninfo = pmix_list_get_size(&ilist))) {
PMIX_INFO_CREATE(fcd->info, fcd->ninfo);
if (NULL == fcd->info) {
rc = PMIX_ERR_NOMEM;
/* if anything came back, construct the blob */
if (0 < pmix_list_get_size(&ilist)) {
PMIX_CONSTRUCT(&buffer, pmix_buffer_t);
PMIX_LIST_FOREACH(kv, &ilist, pmix_kval_t) {
PMIX_BFROPS_PACK(rc, pmix_globals.mypeer, &buffer, kv, 1, PMIX_KVAL);
if (PMIX_SUCCESS != rc) {
PMIX_DESTRUCT(&blob);
PMIX_RELEASE(fcd);
fcd = NULL;
goto depart;
}
n = 0;
PMIX_LIST_FOREACH(kv, &ilist, pmix_kval_t) {
(void)strncpy(fcd->info[n].key, kv->key, PMIX_MAX_KEYLEN);
pmix_value_xfer(&fcd->info[n].value, kv->value);
++n;
}
PMIX_INFO_CREATE(fcd->info, 1);
if (NULL == fcd->info) {
PMIX_DESTRUCT(&blob);
PMIX_RELEASE(fcd);
fcd = NULL;
goto depart;
}
fcd->ninfo = 1;
PMIX_BYTE_OBJECT_CONSTRUCT(&blob);
PMIX_BYTE_OBJECT_LOAD(&blob, buffer.base_ptr, buffer.bytes_used);
PMIX_DESTRUCT(&buffer);
PMIX_INFO_LOAD(&fcd->info[0], PMIX_PNET_SETUP_APP, &blob, PMIX_BYTE_OBJECT);
PMIX_BYTE_OBJECT_DESTRUCT(&blob);
}
depart:
@ -1717,7 +1727,7 @@ static void _spcb(int sd, short args, void *cbdata)
PMIX_SERVER_QUEUE_REPLY(cd->cd->peer, cd->cd->hdr.tag, reply);
/* cleanup */
PMIX_RELEASE(cd->cd);
PMIX_WAKEUP_THREAD(&cd->lock);
PMIX_RELEASE(cd);
}
static void spawn_cbfunc(pmix_status_t status, char *nspace, void *cbdata)
@ -1731,8 +1741,6 @@ static void spawn_cbfunc(pmix_status_t status, char *nspace, void *cbdata)
cd->cd = (pmix_server_caddy_t*)cbdata;;
PMIX_THREADSHIFT(cd, _spcb);
PMIX_WAIT_THREAD(&cd->lock);
PMIX_RELEASE(cd);
}
static void lookup_cbfunc(pmix_status_t status, pmix_pdata_t pdata[], size_t ndata,

16
opal/mca/pmix/pmix3x/pmix/src/server/pmix_server_ops.c
Просмотреть файл

@ -1138,6 +1138,9 @@ pmix_status_t pmix_server_spawn(pmix_peer_t *peer,
cd->peer = peer;
cd->spcbfunc = cbfunc;
cd->cbdata = cbdata;
/* setup the proc name */
(void)strncpy(proc.nspace, peer->info->pname.nspace, PMIX_MAX_NSLEN);
proc.rank = peer->info->pname.rank;
/* unpack the number of job-level directives */
cnt=1;
@ -1150,6 +1153,11 @@ pmix_status_t pmix_server_spawn(pmix_peer_t *peer,
/* always add one directive that indicates whether the requestor
* is a tool or client */
cd->ninfo = ninfo + 1;
/* if it is a client, then we set the parent and
* "spawned" keys as well */
if (!PMIX_PROC_IS_TOOL(peer)) {
cd->ninfo += 2;
}
PMIX_INFO_CREATE(cd->info, cd->ninfo);
if (NULL == cd->info) {
rc = PMIX_ERR_NOMEM;
@ -1194,7 +1202,7 @@ pmix_status_t pmix_server_spawn(pmix_peer_t *peer,
}
/* add the directive to the end */
if (PMIX_PROC_IS_TOOL(peer)) {
PMIX_INFO_LOAD(&cd->info[ninfo], PMIX_REQUESTOR_IS_TOOL, NULL, PMIX_BOOL);
PMIX_INFO_LOAD(&cd->info[cd->ninfo-1], PMIX_REQUESTOR_IS_TOOL, NULL, PMIX_BOOL);
/* if the requestor is a tool, we default to forwarding all
* output IO channels */
if (!stdout_found) {
@ -1207,7 +1215,9 @@ pmix_status_t pmix_server_spawn(pmix_peer_t *peer,
cd->channels |= PMIX_FWD_STDDIAG_CHANNEL;
}
} else {
PMIX_INFO_LOAD(&cd->info[ninfo], PMIX_REQUESTOR_IS_CLIENT, NULL, PMIX_BOOL);
PMIX_INFO_LOAD(&cd->info[cd->ninfo-3], PMIX_SPAWNED, NULL, PMIX_BOOL);
PMIX_INFO_LOAD(&cd->info[cd->ninfo-2], PMIX_PARENT_ID, &proc, PMIX_PROC);
PMIX_INFO_LOAD(&cd->info[cd->ninfo-1], PMIX_REQUESTOR_IS_CLIENT, NULL, PMIX_BOOL);
}
/* unpack the number of apps */
@ -1232,8 +1242,6 @@ pmix_status_t pmix_server_spawn(pmix_peer_t *peer,
}
}
/* call the local server */
(void)strncpy(proc.nspace, peer->info->pname.nspace, PMIX_MAX_NSLEN);
proc.rank = peer->info->pname.rank;
rc = pmix_host_server.spawn(&proc, cd->info, cd->ninfo, cd->apps, cd->napps, spcbfunc, cd);
cleanup:

4
opal/mca/pmix/pmix3x/pmix/test/pmi2_client.c
Просмотреть файл

@ -263,7 +263,7 @@ static int test_item3(void)
};
const char **ptr = tkeys;
if (_legacy || !_legacy) {
if (!_legacy) {
log_error("%s\n", "PMIx and SLURM/PMI2 does not set Job Attributes (Do not mark test as failed)");
return rc;
}
@ -298,7 +298,7 @@ static int test_item4(void)
};
const char **ptr = tkeys;
if (_legacy || !_legacy) {
if (!_legacy) {
log_error("%s\n", "PMIx and SLURM/PMI2 does not set Node Attributes (Do not mark test as failed)");
return rc;
}

2
opal/mca/pmix/pmix3x/pmix/test/pmi_client.c
Просмотреть файл

@ -341,7 +341,7 @@ static int test_item5(void)
};
const char **ptr = tkeys;
if (_legacy || !_legacy) {
if (!_legacy) {
log_error("%s\n", "PMIx and SLURM/PMI1 do not set 'PMI_process_mapping' (Do not mark test as failed)");
return rc;
}

4
opal/mca/pmix/pmix3x/pmix/test/server_callbacks.c
Просмотреть файл

@ -1,5 +1,5 @@
/*
* Copyright (c) 2015-2017 Intel, Inc. All rights reserved.
* Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
* Copyright (c) 2015 Research Organization for Information Science
* and Technology (RIST). All rights reserved.
* Copyright (c) 2015 Mellanox Technologies, Inc.
@ -18,7 +18,7 @@
#include "server_callbacks.h"
#include "src/util/argv.h"
extern int spawn_wait;
extern bool spawn_wait;
pmix_server_module_t mymodule = {
.client_connected = connected,

14
opal/mca/pmix/pmix3x/pmix/test/simple/simptest.c
Просмотреть файл

@ -797,9 +797,23 @@ static pmix_status_t spawn_fn(const pmix_proc_t *proc,
pmix_spawn_cbfunc_t cbfunc, void *cbdata)
{
myxfer_t *x;
size_t n;
pmix_proc_t *pptr;
bool spawned;
pmix_output(0, "SERVER: SPAWN");
/* check the job info for parent and spawned keys */
for (n=0; n < ninfo; n++) {
if (0 == strncmp(job_info[n].key, PMIX_PARENT_ID, PMIX_MAX_KEYLEN)) {
pptr = job_info[n].value.data.proc;
pmix_output(0, "SPAWN: Parent ID %s:%d", pptr->nspace, pptr->rank);
} else if (0 == strncmp(job_info[n].key, PMIX_SPAWNED, PMIX_MAX_KEYLEN)) {
spawned = PMIX_INFO_TRUE(&job_info[n]);
pmix_output(0, "SPAWN: Spawned %s", spawned ? "TRUE" : "FALSE");
}
}
/* in practice, we would pass this request to the local
* resource manager for launch, and then have that server
* execute our callback function. For now, we will fake

23
opal/mca/pmix/pmix3x/pmix3x.c
Просмотреть файл

@ -516,9 +516,6 @@ pmix_status_t pmix3x_convert_opalrc(int rc)
case OPAL_ERR_MODEL_DECLARED:
return PMIX_MODEL_DECLARED;
case OPAL_PMIX_LAUNCH_DIRECTIVE:
return PMIX_LAUNCH_DIRECTIVE;
case OPAL_ERROR:
return PMIX_ERROR;
case OPAL_SUCCESS:
@ -612,9 +609,6 @@ int pmix3x_convert_rc(pmix_status_t rc)
case PMIX_MODEL_DECLARED:
return OPAL_ERR_MODEL_DECLARED;
case PMIX_LAUNCH_DIRECTIVE:
return OPAL_PMIX_LAUNCH_DIRECTIVE;
case PMIX_ERROR:
return OPAL_ERROR;
case PMIX_SUCCESS:
@ -896,7 +890,14 @@ void pmix3x_value_load(pmix_value_t *v,
memcpy(&v->data.state, &kv->data.uint8, sizeof(uint8_t));
break;
case OPAL_PTR:
/* if someone returned a pointer, it must be to a list of
/* if the opal_value_t is passing a true pointer, then
* respect that request and pass it along */
if (0 == strcmp(kv->key, OPAL_PMIX_EVENT_RETURN_OBJECT)) {
v->type = PMIX_POINTER;
v->data.ptr = kv->data.ptr;
break;
}
/* otherwise, it must be to a list of
* opal_value_t's that we need to convert to a pmix_data_array
* of pmix_info_t structures */
list = (opal_list_t*)kv->data.ptr;
@ -1604,12 +1605,8 @@ int pmix3x_convert_state(pmix_proc_state_t state)
return 55;
case PMIX_PROC_STATE_COMM_FAILED:
return 56;
case PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED:
return 57;
case PMIX_PROC_STATE_CALLED_ABORT:
return 58;
case PMIX_PROC_STATE_HEARTBEAT_FAILED:
return 59;
case PMIX_PROC_STATE_MIGRATING:
return 60;
case PMIX_PROC_STATE_CANNOT_RESTART:
@ -1650,13 +1647,9 @@ pmix_proc_state_t pmix3x_convert_opalstate(int state)
return PMIX_PROC_STATE_TERM_WO_SYNC;
case 56:
return PMIX_PROC_STATE_COMM_FAILED;
case 57:
return PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED;
case 58:
return PMIX_PROC_STATE_CALLED_ABORT;
case 59:
return PMIX_PROC_STATE_HEARTBEAT_FAILED;
case 60:
return PMIX_PROC_STATE_MIGRATING;
case 61:
return PMIX_PROC_STATE_CANNOT_RESTART;

5
opal/mca/pmix/pmix3x/pmix3x_client.c
Просмотреть файл

@ -98,6 +98,11 @@ int pmix3x_client_init(opal_list_t *ilist)
ninfo = 0;
}
/* check for direct modex use-case */
if (opal_pmix_base_async_modex && !opal_pmix_collect_all_data) {
opal_setenv("PMIX_MCA_gds", "hash", true, &environ);
}
OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
rc = PMIx_Init(&mca_pmix_pmix3x_component.myproc, pinfo, ninfo);
if (NULL != pinfo) {

5
opal/mca/pmix/pmix3x/pmix3x_server_south.c
Просмотреть файл

@ -129,6 +129,11 @@ int pmix3x_server_init(opal_pmix_server_module_t *module,
}
}
/* check for direct modex use-case */
if (opal_pmix_base_async_modex && !opal_pmix_collect_all_data) {
opal_setenv("PMIX_MCA_gds", "hash", true, &environ);
}
/* insert ourselves into our list of jobids - it will be the
* first, and so we'll check it first */
job = OBJ_NEW(opal_pmix3x_jobid_trkr_t);