static bool pmi_startup(void)
{
#if WANT_CRAY_PMI2_EXT
int spawned, size, rank, appnum;
if (PMI2_Initialized()) {
/* already initialized */
return true;
}
/* if we can't startup PMI, we can't be used */
if (PMI_SUCCESS != PMI2_Init(&spawned, &size, &rank, &appnum)) {
return false;
}
/* flag that we started PMI */
started_by_me = true;
/* ignore the info - we'll pick it up elsewhere */
return true;
#else
PMI_BOOL initialized;
if (PMI_SUCCESS != PMI_Initialized(&initialized)) {
return false;
}
if (PMI_TRUE != initialized) {
if (PMI_SUCCESS != PMI_Init(&initialized)) {
return false;
}
/* flag that we started PMI */
started_by_me = true;
}
return true;
#endif
}
int main(int argc, char **argv, char **envp)
{
int pmi_rank = -1;
int pmi_process_group_size = -1;
int rc = EXIT_SUCCESS;
char *err = NULL;
PMI_BOOL pmi_initialized = PMI_FALSE;
int i;
double pi;
int spawned;
if (1 < argc) {
rc = strtol(argv[1], NULL, 10);
} else {
rc = 3;
}
/* sanity */
if (PMI_SUCCESS != PMI_Initialized(&pmi_initialized) ||
PMI_TRUE == pmi_initialized) {
fprintf(stderr, "=== ERROR: PMI sanity failure\n");
return EXIT_FAILURE;
}
if (PMI_SUCCESS != PMI_Init(&spawned)) {
err = "PMI_Init failure!";
goto done;
}
if (PMI_SUCCESS != PMI_Get_size(&pmi_process_group_size)) {
err = "PMI_Get_size failure!";
goto done;
}
if (PMI_SUCCESS != PMI_Get_rank(&pmi_rank)) {
err = "PMI_Get_rank failure!";
goto done;
}
i = 0;
while (1) {
i++;
pi = i / 3.14159256;
if (i > 10000) i = 0;
if ((pmi_rank == 3 ||
(pmi_process_group_size <= 3 && pmi_rank == 0))
&& i == 9995) {
asprintf(&err, "RANK%d CALLED ABORT", pmi_rank);
fprintf(stderr, "%s\n", err);
fflush(stderr);
PMI_Abort(rc, err);
}
}
done:
if (NULL != err) {
fprintf(stderr, "=== ERROR [rank:%d] %s\n", pmi_rank, err);
rc = EXIT_FAILURE;
}
return rc;
}
static int test_item2(void)
{
int rc = 0;
PMI_BOOL val;
if (PMI_SUCCESS != (rc = PMI_Initialized(&val))) {
log_fatal("PMI_Initialized failed: %d\n", rc);
return rc;
}
log_assert(PMI_TRUE == val, "");
return rc;
}
int orte_grpcomm_pmi_close(void)
{
#if WANT_CRAY_PMI2_EXT
if (started_by_me && PMI2_Initialized()) {
PMI2_Finalize();
}
#else
PMI_BOOL initialized;
/* if we weren't selected, cleanup */
if (started_by_me &&
PMI_SUCCESS == PMI_Initialized(&initialized) &&
PMI_TRUE == initialized) {
PMI_Finalize();
}
#endif
return ORTE_SUCCESS;
}
int main(int argc, char* argv[])
{
int rank;
int size;
int i = 1;
char *kvs_name;
int kvs_name_l;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
PMI_BOOL initialized;
int ret = PMI_Initialized( &initialized );
printf("%d: ret=%d, init=%d\n",rank,ret,initialized);
if( initialized ){
get_kvs_name(&kvs_name, &kvs_name_l);
printf("%d: kvs_name = %s\n",kvs_name);
}
MPI_Finalize();
return 0;
}
static int s1_init(void)
{
PMI_BOOL initialized;
int spawned;
int rc, ret = OPAL_ERROR;
int i, rank, lrank, nrank;
char *pmix_id, tmp[64];
opal_value_t kv;
char *str;
uint32_t ui32;
opal_process_name_t ldr;
char **localranks=NULL;
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;
}
// setup hash table
opal_pmix_base_hash_init();
// 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;
}
/* get our rank */
ret = PMI_Get_rank(&rank);
if( PMI_SUCCESS != ret ) {
OPAL_PMI_ERROR(ret, "PMI_Get_rank");
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. */
s1_pname.jobid = strtoul(pmix_id, &str, 10);
s1_pname.jobid = (s1_pname.jobid << 16) & 0xffff0000;
if (NULL != str) {
ui32 = strtoul(str, NULL, 10);
s1_pname.jobid |= (ui32 & 0x0000ffff);
}
ldr.jobid = s1_pname.jobid;
s1_pname.vpid = rank;
/* 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 */
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));
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_JOBID);
kv.type = OPAL_UINT32;
kv.data.uint32 = s1_pname.jobid;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* save it */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_RANK);
kv.type = OPAL_UINT32;
kv.data.uint32 = rank;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
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(&nlranks))) {
OPAL_PMI_ERROR(rc, "PMI_Get_clique_size");
return rc;
}
/* save the local size */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_LOCAL_SIZE);
kv.type = OPAL_UINT32;
kv.data.uint32 = nlranks;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
lrank = 0;
nrank = 0;
ldr.vpid = rank;
if (0 < nlranks) {
/* now get the specific ranks */
lranks = (int*)calloc(nlranks, sizeof(int));
if (NULL == lranks) {
rc = OPAL_ERR_OUT_OF_RESOURCE;
OPAL_ERROR_LOG(rc);
return rc;
}
if (PMI_SUCCESS != (rc = PMI_Get_clique_ranks(lranks, nlranks))) {
OPAL_PMI_ERROR(rc, "PMI_Get_clique_ranks");
free(lranks);
return rc;
}
/* note the local ldr */
ldr.vpid = lranks[0];
/* save this */
memset(tmp, 0, 64);
for (i=0; i < nlranks; i++) {
(void)snprintf(tmp, 64, "%d", lranks[i]);
opal_argv_append_nosize(&localranks, tmp);
if (rank == lranks[i]) {
lrank = i;
nrank = i;
}
}
str = opal_argv_join(localranks, ',');
opal_argv_free(localranks);
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_LOCAL_PEERS);
kv.type = OPAL_STRING;
kv.data.string = str;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
}
/* save the local leader */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_LOCALLDR);
kv.type = OPAL_UINT64;
kv.data.uint64 = *(uint64_t*)&ldr;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* save our local rank */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_LOCAL_RANK);
kv.type = OPAL_UINT16;
kv.data.uint16 = lrank;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* and our node rank */
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_NODE_RANK);
kv.type = OPAL_UINT16;
kv.data.uint16 = nrank;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* get universe size */
ret = PMI_Get_universe_size(&i);
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_PMIX_UNIV_SIZE);
kv.type = OPAL_UINT32;
kv.data.uint32 = i;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&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(&i);
if (PMI_SUCCESS != ret) {
OPAL_PMI_ERROR(ret, "PMI_Get_size");
goto err_exit;
}
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_JOB_SIZE);
kv.type = OPAL_UINT32;
kv.data.uint32 = i;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* get appnum */
ret = PMI_Get_appnum(&i);
if (PMI_SUCCESS != ret) {
OPAL_PMI_ERROR(ret, "PMI_Get_appnum");
goto err_exit;
}
OBJ_CONSTRUCT(&kv, opal_value_t);
kv.key = strdup(OPAL_PMIX_APPNUM);
kv.type = OPAL_UINT32;
kv.data.uint32 = i;
if (OPAL_SUCCESS != (ret = opal_pmix_base_store(&OPAL_PROC_MY_NAME, &kv))) {
OPAL_ERROR_LOG(ret);
OBJ_DESTRUCT(&kv);
goto err_exit;
}
OBJ_DESTRUCT(&kv);
/* increment the init count */
++pmix_init_count;
return OPAL_SUCCESS;
err_exit:
PMI_Finalize();
return ret;
}
int
main(int argc,
char *argv[])
{
int initialized, rank, size;
int i, max_name_len, max_key_len, max_val_len;
char *name, *key, *val;
if (PMI_SUCCESS != PMI_Initialized(&initialized)) {
return 1;
}
if (0 == initialized) {
if (PMI_SUCCESS != PMI_Init(&initialized)) {
return 1;
}
}
if (PMI_SUCCESS != PMI_Get_rank(&rank)) {
return 1;
}
if (PMI_SUCCESS != PMI_Get_size(&size)) {
return 1;
}
printf("Hello, World. I am %d of %d\n", rank, size);
if (PMI_SUCCESS != PMI_KVS_Get_name_length_max(&max_name_len)) {
return 1;
}
name = (char*) malloc(max_name_len);
if (NULL == name) return 1;
if (PMI_SUCCESS != PMI_KVS_Get_key_length_max(&max_key_len)) {
return 1;
}
key = (char*) malloc(max_key_len);
if (NULL == key) return 1;
if (PMI_SUCCESS != PMI_KVS_Get_value_length_max(&max_val_len)) {
return 1;
}
val = (char*) malloc(max_val_len);
if (NULL == val) return 1;
if (PMI_SUCCESS != PMI_KVS_Get_my_name(name, max_name_len)) {
return 1;
}
/* put my information */
snprintf(key, max_key_len, "pmi_hello-%lu-test", (long unsigned) rank);
snprintf(val, max_val_len, "%lu", (long unsigned) rank);
if (PMI_SUCCESS != PMI_KVS_Put(name, key, val)) {
return 1;
}
if (PMI_SUCCESS != PMI_KVS_Commit(name)) {
return 1;
}
if (PMI_SUCCESS != PMI_Barrier()) {
return 1;
}
/* verify everyone's information */
for (i = 0 ; i < size ; ++i) {
snprintf(key, max_key_len, "pmi_hello-%lu-test", (long unsigned) i);
if (PMI_SUCCESS != PMI_KVS_Get(name, key, val, max_val_len)) {
return 1;
}
if (i != strtol(val, NULL, 0)) {
fprintf(stderr, "%d: Error: Expected %d, got %d\n", rank, i, (int) strtol(val, NULL, 0));
return 1;
}
}
PMI_Finalize();
return 0;
}
main (int argc, char **argv)
{
int i, j, rc;
int nprocs, procid;
int clique_size, *clique_ranks = NULL;
char *jobid_ptr, *nprocs_ptr, *procid_ptr;
int pmi_rank, pmi_size, kvs_name_len, key_len, val_len;
PMI_BOOL initialized;
char *key, *val, *kvs_name;
struct timeval tv1, tv2;
long delta_t;
char tv_str[20];
gettimeofday(&tv1, NULL);
/* Get process count and our id from environment variables */
jobid_ptr = getenv("SLURM_JOB_ID");
nprocs_ptr = getenv("SLURM_NPROCS");
procid_ptr = getenv("SLURM_PROCID");
if (jobid_ptr == NULL) {
printf("WARNING: PMI test not run under SLURM\n");
nprocs = 1;
procid = 0;
} else if ((nprocs_ptr == NULL) || (procid_ptr == NULL)) {
printf("FAILURE: SLURM environment variables not set\n");
exit(1);
} else {
nprocs = atoi(nprocs_ptr);
procid = atoi(procid_ptr);
}
/* Validate process count and our id */
if ((nprocs < 1) || (nprocs > 9999)) {
printf("FAILURE: Invalid nprocs %s\n", nprocs_ptr);
exit(1);
}
if ((procid < 0) || (procid > 9999)) {
printf("FAILURE: Invalid procid %s\n", procid_ptr);
exit(1);
}
/* Get process count and size from PMI and validate */
if ((rc = PMI_Init(&i)) != PMI_SUCCESS) {
printf("FAILURE: PMI_Init: %d\n", rc);
exit(1);
}
initialized = PMI_FALSE;
if ((rc = PMI_Initialized(&initialized)) != PMI_SUCCESS) {
printf("FAILURE: PMI_Initialized: %d\n", rc);
exit(1);
}
if (initialized != PMI_TRUE) {
printf("FAILURE: PMI_Initialized returned false\n");
exit(1);
}
if ((rc = PMI_Get_rank(&pmi_rank)) != PMI_SUCCESS) {
printf("FAILURE: PMI_Get_rank: %d\n", rc);
exit(1);
}
#if _DEBUG
printf("PMI_Get_rank = %d\n", pmi_rank);
#endif
if ((rc = PMI_Get_size(&pmi_size)) != PMI_SUCCESS) {
printf("FAILURE: PMI_Get_size: %d, task %d\n", rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_Get_size = %d\n", pmi_size);
#endif
if (pmi_rank != procid) {
printf("FAILURE: Rank(%d) != PROCID(%d)\n",
pmi_rank, procid);
exit(1);
}
if (pmi_size != nprocs) {
printf("FAILURE: Size(%d) != NPROCS(%d), task %d\n",
pmi_size, nprocs, pmi_rank);
exit(1);
}
if ((rc = PMI_Get_clique_size(&clique_size)) != PMI_SUCCESS) {
printf("FAILURE: PMI_Get_clique_size: %d, task %d\n",
rc, pmi_rank);
exit(1);
}
clique_ranks = malloc(sizeof(int) * clique_size);
if ((rc = PMI_Get_clique_ranks(clique_ranks, clique_size)) !=
PMI_SUCCESS) {
printf("FAILURE: PMI_Get_clique_ranks: %d, task %d\n",
rc, pmi_rank);
exit(1);
}
#if _DEBUG
for (i=0; i<clique_size; i++)
printf("PMI_Get_clique_ranks[%d]=%d\n", i, clique_ranks[i]);
#endif
free(clique_ranks);
if ((rc = PMI_KVS_Get_name_length_max(&kvs_name_len)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Get_name_length_max: %d, task %d\n",
rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Get_name_length_max = %d\n", kvs_name_len);
#endif
kvs_name = malloc(kvs_name_len);
if ((rc = PMI_KVS_Get_my_name(kvs_name, kvs_name_len)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Get_my_name: %d, task %d\n", rc,
pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Get_my_name = %s\n", kvs_name);
#endif
if ((rc = PMI_KVS_Get_key_length_max(&key_len)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Get_key_length_max: %d, task %d\n",
rc, pmi_rank);
exit(1);
}
key = malloc(key_len);
if ((rc = PMI_KVS_Get_value_length_max(&val_len)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Get_value_length_max: %d, task %d\n",
rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Get_value_length_max = %d\n", val_len);
#endif
val = malloc(val_len);
/* Build and set some key=val pairs */
snprintf(key, key_len, "ATTR_1_%d", procid);
snprintf(val, val_len, "A%d", procid+OFFSET_1);
if ((rc = PMI_KVS_Put(kvs_name, key, val)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Put(%s,%s,%s): %d, task %d\n",
kvs_name, key, val, rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Put(%s,%s,%s)\n", kvs_name, key, val);
#endif
snprintf(key, key_len, "attr_2_%d", procid);
snprintf(val, val_len, "B%d", procid+OFFSET_2);
if ((rc = PMI_KVS_Put(kvs_name, key, val)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Put(%s,%s,%s): %d, task %d\n",
kvs_name, key, val, rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Put(%s,%s,%s)\n", kvs_name, key, val);
#endif
/* Sync KVS across all tasks */
if ((rc = PMI_KVS_Commit(kvs_name)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Commit: %d, task %d\n", rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Commit completed\n");
#endif
if ((rc = PMI_Barrier()) != PMI_SUCCESS) {
printf("FAILURE: PMI_Barrier: %d, task %d\n", rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_Barrier completed\n");
#endif
/* Now lets get all keypairs and validate */
for (i=0; i<pmi_size; i++) {
snprintf(key, key_len, "ATTR_1_%d", i);
if ((rc = PMI_KVS_Get(kvs_name, key, val, val_len))
!= PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Get(%s): %d, task %d\n",
key, rc, pmi_rank);
exit(1);
}
if ((val[0] != 'A')
|| ((atoi(&val[1])-OFFSET_1) != i)) {
printf("FAILURE: Bad keypair %s=%s, task %d\n",
key, val, pmi_rank);
exit(1);
}
#if _DEBUG
if ((pmi_size <= 8) && (pmi_rank == 0)) /* limit output */
printf("PMI_KVS_Get(%s,%s) %s\n", kvs_name, key, val);
#endif
snprintf(key, key_len, "attr_2_%d", i);
if ((rc = PMI_KVS_Get(kvs_name, key, val, val_len))
!= PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Get(%s): %d, task %d\n",
key, rc, pmi_rank);
exit(1);
}
if ((val[0] != 'B')
|| ((atoi(&val[1])-OFFSET_2) != i)) {
printf("FAILURE: Bad keypair %s=%s, task %d\n",
key,val, pmi_rank);
exit(1);
}
#if _DEBUG
if ((pmi_size <= 8) && (pmi_rank == 1)) /* limit output */
printf("PMI_KVS_Get(%s,%s) %s\n", kvs_name, key, val);
#endif
}
/* use iterator */
if ((rc = PMI_KVS_Iter_first(kvs_name, key, key_len, val,
val_len)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_iter_first: %d, task %d\n", rc,
pmi_rank);
exit(1);
}
for (i=0; ; i++) {
if (key[0] == '\0') {
if (i != (pmi_size * 2)) {
printf("FAILURE: PMI_KVS_iter_next "
"cycle count(%d, %d), task %d\n",
i, pmi_size, pmi_rank);
}
break;
}
#if _DEBUG
if ((pmi_size <= 8) && (pmi_rank == 1)) { /* limit output */
printf("PMI_KVS_Iter_next(%s,%d): %s=%s\n", kvs_name,
i, key, val);
}
#endif
if ((rc = PMI_KVS_Iter_next(kvs_name, key, key_len,
val, val_len)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_iter_next: %d, task %d\n",
rc, pmi_rank);
exit(1);
}
}
/* Build some more key=val pairs */
snprintf(key, key_len, "ATTR_3_%d", procid);
snprintf(val, val_len, "C%d", procid+OFFSET_1);
if ((rc = PMI_KVS_Put(kvs_name, key, val)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Put(%s,%s,%s): %d, task %d\n",
kvs_name, key, val, rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Put(%s,%s,%s)\n", kvs_name, key, val);
#endif
snprintf(key, key_len, "attr_4_%d", procid);
snprintf(val, val_len, "D%d", procid+OFFSET_2);
if ((rc = PMI_KVS_Put(kvs_name, key, val)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Put(%s,%s,%s): %d, task %d\n",
kvs_name, key, val, rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Put(%s,%s,%s)\n", kvs_name, key, val);
#endif
/* Sync KVS across all tasks */
if ((rc = PMI_KVS_Commit(kvs_name)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Commit: %d, task %d\n", rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Commit completed\n");
#endif
if ((rc = PMI_Barrier()) != PMI_SUCCESS) {
printf("FAILURE: PMI_Barrier: %d, task %d\n", rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_Barrier completed\n");
#endif
/* Now lets get some keypairs and validate */
for (i=0; i<pmi_size; i++) {
snprintf(key, key_len, "ATTR_1_%d", i);
if ((rc = PMI_KVS_Get(kvs_name, key, val, val_len))
!= PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Get(%s): %d, task %d\n",
key, rc, pmi_rank);
exit(1);
}
if ((val[0] != 'A')
|| ((atoi(&val[1])-OFFSET_1) != i)) {
printf("FAILURE: Bad keypair %s=%s, task %d\n",
key, val, pmi_rank);
exit(1);
}
#if _DEBUG
if ((pmi_size <= 8) && (pmi_rank == 1)) /* limit output */
printf("PMI_KVS_Get(%s,%s) %s\n", kvs_name, key, val);
#endif
snprintf(key, key_len, "attr_4_%d", i);
if ((rc = PMI_KVS_Get(kvs_name, key, val, val_len))
!= PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Get(%s): %d, task %d\n",
key, rc, pmi_rank);
exit(1);
}
if ((val[0] != 'D')
|| ((atoi(&val[1])-OFFSET_2) != i)) {
printf("FAILURE: Bad keypair %s=%s, task %d\n",
key,val, pmi_rank);
exit(1);
}
#if _DEBUG
if ((pmi_size <= 8) && (pmi_rank == 1)) /* limit output */
printf("PMI_KVS_Get(%s,%s) %s\n", kvs_name, key, val);
#endif
}
/* Replicate the very heavy load that MVAPICH2 puts on PMI
* This load exceeds that of MPICH2 by a very wide margin */
#if _DEBUG
printf("Starting %d iterations each with %d PMI_KVS_Put and \n"
" one each PMI_KVS_Commit and KVS_Barrier\n",
BARRIER_CNT, PUTS_PER_BARRIER);
fflush(stdout);
#endif
for (i=0; i<BARRIER_CNT; i++) {
for (j=0; j<PUTS_PER_BARRIER; j++) {
snprintf(key, key_len, "ATTR_%d_%d_%d", i, j, procid);
snprintf(val, val_len, "C%d", procid+OFFSET_1);
if ((rc = PMI_KVS_Put(kvs_name, key, val)) !=
PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Put(%s,%s,%s): "
"%d, task %d\n",
kvs_name, key, val, rc, pmi_rank);
exit(1);
}
}
if ((rc= PMI_KVS_Commit(kvs_name)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Commit: %d, task %d\n",
rc, pmi_rank);
exit(1);
}
if ((rc = PMI_Barrier()) != PMI_SUCCESS) {
printf("FAILURE: PMI_Barrier: %d, task %d\n",
rc, pmi_rank);
exit(1);
}
/* Don't bother with PMI_KVS_Get as those are all local
* and do not put a real load on srun or the network */
}
#if _DEBUG
printf("Interative PMI calls successful\n");
#endif
/* create new keyspace and test it */
if ((rc = PMI_KVS_Create(kvs_name, kvs_name_len)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Create: %d, task %d\n", rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Create %s\n", kvs_name);
#endif
if ((rc = PMI_KVS_Put(kvs_name, "KVS_KEY", "KVS_VAL")) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Put: %d, task %d\n", rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Put(%s,KVS_KEY,KVS_VAL)\n", kvs_name);
#endif
if ((rc = PMI_KVS_Get(kvs_name, "KVS_KEY", val, val_len)) !=
PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Get(%s, KVS_KEY): %d, task %d\n",
kvs_name, rc, pmi_rank);
exit(1);
}
#if _DEBUG
printf("PMI_KVS_Get(%s,%s) %s\n", kvs_name, "KVS_KEY", val);
#endif
if ((rc = PMI_KVS_Destroy(kvs_name)) != PMI_SUCCESS) {
printf("FAILURE: PMI_KVS_Destroy(%s): %d, task %d\n",
kvs_name, rc, pmi_rank);
exit(1);
}
if ((rc = PMI_KVS_Get(kvs_name, "KVS_KEY", val, val_len)) !=
PMI_ERR_INVALID_KVS) {
printf("FAILURE: PMI_KVS_Get(%s, KVS_KEY): %d, task %d\n",
kvs_name, rc, pmi_rank);
exit(1);
}
if ((rc = PMI_Finalize()) != PMI_SUCCESS) {
printf("FAILURE: PMI_Finalize: %d, task %d\n", rc, pmi_rank);
exit(1);
}
if (_DEBUG || (pmi_rank < 4)) {
gettimeofday(&tv2, NULL);
delta_t = (tv2.tv_sec - tv1.tv_sec) * 1000000;
delta_t += tv2.tv_usec - tv1.tv_usec;
snprintf(tv_str, sizeof(tv_str), "usec=%ld", delta_t);
printf("PMI test ran successfully, for task %d, %s\n",
pmi_rank, tv_str);
}
if (pmi_rank == 0) {
printf("NOTE: All failures reported, ");
printf("but only first four successes reported\n");
}
exit(0);
}
int main(void)
{
int rc;
int rank, size;
PMI_BOOL initialized;
rc = PMI_Initialized(&initialized);
if (rc!=PMI_SUCCESS)
PMI_Abort(rc,"PMI_Initialized failed");
if (initialized!=PMI_TRUE)
{
int spawned;
rc = PMI_Init(&spawned);
if (rc!=PMI_SUCCESS)
PMI_Abort(rc,"PMI_Init failed");
}
rc = PMI_Get_rank(&rank);
if (rc!=PMI_SUCCESS)
PMI_Abort(rc,"PMI_Get_rank failed");
rc = PMI_Get_size(&size);
if (rc!=PMI_SUCCESS)
PMI_Abort(rc,"PMI_Get_size failed");
printf("rank %d of %d \n", rank, size);
int rpn; /* rpn = ranks per node */
rc = PMI_Get_clique_size(&rpn);
if (rc!=PMI_SUCCESS)
PMI_Abort(rc,"PMI_Get_clique_size failed");
printf("rank %d clique size %d \n", rank, rpn);
int * clique_ranks = malloc( rpn * sizeof(int) );
if (clique_ranks==NULL)
PMI_Abort(rpn,"malloc failed");
rc = PMI_Get_clique_ranks(clique_ranks, rpn);
if (rc!=PMI_SUCCESS)
PMI_Abort(rc,"PMI_Get_clique_ranks failed");
for(int i = 0; i<rpn; i++)
printf("rank %d clique[%d] = %d \n", rank, i, clique_ranks[i]);
int nid;
rc = PMI_Get_nid(rank, &nid);
if (rc!=PMI_SUCCESS)
PMI_Abort(rc,"PMI_Get_nid failed");
printf("rank %d PMI_Get_nid gives nid %d \n", rank, nid);
#if OLD
rca_mesh_coord_t xyz;
rca_get_meshcoord( (uint16_t) nid, &xyz);
printf("rank %d rca_get_meshcoord returns (%2u,%2u,%2u)\n",
rank, xyz.mesh_x, xyz.mesh_y, xyz.mesh_z);
#else // UNTESTED
pmi_mesh_coord_t xyz;
PMI_Get_meshcoord((uint16_t) nid, &xyz);
printf("rank %d PMI_Get_meshcoord returns (%2u,%2u,%2u)\n",
rank, xyz.mesh_x, xyz.mesh_y, xyz.mesh_z);
#endif
fflush(stdout);
return 0;
}
/* gasneti_bootstrapInit
*/
int gasneti_bootstrapInit_pmi(
int *argc_p, char ***argv_p,
gasnet_node_t *nodes_p, gasnet_node_t *mynode_p) {
int size, rank;
#if USE_PMI2_API
int spawned, appnum;
if (PMI2_SUCCESS != PMI2_Init(&spawned, &size, &rank, &appnum)) {
return GASNET_ERR_NOT_INIT;
}
#else
if (PMI_SUCCESS != PMI_Initialized(&gasneti_pmi_initialized)) {
return GASNET_ERR_NOT_INIT;
}
if (PMI_FALSE == gasneti_pmi_initialized) {
int spawned;
if (PMI_SUCCESS != PMI_Init(&spawned)) {
return GASNET_ERR_NOT_INIT;
}
}
if (PMI_SUCCESS != PMI_Get_rank(&rank)) {
gasneti_fatalerror("PMI_Get_rank() failed");
}
if (PMI_SUCCESS != PMI_Get_size(&size)) {
gasneti_fatalerror("PMI_Get_size() failed");
}
#endif
*mynode_p = rank;
*nodes_p = size;
#if USE_PMI2_API
max_name_len = 1024; /* XXX: can almost certainly be shorter than this! */
max_key_len = PMI2_MAX_KEYLEN;
max_val_len = PMI2_MAX_VALLEN;
#else
if (PMI_SUCCESS != PMI_KVS_Get_name_length_max(&max_name_len)) {
gasneti_fatalerror("PMI_KVS_Get_name_length_max() failed");
}
if (PMI_SUCCESS != PMI_KVS_Get_key_length_max(&max_key_len)) {
gasneti_fatalerror("PMI_KVS_Get_key_length_max() failed");
}
if (PMI_SUCCESS != PMI_KVS_Get_value_length_max(&max_val_len)) {
gasneti_fatalerror("PMI_KVS_Get_value_length_max() failed");
}
#endif
kvs_name = (char*) gasneti_malloc(max_name_len);
kvs_key = (char*) gasneti_malloc(max_key_len);
kvs_value = (char*) gasneti_malloc(max_val_len);
max_val_bytes = 4 * (max_val_len / 5);
#if USE_PMI2_API
if (PMI2_SUCCESS != PMI2_Job_GetId(kvs_name, max_name_len)) {
gasneti_fatalerror("PMI2_Job_GetId() failed");
}
#else
if (PMI_SUCCESS != PMI_KVS_Get_my_name(kvs_name, max_name_len)) {
gasneti_fatalerror("PMI_KVS_Get_my_name() failed");
}
#endif
return GASNET_OK;
}
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;
}
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.jid = s1_jobid;
s1_pname.vid = s1_rank;
opal_proc_set_name((opal_process_name_t*)&s1_pname);
opal_output_verbose(2, opal_pmix_base_framework.framework_output,
"%s pmix:s1: assigned tmp name",
OPAL_NAME_PRINT(*(opal_process_name_t*)&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;
}
return OPAL_SUCCESS;
err_exit:
PMI_Finalize();
return ret;
}
bool mca_common_pmi_init (void) {
if (0 < mca_common_pmi_init_count++) {
return true;
}
#if WANT_PMI2_SUPPORT
{
int spawned, size, rank, appnum;
int rc;
size = -1;
rank = -1;
appnum = -1;
/* deal with a Slurm bug by first checking if we were
* even launched by a PMI server before attempting
* to use PMI */
if (NULL == getenv("PMI_FD")) {
mca_common_pmi_init_count--;
return false;
}
/* if we can't startup PMI, we can't be used */
if (PMI2_Initialized ()) {
return true;
}
if (PMI2_SUCCESS != (rc = PMI2_Init(&spawned, &size, &rank, &appnum))) {
opal_show_help("help-common-pmi.txt", "pmi2-init-failed", true, rc);
mca_common_pmi_init_count--;
return false;
}
if (size < 0 || rank < 0 ) {
opal_show_help("help-common-pmi.txt", "pmi2-init-returned-bad-values", true);
mca_common_pmi_init_count--;
return false;
}
mca_common_pmi_init_size = size;
mca_common_pmi_init_rank = rank;
mca_common_pmi_init_count--;
return true;
}
#else
{
PMI_BOOL initialized;
/* deal with a Slurm bug by first checking if we were
* even launched by a PMI server before attempting
* to use PMI */
if (NULL == getenv("PMI_FD")) {
mca_common_pmi_init_count--;
return false;
}
if (PMI_SUCCESS != PMI_Initialized(&initialized)) {
mca_common_pmi_init_count--;
return false;
}
if (PMI_TRUE != initialized && PMI_SUCCESS != PMI_Init(&initialized)) {
mca_common_pmi_init_count--;
return false;
}
}
#endif
return true;
}
int main(int argc, char **argv, char **envp)
{
int pmi_rank = -1;
int pmi_process_group_size = -1;
int num_local_procs = 0;
int *local_rank_ids = NULL;
int spawned = PMI_FALSE;
int rc = EXIT_SUCCESS;
char *err = NULL;
PMI_BOOL pmi_initialized = PMI_FALSE;
int pmi_vallen_max, max_length;
char *pmi_kvs_name;
/* sanity */
if (PMI_SUCCESS != PMI_Initialized(&pmi_initialized) ||
PMI_TRUE == pmi_initialized) {
fprintf(stderr, "=== ERROR: PMI sanity failure\n");
return EXIT_FAILURE;
}
if (PMI_SUCCESS != PMI_Init(&spawned)) {
err = "PMI_Init failure!";
goto done;
}
if (PMI_SUCCESS != PMI_Get_size(&pmi_process_group_size)) {
err = "PMI_Get_size failure!";
goto done;
}
if (PMI_SUCCESS != PMI_Get_rank(&pmi_rank)) {
err = "PMI_Get_rank failure!";
goto done;
}
if (PMI_SUCCESS != PMI_Get_clique_size(&num_local_procs)) {
err = "PMI_Get_clique_size failure!";
goto done;
}
if (PMI_SUCCESS != PMI_KVS_Get_value_length_max(&pmi_vallen_max)) {
err = "PMI_KVS_Get_value_length_max failure!";
goto done;
}
if (PMI_SUCCESS != PMI_KVS_Get_name_length_max(&max_length)) {
err = "PMI_KVS_Get_name_length_max failure!";
goto done;
}
pmi_kvs_name = (char*)malloc(max_length);
if (NULL == pmi_kvs_name) {
err = "malloc failure!";
goto done;
}
if (PMI_SUCCESS != PMI_KVS_Get_my_name(pmi_kvs_name,max_length)) {
err = "PMI_KVS_Get_my_name failure!";
goto done;
}
if (NULL == (local_rank_ids = calloc(num_local_procs, sizeof(int)))) {
err = "out of resources";
goto done;
}
if (PMI_SUCCESS != PMI_Get_clique_ranks(local_rank_ids, num_local_procs)) {
err = "PMI_Get_clique_size failure!";
goto done;
}
/* lowest local rank will print env info and tag its output*/
// if (pmi_rank == local_rank_ids[0]) {
// for (; NULL != envp && NULL != *envp; ++envp) {
// printf("===[%d]: %s\n", pmi_rank, *envp);
// }
//}
done:
if (PMI_TRUE == pmi_initialized) {
if (PMI_SUCCESS != PMI_Finalize()) {
err = "PMI_Finalize failure!";
}
}
if (NULL != err) {
fprintf(stderr, "=== ERROR [rank:%d] %s\n", pmi_rank, err);
rc = EXIT_FAILURE;
}
return rc;
}
static int mca_initialize_pmi_v1(void)
{
PMI_BOOL initialized;
int spawned;
int rc, ret = OPAL_ERROR;
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(&pmi_vallen_max);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_value_length_max");
goto err_exit;
}
rc = PMI_KVS_Get_name_length_max(&pmi_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(&pmi_keylen_max);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_KVS_Get_key_length_max");
goto err_exit;
}
// Initialize job environment information
rc = PMI_Get_rank(&pmi_rank);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_rank");
return OPAL_ERROR;
}
rc = PMI_Get_universe_size(&pmi_usize);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_universe_size");
goto err_exit;
}
rc = PMI_Get_size(&pmi_size);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_size");
goto err_exit;
}
rc = PMI_Get_appnum(&pmi_appnum);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI_Get_appnum");
goto err_exit;
}
pmi_kvs_name = (char*)malloc(pmi_kvslen_max);
if( pmi_kvs_name == NULL ){
ret = OPAL_ERR_OUT_OF_RESOURCE;
goto err_exit;
}
rc = PMI_KVS_Get_my_name(pmi_kvs_name,pmi_kvslen_max);
if( PMI_SUCCESS != rc ) {
OPAL_PMI_ERROR(rc, "PMI2_Job_GetId");
goto err_exit;
}
return OPAL_SUCCESS;
err_exit:
PMI_Finalize();
return ret;
}