opal/mca/pmix/ext1x/pmix1x

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
completion_handler
myerr
errreg_cbfunc
pmix1_client_init
pmix1_client_finalize
pmix1_initialized
pmix1_abort
pmix1_store_local
pmix1_commit
opcbfunc
pmix1_fence
pmix1_fencenb
pmix1_put
pmix1_get
val_cbfunc
pmix1_getnb
pmix1_publish
pmix1_publishnb
pmix1_lookup
lk_cbfunc
pmix1_lookupnb
pmix1_unpublish
pmix1_unpublishnb
pmix1_spawn
spcbfunc
pmix1_spawnnb
pmix1_connect
pmix1_connectnb
pmix1_disconnect
pmix1_disconnectnb
pmix1_resolve_peers
pmix1_resolve_nodes
   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2014-2018 Intel, Inc. All rights reserved.
   4  * Copyright (c) 2014-2018 Research Organization for Information Science
   5  *                         and Technology (RIST). All rights reserved.
   6  * Copyright (c) 2014-2015 Mellanox Technologies, Inc.
   7  *                         All rights reserved.
   8  * Copyright (c) 2016 Cisco Systems, Inc.  All rights reserved.
   9  * $COPYRIGHT$
  10  *
  11  * Additional copyrights may follow
  12  *
  13  * $HEADER$
  14  */
  15 
  16 #include "opal_config.h"
  17 #include "opal/constants.h"
  18 #include "opal/types.h"
  19 
  20 #ifdef HAVE_STRING_H
  21 #include <string.h>
  22 #endif
  23 #ifdef HAVE_UNISTD_H
  24 #include <unistd.h>
  25 #endif
  26 
  27 #include "opal/util/argv.h"
  28 #include "opal/util/proc.h"
  29 #include "opal/util/string_copy.h"
  30 
  31 #include "opal/mca/pmix/base/base.h"
  32 #include "pmix1x.h"
  33 #include "pmix.h"
  34 
  35 static pmix_proc_t my_proc;
  36 static char *dbgvalue=NULL;
  37 static int errhdler_ref = 0;
  38 
  39 #define PMIX_WAIT_FOR_COMPLETION(a)             \
  40     do {                                        \
  41         while ((a)) {                           \
  42             usleep(10);                         \
  43         }                                       \
  44     } while (0)
  45 
  46 
  47 static void completion_handler(int status, opal_list_t *results,
  48                                opal_pmix_op_cbfunc_t cbfunc, void *thiscbdata,
  49                                void *notification_cbdata) {
  50     int * cond = (int *)notification_cbdata;
  51     *cond = 0;
  52 }
  53 
  54 static void myerr(pmix_status_t status,
  55                   pmix_proc_t procs[], size_t nprocs,
  56                   pmix_info_t info[], size_t ninfo)
  57 {
  58     int rc;
  59     opal_list_t plist, ilist;
  60     opal_namelist_t *nm;
  61     opal_value_t *iptr;
  62     size_t n;
  63     volatile int cond = 1;
  64 
  65     /* convert the incoming status */
  66     rc = pmix1_convert_rc(status);
  67 
  68     /* convert the array of procs */
  69     OBJ_CONSTRUCT(&plist, opal_list_t);
  70     for (n=0; n < nprocs; n++) {
  71         nm = OBJ_NEW(opal_namelist_t);
  72         nm->name.jobid = strtoul(procs[n].nspace, NULL, 10);
  73         nm->name.vpid = procs[n].rank;
  74         opal_list_append(&plist, &nm->super);
  75     }
  76 
  77     /* convert the array of info */
  78     OBJ_CONSTRUCT(&ilist, opal_list_t);
  79     for (n=0; n < ninfo; n++) {
  80         iptr = OBJ_NEW(opal_value_t);
  81         iptr->key = strdup(info[n].key);
  82         pmix1_value_unload(iptr, &info[n].value);
  83         opal_list_append(&plist, &iptr->super);
  84     }
  85 
  86     /* call the base errhandler */
  87     opal_pmix_base_evhandler(rc, &OPAL_PROC_MY_NAME, &plist, &ilist, completion_handler, (void *)&cond);
  88     PMIX_WAIT_FOR_COMPLETION(cond);
  89 
  90     OPAL_LIST_DESTRUCT(&plist);
  91     OPAL_LIST_DESTRUCT(&ilist);
  92 }
  93 
  94 static void errreg_cbfunc (pmix_status_t status,
  95                            int errhandler_ref,
  96                            void *cbdata)
  97 {
  98     errhdler_ref = errhandler_ref;
  99     opal_output_verbose(5, opal_pmix_base_framework.framework_output,
 100                         "PMIX client errreg_cbfunc - error handler registered status=%d, reference=%d",
 101                         status, errhandler_ref);
 102 }
 103 
 104 int pmix1_client_init(opal_list_t *ilist)
 105 {
 106     opal_process_name_t pname;
 107     pmix_status_t rc;
 108     int dbg;
 109     opal_pmix1_jobid_trkr_t *job;
 110 
 111     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 112                         "PMIx_client init");
 113 
 114     if (0 < (dbg = opal_output_get_verbosity(opal_pmix_base_framework.framework_output))) {
 115         asprintf(&dbgvalue, "PMIX_DEBUG=%d", dbg);
 116         putenv(dbgvalue);
 117     }
 118 
 119     rc = PMIx_Init(&my_proc);
 120     if (PMIX_SUCCESS != rc) {
 121         return pmix1_convert_rc(rc);
 122     }
 123 
 124     /* store our jobid and rank */
 125     if (NULL != getenv(OPAL_MCA_PREFIX"orte_launch")) {
 126         /* if we were launched by the OMPI RTE, then
 127          * the jobid is in a special format - so get it */
 128         mca_pmix_ext1x_component.native_launch = true;
 129         opal_convert_string_to_jobid(&pname.jobid, my_proc.nspace);
 130     } else {
 131         /* we were launched by someone else, so make the
 132          * jobid just be the hash of the nspace */
 133         OPAL_HASH_JOBID(my_proc.nspace, pname.jobid);
 134     }
 135     /* insert this into our list of jobids - it will be the
 136      * first, and so we'll check it first */
 137     job = OBJ_NEW(opal_pmix1_jobid_trkr_t);
 138     (void)opal_string_copy(job->nspace, my_proc.nspace, PMIX_MAX_NSLEN);
 139     job->jobid = pname.jobid;
 140     opal_list_append(&mca_pmix_ext1x_component.jobids, &job->super);
 141 
 142     pname.vpid = my_proc.rank;
 143     opal_proc_set_name(&pname);
 144 
 145     /* register the errhandler */
 146     PMIx_Register_errhandler(NULL, 0, myerr, errreg_cbfunc, NULL );
 147     return OPAL_SUCCESS;
 148 
 149 }
 150 
 151 int pmix1_client_finalize(void)
 152 {
 153     pmix_status_t rc;
 154 
 155     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 156                         "PMIx_client finalize");
 157 
 158     /* deregister the errhandler */
 159     PMIx_Deregister_errhandler(errhdler_ref, NULL, NULL);
 160 
 161     rc = PMIx_Finalize();
 162     return pmix1_convert_rc(rc);
 163 }
 164 
 165 int pmix1_initialized(void)
 166 {
 167     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 168                         "PMIx_client initialized");
 169 
 170     return PMIx_Initialized();
 171 }
 172 
 173 int pmix1_abort(int flag, const char *msg,
 174                 opal_list_t *procs)
 175 {
 176     pmix_status_t rc;
 177     pmix_proc_t *parray=NULL;
 178     size_t n, cnt=0;
 179     opal_namelist_t *ptr;
 180     opal_pmix1_jobid_trkr_t *job, *jptr;
 181 
 182     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 183                         "PMIx_client abort");
 184 
 185     /* convert the list of procs to an array
 186      * of pmix_proc_t */
 187     if (NULL != procs && 0 < (cnt = opal_list_get_size(procs))) {
 188         PMIX_PROC_CREATE(parray, cnt);
 189         n=0;
 190         OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
 191             /* look thru our list of jobids and find the
 192              * corresponding nspace */
 193             job = NULL;
 194             OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
 195                 if (jptr->jobid == ptr->name.jobid) {
 196                     job = jptr;
 197                     break;
 198                 }
 199             }
 200             if (NULL == job) {
 201                 return OPAL_ERR_NOT_FOUND;
 202             }
 203             (void)opal_string_copy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN);
 204             parray[n].rank = ptr->name.vpid;
 205             ++n;
 206         }
 207     }
 208 
 209     /* call the library abort */
 210     rc = PMIx_Abort(flag, msg, parray, cnt);
 211 
 212     /* release the array */
 213     PMIX_PROC_FREE(parray, cnt);
 214 
 215     return pmix1_convert_rc(rc);
 216 }
 217 
 218 int pmix1_store_local(const opal_process_name_t *proc, opal_value_t *val)
 219 {
 220     pmix_value_t kv;
 221     pmix_status_t rc;
 222     pmix_proc_t p;
 223     opal_pmix1_jobid_trkr_t *job, *jptr;
 224     opal_value_t *hack;
 225 
 226     if (NULL != proc) {
 227         /* look thru our list of jobids and find the
 228          * corresponding nspace */
 229         job = NULL;
 230         OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
 231             if (jptr->jobid == proc->jobid) {
 232                 job = jptr;
 233                 break;
 234             }
 235         }
 236         if (NULL == job) {
 237             /* if we don't know about the job, then neither will the internal
 238              * storage routine in PMIx. In this older version of PMIx, there
 239              * is no way to insert an nspace into the client, and so we cannot
 240              * get around the problem there. Instead, we need to hold such
 241              * values locally in the component. Sadly, we cannot just use
 242              * the input val param as it might not be dynamic, so copy it here */
 243             opal_dss.copy((void**)&hack, val, OPAL_VALUE);
 244             opal_list_append(&mca_pmix_ext1x_component.values, &hack->super);
 245             return OPAL_SUCCESS;
 246         }
 247         (void)opal_string_copy(p.nspace, job->nspace, PMIX_MAX_NSLEN);
 248         p.rank = proc->vpid;
 249     } else {
 250         /* use our name */
 251         (void)opal_string_copy(p.nspace, my_proc.nspace, PMIX_MAX_NSLEN);
 252         p.rank = OPAL_PROC_MY_NAME.vpid;
 253     }
 254 
 255     PMIX_VALUE_CONSTRUCT(&kv);
 256     pmix1_value_load(&kv, val);
 257 
 258     rc = PMIx_Store_internal(&p, val->key, &kv);
 259     PMIX_VALUE_DESTRUCT(&kv);
 260 
 261     return pmix1_convert_rc(rc);
 262 }
 263 
 264 int pmix1_commit(void)
 265 {
 266     pmix_status_t rc;
 267 
 268     rc = PMIx_Commit();
 269     return pmix1_convert_rc(rc);
 270 }
 271 
 272 static void opcbfunc(pmix_status_t status, void *cbdata)
 273 {
 274     pmix1_opcaddy_t *op = (pmix1_opcaddy_t*)cbdata;
 275 
 276     if (NULL != op->opcbfunc) {
 277         op->opcbfunc(pmix1_convert_rc(status), op->cbdata);
 278     }
 279     OBJ_RELEASE(op);
 280 }
 281 
 282 int pmix1_fence(opal_list_t *procs, int collect_data)
 283 {
 284     pmix_status_t rc;
 285     pmix_proc_t *parray=NULL;
 286     size_t n, cnt=0;
 287     opal_namelist_t *ptr;
 288     pmix_info_t info, *iptr;
 289     opal_pmix1_jobid_trkr_t *job, *jptr;
 290 
 291     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 292                         "PMIx_client fence");
 293 
 294     /* convert the list of procs to an array
 295      * of pmix_proc_t */
 296     if (NULL != procs && 0 < (cnt = opal_list_get_size(procs))) {
 297         PMIX_PROC_CREATE(parray, cnt);
 298         n=0;
 299         OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
 300             /* look thru our list of jobids and find the
 301              * corresponding nspace */
 302             job = NULL;
 303             OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
 304                 if (jptr->jobid == ptr->name.jobid) {
 305                     job = jptr;
 306                     break;
 307                 }
 308             }
 309             if (NULL == job) {
 310                 return OPAL_ERR_NOT_FOUND;
 311             }
 312             (void)opal_string_copy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN);
 313             parray[n].rank = ptr->name.vpid;
 314             ++n;
 315         }
 316     }
 317     if (collect_data) {
 318         PMIX_INFO_CONSTRUCT(&info);
 319         (void)opal_string_copy(info.key, PMIX_COLLECT_DATA, PMIX_MAX_KEYLEN);
 320         info.value.type = PMIX_BOOL;
 321         info.value.data.flag = true;
 322         iptr = &info;
 323         n = 1;
 324     } else {
 325         iptr = NULL;
 326         n = 0;
 327     }
 328 
 329     /* call the library function */
 330     rc = PMIx_Fence(parray, cnt, iptr, n);
 331 
 332     /* release the array */
 333     PMIX_PROC_FREE(parray, cnt);
 334     if (NULL != iptr) {
 335         PMIX_INFO_DESTRUCT(&info);
 336     }
 337 
 338     return pmix1_convert_rc(rc);
 339 
 340 }
 341 
 342 int pmix1_fencenb(opal_list_t *procs, int collect_data,
 343                   opal_pmix_op_cbfunc_t cbfunc, void *cbdata)
 344 {
 345     pmix_status_t rc;
 346     pmix_proc_t *parray=NULL;
 347     size_t n, cnt=0;
 348     opal_namelist_t *ptr;
 349     pmix1_opcaddy_t *op;
 350     pmix_info_t info, *iptr;
 351     opal_pmix1_jobid_trkr_t *job, *jptr;
 352 
 353     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 354                         "PMIx_client fence_nb");
 355 
 356     /* convert the list of procs to an array
 357      * of pmix_proc_t */
 358     if (NULL != procs && 0 < (cnt = opal_list_get_size(procs))) {
 359         PMIX_PROC_CREATE(parray, cnt);
 360         n=0;
 361         OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
 362             /* look thru our list of jobids and find the
 363              * corresponding nspace */
 364             job = NULL;
 365             OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
 366                 if (jptr->jobid == ptr->name.jobid) {
 367                     job = jptr;
 368                     break;
 369                 }
 370             }
 371             if (NULL == job) {
 372                 return OPAL_ERR_NOT_FOUND;
 373             }
 374             (void)opal_string_copy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN);
 375             parray[n].rank = ptr->name.vpid;
 376             ++n;
 377         }
 378     }
 379 
 380     if (collect_data) {
 381         PMIX_INFO_CONSTRUCT(&info);
 382         (void)opal_string_copy(info.key, PMIX_COLLECT_DATA, PMIX_MAX_KEYLEN);
 383         info.value.type = PMIX_BOOL;
 384         info.value.data.flag = true;
 385         iptr = &info;
 386         n = 1;
 387     } else {
 388         iptr = NULL;
 389         n = 0;
 390     }
 391 
 392     /* create the caddy */
 393     op = OBJ_NEW(pmix1_opcaddy_t);
 394     op->opcbfunc = cbfunc;
 395     op->cbdata = cbdata;
 396     op->procs = parray;
 397     op->nprocs = cnt;
 398 
 399     /* call the library function */
 400     rc = PMIx_Fence_nb(parray, cnt, iptr, n, opcbfunc, op);
 401     if (PMIX_SUCCESS != rc) {
 402         OBJ_RELEASE(op);
 403     }
 404 
 405     return pmix1_convert_rc(rc);
 406 
 407 }
 408 
 409 int pmix1_put(opal_pmix_scope_t opal_scope,
 410               opal_value_t *val)
 411 {
 412     pmix_value_t kv;
 413     pmix_scope_t pmix_scope = pmix1_convert_opalscope(opal_scope);
 414     pmix_status_t rc;
 415 
 416     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 417                         "PMIx_client put");
 418 
 419     PMIX_VALUE_CONSTRUCT(&kv);
 420     pmix1_value_load(&kv, val);
 421 
 422     rc = PMIx_Put(pmix_scope, val->key, &kv);
 423     PMIX_VALUE_DESTRUCT(&kv);
 424     return pmix1_convert_rc(rc);
 425 }
 426 
 427 int pmix1_get(const opal_process_name_t *proc, const char *key,
 428               opal_list_t *info, opal_value_t **val)
 429 {
 430     int ret;
 431     pmix_value_t *kv;
 432     pmix_status_t rc;
 433     pmix_proc_t p, *pptr;
 434     size_t ninfo, n;
 435     pmix_info_t *pinfo;
 436     opal_value_t *ival;
 437     opal_pmix1_jobid_trkr_t *job, *jptr;
 438 
 439     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 440                         "%s PMIx_client get on proc %s key %s",
 441                         OPAL_NAME_PRINT(OPAL_PROC_MY_NAME),
 442                         (NULL == proc) ? "NULL" : OPAL_NAME_PRINT(*proc), key);
 443 
 444     /* prep default response */
 445     *val = NULL;
 446     if (NULL != proc) {
 447         /* look thru our list of jobids and find the
 448          * corresponding nspace */
 449         job = NULL;
 450         OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
 451             if (jptr->jobid == proc->jobid) {
 452                 job = jptr;
 453                 break;
 454             }
 455         }
 456         if (NULL == job) {
 457             /* see if we have this key on our local value list */
 458             OPAL_LIST_FOREACH(ival, &mca_pmix_ext1x_component.values, opal_value_t) {
 459                 if (0 == strcmp(key, ival->key)) {
 460                     /* got it */
 461                     opal_dss.copy((void**)val, ival, OPAL_VALUE);
 462                     return OPAL_SUCCESS;
 463                 }
 464             }
 465             /* otherwise, we can't find it */
 466             return OPAL_ERR_NOT_FOUND;
 467         }
 468         (void)opal_string_copy(p.nspace, job->nspace, PMIX_MAX_NSLEN);
 469         if (OPAL_VPID_WILDCARD == proc->vpid) {
 470             p.rank = my_proc.rank;
 471         } else {
 472             p.rank = proc->vpid;
 473         }
 474         pptr = &p;
 475     } else {
 476         /* if they are asking for our jobid, then return it */
 477         if (0 == strcmp(key, OPAL_PMIX_JOBID)) {
 478             (*val) = OBJ_NEW(opal_value_t);
 479             (*val)->type = OPAL_UINT32;
 480             (*val)->data.uint32 = OPAL_PROC_MY_NAME.jobid;
 481             return OPAL_SUCCESS;
 482         } else if (0 == strcmp(key, OPAL_PMIX_RANK)) {
 483             (*val) = OBJ_NEW(opal_value_t);
 484             (*val)->type = OPAL_INT;
 485             (*val)->data.integer = my_proc.rank;
 486             return OPAL_SUCCESS;
 487         }
 488         pptr = NULL;
 489     }
 490 
 491     if (NULL != info && 0 < (ninfo = opal_list_get_size(info))) {
 492         PMIX_INFO_CREATE(pinfo, ninfo);
 493         n=0;
 494         OPAL_LIST_FOREACH(ival, info, opal_value_t) {
 495             if (0 == strcmp(ival->key, OPAL_PMIX_IMMEDIATE)) {
 496                 (void)opal_string_copy(pinfo[n].key, OPAL_PMIX_OPTIONAL, PMIX_MAX_KEYLEN);
 497                 pmix1_value_load(&pinfo[n].value, ival);
 498             } else {
 499                 (void)opal_string_copy(pinfo[n].key, ival->key, PMIX_MAX_KEYLEN);
 500                 pmix1_value_load(&pinfo[n].value, ival);
 501             }
 502             ++n;
 503         }
 504     } else {
 505         pinfo = NULL;
 506         ninfo = 0;
 507     }
 508 
 509     /* pass the request down */
 510     rc = PMIx_Get(pptr, key, pinfo, ninfo, &kv);
 511     if (PMIX_SUCCESS == rc) {
 512         if (NULL == kv) {
 513             ret = OPAL_SUCCESS;
 514         } else {
 515             *val = OBJ_NEW(opal_value_t);
 516             if (NULL != key) {
 517                 (*val)->key = strdup(key);
 518             }
 519             ret = pmix1_value_unload(*val, kv);
 520             PMIX_VALUE_FREE(kv, 1);
 521         }
 522     } else {
 523         ret = pmix1_convert_rc(rc);
 524     }
 525     PMIX_INFO_FREE(pinfo, ninfo);
 526     return ret;
 527 }
 528 
 529 static void val_cbfunc(pmix_status_t status,
 530                        pmix_value_t *kv, void *cbdata)
 531 {
 532     pmix1_opcaddy_t *op = (pmix1_opcaddy_t*)cbdata;
 533     int rc;
 534     opal_value_t val, *v=NULL;
 535 
 536     rc = pmix1_convert_opalrc(status);
 537     if (PMIX_SUCCESS == status && NULL != kv) {
 538         rc = pmix1_value_unload(&val, kv);
 539         v = &val;
 540     }
 541 
 542     if (NULL != op->valcbfunc) {
 543         op->valcbfunc(rc, v, op->cbdata);
 544     }
 545     OBJ_RELEASE(op);
 546 }
 547 
 548 int pmix1_getnb(const opal_process_name_t *proc, const char *key,
 549                 opal_list_t *info,
 550                 opal_pmix_value_cbfunc_t cbfunc, void *cbdata)
 551 {
 552     pmix1_opcaddy_t *op;
 553     pmix_status_t rc;
 554     size_t n;
 555     opal_value_t *ival;
 556     opal_pmix1_jobid_trkr_t *job, *jptr;
 557 
 558     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 559                         "%s PMIx_client get_nb on proc %s key %s",
 560                         OPAL_NAME_PRINT(OPAL_PROC_MY_NAME),
 561                         (NULL == proc) ? "NULL" : OPAL_NAME_PRINT(*proc), key);
 562 
 563     /* create the caddy */
 564     op = OBJ_NEW(pmix1_opcaddy_t);
 565     op->valcbfunc = cbfunc;
 566     op->cbdata = cbdata;
 567 
 568     if (NULL != proc) {
 569         /* look thru our list of jobids and find the
 570          * corresponding nspace */
 571         job = NULL;
 572         OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
 573             if (jptr->jobid == proc->jobid) {
 574                 job = jptr;
 575                 break;
 576             }
 577         }
 578         if (NULL == job) {
 579             return OPAL_ERR_NOT_FOUND;
 580         }
 581         (void)opal_string_copy(op->p.nspace, job->nspace, PMIX_MAX_NSLEN);
 582         op->p.rank = proc->vpid;
 583     } else {
 584         (void)opal_string_copy(op->p.nspace, my_proc.nspace, PMIX_MAX_NSLEN);
 585         op->p.rank = PMIX_RANK_WILDCARD;
 586     }
 587 
 588     if (NULL != info && 0 < (op->sz = opal_list_get_size(info))) {
 589         PMIX_INFO_CREATE(op->info, op->sz);
 590         n=0;
 591         OPAL_LIST_FOREACH(ival, info, opal_value_t) {
 592             if (0 == strcmp(ival->key, OPAL_PMIX_IMMEDIATE)) {
 593                 (void)opal_string_copy(op->info[n].key, OPAL_PMIX_OPTIONAL, PMIX_MAX_KEYLEN);
 594                 pmix1_value_load(&op->info[n].value, ival);
 595             } else {
 596                 (void)opal_string_copy(op->info[n].key, ival->key, PMIX_MAX_KEYLEN);
 597                 pmix1_value_load(&op->info[n].value, ival);
 598             }
 599             ++n;
 600         }
 601     }
 602 
 603     /* call the library function */
 604     rc = PMIx_Get_nb(&op->p, key, op->info, op->sz, val_cbfunc, op);
 605     if (PMIX_SUCCESS != rc) {
 606         OBJ_RELEASE(op);
 607     }
 608 
 609     return pmix1_convert_rc(rc);
 610 }
 611 
 612 int pmix1_publish(opal_list_t *info)
 613 {
 614     pmix_info_t *pinfo;
 615     pmix_status_t ret;
 616     opal_value_t *iptr;
 617     size_t sz, n;
 618 
 619     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 620                         "PMIx_client publish");
 621 
 622     if (NULL == info) {
 623         return OPAL_ERR_BAD_PARAM;
 624     }
 625 
 626     sz = opal_list_get_size(info);
 627     if (0 < sz) {
 628         PMIX_INFO_CREATE(pinfo, sz);
 629         n=0;
 630         OPAL_LIST_FOREACH(iptr, info, opal_value_t) {
 631             (void)opal_string_copy(pinfo[n].key, iptr->key, PMIX_MAX_KEYLEN);
 632             pmix1_value_load(&pinfo[n].value, iptr);
 633             ++n;
 634         }
 635     } else {
 636         pinfo = NULL;
 637     }
 638 
 639     ret = PMIx_Publish(pinfo, sz);
 640     if (0 < sz) {
 641         PMIX_INFO_FREE(pinfo, sz);
 642     }
 643 
 644     return pmix1_convert_rc(ret);
 645 }
 646 
 647 int pmix1_publishnb(opal_list_t *info,
 648                     opal_pmix_op_cbfunc_t cbfunc, void *cbdata)
 649 {
 650     pmix_status_t ret;
 651     opal_value_t *iptr;
 652     size_t n;
 653     pmix1_opcaddy_t *op;
 654 
 655     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 656                         "PMIx_client publish_nb");
 657 
 658     if (NULL == info) {
 659         return OPAL_ERR_BAD_PARAM;
 660     }
 661 
 662     /* create the caddy */
 663     op = OBJ_NEW(pmix1_opcaddy_t);
 664     op->opcbfunc = cbfunc;
 665     op->cbdata = cbdata;
 666 
 667     op->sz = opal_list_get_size(info);
 668     if (0 < op->sz) {
 669         PMIX_INFO_CREATE(op->info, op->sz);
 670         n=0;
 671         OPAL_LIST_FOREACH(iptr, info, opal_value_t) {
 672             (void)opal_string_copy(op->info[n].key, iptr->key, PMIX_MAX_KEYLEN);
 673             pmix1_value_load(&op->info[n].value, iptr);
 674             ++n;
 675         }
 676     }
 677 
 678     ret = PMIx_Publish_nb(op->info, op->sz, opcbfunc, op);
 679     if (0 < op->sz) {
 680         PMIX_INFO_FREE(op->info, op->sz);
 681     }
 682 
 683     return pmix1_convert_rc(ret);
 684 }
 685 
 686 int pmix1_lookup(opal_list_t *data, opal_list_t *info)
 687 {
 688     pmix_pdata_t *pdata;
 689     pmix_info_t *pinfo;
 690     size_t sz, ninfo, n;
 691     int rc;
 692     pmix_status_t ret;
 693     opal_pmix_pdata_t *d;
 694     opal_value_t *iptr;
 695     opal_pmix1_jobid_trkr_t *job, *jptr;
 696 
 697     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 698                         "PMIx_client lookup");
 699 
 700     if (NULL == data) {
 701         return OPAL_ERR_BAD_PARAM;
 702     }
 703 
 704     sz = opal_list_get_size(data);
 705     PMIX_PDATA_CREATE(pdata, sz);
 706     n=0;
 707     OPAL_LIST_FOREACH(d, data, opal_pmix_pdata_t) {
 708         (void)opal_string_copy(pdata[n++].key, d->value.key, PMIX_MAX_KEYLEN);
 709     }
 710 
 711     if (NULL != info && (0 < (ninfo = opal_list_get_size(info)))) {
 712         PMIX_INFO_CREATE(pinfo, ninfo);
 713         n=0;
 714         OPAL_LIST_FOREACH(iptr, info, opal_value_t) {
 715             (void)opal_string_copy(pinfo[n].key, iptr->key, PMIX_MAX_KEYLEN);
 716             pmix1_value_load(&pinfo[n].value, iptr);
 717             ++n;
 718         }
 719     } else {
 720         pinfo = NULL;
 721         ninfo = 0;
 722     }
 723 
 724     ret = PMIx_Lookup(pdata, sz, pinfo, ninfo);
 725     PMIX_INFO_FREE(pinfo, ninfo);
 726 
 727     if (PMIX_SUCCESS == ret) {
 728         /* transfer the data back */
 729         n=0;
 730         OPAL_LIST_FOREACH(d, data, opal_pmix_pdata_t) {
 731             if (mca_pmix_ext1x_component.native_launch) {
 732                 /* if we were launched by the OMPI RTE, then
 733                  * the jobid is in a special format - so get it */
 734                 opal_convert_string_to_jobid(&d->proc.jobid, pdata[n].proc.nspace);
 735             } else {
 736                 /* we were launched by someone else, so make the
 737                  * jobid just be the hash of the nspace */
 738                 OPAL_HASH_JOBID(pdata[n].proc.nspace, d->proc.jobid);
 739             }
 740             /* if we don't already have it, add this to our jobid tracker */
 741             job = NULL;
 742             OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
 743                 if (jptr->jobid == d->proc.jobid) {
 744                     job = jptr;
 745                     break;
 746                 }
 747             }
 748             if (NULL == job) {
 749                 job = OBJ_NEW(opal_pmix1_jobid_trkr_t);
 750                 (void)opal_string_copy(job->nspace, pdata[n].proc.nspace, PMIX_MAX_NSLEN);
 751                 job->jobid = d->proc.jobid;
 752                 opal_list_append(&mca_pmix_ext1x_component.jobids, &job->super);
 753             }
 754             if (PMIX_RANK_WILDCARD == pdata[n].proc.rank) {
 755                 d->proc.vpid = OPAL_VPID_WILDCARD;
 756             } else {
 757                 d->proc.vpid = pdata[n].proc.rank;
 758             }
 759             rc = pmix1_value_unload(&d->value, &pdata[n].value);
 760             if (OPAL_SUCCESS != rc) {
 761                 OPAL_ERROR_LOG(rc);
 762                 PMIX_PDATA_FREE(pdata, sz);
 763                 return OPAL_ERR_BAD_PARAM;
 764             }
 765             ++n;
 766         }
 767     }
 768 
 769     return pmix1_convert_rc(ret);
 770 }
 771 
 772 static void lk_cbfunc(pmix_status_t status,
 773                       pmix_pdata_t data[], size_t ndata,
 774                       void *cbdata)
 775 {
 776     pmix1_opcaddy_t *op = (pmix1_opcaddy_t*)cbdata;
 777     opal_pmix_pdata_t *d;
 778     opal_list_t results, *r = NULL;
 779     int rc;
 780     size_t n;
 781     opal_pmix1_jobid_trkr_t *job, *jptr;
 782 
 783     if (NULL == op->lkcbfunc) {
 784         OBJ_RELEASE(op);
 785         return;
 786     }
 787 
 788     rc = pmix1_convert_rc(status);
 789     if (OPAL_SUCCESS == rc) {
 790         OBJ_CONSTRUCT(&results, opal_list_t);
 791         for (n=0; n < ndata; n++) {
 792             d = OBJ_NEW(opal_pmix_pdata_t);
 793             opal_list_append(&results, &d->super);
 794             if (mca_pmix_ext1x_component.native_launch) {
 795                 /* if we were launched by the OMPI RTE, then
 796                  * the jobid is in a special format - so get it */
 797                 opal_convert_string_to_jobid(&d->proc.jobid, data[n].proc.nspace);
 798             } else {
 799                 /* we were launched by someone else, so make the
 800                  * jobid just be the hash of the nspace */
 801                 OPAL_HASH_JOBID(data[n].proc.nspace, d->proc.jobid);
 802             }
 803             /* if we don't already have it, add this to our jobid tracker */
 804             job = NULL;
 805             OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
 806                 if (jptr->jobid == d->proc.jobid) {
 807                     job = jptr;
 808                     break;
 809                 }
 810             }
 811             if (NULL == job) {
 812                 job = OBJ_NEW(opal_pmix1_jobid_trkr_t);
 813                 (void)opal_string_copy(job->nspace, data[n].proc.nspace, PMIX_MAX_NSLEN);
 814                 job->jobid = d->proc.jobid;
 815                 opal_list_append(&mca_pmix_ext1x_component.jobids, &job->super);
 816             }
 817             if (PMIX_RANK_WILDCARD == data[n].proc.rank) {
 818                 d->proc.vpid = OPAL_VPID_WILDCARD;
 819             } else {
 820                 d->proc.vpid = data[n].proc.rank;
 821             }
 822             d->value.key = strdup(data[n].key);
 823             rc = pmix1_value_unload(&d->value, &data[n].value);
 824             if (OPAL_SUCCESS != rc) {
 825                 rc = OPAL_ERR_BAD_PARAM;
 826                 OPAL_ERROR_LOG(rc);
 827                 goto release;
 828             }
 829         }
 830         r = &results;
 831     }
 832 release:
 833     /* execute the callback */
 834     op->lkcbfunc(rc, r, op->cbdata);
 835 
 836     if (NULL != r) {
 837         OPAL_LIST_DESTRUCT(&results);
 838     }
 839     OBJ_RELEASE(op);
 840 }
 841 
 842 int pmix1_lookupnb(char **keys, opal_list_t *info,
 843                    opal_pmix_lookup_cbfunc_t cbfunc, void *cbdata)
 844 {
 845     pmix_status_t ret;
 846     pmix1_opcaddy_t *op;
 847     opal_value_t *iptr;
 848     size_t n;
 849 
 850 
 851     opal_output_verbose(1, opal_pmix_base_framework.framework_output,
 852                         "PMIx_client lookup_nb");
 853 
 854     /* create the caddy */
 855     op = OBJ_NEW(pmix1_opcaddy_t);
 856     op->lkcbfunc = cbfunc;
 857     op->cbdata = cbdata;
 858 
 859     if (NULL != info && 0 < (op->sz = opal_list_get_size(info))) {
 860         PMIX_INFO_CREATE(op->info, op->sz);
 861         n=0;
 862         OPAL_LIST_FOREACH(iptr, info, opal_value_t) {
 863             (void)opal_string_copy(op->info[n].key, iptr->key, PMIX_MAX_KEYLEN);
 864             pmix1_value_load(&op->info[n].value, iptr);
 865             ++n;
 866         }
 867     }
 868 
 869     ret = PMIx_Lookup_nb(keys, op->info, op->sz, lk_cbfunc, op);
 870 
 871     return pmix1_convert_rc(ret);
 872 }
 873 
 874 int pmix1_unpublish(char **keys, opal_list_t *info)
 875 {
 876     pmix_status_t ret;
 877     size_t ninfo, n;
 878     pmix_info_t *pinfo;
 879     opal_value_t *iptr;
 880 
 881     if (NULL != info && 0 < (ninfo = opal_list_get_size(info))) {
 882         PMIX_INFO_CREATE(pinfo, ninfo);
 883         n=0;
 884         OPAL_LIST_FOREACH(iptr, info, opal_value_t) {
 885             (void)opal_string_copy(pinfo[n].key, iptr->key, PMIX_MAX_KEYLEN);
 886             pmix1_value_load(&pinfo[n].value, iptr);
 887             ++n;
 888         }
 889     } else {
 890         pinfo = NULL;
 891         ninfo = 0;
 892     }
 893 
 894     ret = PMIx_Unpublish(keys, pinfo, ninfo);
 895     PMIX_INFO_FREE(pinfo, ninfo);
 896 
 897     return pmix1_convert_rc(ret);
 898 }
 899 
 900 int pmix1_unpublishnb(char **keys, opal_list_t *info,
 901                       opal_pmix_op_cbfunc_t cbfunc, void *cbdata)
 902 {
 903     pmix_status_t ret;
 904     pmix1_opcaddy_t *op;
 905     opal_value_t *iptr;
 906     size_t n;
 907 
 908     /* create the caddy */
 909     op = OBJ_NEW(pmix1_opcaddy_t);
 910     op->opcbfunc = cbfunc;
 911     op->cbdata = cbdata;
 912 
 913     if (NULL != info && 0 < (op->sz = opal_list_get_size(info))) {
 914         PMIX_INFO_CREATE(op->info, op->sz);
 915         n=0;
 916         OPAL_LIST_FOREACH(iptr, info, opal_value_t) {
 917             (void)opal_string_copy(op->info[n].key, iptr->key, PMIX_MAX_KEYLEN);
 918             pmix1_value_load(&op->info[n].value, iptr);
 919             ++n;
 920         }
 921     }
 922 
 923     ret = PMIx_Unpublish_nb(keys, op->info, op->sz, opcbfunc, op);
 924 
 925     return pmix1_convert_rc(ret);
 926 }
 927 
 928 int pmix1_spawn(opal_list_t *job_info, opal_list_t *apps, opal_jobid_t *jobid)
 929 {
 930     pmix_status_t ret;
 931     pmix_info_t *pinfo = NULL;
 932     pmix_app_t *papps;
 933     size_t napps, n, m, ninfo = 0;
 934     char nspace[PMIX_MAX_NSLEN+1];
 935     opal_value_t *info;
 936     opal_pmix_app_t *app;
 937     opal_pmix1_jobid_trkr_t *job;
 938 
 939     if (NULL != job_info && 0 < (ninfo = opal_list_get_size(job_info))) {
 940         PMIX_INFO_CREATE(pinfo, ninfo);
 941         n=0;
 942         OPAL_LIST_FOREACH(info, job_info, opal_value_t) {
 943             (void)opal_string_copy(pinfo[n].key, info->key, PMIX_MAX_KEYLEN);
 944             pmix1_value_load(&pinfo[n].value, info);
 945             ++n;
 946         }
 947     }
 948 
 949     napps = opal_list_get_size(apps);
 950     PMIX_APP_CREATE(papps, napps);
 951     n=0;
 952     OPAL_LIST_FOREACH(app, apps, opal_pmix_app_t) {
 953         papps[n].cmd = strdup(app->cmd);
 954         papps[n].argc = opal_argv_count(app->argv);
 955         papps[n].argv = opal_argv_copy(app->argv);
 956         papps[n].env = opal_argv_copy(app->env);
 957         papps[n].maxprocs = app->maxprocs;
 958         if (0 < (papps[n].ninfo = opal_list_get_size(&app->info))) {
 959             PMIX_INFO_CREATE(papps[n].info, papps[n].ninfo);
 960             m=0;
 961             OPAL_LIST_FOREACH(info, &app->info, opal_value_t) {
 962                 (void)opal_string_copy(papps[n].info[m].key, info->key, PMIX_MAX_KEYLEN);
 963                 pmix1_value_load(&papps[n].info[m].value, info);
 964                 ++m;
 965             }
 966         }
 967         ++n;
 968     }
 969 
 970     ret = PMIx_Spawn(pinfo, ninfo, papps, napps, nspace);
 971     if (PMIX_SUCCESS == ret) {
 972         if (mca_pmix_ext1x_component.native_launch) {
 973             /* if we were launched by the OMPI RTE, then
 974              * the jobid is in a special format - so get it */
 975             opal_convert_string_to_jobid(jobid, nspace);
 976         } else {
 977             /* we were launched by someone else, so make the
 978              * jobid just be the hash of the nspace */
 979             OPAL_HASH_JOBID(nspace, *jobid);
 980         }
 981         /* add this to our jobid tracker */
 982         job = OBJ_NEW(opal_pmix1_jobid_trkr_t);
 983         (void)opal_string_copy(job->nspace, nspace, PMIX_MAX_NSLEN);
 984         job->jobid = *jobid;
 985         opal_list_append(&mca_pmix_ext1x_component.jobids, &job->super);
 986     }
 987     if (0 < ninfo) {
 988         PMIX_INFO_FREE(pinfo, ninfo);
 989     }
 990     PMIX_APP_FREE(papps, napps);
 991 
 992     return pmix1_convert_rc(ret);
 993 }
 994 
 995 static void spcbfunc(pmix_status_t status,
 996                      char *nspace, void *cbdata)
 997 {
 998     pmix1_opcaddy_t *op = (pmix1_opcaddy_t*)cbdata;
 999     int rc;
1000     opal_jobid_t jobid=OPAL_JOBID_INVALID;
1001     opal_pmix1_jobid_trkr_t *job;
1002 
1003     rc = pmix1_convert_rc(status);
1004     if (PMIX_SUCCESS == status) {
1005         if (mca_pmix_ext1x_component.native_launch) {
1006             /* if we were launched by the OMPI RTE, then
1007              * the jobid is in a special format - so get it */
1008             opal_convert_string_to_jobid(&jobid, nspace);
1009         } else {
1010             /* we were launched by someone else, so make the
1011              * jobid just be the hash of the nspace */
1012             OPAL_HASH_JOBID(nspace, jobid);
1013         }
1014         /* add this to our jobid tracker */
1015         job = OBJ_NEW(opal_pmix1_jobid_trkr_t);
1016         (void)opal_string_copy(job->nspace, nspace, PMIX_MAX_NSLEN);
1017         job->jobid = jobid;
1018         opal_list_append(&mca_pmix_ext1x_component.jobids, &job->super);
1019     }
1020 
1021     op->spcbfunc(rc, jobid, op->cbdata);
1022     OBJ_RELEASE(op);
1023 }
1024 
1025 int pmix1_spawnnb(opal_list_t *job_info, opal_list_t *apps,
1026                   opal_pmix_spawn_cbfunc_t cbfunc, void *cbdata)
1027 {
1028     pmix_status_t ret;
1029     pmix1_opcaddy_t *op;
1030     size_t n, m;
1031     opal_value_t *info;
1032     opal_pmix_app_t *app;
1033 
1034     /* create the caddy */
1035     op = OBJ_NEW(pmix1_opcaddy_t);
1036     op->spcbfunc = cbfunc;
1037     op->cbdata = cbdata;
1038 
1039     if (NULL != job_info && 0 < (op->ninfo = opal_list_get_size(job_info))) {
1040         PMIX_INFO_CREATE(op->info, op->ninfo);
1041         n=0;
1042         OPAL_LIST_FOREACH(info, job_info, opal_value_t) {
1043             (void)opal_string_copy(op->info[n].key, info->key, PMIX_MAX_KEYLEN);
1044             pmix1_value_load(&op->info[n].value, info);
1045             ++n;
1046         }
1047     }
1048 
1049     op->sz = opal_list_get_size(apps);
1050     PMIX_APP_CREATE(op->apps, op->sz);
1051     n=0;
1052     OPAL_LIST_FOREACH(app, apps, opal_pmix_app_t) {
1053         op->apps[n].cmd = strdup(app->cmd);
1054         op->apps[n].argc = opal_argv_count(app->argv);
1055         op->apps[n].argv = opal_argv_copy(app->argv);
1056         op->apps[n].env = opal_argv_copy(app->env);
1057         op->apps[n].maxprocs = app->maxprocs;
1058         if (0 < (op->apps[n].ninfo = opal_list_get_size(&app->info))) {
1059             PMIX_INFO_CREATE(op->apps[n].info, op->apps[n].ninfo);
1060             m=0;
1061             OPAL_LIST_FOREACH(info, &app->info, opal_value_t) {
1062                 (void)opal_string_copy(op->apps[n].info[m].key, info->key, PMIX_MAX_KEYLEN);
1063                 pmix1_value_load(&op->apps[n].info[m].value, info);
1064                 ++m;
1065             }
1066         }
1067         ++n;
1068     }
1069 
1070     ret = PMIx_Spawn_nb(op->info, op->ninfo, op->apps, op->sz, spcbfunc, op);
1071 
1072     return pmix1_convert_rc(ret);
1073 }
1074 
1075 int pmix1_connect(opal_list_t *procs)
1076 {
1077     pmix_status_t ret;
1078     pmix_proc_t *parray=NULL;
1079     size_t n, cnt=0;
1080     opal_namelist_t *ptr;
1081     opal_pmix1_jobid_trkr_t *job, *jptr;
1082 
1083     /* protect against bozo error */
1084     if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) {
1085         return OPAL_ERR_BAD_PARAM;
1086     }
1087 
1088     /* convert the list of procs to an array
1089      * of pmix_proc_t */
1090     PMIX_PROC_CREATE(parray, cnt);
1091     n=0;
1092     OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
1093         /* look thru our list of jobids and find the
1094      * corresponding nspace */
1095         job = NULL;
1096         OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
1097             if (jptr->jobid == ptr->name.jobid) {
1098                 job = jptr;
1099                 break;
1100             }
1101         }
1102         if (NULL == job) {
1103             OPAL_ERROR_LOG(OPAL_ERR_NOT_FOUND);
1104             return OPAL_ERR_NOT_FOUND;
1105         }
1106         (void)opal_string_copy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN);
1107         if (OPAL_VPID_WILDCARD == ptr->name.vpid) {
1108             parray[n].rank = PMIX_RANK_WILDCARD;
1109         } else {
1110             parray[n].rank = ptr->name.vpid;
1111         }
1112         ++n;
1113     }
1114 
1115     ret = PMIx_Connect(parray, cnt, NULL, 0);
1116     PMIX_PROC_FREE(parray, cnt);
1117 
1118     return pmix1_convert_rc(ret);
1119 }
1120 
1121 int pmix1_connectnb(opal_list_t *procs,
1122                     opal_pmix_op_cbfunc_t cbfunc,
1123                     void *cbdata)
1124 {
1125     pmix_status_t ret;
1126     size_t n, cnt=0;
1127     opal_namelist_t *ptr;
1128     pmix1_opcaddy_t *op;
1129     opal_pmix1_jobid_trkr_t *job;
1130 
1131     /* protect against bozo error */
1132     if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) {
1133         return OPAL_ERR_BAD_PARAM;
1134     }
1135 
1136     /* create the caddy */
1137     op = OBJ_NEW(pmix1_opcaddy_t);
1138     op->opcbfunc = cbfunc;
1139     op->cbdata = cbdata;
1140     op->nprocs = cnt;
1141 
1142     /* convert the list of procs to an array
1143      * of pmix_proc_t */
1144     PMIX_PROC_CREATE(op->procs, op->nprocs);
1145     n=0;
1146     OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
1147         /* look thru our list of jobids and find the
1148      * corresponding nspace */
1149         OPAL_LIST_FOREACH(job, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
1150             if (job->jobid == ptr->name.jobid) {
1151                 (void)opal_string_copy(op->procs[n].nspace, job->nspace, PMIX_MAX_NSLEN);
1152                 break;
1153             }
1154         }
1155         if (OPAL_VPID_WILDCARD == ptr->name.vpid) {
1156             op->procs[n].rank = PMIX_RANK_WILDCARD;
1157         } else {
1158             op->procs[n].rank = ptr->name.vpid;
1159         }
1160         ++n;
1161     }
1162 
1163     ret = PMIx_Connect_nb(op->procs, op->nprocs, NULL, 0, opcbfunc, op);
1164 
1165     return pmix1_convert_rc(ret);
1166 }
1167 
1168 int pmix1_disconnect(opal_list_t *procs)
1169 {
1170     pmix_status_t ret;
1171     pmix_proc_t *parray=NULL;
1172     size_t n, cnt=0;
1173     opal_namelist_t *ptr;
1174     opal_pmix1_jobid_trkr_t *job;
1175 
1176     /* protect against bozo error */
1177     if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) {
1178         return OPAL_ERR_BAD_PARAM;
1179     }
1180 
1181     /* convert the list of procs to an array
1182      * of pmix_proc_t */
1183     PMIX_PROC_CREATE(parray, cnt);
1184     n=0;
1185     OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
1186         /* look thru our list of jobids and find the
1187      * corresponding nspace */
1188         OPAL_LIST_FOREACH(job, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
1189             if (job->jobid == ptr->name.jobid) {
1190                 (void)opal_string_copy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN);
1191                 break;
1192             }
1193         }
1194         if (OPAL_VPID_WILDCARD == ptr->name.vpid) {
1195             parray[n].rank = PMIX_RANK_WILDCARD;
1196         } else {
1197             parray[n].rank = ptr->name.vpid;
1198         }
1199         ++n;
1200     }
1201 
1202     ret = PMIx_Disconnect(parray, cnt, NULL, 0);
1203     PMIX_PROC_FREE(parray, cnt);
1204 
1205     return pmix1_convert_rc(ret);
1206 }
1207 
1208 int pmix1_disconnectnb(opal_list_t *procs,
1209                        opal_pmix_op_cbfunc_t cbfunc,
1210                        void *cbdata)
1211 {
1212     pmix_status_t ret;
1213     size_t n, cnt=0;
1214     opal_namelist_t *ptr;
1215     pmix1_opcaddy_t *op;
1216     opal_pmix1_jobid_trkr_t *job;
1217 
1218     /* protect against bozo error */
1219     if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) {
1220         return OPAL_ERR_BAD_PARAM;
1221     }
1222 
1223     /* create the caddy */
1224     op = OBJ_NEW(pmix1_opcaddy_t);
1225     op->opcbfunc = cbfunc;
1226     op->cbdata = cbdata;
1227     op->nprocs = cnt;
1228 
1229     /* convert the list of procs to an array
1230      * of pmix_proc_t */
1231     PMIX_PROC_CREATE(op->procs, op->nprocs);
1232     n=0;
1233     OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
1234         /* look thru our list of jobids and find the
1235      * corresponding nspace */
1236         OPAL_LIST_FOREACH(job, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
1237             if (job->jobid == ptr->name.jobid) {
1238                 (void)opal_string_copy(op->procs[n].nspace, job->nspace, PMIX_MAX_NSLEN);
1239                 break;
1240             }
1241         }
1242         if (OPAL_VPID_WILDCARD == ptr->name.vpid) {
1243             op->procs[n].rank = PMIX_RANK_WILDCARD;
1244         } else {
1245             op->procs[n].rank = ptr->name.vpid;
1246         }
1247         ++n;
1248     }
1249 
1250     ret = PMIx_Disconnect_nb(op->procs, op->nprocs, NULL, 0, opcbfunc, op);
1251 
1252     return pmix1_convert_rc(ret);
1253 }
1254 
1255 
1256 int pmix1_resolve_peers(const char *nodename, opal_jobid_t jobid,
1257                         opal_list_t *procs)
1258 {
1259     char *nspace;
1260     pmix_proc_t *array=NULL;
1261     size_t nprocs, n;
1262     opal_namelist_t *nm;
1263     int rc;
1264     pmix_status_t ret;
1265     opal_pmix1_jobid_trkr_t *job, *jptr;
1266 
1267     if (OPAL_JOBID_WILDCARD == jobid) {
1268         nspace = NULL;
1269     } else {
1270         job = NULL;
1271         OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
1272             if (jptr->jobid == jobid) {
1273                 job = jptr;
1274                 break;
1275             }
1276         }
1277         if (NULL == job) {
1278             return OPAL_ERR_NOT_FOUND;
1279         }
1280         nspace = job->nspace;
1281     }
1282 
1283     ret = PMIx_Resolve_peers(nodename, nspace, &array, &nprocs);
1284     rc = pmix1_convert_rc(ret);
1285 
1286     if (NULL != array && 0 < nprocs) {
1287         for (n=0; n < nprocs; n++) {
1288             nm = OBJ_NEW(opal_namelist_t);
1289             opal_list_append(procs, &nm->super);
1290             if (mca_pmix_ext1x_component.native_launch) {
1291                 /* if we were launched by the OMPI RTE, then
1292                  * the jobid is in a special format - so get it */
1293                 opal_convert_string_to_jobid(&nm->name.jobid, array[n].nspace);
1294             } else {
1295                 /* we were launched by someone else, so make the
1296                  * jobid just be the hash of the nspace */
1297                 OPAL_HASH_JOBID(array[n].nspace, nm->name.jobid);
1298             }
1299             /* if we don't already have it, add this to our jobid tracker */
1300             job = NULL;
1301             OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
1302                 if (jptr->jobid == nm->name.jobid) {
1303                     job = jptr;
1304                     break;
1305                 }
1306             }
1307             if (NULL == job) {
1308                 job = OBJ_NEW(opal_pmix1_jobid_trkr_t);
1309                 (void)opal_string_copy(job->nspace, nspace, PMIX_MAX_NSLEN);
1310                 job->jobid = jobid;
1311                 opal_list_append(&mca_pmix_ext1x_component.jobids, &job->super);
1312             }
1313             nm->name.vpid = array[n].rank;
1314         }
1315     }
1316     PMIX_PROC_FREE(array, nprocs);
1317 
1318     return rc;
1319 }
1320 
1321 int pmix1_resolve_nodes(opal_jobid_t jobid, char **nodelist)
1322 {
1323     pmix_status_t ret;
1324     char *nspace=NULL;
1325     opal_pmix1_jobid_trkr_t *job, *jptr;
1326 
1327     if (OPAL_JOBID_WILDCARD != jobid) {
1328         /* look thru our list of jobids and find the
1329          * corresponding nspace */
1330         job = NULL;
1331         OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
1332             if (jptr->jobid == jobid) {
1333                 job = jptr;
1334                 break;
1335             }
1336         }
1337         if (NULL == job) {
1338             return OPAL_ERR_NOT_FOUND;
1339         }
1340         nspace = job->nspace;
1341     }
1342 
1343     ret = PMIx_Resolve_nodes(nspace, nodelist);
1344 
1345     return pmix1_convert_rc(ret);;
1346 }
/* [<][>][^][v][top][bottom][index][help] */
root/opal/mca/pmix/ext1x/pmix1x_client.c

DEFINITIONS
