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
2
3
4
5
6
7
8
9
10
11
12
13
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
66 rc = pmix1_convert_rc(status);
67
68
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
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
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
125 if (NULL != getenv(OPAL_MCA_PREFIX"orte_launch")) {
126
127
128 mca_pmix_ext1x_component.native_launch = true;
129 opal_convert_string_to_jobid(&pname.jobid, my_proc.nspace);
130 } else {
131
132
133 OPAL_HASH_JOBID(my_proc.nspace, pname.jobid);
134 }
135
136
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
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
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
186
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
192
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
210 rc = PMIx_Abort(flag, msg, parray, cnt);
211
212
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
228
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
238
239
240
241
242
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
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
295
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
301
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
330 rc = PMIx_Fence(parray, cnt, iptr, n);
331
332
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
357
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
363
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
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
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
445 *val = NULL;
446 if (NULL != proc) {
447
448
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
458 OPAL_LIST_FOREACH(ival, &mca_pmix_ext1x_component.values, opal_value_t) {
459 if (0 == strcmp(key, ival->key)) {
460
461 opal_dss.copy((void**)val, ival, OPAL_VALUE);
462 return OPAL_SUCCESS;
463 }
464 }
465
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
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
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
564 op = OBJ_NEW(pmix1_opcaddy_t);
565 op->valcbfunc = cbfunc;
566 op->cbdata = cbdata;
567
568 if (NULL != proc) {
569
570
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
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
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
729 n=0;
730 OPAL_LIST_FOREACH(d, data, opal_pmix_pdata_t) {
731 if (mca_pmix_ext1x_component.native_launch) {
732
733
734 opal_convert_string_to_jobid(&d->proc.jobid, pdata[n].proc.nspace);
735 } else {
736
737
738 OPAL_HASH_JOBID(pdata[n].proc.nspace, d->proc.jobid);
739 }
740
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
796
797 opal_convert_string_to_jobid(&d->proc.jobid, data[n].proc.nspace);
798 } else {
799
800
801 OPAL_HASH_JOBID(data[n].proc.nspace, d->proc.jobid);
802 }
803
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
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
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
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
974
975 opal_convert_string_to_jobid(jobid, nspace);
976 } else {
977
978
979 OPAL_HASH_JOBID(nspace, *jobid);
980 }
981
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
1007
1008 opal_convert_string_to_jobid(&jobid, nspace);
1009 } else {
1010
1011
1012 OPAL_HASH_JOBID(nspace, jobid);
1013 }
1014
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
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
1084 if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) {
1085 return OPAL_ERR_BAD_PARAM;
1086 }
1087
1088
1089
1090 PMIX_PROC_CREATE(parray, cnt);
1091 n=0;
1092 OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
1093
1094
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
1132 if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) {
1133 return OPAL_ERR_BAD_PARAM;
1134 }
1135
1136
1137 op = OBJ_NEW(pmix1_opcaddy_t);
1138 op->opcbfunc = cbfunc;
1139 op->cbdata = cbdata;
1140 op->nprocs = cnt;
1141
1142
1143
1144 PMIX_PROC_CREATE(op->procs, op->nprocs);
1145 n=0;
1146 OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
1147
1148
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
1177 if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) {
1178 return OPAL_ERR_BAD_PARAM;
1179 }
1180
1181
1182
1183 PMIX_PROC_CREATE(parray, cnt);
1184 n=0;
1185 OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
1186
1187
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
1219 if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) {
1220 return OPAL_ERR_BAD_PARAM;
1221 }
1222
1223
1224 op = OBJ_NEW(pmix1_opcaddy_t);
1225 op->opcbfunc = cbfunc;
1226 op->cbdata = cbdata;
1227 op->nprocs = cnt;
1228
1229
1230
1231 PMIX_PROC_CREATE(op->procs, op->nprocs);
1232 n=0;
1233 OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) {
1234
1235
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
1292
1293 opal_convert_string_to_jobid(&nm->name.jobid, array[n].nspace);
1294 } else {
1295
1296
1297 OPAL_HASH_JOBID(array[n].nspace, nm->name.jobid);
1298 }
1299
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
1329
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 }