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 # command, or with the date (if "git describe" fails) in the form of
# "date<date>". # "date<date>".
repo_rev=git36e7e24 repo_rev=gitf0b8151
# If tarball_version is not empty, it is used as the version string in # If tarball_version is not empty, it is used as the version string in
# the tarball filename, regardless of all other versions listed in # the tarball filename, regardless of all other versions listed in
@ -44,7 +44,7 @@ tarball_version=
# The date when this release was created # 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. # The shared library version of each of PMIx's public libraries.
# These versions are maintained in accordance with the "Library # 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 All rights reserved.
dnl Copyright (c) 2006-2016 Cisco Systems, Inc. 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) 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 Copyright (c) 2009 Los Alamos National Security, LLC. All rights
dnl reserved. dnl reserved.
dnl Copyright (c) 2009-2011 Oak Ridge National Labs. All rights 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) 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 Copyright (c) 2015-2017 Research Organization for Information Science
dnl and Technology (RIST). All rights reserved. dnl and Technology (RIST). All rights reserved.
dnl Copyright (c) 2016 Mellanox Technologies, Inc. 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], AC_DEFINE_UNQUOTED([PMIX_MINOR_VERSION], [$PMIX_MINOR_VERSION],
[The library minor version is always available, contrary to 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`" PMIX_RELEASE_VERSION="`$PMIX_top_srcdir/config/pmix_get_version.sh $PMIX_top_srcdir/VERSION --release`"
if test "$?" != "0"; then if test "$?" != "0"; then
AC_MSG_ERROR([Cannot continue]) AC_MSG_ERROR([Cannot continue])
@ -123,6 +117,14 @@ AC_DEFUN([PMIX_SETUP_CORE],[
AC_DEFINE_UNQUOTED([PMIX_RELEASE_VERSION], [$PMIX_RELEASE_VERSION], AC_DEFINE_UNQUOTED([PMIX_RELEASE_VERSION], [$PMIX_RELEASE_VERSION],
[The library release version is always available, contrary to 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`" PMIX_GREEK_VERSION="`$PMIX_top_srcdir/config/pmix_get_version.sh $PMIX_top_srcdir/VERSION --greek`"
if test "$?" != "0"; then if test "$?" != "0"; then
AC_MSG_ERROR([Cannot continue]) 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); 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 */ /* Out of the perf path - send our results to rank 0 using same PMI */
char key[128]; char key[128];
sprintf(key, "PMIX_PERF_get_total_time.%d", rank); 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 * Copyright (c) 2016 Research Organization for Information Science
* and Technology (RIST). All rights reserved. * and Technology (RIST). All rights reserved.
* *

120
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_GRPID "pmix.egid" // (uint32_t) effective group id
#define PMIX_DSTPATH "pmix.dstpath" // (char*) path to dstore files #define PMIX_DSTPATH "pmix.dstpath" // (char*) path to dstore files
#define PMIX_VERSION_INFO "pmix.version" // (char*) PMIx version of contactor #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_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_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_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_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_MODEL_NUM_THREADS "pmix.mdl.nthrds" // (uint64_t) number of active threads being used by the model
#define PMIX_REQUESTOR_IS_CLIENT "pmix.req.client" // (bool) requesting process is a client process #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 */ /* attributes for the USOCK rendezvous socket */
#define PMIX_USOCK_DISABLE "pmix.usock.disable" // (bool) disable legacy usock support #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_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_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_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 */ /* Resource Manager identification */
#define PMIX_RM_NAME "pmix.rm.name" // (char*) string name of the resource manager #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 */ /* environmental variable operation attributes */
#define PMIX_SET_ENVAR "pmix.envar.set" // (pmix_envar_t*) set the envar to the given value, #define PMIX_SET_ENVAR "pmix.envar.set" // (pmix_envar_t*) set the envar to the given value,
// overwriting any pre-existing one // 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_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 #define PMIX_PREPEND_ENVAR "pmix.envar.prepnd" // (pmix_envar_t*) prepend the given value to the
// specified envar using the separator // specified envar using the separator
@ -511,38 +520,32 @@ typedef uint32_t pmix_rank_t;
// generating the event // generating the event
/* security attributes */ /* 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 // comma-delimited list of desired credential types for use
// in environments where multiple authentication mechanisms // in environments where multiple authentication mechanisms
// may be available. When returned in a callback function, a // may be available. When returned in a callback function, a
// string identifier of the credential type // string identifier of the credential type
/* IO Forwarding Attributes */ /* IO Forwarding Attributes */
#define PMIX_IOF_CACHE_SIZE "pmix.iof.csize" // (uint32_t) requested size of the server cache in bytes for each specified channel. #define PMIX_IOF_CACHE_SIZE "pmix.iof.csize" // (uint32_t) requested size of the server cache in bytes for each specified channel.
// By default, the server is allowed (but not required) to drop // By default, the server is allowed (but not required) to drop
// all bytes received beyond the max size // all bytes received beyond the max size
#define PMIX_IOF_DROP_OLDEST "pmix.iof.old" // (bool) in an overflow situation, drop the oldest bytes to make room in the cache #define PMIX_IOF_DROP_OLDEST "pmix.iof.old" // (bool) in an overflow situation, drop the oldest bytes to make room in the cache
#define PMIX_IOF_DROP_NEWEST "pmix.iof.new" // (bool) in an overflow situation, drop any new bytes received until room becomes #define PMIX_IOF_DROP_NEWEST "pmix.iof.new" // (bool) in an overflow situation, drop any new bytes received until room becomes
// available in the cache (default) // available in the cache (default)
#define PMIX_IOF_BUFFERING_SIZE "pmix.iof.bsize" // (uint32_t) basically controls grouping of IO on the specified channel(s) to #define PMIX_IOF_BUFFERING_SIZE "pmix.iof.bsize" // (uint32_t) basically controls grouping of IO on the specified channel(s) to
// avoid being called every time a bit of IO arrives. The library // avoid being called every time a bit of IO arrives. The library
// will execute the callback whenever the specified number of bytes // will execute the callback whenever the specified number of bytes
// becomes available. Any remaining buffered data will be "flushed" // becomes available. Any remaining buffered data will be "flushed"
// upon call to deregister the respective channel // upon call to deregister the respective channel
#define PMIX_IOF_BUFFERING_TIME "pmix.iof.btime" // (uint32_t) max time in seconds to buffer IO before delivering it. Used in conjunction #define PMIX_IOF_BUFFERING_TIME "pmix.iof.btime" // (uint32_t) max time in seconds to buffer IO before delivering it. Used in conjunction
// with buffering size, this prevents IO from being held indefinitely // with buffering size, this prevents IO from being held indefinitely
// while waiting for another payload to arrive // while waiting for another payload to arrive
#define PMIX_IOF_COMPLETE "pmix.iof.cmp" // (bool) indicates whether or not the specified IO channel has been closed #define PMIX_IOF_COMPLETE "pmix.iof.cmp" // (bool) indicates whether or not the specified IO channel has been closed
// by the source // by the source
#define PMIX_IOF_PUSH_STDIN "pmix.iof.stdin" // (bool) Used by a tool to request that the PMIx library collect #define PMIX_IOF_PUSH_STDIN "pmix.iof.stdin" // (bool) Used by a tool to request that the PMIx library collect
// the tool's stdin and forward it to the procs specified in // the tool's stdin and forward it to the procs specified in
// the PMIx_IOF_push call // 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 ****/ /**** PROCESS STATE DEFINITIONS ****/
typedef uint8_t pmix_proc_state_t; typedef uint8_t pmix_proc_state_t;
@ -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_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_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_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 + 7) /* process called "PMIx_Abort" */
#define PMIX_PROC_STATE_CALLED_ABORT (PMIX_PROC_STATE_ERROR + 8) /* 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_HEARTBEAT_FAILED (PMIX_PROC_STATE_ERROR + 9) /* process failed to send heartbeat w/in time limit */ #define PMIX_PROC_STATE_CANNOT_RESTART (PMIX_PROC_STATE_ERROR + 9) /* process failed and cannot be restarted */
#define PMIX_PROC_STATE_MIGRATING (PMIX_PROC_STATE_ERROR + 10) /* process failed and is waiting for resources before restarting */ #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_CANNOT_RESTART (PMIX_PROC_STATE_ERROR + 11) /* process failed and cannot be restarted */ #define PMIX_PROC_STATE_FAILED_TO_LAUNCH (PMIX_PROC_STATE_ERROR + 11) /* unable to launch process */
#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 */
/**** PMIX ERROR CONSTANTS ****/ /**** PMIX ERROR CONSTANTS ****/
@ -682,7 +683,9 @@ typedef int pmix_status_t;
#define PMIX_GDS_ACTION_COMPLETE (PMIX_ERR_OP_BASE - 18) #define PMIX_GDS_ACTION_COMPLETE (PMIX_ERR_OP_BASE - 18)
#define PMIX_PROC_HAS_CONNECTED (PMIX_ERR_OP_BASE - 19) #define PMIX_PROC_HAS_CONNECTED (PMIX_ERR_OP_BASE - 19)
#define PMIX_CONNECT_REQUESTED (PMIX_ERR_OP_BASE - 20) #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 /* define a starting point for system error constants so
* we avoid renumbering when making additions */ * we avoid renumbering when making additions */
@ -1105,17 +1108,6 @@ typedef struct pmix_data_array {
size_t size; size_t size;
void *array; void *array;
} pmix_data_array_t; } 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 { typedef struct pmix_info_array {
size_t size; size_t size;
@ -1358,20 +1350,16 @@ struct pmix_info_t {
} \ } \
} while (0) } while (0)
#define PMIX_INFO_LOAD(m, k, v, t) \ #define PMIX_INFO_LOAD(m, k, v, t) \
do { \ do { \
if (NULL != (k)) { \ (void)strncpy((m)->key, (k), PMIX_MAX_KEYLEN); \
(void)strncpy((m)->key, (k), PMIX_MAX_KEYLEN); \ pmix_value_load(&((m)->value), (v), (t)); \
} \
pmix_value_load(&((m)->value), (v), (t)); \
} while (0) } while (0)
#define PMIX_INFO_XFER(d, s) \ #define PMIX_INFO_XFER(d, s) \
do { \ do { \
if (NULL != (s)->key) { \ (void)strncpy((d)->key, (s)->key, PMIX_MAX_KEYLEN); \
(void)strncpy((d)->key, (s)->key, PMIX_MAX_KEYLEN); \ (d)->flags = (s)->flags; \
} \ pmix_value_xfer(&(d)->value, &(s)->value); \
(d)->flags = (s)->flags; \
pmix_value_xfer(&(d)->value, &(s)->value); \
} while(0) } while(0)
#define PMIX_INFO_REQUIRED(m) \ #define PMIX_INFO_REQUIRED(m) \
@ -1392,9 +1380,7 @@ struct pmix_info_t {
(r) = PMIX_ERR_NOMEM; \ (r) = PMIX_ERR_NOMEM; \
break; \ break; \
} \ } \
if (NULL != _info[_n].key) { \ _kv->key = strdup(_info[_n].key); \
_kv->key = strdup(_info[_n].key); \
} \
PMIX_VALUE_XFER((r), _kv->value, &_info[_n].value);\ PMIX_VALUE_XFER((r), _kv->value, &_info[_n].value);\
if (PMIX_SUCCESS != (r)) { \ if (PMIX_SUCCESS != (r)) { \
PMIX_RELEASE(_kv); \ PMIX_RELEASE(_kv); \

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

@ -1,6 +1,7 @@
/* /*
* Copyright (c) 2016 Mellanox Technologies, Inc. * Copyright (c) 2016 Mellanox Technologies, Inc.
* All rights reserved. * All rights reserved.
* Copyright (c) 2018 IBM Corporation. All rights reserved.
* $COPYRIGHT$ * $COPYRIGHT$
* *
* Additional copyrights may follow * Additional copyrights may follow
@ -15,5 +16,5 @@
/* define PMIx version */ /* define PMIx version */
#define PMIX_VERSION_MAJOR @pmixmajor@ #define PMIX_VERSION_MAJOR @pmixmajor@
#define PMIX_VERSION_MINOR @pmixminor@ #define PMIX_VERSION_MINOR @pmixminor@
#define PMIX_VERSION_RELEASE @pmixrelease@
#endif #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-2016 Cisco Systems, Inc. All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, LLC. 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$ * $COPYRIGHT$
* *
* Additional copyrights may follow * 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-2016 Cisco Systems, Inc. All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, LLC. 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$ * $COPYRIGHT$
* *
* Additional copyrights may follow * 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; 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 */ /* need to thread-shift this request */
PMIX_EXPORT pmix_status_t PMIx_Resolve_peers(const char *nodename, PMIX_EXPORT pmix_status_t PMIx_Resolve_peers(const char *nodename,
const char *nspace, const char *nspace,
pmix_proc_t **procs, size_t *nprocs) 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); PMIX_ACQUIRE_THREAD(&pmix_global_lock);
if (pmix_globals.init_cntr <= 0) { if (pmix_globals.init_cntr <= 0) {
PMIX_RELEASE_THREAD(&pmix_global_lock); 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); PMIX_RELEASE_THREAD(&pmix_global_lock);
/* set default */
*procs = NULL;
*nprocs = 0;
cb = PMIX_NEW(pmix_cb_t); return pmix_preg.resolve_peers(nodename, nspace, procs, nprocs);
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);
} }
/* need to thread-shift this request */ /* need to thread-shift this request */
PMIX_EXPORT pmix_status_t PMIx_Resolve_nodes(const char *nspace, char **nodelist) 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); PMIX_ACQUIRE_THREAD(&pmix_global_lock);
if (pmix_globals.init_cntr <= 0) { if (pmix_globals.init_cntr <= 0) {
PMIX_RELEASE_THREAD(&pmix_global_lock); 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); PMIX_RELEASE_THREAD(&pmix_global_lock);
cb = PMIX_NEW(pmix_cb_t); /* set default */
cb->pname.nspace = strdup(nspace); *nodelist = NULL;
PMIX_THREADSHIFT(cb, _resolve_nodes); return pmix_preg.resolve_nodes(nspace, nodelist);
/* 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;
} }

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); PMIX_BFROPS_UNPACK(rc, peer, buf, &results->status, &cnt, PMIX_STATUS);
if (PMIX_SUCCESS != rc) { if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc); PMIX_ERROR_LOG(rc);
results->status = rc;
goto complete; goto complete;
} }
if (PMIX_SUCCESS != results->status) { 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); PMIX_BFROPS_UNPACK(rc, peer, buf, &results->ninfo, &cnt, PMIX_SIZE);
if (PMIX_SUCCESS != rc) { if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc); PMIX_ERROR_LOG(rc);
results->status = rc;
goto complete; goto complete;
} }
if (0 < results->ninfo) { 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); PMIX_BFROPS_UNPACK(rc, peer, buf, results->info, &cnt, PMIX_INFO);
if (PMIX_SUCCESS != rc) { if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc); PMIX_ERROR_LOG(rc);
results->status = rc;
goto complete; 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"; return "PROC TERMINATED WITHOUT CALLING PMIx_Finalize";
case PMIX_PROC_STATE_COMM_FAILED: case PMIX_PROC_STATE_COMM_FAILED:
return "PROC LOST COMMUNICATION"; return "PROC LOST COMMUNICATION";
case PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED:
return "PROC SENSOR BOUND EXCEEDED";
case PMIX_PROC_STATE_CALLED_ABORT: case PMIX_PROC_STATE_CALLED_ABORT:
return "PROC CALLED PMIx_Abort"; return "PROC CALLED PMIx_Abort";
case PMIX_PROC_STATE_HEARTBEAT_FAILED:
return "PROC FAILED TO REPORT HEARTBEAT";
case PMIX_PROC_STATE_MIGRATING: case PMIX_PROC_STATE_MIGRATING:
return "PROC WAITING TO MIGRATE"; return "PROC WAITING TO MIGRATE";
case PMIX_PROC_STATE_CANNOT_RESTART: 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_dirs, pmix_list_t);
PMIX_CONSTRUCT(&p->epilog.cleanup_files, pmix_list_t); PMIX_CONSTRUCT(&p->epilog.cleanup_files, pmix_list_t);
PMIX_CONSTRUCT(&p->epilog.ignores, 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) 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_dirs);
PMIX_LIST_DESTRUCT(&p->epilog.cleanup_files); PMIX_LIST_DESTRUCT(&p->epilog.cleanup_files);
PMIX_LIST_DESTRUCT(&p->epilog.ignores); PMIX_LIST_DESTRUCT(&p->epilog.ignores);
PMIX_LIST_DESTRUCT(&p->setup_data);
} }
PMIX_EXPORT PMIX_CLASS_INSTANCE(pmix_nspace_t, PMIX_EXPORT PMIX_CLASS_INSTANCE(pmix_nspace_t,
pmix_list_item_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_personality_t compat;
pmix_epilog_t epilog; // things to do upon termination of all local clients pmix_epilog_t epilog; // things to do upon termination of all local clients
// from this nspace // 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_nspace_t;
PMIX_CLASS_DECLARATION(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. * University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California. * Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved. * 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. * Copyright (c) 2015 Mellanox Technologies, Inc.
* All rights reserved. * All rights reserved.
* $COPYRIGHT$ * $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. * Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved. * All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, Inc. 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 * Copyright (c) 2015 Research Organization for Information Science
* and Technology (RIST). All rights reserved. * and Technology (RIST). All rights reserved.
* $COPYRIGHT$ * $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. * University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California. * Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved. * 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 * Copyright (c) 2015 Research Organization for Information Science
* and Technology (RIST). All rights reserved. * and Technology (RIST). All rights reserved.
* $COPYRIGHT$ * $COPYRIGHT$
@ -367,23 +367,18 @@ pmix_status_t pmix_bfrops_base_copy_pinfo(pmix_proc_info_t **dest,
pmix_proc_info_t *src, pmix_proc_info_t *src,
pmix_data_type_t type) pmix_data_type_t type)
{ {
pmix_proc_info_t *p; *dest = (pmix_proc_info_t*)malloc(sizeof(pmix_proc_info_t));
(void)strncpy((*dest)->proc.nspace, src->proc.nspace, PMIX_MAX_NSLEN);
PMIX_PROC_INFO_CREATE(p, 1); (*dest)->proc.rank = src->proc.rank;
if (NULL == p) {
return PMIX_ERR_NOMEM;
}
memcpy(&p->proc, &src->proc, sizeof(pmix_proc_t));
if (NULL != src->hostname) { if (NULL != src->hostname) {
p->hostname = strdup(src->hostname); (*dest)->hostname = strdup(src->hostname);
} }
if (NULL != src->executable_name) { 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)); (*dest)->pid = src->pid;
memcpy(&p->exit_code, &src->exit_code, sizeof(int)); (*dest)->exit_code = src->exit_code;
memcpy(&p->state, &src->state, sizeof(pmix_proc_state_t)); (*dest)->state = src->state;
*dest = p;
return PMIX_SUCCESS; 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; p1 = (pmix_info_t*)p->array;
s1 = (pmix_info_t*)src->array; s1 = (pmix_info_t*)src->array;
for (n=0; n < src->size; n++) { 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; break;
case PMIX_PDATA: 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; pd = (pmix_pdata_t*)p->array;
sd = (pmix_pdata_t*)src->array; sd = (pmix_pdata_t*)src->array;
for (n=0; n < src->size; n++) { 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; break;
case PMIX_BUFFER: case PMIX_BUFFER:
@ -906,7 +901,7 @@ pmix_status_t pmix_bfrops_base_copy_envar(pmix_envar_t **dest,
pmix_envar_t *src, pmix_envar_t *src,
pmix_data_type_t type) pmix_data_type_t type)
{ {
PMIX_ENVAR_CREATE(*dest, 1); *dest = (pmix_envar_t*)malloc(sizeof(pmix_envar_t));
if (NULL == (*dest)) { if (NULL == (*dest)) {
return PMIX_ERR_NOMEM; 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. * University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California. * Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved. * All rights reserved.
* Copyright (c) 2015-2017 Intel, Inc. All rights reserved. * Copyright (c) 2015-2018 Intel, Inc. All rights reserved.
* $COPYRIGHT$ * $COPYRIGHT$
* *
* Additional copyrights may follow * 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_byte_object_t *bo;
pmix_proc_info_t *pi; pmix_proc_info_t *pi;
pmix_envar_t *envar; pmix_envar_t *envar;
pmix_data_array_t *darray;
pmix_status_t rc;
v->type = type; v->type = type;
if (NULL == data) { 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; v->data.envar.separator = envar->separator;
break; 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: default:
/* silence warnings */ /* silence warnings */
break; break;
@ -209,7 +199,6 @@ pmix_status_t pmix_bfrops_base_value_unload(pmix_value_t *kv,
{ {
pmix_status_t rc; pmix_status_t rc;
pmix_envar_t *envar; pmix_envar_t *envar;
pmix_data_array_t **darray;
rc = PMIX_SUCCESS; rc = PMIX_SUCCESS;
if (NULL == data || 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*)); memcpy(*data, &(kv->data.ptr), sizeof(void*));
*sz = sizeof(void*); *sz = sizeof(void*);
break; 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: case PMIX_ENVAR:
PMIX_ENVAR_CREATE(envar, 1); PMIX_ENVAR_CREATE(envar, 1);
if (NULL == envar) { 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)); memcpy(&p->data.state, &src->data.state, sizeof(pmix_proc_state_t));
break; break;
case PMIX_PROC_INFO: 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: 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: case PMIX_POINTER:
memcpy(&p->data.ptr, &src->data.ptr, sizeof(void*)); memcpy(&p->data.ptr, &src->data.ptr, sizeof(void*));
break; 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 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. * Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved. * All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, Inc. 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. * Copyright (c) 2016 Mellanox Technologies, Inc.
* All rights reserved. * 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. * Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved. * All rights reserved.
* Copyright (c) 2012 Los Alamos National Security, Inc. 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 * Copyright (c) 2015 Research Organization for Information Science
* and Technology (RIST). All rights reserved. * and Technology (RIST). All rights reserved.
* Copyright (c) 2016 Mellanox Technologies, Inc. * 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 */ if (PMIX_INT32 != local_type) { /* if the length wasn't first, then error */
*num_vals = 0; *num_vals = 0;
PMIX_ERROR_LOG(PMIX_ERR_UNPACK_FAILURE);
return 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; return ret;
} }
break; break;
case PMIX_ALLOC_DIRECTIVE: case PMIX_QUERY:
if (PMIX_SUCCESS != (ret = pmix_bfrops_base_unpack_alloc_directive(buffer, &val->data.adir, &m, PMIX_ALLOC_DIRECTIVE))) { if (PMIX_SUCCESS != (ret = pmix_bfrops_base_unpack_query(buffer, val->data.darray, &m, PMIX_QUERY))) {
return ret; return ret;
} }
break; break;
case PMIX_ENVAR: 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; return ret;
} }
break; 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. # Copyright (c) 2004-2005 The Regents of the University of California.
# All rights reserved. # All rights reserved.
# Copyright (c) 2012 Los Alamos National Security, Inc. 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) 2013-2017 Intel, Inc. All rights reserved.
# Copyright (c) 2017 Research Organization for Information Science
# and Technology (RIST). All rights reserved.
# $COPYRIGHT$ # $COPYRIGHT$
# #
# Additional copyrights may follow # Additional copyrights may follow
@ -21,22 +19,22 @@
# $HEADER$ # $HEADER$
# #
headers = pnet_test.h headers = bfrop_pmix3.h
sources = \ sources = \
pnet_test_component.c \ bfrop_pmix3_component.c \
pnet_test.c bfrop_pmix3.c
# Make the output library in this directory, and name it either # Make the output library in this directory, and name it either
# mca_<type>_<name>.la (for DSO builds) or libmca_<type>_<name>.la # mca_<type>_<name>.la (for DSO builds) or libmca_<type>_<name>.la
# (for static builds). # (for static builds).
if MCA_BUILD_pmix_pnet_test_DSO if MCA_BUILD_pmix_bfrops_v3_DSO
lib = lib =
lib_sources = lib_sources =
component = mca_pnet_test.la component = mca_bfrops_v3.la
component_sources = $(headers) $(sources) component_sources = $(headers) $(sources)
else else
lib = libmca_pnet_test.la lib = libmca_bfrops_v3.la
lib_sources = $(headers) $(sources) lib_sources = $(headers) $(sources)
component = component =
component_sources = component_sources =
@ -44,9 +42,9 @@ endif
mcacomponentdir = $(pmixlibdir) mcacomponentdir = $(pmixlibdir)
mcacomponent_LTLIBRARIES = $(component) mcacomponent_LTLIBRARIES = $(component)
mca_pnet_test_la_SOURCES = $(component_sources) mca_bfrops_v3_la_SOURCES = $(component_sources)
mca_pnet_test_la_LDFLAGS = -module -avoid-version mca_bfrops_v3_la_LDFLAGS = -module -avoid-version
noinst_LTLIBRARIES = $(lib) noinst_LTLIBRARIES = $(lib)
libmca_pnet_test_la_SOURCES = $(lib_sources) libmca_bfrops_v3_la_SOURCES = $(lib_sources)
libmca_pnet_test_la_LDFLAGS = -module -avoid-version 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 /* store the comma-delimited list of nodes hosting
* procs in this nspace in case someone using PMIx v2 * procs in this nspace */
* requests it */
kp2 = PMIX_NEW(pmix_kval_t); kp2 = PMIX_NEW(pmix_kval_t);
kp2->key = strdup(PMIX_NODE_LIST); kp2->key = strdup(PMIX_NODE_LIST);
kp2->value = (pmix_value_t*)malloc(sizeof(pmix_value_t)); 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; ht = &trk->internal;
for (n=0; n < ninfo; n++) { for (n=0; n < ninfo; n++) {
if (0 == strcmp(info[n].key, PMIX_NODE_MAP)) { 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 */ /* 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))) { if (PMIX_SUCCESS != (rc = pmix_preg.parse_nodes(info[n].value.data.string, &nodes))) {
PMIX_ERROR_LOG(rc); 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 extern pmix_pnet_globals_t pmix_pnet_globals;
PMIX_EXPORT pmix_status_t pmix_pnet_base_setup_app(char *nspace, PMIX_EXPORT pmix_status_t pmix_pnet_base_setup_app(char *nspace, pmix_list_t *ilist);
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist);
PMIX_EXPORT pmix_status_t pmix_pnet_base_setup_local_network(char *nspace, PMIX_EXPORT pmix_status_t pmix_pnet_base_setup_local_network(char *nspace,
pmix_info_t info[], pmix_info_t info[],
size_t ninfo); 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/class/pmix_list.h"
#include "src/util/error.h" #include "src/util/error.h"
#include "src/server/pmix_server_ops.h"
#include "src/mca/pnet/base/base.h" #include "src/mca/pnet/base/base.h"
/* NOTE: a tool (e.g., prun) may call this function to pmix_status_t pmix_pnet_base_setup_app(char *nspace, pmix_list_t *ilist)
* 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_pnet_base_active_module_t *active; pmix_pnet_base_active_module_t *active;
pmix_status_t rc; pmix_status_t rc;
pmix_nspace_t *nptr, *ns;
if (!pmix_pnet_globals.initialized) { if (!pmix_pnet_globals.initialized) {
return PMIX_ERR_INIT; return PMIX_ERR_INIT;
} }
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet: setup_app called");
/* protect against bozo inputs */ /* protect against bozo inputs */
if (NULL == nspace || NULL == ilist) { if (NULL == nspace || NULL == ilist) {
return PMIX_ERR_BAD_PARAM; 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) { PMIX_LIST_FOREACH(active, &pmix_pnet_globals.actives, pmix_pnet_base_active_module_t) {
if (NULL != active->module->setup_app) { 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; return rc;
} }
} }
@ -78,48 +47,25 @@ pmix_status_t pmix_pnet_base_setup_app(char *nspace,
return PMIX_SUCCESS; return PMIX_SUCCESS;
} }
/* can only be called by a server */
pmix_status_t pmix_pnet_base_setup_local_network(char *nspace, pmix_status_t pmix_pnet_base_setup_local_network(char *nspace,
pmix_info_t info[], pmix_info_t info[],
size_t ninfo) size_t ninfo)
{ {
pmix_pnet_base_active_module_t *active; pmix_pnet_base_active_module_t *active;
pmix_status_t rc; pmix_status_t rc;
pmix_nspace_t *nptr, *ns;
if (!pmix_pnet_globals.initialized) { if (!pmix_pnet_globals.initialized) {
return PMIX_ERR_INIT; return PMIX_ERR_INIT;
} }
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet: setup_local_network called");
/* protect against bozo inputs */ /* protect against bozo inputs */
if (NULL == nspace) { if (NULL == nspace) {
return PMIX_ERR_BAD_PARAM; 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) { PMIX_LIST_FOREACH(active, &pmix_pnet_globals.actives, pmix_pnet_base_active_module_t) {
if (NULL != active->module->setup_local_network) { 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; return rc;
} }
} }
@ -128,43 +74,23 @@ pmix_status_t pmix_pnet_base_setup_local_network(char *nspace,
return PMIX_SUCCESS; return PMIX_SUCCESS;
} }
/* can only be called by a server */ pmix_status_t pmix_pnet_base_setup_fork(const pmix_proc_t *peer, char ***env)
pmix_status_t pmix_pnet_base_setup_fork(const pmix_proc_t *proc, char ***env)
{ {
pmix_pnet_base_active_module_t *active; pmix_pnet_base_active_module_t *active;
pmix_status_t rc; pmix_status_t rc;
pmix_nspace_t *nptr, *ns;
if (!pmix_pnet_globals.initialized) { if (!pmix_pnet_globals.initialized) {
return PMIX_ERR_INIT; return PMIX_ERR_INIT;
} }
/* protect against bozo inputs */ /* protect against bozo inputs */
if (NULL == proc || NULL == env) { if (NULL == peer || NULL == env) {
return PMIX_ERR_BAD_PARAM; 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) { PMIX_LIST_FOREACH(active, &pmix_pnet_globals.actives, pmix_pnet_base_active_module_t) {
if (NULL != active->module->setup_fork) { 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; return rc;
} }
} }

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

@ -45,7 +45,7 @@
/* Instantiate the global vars */ /* Instantiate the global vars */
pmix_pnet_globals_t pmix_pnet_globals = {{{0}}}; 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_app = pmix_pnet_base_setup_app,
.setup_local_network = pmix_pnet_base_setup_local_network, .setup_local_network = pmix_pnet_base_setup_local_network,
.setup_fork = pmix_pnet_base_setup_fork, .setup_fork = pmix_pnet_base_setup_fork,

219
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 (c) 2016 IBM Corporation. All rights reserved.
* *
* $COPYRIGHT$ * $COPYRIGHT$
@ -37,21 +37,17 @@
#include "src/util/error.h" #include "src/util/error.h"
#include "src/util/output.h" #include "src/util/output.h"
#include "src/util/pmix_environ.h" #include "src/util/pmix_environ.h"
#include "src/mca/preg/preg.h"
#include "src/mca/pnet/pnet.h" #include "src/mca/pnet/pnet.h"
#include "src/mca/pnet/base/base.h"
#include "pnet_opa.h" #include "pnet_opa.h"
static pmix_status_t opa_init(void); static pmix_status_t opa_init(void);
static void opa_finalize(void); static void opa_finalize(void);
static pmix_status_t setup_app(pmix_nspace_t *nptr, static pmix_status_t setup_app(char *nspace, pmix_list_t *ilist);
pmix_info_t info[], size_t ninfo, static pmix_status_t setup_local_network(char *nspace,
pmix_list_t *ilist);
static pmix_status_t setup_local_network(pmix_nspace_t *nptr,
pmix_info_t info[], pmix_info_t info[],
size_t ninfo); 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 child_finalized(pmix_peer_t *peer);
static void local_app_finalized(char *nspace); 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) 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"); "pnet: opa init");
return PMIX_SUCCESS; return PMIX_SUCCESS;
} }
static void opa_finalize(void) 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"); "pnet: opa finalize");
} }
@ -161,190 +157,75 @@ static char* transports_print(uint64_t *unique_key)
return string_key; return string_key;
} }
/* NOTE: if there is any binary data to be transferred, then static pmix_status_t setup_app(char *nspace, pmix_list_t *ilist)
* 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]; uint64_t unique_key[2];
char *string_key, *cs_env; char *string_key, *cs_env;
int fd_rand; int fd_rand;
size_t n, bytes_read, len; size_t bytes_read;
pmix_kval_t *kv, *next; pmix_kval_t *kv;
int i, j;
bool envars, seckeys;
if (NULL == info) { /* put the number here - or else create an appropriate string. this just needs to
envars = true; * eventually be a string variable
seckeys = true; */
if(-1 == (fd_rand = open("/dev/urandom", O_RDONLY))) {
transports_use_rand(unique_key);
} else { } else {
envars = false; bytes_read = read(fd_rand, (char *) unique_key, 16);
seckeys = false; if(bytes_read != 16) {
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
*/
if(-1 == (fd_rand = open("/dev/urandom", O_RDONLY))) {
transports_use_rand(unique_key); transports_use_rand(unique_key);
} else {
bytes_read = read(fd_rand, (char *) unique_key, 16);
if(bytes_read != 16) {
transports_use_rand(unique_key);
}
close(fd_rand);
} }
close(fd_rand);
}
if (NULL == (string_key = transports_print(unique_key))) { if (NULL == (string_key = transports_print(unique_key))) {
PMIX_ERROR_LOG(PMIX_ERR_OUT_OF_RESOURCE); PMIX_ERROR_LOG(PMIX_ERR_OUT_OF_RESOURCE);
return PMIX_ERR_OUT_OF_RESOURCE; 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); PMIX_ERROR_LOG(PMIX_ERR_OUT_OF_RESOURCE);
free(string_key);
return PMIX_ERR_OUT_OF_RESOURCE;
}
kv = PMIX_NEW(pmix_kval_t);
if (NULL == kv) {
free(string_key);
free(cs_env);
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) {
free(string_key);
free(cs_env);
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, ':');
pmix_list_append(ilist, &kv->super);
free(cs_env);
free(string_key); free(string_key);
return PMIX_ERR_OUT_OF_RESOURCE;
} }
if (envars) { kv = PMIX_NEW(pmix_kval_t);
/* harvest envars to pass along */ if (NULL == kv) {
if (NULL != mca_pnet_opa_component.include) { free(string_key);
for (j=0; NULL != mca_pnet_opa_component.include[j]; j++) { free(cs_env);
len = strlen(mca_pnet_opa_component.include[j]); return PMIX_ERR_OUT_OF_RESOURCE;
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);
}
}
}
}
} }
kv->key = strdup(PMIX_SET_ENVAR);
kv->value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
if (NULL == kv->value) {
free(string_key);
free(cs_env);
PMIX_RELEASE(kv);
return PMIX_ERR_OUT_OF_RESOURCE;
}
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);
return PMIX_SUCCESS; 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[], pmix_info_t info[],
size_t ninfo) 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; 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; 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$ * $COPYRIGHT$
* *
@ -18,19 +18,10 @@
BEGIN_C_DECLS 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 */ /* 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; 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 END_C_DECLS
#endif #endif

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

@ -12,7 +12,7 @@
* All rights reserved. * All rights reserved.
* Copyright (c) 2015 Los Alamos National Security, LLC. All rights * Copyright (c) 2015 Los Alamos National Security, LLC. All rights
* reserved. * reserved.
* Copyright (c) 2016-2018 Intel, Inc. All rights reserved. * Copyright (c) 2016 Intel, Inc. All rights reserved.
* $COPYRIGHT$ * $COPYRIGHT$
* *
* Additional copyrights may follow * Additional copyrights may follow
@ -29,85 +29,48 @@
#include <src/include/pmix_config.h> #include <src/include/pmix_config.h>
#include "pmix_common.h" #include "pmix_common.h"
#include "src/util/argv.h"
#include "src/mca/pnet/pnet.h" #include "src/mca/pnet/pnet.h"
#include "pnet_opa.h" #include "pnet_opa.h"
static pmix_status_t component_open(void); static pmix_status_t component_open(void);
static pmix_status_t component_close(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_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 * Instantiate the public struct with all of our public information
* and pointers to our public functions in it * and pointers to our public functions in it
*/ */
pmix_pnet_opa_component_t mca_pnet_opa_component = { pmix_pnet_base_component_t mca_pnet_opa_component = {
.super = { .base = {
.base = { PMIX_PNET_BASE_VERSION_1_0_0,
PMIX_PNET_BASE_VERSION_1_0_0,
/* Component name and version */ /* Component name and version */
.pmix_mca_component_name = "opa", .pmix_mca_component_name = "opa",
PMIX_MCA_BASE_MAKE_VERSION(component, PMIX_MCA_BASE_MAKE_VERSION(component,
PMIX_MAJOR_VERSION, PMIX_MAJOR_VERSION,
PMIX_MINOR_VERSION, PMIX_MINOR_VERSION,
PMIX_RELEASE_VERSION), PMIX_RELEASE_VERSION),
/* Component open and close functions */ /* Component open and close functions */
.pmix_mca_open_component = component_open, .pmix_mca_open_component = component_open,
.pmix_mca_close_component = component_close, .pmix_mca_close_component = component_close,
.pmix_mca_register_component_params = component_register, .pmix_mca_query_component = component_query,
.pmix_mca_query_component = component_query,
},
.data = {
/* The component is checkpoint ready */
PMIX_MCA_BASE_METADATA_PARAM_CHECKPOINT
}
}, },
.include = NULL, .data = {
.exclude = NULL /* The component is checkpoint ready */
PMIX_MCA_BASE_METADATA_PARAM_CHECKPOINT
}
}; };
static char *includeparam;
static char *excludeparam;
static pmix_status_t component_register(void) static int component_open(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)
{ {
return PMIX_SUCCESS; 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; *priority = 10;
*module = (pmix_mca_base_module_t *)&pmix_opa_module; *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; 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 * tokens required for application processes to communicate with
* each other * each other
*/ */
typedef pmix_status_t (*pmix_pnet_base_module_setup_app_fn_t)(pmix_nspace_t *nptr, typedef pmix_status_t (*pmix_pnet_base_module_setup_app_fn_t)(char *nspace, pmix_list_t *ilist);
pmix_info_t info[], size_t ninfo,
pmix_list_t *ilist);
/** /**
* Give the local network library an opportunity to setup address information * Give the local network library an opportunity to setup address information
* for the application by passing in the layout type and a regex describing * for the application by passing in the layout type and a regex describing
* the layout */ * 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[], pmix_info_t info[],
size_t ninfo); 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 * Give the local network library an opportunity to add any envars to the
* environment of a local application process prior to fork/exec * 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 * 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_base_module_local_app_finalized_fn_t local_app_finalized;
} pmix_pnet_module_t; } 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 */ /* 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 * 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;
}

250
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) 2016 IBM Corporation. All rights reserved.
* Copyright (c) 2018 Research Organization for Information Science * Copyright (c) 2018 Research Organization for Information Science
* and Technology (RIST). All rights reserved. * and Technology (RIST). All rights reserved.
@ -501,32 +501,27 @@ static pmix_status_t parse_procs(const char *regexp,
return rc; return rc;
} }
static pmix_status_t resolve_peers(const char *nodename, static void _resolve_peers(int sd, short args, void *cbdata)
const char *nspace,
pmix_proc_t **procs, size_t *nprocs)
{ {
pmix_cb_t cb; pmix_cb_t *cb = (pmix_cb_t*)cbdata;
pmix_status_t rc; pmix_status_t rc;
pmix_kval_t *kv; pmix_kval_t *kv;
pmix_proc_t proc; pmix_proc_t proc;
char **ptr; char **ptr;
pmix_info_t *info; pmix_info_t *info;
pmix_proc_t *p=NULL; pmix_proc_t *procs;
size_t ninfo, np=0, n, j; 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 */ /* 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 */ /* 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 */ /* 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; 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_SUCCESS != rc) {
if (PMIX_ERR_INVALID_NAMESPACE != rc) { if (PMIX_ERR_INVALID_NAMESPACE != rc) {
PMIX_ERROR_LOG(rc); PMIX_ERROR_LOG(rc);
@ -534,12 +529,12 @@ static pmix_status_t resolve_peers(const char *nodename,
goto complete; goto complete;
} }
/* should just be the one value on the list */ /* 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); PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
rc = PMIX_ERR_BAD_PARAM; rc = PMIX_ERR_BAD_PARAM;
goto complete; 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 /* the hostname used as a key with wildcard rank will return
* a pmix_data_array_t of pmix_info_t structs */ * a pmix_data_array_t of pmix_info_t structs */
if (NULL == kv->value || if (NULL == kv->value ||
@ -557,103 +552,184 @@ static pmix_status_t resolve_peers(const char *nodename,
if (0 == strncmp(info[n].key, PMIX_LOCAL_PEERS, PMIX_MAX_KEYLEN)) { if (0 == strncmp(info[n].key, PMIX_LOCAL_PEERS, PMIX_MAX_KEYLEN)) {
/* split the string */ /* split the string */
ptr = pmix_argv_split(info[n].value.data.string, ','); ptr = pmix_argv_split(info[n].value.data.string, ',');
np = pmix_argv_count(ptr); nprocs = pmix_argv_count(ptr);
PMIX_PROC_CREATE(p, np); PMIX_PROC_CREATE(procs, nprocs);
if (NULL == p) { if (NULL == procs) {
rc = PMIX_ERR_NOMEM; rc = PMIX_ERR_NOMEM;
pmix_argv_free(ptr); pmix_argv_free(ptr);
goto complete; goto complete;
} }
for (j=0; j < np; j++) { for (j=0; j < nprocs; j++) {
(void)strncpy(p[j].nspace, nspace, PMIX_MAX_NSLEN); (void)strncpy(procs[j].nspace, cb->pname.nspace, PMIX_MAX_NSLEN);
p[j].rank = strtoul(ptr[j], NULL, 10); procs[j].rank = strtoul(ptr[j], NULL, 10);
} }
cb->procs = procs;
cb->nprocs = nprocs;
rc = PMIX_SUCCESS; rc = PMIX_SUCCESS;
pmix_argv_free(ptr); pmix_argv_free(ptr);
break; goto complete;
} }
} }
complete: complete:
if (NULL != cb.info) { cb->status = rc;
PMIX_INFO_FREE(cb.info, cb.ninfo); if (NULL != cb->info) {
PMIX_INFO_FREE(cb->info, cb->ninfo);
} }
if (NULL != cb.key) { cb->pstatus = rc;
free(cb.key); /* post the data so the receiving thread can acquire it */
cb.key = NULL; PMIX_POST_OBJECT(cb);
} PMIX_WAKEUP_THREAD(&cb->lock);
PMIX_DESTRUCT(&cb); return;
*procs = p; }
*nprocs = np;
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; return rc;
} }
static void _resolve_nodes(int sd, short args, void *cbdata)
{
pmix_cb_t *cb = (pmix_cb_t*)cbdata;
pmix_status_t rc;
pmix_kval_t *kv;
pmix_proc_t proc;
/* 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) {
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, cb->pname.nspace, PMIX_STRING);
/* tell the GDS what we want */
cb->key = PMIX_NODE_LIST;
/* this data isn't going anywhere, so we don't require a copy */
cb->copy = false;
/* scope is irrelevant as the info we seek must be local */
cb->scope = PMIX_SCOPE_UNDEF;
/* put the nspace in the proc field */
(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;
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)) {
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_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);
rc = PMIX_ERR_DATA_VALUE_NOT_FOUND;
goto complete;
}
/* return the string */
if (NULL != kv->value->data.string) {
cb->key = strdup(kv->value->data.string);
}
complete:
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, static pmix_status_t resolve_nodes(const char *nspace,
char **nodelist) char **nodelist)
{ {
pmix_cb_t cb; pmix_cb_t *cb;
pmix_status_t rc; pmix_status_t rc;
pmix_kval_t *kv;
pmix_proc_t proc; pmix_proc_t proc;
PMIX_CONSTRUCT(&cb, pmix_cb_t); cb = PMIX_NEW(pmix_cb_t);
cb->pname.nspace = (char*)nspace;
/* setup default answer */ PMIX_THREADSHIFT(cb, _resolve_nodes);
*nodelist = NULL;
/* create a pmix_info_t so we can pass the nspace /* wait for the result */
* into the fetch as a qualifier */ PMIX_WAIT_THREAD(&cb->lock);
PMIX_INFO_CREATE(cb.info, 1);
if (NULL == cb.info) {
PMIX_DESTRUCT(&cb);
return PMIX_ERR_NOMEM;
}
cb.ninfo = 1;
PMIX_INFO_LOAD(&cb.info[0], PMIX_NSPACE, nspace, PMIX_STRING);
/* tell the GDS what we want */ /* if the nspace wasn't found, then we need to
cb.key = PMIX_NODE_MAP; * ask the server for that info */
/* this data isn't going anywhere, so we don't require a copy */ if (PMIX_ERR_INVALID_NAMESPACE == cb->status) {
cb.copy = false; (void)strncpy(proc.nspace, nspace, PMIX_MAX_NSLEN);
/* scope is irrelevant as the info we seek must be local */ proc.rank = PMIX_RANK_WILDCARD;
cb.scope = PMIX_SCOPE_UNDEF; /* any key will suffice as it will bring down
/* put the nspace in the proc field */ * the entire data blob */
(void)strncpy(proc.nspace, nspace, PMIX_MAX_NSLEN); rc = PMIx_Get(&proc, PMIX_UNIV_SIZE, NULL, 0, NULL);
/* the info will be associated with PMIX_RANK_WILDCARD */ if (PMIX_SUCCESS != rc) {
proc.rank = PMIX_RANK_WILDCARD; PMIX_RELEASE(cb);
cb.proc = &proc; 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;
PMIX_GDS_FETCH_KV(rc, pmix_client_globals.myserver, &cb); rc = cb->status;
if (PMIX_SUCCESS != rc) { PMIX_RELEASE(cb);
PMIX_ERROR_LOG(rc);
goto complete;
}
/* should just be the one value on the list */
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 */
if (NULL == kv->value ||
PMIX_STRING != kv->value->type) {
PMIX_ERROR_LOG(PMIX_ERR_DATA_VALUE_NOT_FOUND);
rc = PMIX_ERR_DATA_VALUE_NOT_FOUND;
goto complete;
}
/* return the string */
if (NULL != kv->value->data.string) {
*nodelist = strdup(kv->value->data.string);
}
complete:
if (NULL != cb.info) {
PMIX_INFO_FREE(cb.info, cb.ninfo);
}
return rc; return rc;
} }
static pmix_status_t pmix_regex_extract_nodes(char *regexp, char ***names) 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) static void _setup_app(int sd, short args, void *cbdata)
{ {
pmix_setup_caddy_t *cd = (pmix_setup_caddy_t*)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_setup_caddy_t *fcd = NULL;
pmix_status_t rc; pmix_status_t rc;
pmix_list_t ilist; pmix_list_t ilist;
pmix_kval_t *kv; pmix_kval_t *kv;
size_t n;
PMIX_ACQUIRE_OBJECT(cd); PMIX_ACQUIRE_OBJECT(cd);
PMIX_CONSTRUCT(&ilist, pmix_list_t); PMIX_CONSTRUCT(&ilist, pmix_list_t);
/* pass to the network libraries */ /* pass to the network libraries */
if (PMIX_SUCCESS != (rc = pmix_pnet.setup_app(cd->nspace, if (PMIX_SUCCESS != (rc = pmix_pnet.setup_app(cd->nspace, &ilist))) {
cd->info, cd->ninfo,
&ilist))) {
goto depart; goto depart;
} }
@ -1356,20 +1355,31 @@ static void _setup_app(int sd, short args, void *cbdata)
goto depart; goto depart;
} }
/* if anything came back, construct an info array */ /* if anything came back, construct the blob */
if (0 < (fcd->ninfo = pmix_list_get_size(&ilist))) { if (0 < pmix_list_get_size(&ilist)) {
PMIX_INFO_CREATE(fcd->info, fcd->ninfo); 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;
}
}
PMIX_INFO_CREATE(fcd->info, 1);
if (NULL == fcd->info) { if (NULL == fcd->info) {
rc = PMIX_ERR_NOMEM; PMIX_DESTRUCT(&blob);
PMIX_RELEASE(fcd); PMIX_RELEASE(fcd);
fcd = NULL;
goto depart; goto depart;
} }
n = 0; fcd->ninfo = 1;
PMIX_LIST_FOREACH(kv, &ilist, pmix_kval_t) { PMIX_BYTE_OBJECT_CONSTRUCT(&blob);
(void)strncpy(fcd->info[n].key, kv->key, PMIX_MAX_KEYLEN); PMIX_BYTE_OBJECT_LOAD(&blob, buffer.base_ptr, buffer.bytes_used);
pmix_value_xfer(&fcd->info[n].value, kv->value); PMIX_DESTRUCT(&buffer);
++n; PMIX_INFO_LOAD(&fcd->info[0], PMIX_PNET_SETUP_APP, &blob, PMIX_BYTE_OBJECT);
} PMIX_BYTE_OBJECT_DESTRUCT(&blob);
} }
depart: 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); PMIX_SERVER_QUEUE_REPLY(cd->cd->peer, cd->cd->hdr.tag, reply);
/* cleanup */ /* cleanup */
PMIX_RELEASE(cd->cd); PMIX_RELEASE(cd->cd);
PMIX_WAKEUP_THREAD(&cd->lock); PMIX_RELEASE(cd);
} }
static void spawn_cbfunc(pmix_status_t status, char *nspace, void *cbdata) 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;; cd->cd = (pmix_server_caddy_t*)cbdata;;
PMIX_THREADSHIFT(cd, _spcb); 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, 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->peer = peer;
cd->spcbfunc = cbfunc; cd->spcbfunc = cbfunc;
cd->cbdata = cbdata; 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 */ /* unpack the number of job-level directives */
cnt=1; 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 /* always add one directive that indicates whether the requestor
* is a tool or client */ * is a tool or client */
cd->ninfo = ninfo + 1; 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); PMIX_INFO_CREATE(cd->info, cd->ninfo);
if (NULL == cd->info) { if (NULL == cd->info) {
rc = PMIX_ERR_NOMEM; rc = PMIX_ERR_NOMEM;
@ -1194,7 +1202,7 @@ pmix_status_t pmix_server_spawn(pmix_peer_t *peer,
} }
/* add the directive to the end */ /* add the directive to the end */
if (PMIX_PROC_IS_TOOL(peer)) { 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 /* if the requestor is a tool, we default to forwarding all
* output IO channels */ * output IO channels */
if (!stdout_found) { if (!stdout_found) {
@ -1207,7 +1215,9 @@ pmix_status_t pmix_server_spawn(pmix_peer_t *peer,
cd->channels |= PMIX_FWD_STDDIAG_CHANNEL; cd->channels |= PMIX_FWD_STDDIAG_CHANNEL;
} }
} else { } 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 */ /* unpack the number of apps */
@ -1232,8 +1242,6 @@ pmix_status_t pmix_server_spawn(pmix_peer_t *peer,
} }
} }
/* call the local server */ /* 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); rc = pmix_host_server.spawn(&proc, cd->info, cd->ninfo, cd->apps, cd->napps, spcbfunc, cd);
cleanup: cleanup:

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

@ -263,7 +263,7 @@ static int test_item3(void)
}; };
const char **ptr = tkeys; 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)"); log_error("%s\n", "PMIx and SLURM/PMI2 does not set Job Attributes (Do not mark test as failed)");
return rc; return rc;
} }
@ -298,7 +298,7 @@ static int test_item4(void)
}; };
const char **ptr = tkeys; 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)"); log_error("%s\n", "PMIx and SLURM/PMI2 does not set Node Attributes (Do not mark test as failed)");
return rc; 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; 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)"); log_error("%s\n", "PMIx and SLURM/PMI1 do not set 'PMI_process_mapping' (Do not mark test as failed)");
return rc; 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 * Copyright (c) 2015 Research Organization for Information Science
* and Technology (RIST). All rights reserved. * and Technology (RIST). All rights reserved.
* Copyright (c) 2015 Mellanox Technologies, Inc. * Copyright (c) 2015 Mellanox Technologies, Inc.
@ -18,7 +18,7 @@
#include "server_callbacks.h" #include "server_callbacks.h"
#include "src/util/argv.h" #include "src/util/argv.h"
extern int spawn_wait; extern bool spawn_wait;
pmix_server_module_t mymodule = { pmix_server_module_t mymodule = {
.client_connected = connected, .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) pmix_spawn_cbfunc_t cbfunc, void *cbdata)
{ {
myxfer_t *x; myxfer_t *x;
size_t n;
pmix_proc_t *pptr;
bool spawned;
pmix_output(0, "SERVER: SPAWN"); 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 /* in practice, we would pass this request to the local
* resource manager for launch, and then have that server * resource manager for launch, and then have that server
* execute our callback function. For now, we will fake * 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: case OPAL_ERR_MODEL_DECLARED:
return PMIX_MODEL_DECLARED; return PMIX_MODEL_DECLARED;
case OPAL_PMIX_LAUNCH_DIRECTIVE:
return PMIX_LAUNCH_DIRECTIVE;
case OPAL_ERROR: case OPAL_ERROR:
return PMIX_ERROR; return PMIX_ERROR;
case OPAL_SUCCESS: case OPAL_SUCCESS:
@ -612,9 +609,6 @@ int pmix3x_convert_rc(pmix_status_t rc)
case PMIX_MODEL_DECLARED: case PMIX_MODEL_DECLARED:
return OPAL_ERR_MODEL_DECLARED; return OPAL_ERR_MODEL_DECLARED;
case PMIX_LAUNCH_DIRECTIVE:
return OPAL_PMIX_LAUNCH_DIRECTIVE;
case PMIX_ERROR: case PMIX_ERROR:
return OPAL_ERROR; return OPAL_ERROR;
case PMIX_SUCCESS: 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)); memcpy(&v->data.state, &kv->data.uint8, sizeof(uint8_t));
break; break;
case OPAL_PTR: 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 * opal_value_t's that we need to convert to a pmix_data_array
* of pmix_info_t structures */ * of pmix_info_t structures */
list = (opal_list_t*)kv->data.ptr; list = (opal_list_t*)kv->data.ptr;
@ -1604,12 +1605,8 @@ int pmix3x_convert_state(pmix_proc_state_t state)
return 55; return 55;
case PMIX_PROC_STATE_COMM_FAILED: case PMIX_PROC_STATE_COMM_FAILED:
return 56; return 56;
case PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED:
return 57;
case PMIX_PROC_STATE_CALLED_ABORT: case PMIX_PROC_STATE_CALLED_ABORT:
return 58; return 58;
case PMIX_PROC_STATE_HEARTBEAT_FAILED:
return 59;
case PMIX_PROC_STATE_MIGRATING: case PMIX_PROC_STATE_MIGRATING:
return 60; return 60;
case PMIX_PROC_STATE_CANNOT_RESTART: 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; return PMIX_PROC_STATE_TERM_WO_SYNC;
case 56: case 56:
return PMIX_PROC_STATE_COMM_FAILED; return PMIX_PROC_STATE_COMM_FAILED;
case 57:
return PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED;
case 58: case 58:
return PMIX_PROC_STATE_CALLED_ABORT; return PMIX_PROC_STATE_CALLED_ABORT;
case 59: case 59:
return PMIX_PROC_STATE_HEARTBEAT_FAILED;
case 60:
return PMIX_PROC_STATE_MIGRATING; return PMIX_PROC_STATE_MIGRATING;
case 61: case 61:
return PMIX_PROC_STATE_CANNOT_RESTART; 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; 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); OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
rc = PMIx_Init(&mca_pmix_pmix3x_component.myproc, pinfo, ninfo); rc = PMIx_Init(&mca_pmix_pmix3x_component.myproc, pinfo, ninfo);
if (NULL != pinfo) { 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 /* insert ourselves into our list of jobids - it will be the
* first, and so we'll check it first */ * first, and so we'll check it first */
job = OBJ_NEW(opal_pmix3x_jobid_trkr_t); job = OBJ_NEW(opal_pmix3x_jobid_trkr_t);