780c93ee57
We recognize that this means other users of OPAL will need to "wrap" the opal_process_name_t if they desire to abstract it in some fashion. This is regrettable, and we are looking at possible alternatives that might mitigate that requirement. Meantime, however, we have to put the needs of the OMPI community first, and are taking this step to restore hetero and SPARC support.
664 строки
20 KiB
C
664 строки
20 KiB
C
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
|
|
/*
|
|
* Copyright (c) 2014 Intel, Inc. All rights reserved.
|
|
* Copyright (c) 2014 Research Organization for Information Science
|
|
* and Technology (RIST). All rights reserved.
|
|
* $COPYRIGHT$
|
|
*
|
|
* Additional copyrights may follow
|
|
*
|
|
* $HEADER$
|
|
*/
|
|
|
|
#include "opal_config.h"
|
|
#include "opal/constants.h"
|
|
#include "opal/types.h"
|
|
|
|
#include "opal_stdint.h"
|
|
#include "opal/mca/base/mca_base_var.h"
|
|
#include "opal/mca/hwloc/base/base.h"
|
|
#include "opal/util/opal_environ.h"
|
|
#include "opal/util/output.h"
|
|
#include "opal/util/proc.h"
|
|
#include "opal/util/show_help.h"
|
|
|
|
#include <string.h>
|
|
#include <pmi.h>
|
|
|
|
#include "opal/mca/pmix/base/base.h"
|
|
#include "pmix_s1.h"
|
|
|
|
static int s1_init(void);
|
|
static int s1_fini(void);
|
|
static bool s1_initialized(void);
|
|
static int s1_abort(int flag, const char msg[]);
|
|
static int s1_fence(opal_process_name_t *procs, size_t nprocs);
|
|
static int s1_put(opal_pmix_scope_t scope,
|
|
opal_value_t *kv);
|
|
static int s1_get(const opal_process_name_t *id,
|
|
const char *key,
|
|
opal_value_t **kv);
|
|
static int s1_publish(const char service_name[],
|
|
opal_list_t *info,
|
|
const char port[]);
|
|
static int s1_lookup(const char service_name[],
|
|
opal_list_t *info,
|
|
char port[], int portLen);
|
|
static int s1_unpublish(const char service_name[],
|
|
opal_list_t *info);
|
|
static bool s1_get_attr(const char *attr, opal_value_t **kv);
|
|
static int s1_spawn(int count, const char * cmds[],
|
|
int argcs[], const char ** argvs[],
|
|
const int maxprocs[],
|
|
opal_list_t *info_keyval_vector,
|
|
opal_list_t *preput_keyval_vector,
|
|
char jobId[], int jobIdSize,
|
|
int errors[]);
|
|
static int s1_job_connect(const char jobId[]);
|
|
static int s1_job_disconnect(const char jobId[]);
|
|
|
|
const opal_pmix_base_module_t opal_pmix_s1_module = {
|
|
s1_init,
|
|
s1_fini,
|
|
s1_initialized,
|
|
s1_abort,
|
|
s1_fence,
|
|
NULL,
|
|
s1_put,
|
|
s1_get,
|
|
NULL,
|
|
s1_publish,
|
|
s1_lookup,
|
|
s1_unpublish,
|
|
s1_get_attr,
|
|
NULL,
|
|
s1_spawn,
|
|
s1_job_connect,
|
|
s1_job_disconnect,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
// usage accounting
|
|
static int pmix_init_count = 0;
|
|
|
|
// PMI constant values:
|
|
static int pmix_kvslen_max = 0;
|
|
static int pmix_keylen_max = 0;
|
|
static int pmix_vallen_max = 0;
|
|
static int pmix_vallen_threshold = INT_MAX;
|
|
|
|
// Job environment description
|
|
static char *pmix_kvs_name = NULL;
|
|
static bool s1_committed = false;
|
|
static char* pmix_packed_data = NULL;
|
|
static int pmix_packed_data_offset = 0;
|
|
static char* pmix_packed_encoded_data = NULL;
|
|
static int pmix_packed_encoded_data_offset = 0;
|
|
static int pmix_pack_key = 0;
|
|
static uint32_t s1_jobid;
|
|
static int s1_rank;
|
|
static uint16_t s1_lrank;
|
|
static uint16_t s1_nrank;
|
|
static int s1_usize;
|
|
static int s1_jsize;
|
|
static int s1_appnum;
|
|
static int s1_nlranks;
|
|
static int *s1_lranks=NULL;
|
|
static opal_process_name_t s1_pname;
|
|
|
|
static bool got_modex_data = false;
|
|
static char* pmix_error(int pmix_err);
|
|
#define OPAL_PMI_ERROR(pmi_err, pmi_func) \
|
|
do { \
|
|
opal_output(0, "%s [%s:%d:%s]: %s\n", \
|
|
pmi_func, __FILE__, __LINE__, __func__, \
|
|
pmix_error(pmi_err)); \
|
|
} while(0);
|
|
|
|
static int kvs_get(const char key[], char value [], int maxvalue)
|
|
{
|
|
int rc;
|
|
rc = PMI_KVS_Get(pmix_kvs_name, key, value, maxvalue);
|
|
if( PMI_SUCCESS != rc ){
|
|
OPAL_PMI_ERROR(rc, "PMI_KVS_Get");
|
|
return OPAL_ERROR;
|
|
}
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
static int kvs_put(const char key[], const char value[])
|
|
{
|
|
int rc;
|
|
rc = PMI_KVS_Put(pmix_kvs_name, key, value);
|
|
if( PMI_SUCCESS != rc ){
|
|
OPAL_PMI_ERROR(rc, "PMI_KVS_Put");
|
|
return OPAL_ERROR;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static int s1_init(void)
|
|
{
|
|
PMI_BOOL initialized;
|
|
int spawned;
|
|
int rc, ret = OPAL_ERROR;
|
|
int i;
|
|
char *pmix_id, *tmp;
|
|
uint32_t jobfam, stepid;
|
|
opal_value_t kv;
|
|
|
|
if (PMI_SUCCESS != (rc = PMI_Initialized(&initialized))) {
|
|
OPAL_PMI_ERROR(rc, "PMI_Initialized");
|
|
return OPAL_ERROR;
|
|
}
|
|
|
|
if( PMI_TRUE != initialized && PMI_SUCCESS != (rc = PMI_Init(&spawned)) ) {
|
|
OPAL_PMI_ERROR(rc, "PMI_Init");
|
|
return OPAL_ERROR;
|
|
}
|
|
|
|
// Initialize space demands
|
|
rc = PMI_KVS_Get_value_length_max(&pmix_vallen_max);
|
|
if( PMI_SUCCESS != rc ) {
|
|
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_value_length_max");
|
|
goto err_exit;
|
|
}
|
|
pmix_vallen_threshold = pmix_vallen_max * 3;
|
|
pmix_vallen_threshold >>= 2;
|
|
|
|
rc = PMI_KVS_Get_name_length_max(&pmix_kvslen_max);
|
|
if (PMI_SUCCESS != rc ) {
|
|
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_name_length_max");
|
|
goto err_exit;
|
|
}
|
|
|
|
rc = PMI_KVS_Get_key_length_max(&pmix_keylen_max);
|
|
if( PMI_SUCCESS != rc ) {
|
|
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_key_length_max");
|
|
goto err_exit;
|
|
}
|
|
|
|
// Initialize job environment information
|
|
pmix_id = (char*)malloc(pmix_vallen_max);
|
|
if( pmix_id == NULL ){
|
|
ret = OPAL_ERR_OUT_OF_RESOURCE;
|
|
goto err_exit;
|
|
}
|
|
/* Get domain id */
|
|
if (PMI_SUCCESS != (rc = PMI_Get_kvs_domain_id(pmix_id, pmix_vallen_max))) {
|
|
free(pmix_id);
|
|
goto err_exit;
|
|
}
|
|
/* Slurm PMI provides the job id as an integer followed
|
|
* by a '.', followed by essentially a stepid. The first integer
|
|
* defines an overall job number. The second integer is the number of
|
|
* individual jobs we have run within that allocation. So we translate
|
|
* this as the overall job number equating to our job family, and
|
|
* the individual number equating to our local jobid
|
|
*/
|
|
jobfam = strtoul(pmix_id, &tmp, 10);
|
|
if (NULL == tmp) {
|
|
/* hmmm - no '.', so let's just use zero */
|
|
stepid = 0;
|
|
} else {
|
|
tmp++; /* step over the '.' */
|
|
stepid = strtoul(tmp, NULL, 10);
|
|
}
|
|
/* now build the jobid */
|
|
s1_jobid = (jobfam << 16) | stepid;
|
|
free(pmix_id);
|
|
|
|
/* get our rank */
|
|
ret = PMI_Get_rank(&s1_rank);
|
|
if( PMI_SUCCESS != ret ) {
|
|
OPAL_PMI_ERROR(ret, "PMI_Get_rank");
|
|
goto err_exit;
|
|
}
|
|
/* store our name in the opal_proc_t so that
|
|
* debug messages will make sense - an upper
|
|
* layer will eventually overwrite it, but that
|
|
* won't do any harm */
|
|
s1_pname.jobid = s1_jobid;
|
|
s1_pname.vpid = s1_rank;
|
|
opal_proc_set_name(&s1_pname);
|
|
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
|
|
"%s pmix:s1: assigned tmp name",
|
|
OPAL_NAME_PRINT(s1_pname));
|
|
|
|
pmix_kvs_name = (char*)malloc(pmix_kvslen_max);
|
|
if( pmix_kvs_name == NULL ){
|
|
ret = OPAL_ERR_OUT_OF_RESOURCE;
|
|
goto err_exit;
|
|
}
|
|
|
|
rc = PMI_KVS_Get_my_name(pmix_kvs_name, pmix_kvslen_max);
|
|
if( PMI_SUCCESS != rc ) {
|
|
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_my_name");
|
|
goto err_exit;
|
|
}
|
|
|
|
/* get our local proc info to find our local rank */
|
|
if (PMI_SUCCESS != (rc = PMI_Get_clique_size(&s1_nlranks))) {
|
|
OPAL_PMI_ERROR(rc, "PMI_Get_clique_size");
|
|
return rc;
|
|
}
|
|
/* now get the specific ranks */
|
|
s1_lranks = (int*)calloc(s1_nlranks, sizeof(int));
|
|
if (NULL == s1_lranks) {
|
|
rc = OPAL_ERR_OUT_OF_RESOURCE;
|
|
OPAL_ERROR_LOG(rc);
|
|
return rc;
|
|
}
|
|
if (PMI_SUCCESS != (rc = PMI_Get_clique_ranks(s1_lranks, s1_nlranks))) {
|
|
OPAL_PMI_ERROR(rc, "PMI_Get_clique_ranks");
|
|
free(s1_lranks);
|
|
return rc;
|
|
}
|
|
/* find ourselves */
|
|
for (i=0; i < s1_nlranks; i++) {
|
|
if (s1_rank == s1_lranks[i]) {
|
|
s1_lrank = i;
|
|
s1_nrank = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* get universe size */
|
|
ret = PMI_Get_universe_size(&s1_usize);
|
|
if (PMI_SUCCESS != ret) {
|
|
OPAL_PMI_ERROR(ret, "PMI_Get_universe_size");
|
|
goto err_exit;
|
|
}
|
|
/* push this into the dstore for subsequent fetches */
|
|
OBJ_CONSTRUCT(&kv, opal_value_t);
|
|
kv.key = strdup(OPAL_DSTORE_UNIV_SIZE);
|
|
kv.type = OPAL_UINT32;
|
|
kv.data.uint32 = s1_usize;
|
|
if (OPAL_SUCCESS != (ret = opal_dstore.store(opal_dstore_internal, &OPAL_PROC_MY_NAME, &kv))) {
|
|
OPAL_ERROR_LOG(ret);
|
|
OBJ_DESTRUCT(&kv);
|
|
goto err_exit;
|
|
}
|
|
OBJ_DESTRUCT(&kv);
|
|
|
|
/* get job size */
|
|
ret = PMI_Get_size(&s1_jsize);
|
|
if (PMI_SUCCESS != ret) {
|
|
OPAL_PMI_ERROR(ret, "PMI_Get_size");
|
|
goto err_exit;
|
|
}
|
|
|
|
/* get appnum */
|
|
ret = PMI_Get_appnum(&s1_appnum);
|
|
if (PMI_SUCCESS != ret) {
|
|
OPAL_PMI_ERROR(ret, "PMI_Get_appnum");
|
|
goto err_exit;
|
|
}
|
|
|
|
/* setup any local envars we were asked to do */
|
|
mca_base_var_process_env_list(&environ);
|
|
|
|
return OPAL_SUCCESS;
|
|
|
|
err_exit:
|
|
PMI_Finalize();
|
|
return ret;
|
|
}
|
|
|
|
static int s1_fini(void) {
|
|
if (0 == pmix_init_count) {
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
if (0 == --pmix_init_count) {
|
|
PMI_Finalize ();
|
|
}
|
|
|
|
if (NULL != s1_lranks) {
|
|
free(s1_lranks);
|
|
}
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
static bool s1_initialized(void)
|
|
{
|
|
if (0 < pmix_init_count) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static int s1_abort(int flag, const char msg[])
|
|
{
|
|
PMI_Abort(flag, msg);
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
static int s1_spawn(int count, const char * cmds[],
|
|
int argcs[], const char ** argvs[],
|
|
const int maxprocs[],
|
|
opal_list_t *info_keyval_vector,
|
|
opal_list_t *preput_keyval_vector,
|
|
char jobId[], int jobIdSize,
|
|
int errors[])
|
|
{
|
|
/*
|
|
int rc;
|
|
size_t preput_vector_size;
|
|
const int info_keyval_sizes[1];
|
|
info_keyval_sizes[0] = (int)opal_list_get_size(info_keyval_vector);
|
|
//FIXME what's the size of array of lists?
|
|
preput_vector_size = opal_list_get_size(preput_keyval_vector);
|
|
rc = PMI_Spawn_multiple(count, cmds, argcs, argvs, maxprocs, info_keyval_sizes, info_keyval_vector, (int)preput_vector_size, preput_keyval_vector);
|
|
if( PMI_SUCCESS != rc ) {
|
|
OPAL_PMI_ERROR(rc, "PMI_Spawn_multiple");
|
|
return OPAL_ERROR;
|
|
}*/
|
|
return OPAL_ERR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
static int s1_put(opal_pmix_scope_t scope,
|
|
opal_value_t *kv)
|
|
{
|
|
int rc;
|
|
|
|
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
|
|
"%s pmix:s1 put for key %s",
|
|
OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), kv->key);
|
|
|
|
if (OPAL_SUCCESS != (rc = opal_pmix_base_store_encoded (kv->key, (void*)&kv->data, kv->type, &pmix_packed_data, &pmix_packed_data_offset))) {
|
|
OPAL_ERROR_LOG(rc);
|
|
return rc;
|
|
}
|
|
|
|
if (pmix_packed_data_offset == 0) {
|
|
/* nothing to write */
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
if (((pmix_packed_data_offset/3)*4) + pmix_packed_encoded_data_offset < pmix_vallen_max) {
|
|
/* this meta-key is still being filled,
|
|
* nothing to put yet
|
|
*/
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
rc = opal_pmix_base_partial_commit_packed (&pmix_packed_data, &pmix_packed_data_offset,
|
|
&pmix_packed_encoded_data, &pmix_packed_encoded_data_offset,
|
|
pmix_vallen_max, &pmix_pack_key, kvs_put);
|
|
|
|
s1_committed = false;
|
|
return rc;
|
|
}
|
|
|
|
static int s1_fence(opal_process_name_t *procs, size_t nprocs)
|
|
{
|
|
int rc;
|
|
int32_t i;
|
|
opal_value_t *kp, kvn;
|
|
opal_hwloc_locality_t locality;
|
|
|
|
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
|
|
"%s pmix:s1 called fence",
|
|
OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
|
|
|
|
/* check if there is partially filled meta key and put them */
|
|
opal_pmix_base_commit_packed (&pmix_packed_data, &pmix_packed_data_offset,
|
|
&pmix_packed_encoded_data, &pmix_packed_encoded_data_offset,
|
|
pmix_vallen_max, &pmix_pack_key, kvs_put);
|
|
|
|
/* if we haven't already done it, ensure we have committed our values */
|
|
if (!s1_committed) {
|
|
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
|
|
"%s pmix:s1 committing values",
|
|
OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
|
|
if (PMI_SUCCESS != (rc = PMI_KVS_Commit(pmix_kvs_name))) {
|
|
OPAL_PMI_ERROR(rc, "PMI_KVS_Commit");
|
|
return OPAL_ERROR;
|
|
}
|
|
}
|
|
|
|
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
|
|
"%s pmix:s1 performing barrier",
|
|
OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
|
|
|
|
/* use the PMI barrier function */
|
|
if (PMI_SUCCESS != (rc = PMI_Barrier())) {
|
|
OPAL_PMI_ERROR(rc, "PMI_Barrier");
|
|
return OPAL_ERROR;
|
|
}
|
|
|
|
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
|
|
"%s pmix:s1 barrier complete",
|
|
OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
|
|
|
|
/* get the modex data from each local process and set the
|
|
* localities to avoid having the MPI layer fetch data
|
|
* for every process in the job */
|
|
if (!got_modex_data) {
|
|
got_modex_data = true;
|
|
/* we only need to set locality for each local rank as "not found"
|
|
* equates to "non-local" */
|
|
for (i=0; i < s1_nlranks; i++) {
|
|
s1_pname.vpid = s1_lranks[i];
|
|
rc = opal_pmix_base_cache_keys_locally(&s1_pname, OPAL_DSTORE_CPUSET,
|
|
&kp, pmix_kvs_name, pmix_vallen_max, kvs_get);
|
|
if (OPAL_SUCCESS != rc) {
|
|
OPAL_ERROR_LOG(rc);
|
|
return rc;
|
|
}
|
|
#if OPAL_HAVE_HWLOC
|
|
if (NULL == kp || NULL == kp->data.string) {
|
|
/* if we share a node, but we don't know anything more, then
|
|
* mark us as on the node as this is all we know
|
|
*/
|
|
locality = OPAL_PROC_ON_CLUSTER | OPAL_PROC_ON_CU | OPAL_PROC_ON_NODE;
|
|
} else {
|
|
/* determine relative location on our node */
|
|
locality = opal_hwloc_base_get_relative_locality(opal_hwloc_topology,
|
|
opal_process_info.cpuset,
|
|
kp->data.string);
|
|
}
|
|
if (NULL != kp) {
|
|
OBJ_RELEASE(kp);
|
|
}
|
|
#else
|
|
/* all we know is we share a node */
|
|
locality = OPAL_PROC_ON_CLUSTER | OPAL_PROC_ON_CU | OPAL_PROC_ON_NODE;
|
|
#endif
|
|
OPAL_OUTPUT_VERBOSE((1, opal_pmix_base_framework.framework_output,
|
|
"%s pmix:s1 proc %s locality %s",
|
|
OPAL_NAME_PRINT(OPAL_PROC_MY_NAME),
|
|
OPAL_NAME_PRINT(s1_pname),
|
|
opal_hwloc_base_print_locality(locality)));
|
|
|
|
OBJ_CONSTRUCT(&kvn, opal_value_t);
|
|
kvn.key = strdup(OPAL_DSTORE_LOCALITY);
|
|
kvn.type = OPAL_UINT16;
|
|
kvn.data.uint16 = locality;
|
|
(void)opal_dstore.store(opal_dstore_internal, &s1_pname, &kvn);
|
|
OBJ_DESTRUCT(&kvn);
|
|
}
|
|
}
|
|
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
static int s1_get(const opal_process_name_t *id,
|
|
const char *key,
|
|
opal_value_t **kv)
|
|
{
|
|
int rc;
|
|
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
|
|
"%s pmix:s1 called get for key %s",
|
|
OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), key);
|
|
|
|
rc = opal_pmix_base_cache_keys_locally(id, key, kv, pmix_kvs_name, pmix_vallen_max, kvs_get);
|
|
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
|
|
"%s pmix:s1 got key %s",
|
|
OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), key);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int s1_publish(const char service_name[],
|
|
opal_list_t *info,
|
|
const char port[])
|
|
{
|
|
int rc;
|
|
|
|
if (PMI_SUCCESS != (rc = PMI_Publish_name(service_name, port))) {
|
|
OPAL_PMI_ERROR(rc, "PMI_Publish_name");
|
|
return OPAL_ERROR;
|
|
}
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
static int s1_lookup(const char service_name[],
|
|
opal_list_t *info,
|
|
char port[], int portLen)
|
|
{
|
|
int rc;
|
|
|
|
// Allocate mem for port here? Otherwise we won't get success!
|
|
// SLURM PMIv1 doesn't implement this function
|
|
/* I don't understand this comment. Is it still valid? */
|
|
if (PMI_SUCCESS != (rc = PMI_Lookup_name(service_name, port))) {
|
|
OPAL_PMI_ERROR(rc, "PMI_Lookup_name");
|
|
return OPAL_ERROR;
|
|
}
|
|
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
static int s1_unpublish(const char service_name[],
|
|
opal_list_t *info)
|
|
{
|
|
int rc;
|
|
|
|
if (PMI_SUCCESS != (rc = PMI_Unpublish_name(service_name))) {
|
|
OPAL_PMI_ERROR(rc, "PMI2_Nameserv_unpublish");
|
|
return OPAL_ERROR;
|
|
}
|
|
return OPAL_SUCCESS;
|
|
}
|
|
|
|
static bool s1_get_attr(const char *attr, opal_value_t **kv)
|
|
{
|
|
opal_value_t *kp;
|
|
|
|
if (0 == strcmp(PMIX_JOBID, attr)) {
|
|
kp = OBJ_NEW(opal_value_t);
|
|
kp->key = strdup(attr);
|
|
kp->type = OPAL_UINT32;
|
|
kp->data.uint32 = s1_jobid;
|
|
*kv = kp;
|
|
return true;
|
|
}
|
|
|
|
if (0 == strcmp(PMIX_RANK, attr)) {
|
|
kp = OBJ_NEW(opal_value_t);
|
|
kp->key = strdup(attr);
|
|
kp->type = OPAL_UINT32;
|
|
kp->data.uint32 = s1_rank;
|
|
*kv = kp;
|
|
return true;
|
|
}
|
|
|
|
if (0 == strcmp(PMIX_UNIV_SIZE, attr)) {
|
|
kp = OBJ_NEW(opal_value_t);
|
|
kp->key = strdup(attr);
|
|
kp->type = OPAL_UINT32;
|
|
kp->data.uint32 = s1_usize;
|
|
*kv = kp;
|
|
return true;
|
|
}
|
|
|
|
if (0 == strcmp(PMIX_JOB_SIZE, attr)) {
|
|
kp = OBJ_NEW(opal_value_t);
|
|
kp->key = strdup(attr);
|
|
kp->type = OPAL_UINT32;
|
|
kp->data.uint32 = s1_jsize;
|
|
*kv = kp;
|
|
return true;
|
|
}
|
|
|
|
if (0 == strcmp(PMIX_LOCAL_SIZE, attr)) {
|
|
kp = OBJ_NEW(opal_value_t);
|
|
kp->key = strdup(attr);
|
|
kp->type = OPAL_UINT32;
|
|
kp->data.uint32 = s1_nlranks;
|
|
*kv = kp;
|
|
return true;
|
|
}
|
|
|
|
if (0 == strcmp(PMIX_APPNUM, attr)) {
|
|
kp = OBJ_NEW(opal_value_t);
|
|
kp->key = strdup(attr);
|
|
kp->type = OPAL_UINT32;
|
|
kp->data.uint32 = s1_appnum;
|
|
*kv = kp;
|
|
return true;
|
|
}
|
|
|
|
if (0 == strcmp(PMIX_LOCAL_RANK, attr)) {
|
|
kp = OBJ_NEW(opal_value_t);
|
|
kp->key = strdup(attr);
|
|
kp->type = OPAL_UINT32;
|
|
kp->data.uint32 = s1_lrank;
|
|
*kv = kp;
|
|
return true;
|
|
}
|
|
|
|
if (0 == strcmp(PMIX_NODE_RANK, attr)) {
|
|
kp = OBJ_NEW(opal_value_t);
|
|
kp->key = strdup(attr);
|
|
kp->type = OPAL_UINT32;
|
|
kp->data.uint32 = s1_nrank;
|
|
*kv = kp;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static int s1_job_connect(const char jobId[])
|
|
{
|
|
return OPAL_ERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
static int s1_job_disconnect(const char jobId[])
|
|
{
|
|
return OPAL_ERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
static char* pmix_error(int pmix_err)
|
|
{
|
|
char * err_msg;
|
|
|
|
switch(pmix_err) {
|
|
case PMI_FAIL: err_msg = "Operation failed"; break;
|
|
case PMI_ERR_INIT: err_msg = "PMI is not initialized"; break;
|
|
case PMI_ERR_NOMEM: err_msg = "Input buffer not large enough"; break;
|
|
case PMI_ERR_INVALID_ARG: err_msg = "Invalid argument"; break;
|
|
case PMI_ERR_INVALID_KEY: err_msg = "Invalid key argument"; break;
|
|
case PMI_ERR_INVALID_KEY_LENGTH: err_msg = "Invalid key length argument"; break;
|
|
case PMI_ERR_INVALID_VAL: err_msg = "Invalid value argument"; break;
|
|
case PMI_ERR_INVALID_VAL_LENGTH: err_msg = "Invalid value length argument"; break;
|
|
case PMI_ERR_INVALID_LENGTH: err_msg = "Invalid length argument"; break;
|
|
case PMI_ERR_INVALID_NUM_ARGS: err_msg = "Invalid number of arguments"; break;
|
|
case PMI_ERR_INVALID_ARGS: err_msg = "Invalid args argument"; break;
|
|
case PMI_ERR_INVALID_NUM_PARSED: err_msg = "Invalid num_parsed length argument"; break;
|
|
case PMI_ERR_INVALID_KEYVALP: err_msg = "Invalid keyvalp argument"; break;
|
|
case PMI_ERR_INVALID_SIZE: err_msg = "Invalid size argument"; break;
|
|
#if defined(PMI_ERR_INVALID_KVS)
|
|
/* pmix.h calls this a valid return code but mpich doesn't define it (slurm does). */
|
|
case PMI_ERR_INVALID_KVS: err_msg = "Invalid kvs argument"; break;
|
|
#endif
|
|
case PMI_SUCCESS: err_msg = "Success"; break;
|
|
default: err_msg = "Unkown error";
|
|
}
|
|
return err_msg;
|
|
}
|