This source file includes following definitions.
- PMI2_Init
- PMI2_Initialized
- PMI2_Finalize
- PMI2_Abort
- PMI2_Job_Spawn
- PMI2_Job_GetId
- PMI2_Job_GetRank
- PMI2_Info_GetSize
- PMI2_Job_Connect
- PMI2_Job_Disconnect
- PMI2_KVS_Put
- PMI2_KVS_Fence
- PMI2_KVS_Get
- PMI2_Info_GetNodeAttr
- PMI2_Info_GetNodeAttrIntArray
- PMI2_Info_PutNodeAttr
- PMI2_Info_GetJobAttr
- PMI2_Info_GetJobAttrIntArray
- PMI2_Nameserv_publish
- PMI2_Nameserv_lookup
- PMI2_Nameserv_unpublish
- convert_int
- convert_err
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 #include <src/include/pmix_config.h>
16
17 #ifdef HAVE_STRING_H
18 #include <string.h>
19 #endif
20 #ifdef HAVE_UNISTD_H
21 #include <unistd.h>
22 #endif
23 #ifdef HAVE_STDLIB_H
24 #include <stdlib.h>
25 #endif
26 #include PMIX_EVENT_HEADER
27
28 #include <pmi2.h>
29 #include <pmix.h>
30
31 #include "src/mca/bfrops/bfrops.h"
32 #include "src/util/argv.h"
33 #include "src/util/error.h"
34 #include "src/util/output.h"
35 #include "src/include/pmix_globals.h"
36
37 #define ANL_MAPPING "PMI_process_mapping"
38
39 #define PMI2_CHECK() \
40 do { \
41 if (!pmi2_init) { \
42 return PMI2_FAIL; \
43 } \
44 } while (0)
45
46
47 static pmix_status_t convert_int(int *value, pmix_value_t *kv);
48 static int convert_err(pmix_status_t rc);
49 static pmix_proc_t myproc;
50 static int pmi2_init = 0;
51 static bool commit_reqd = false;
52 static bool pmi2_singleton = false;
53
54 PMIX_EXPORT int PMI2_Init(int *spawned, int *size, int *rank, int *appnum)
55 {
56 pmix_status_t rc = PMIX_SUCCESS;
57 pmix_value_t *val;
58 pmix_info_t info[1];
59 bool val_optinal = 1;
60 pmix_proc_t proc = myproc;
61 proc.rank = PMIX_RANK_WILDCARD;
62
63 if (PMIX_SUCCESS != (rc = PMIx_Init(&myproc, NULL, 0))) {
64
65
66 if (PMIX_ERR_INVALID_NAMESPACE == rc) {
67 if (NULL != spawned) {
68 *spawned = 0;
69 }
70 if (NULL != size) {
71 *size = 1;
72 }
73 if (NULL != rank) {
74 *rank = 0;
75 }
76 if (NULL != appnum) {
77 *appnum = 0;
78 }
79 pmi2_singleton = true;
80 pmix_strncpy(myproc.nspace, "1234", PMIX_MAX_NSLEN);
81 myproc.rank = 0;
82 pmi2_init = 1;
83 return PMI2_SUCCESS;
84 }
85 return PMI2_ERR_INIT;
86 }
87
88
89 *rank = myproc.rank;
90
91
92
93
94 PMIX_INFO_CONSTRUCT(&info[0]);
95 PMIX_INFO_LOAD(&info[0], PMIX_OPTIONAL, &val_optinal, PMIX_BOOL);
96
97 if (NULL != size) {
98
99
100
101
102 if (PMIX_SUCCESS == PMIx_Get(&proc, PMIX_UNIV_SIZE, info, 1, &val)) {
103 rc = convert_int(size, val);
104 PMIX_VALUE_RELEASE(val);
105 if (PMIX_SUCCESS != rc) {
106 goto error;
107 }
108 } else {
109
110 rc = PMIX_ERR_INIT;
111 goto error;
112 }
113 }
114
115 if (NULL != spawned) {
116
117 if (PMIX_SUCCESS == PMIx_Get(&proc, PMIX_SPAWNED, info, 1, &val)) {
118 rc = convert_int(spawned, val);
119 PMIX_VALUE_RELEASE(val);
120 if (PMIX_SUCCESS != rc) {
121 goto error;
122 }
123 } else {
124
125 *spawned = 0;
126 }
127 }
128
129 if (NULL != appnum) {
130
131 if (PMIX_SUCCESS == PMIx_Get(&proc, PMIX_APPNUM, info, 1, &val)) {
132 rc = convert_int(appnum, val);
133 PMIX_VALUE_RELEASE(val);
134 if (PMIX_SUCCESS != rc) {
135 goto error;
136 }
137 } else {
138
139 *appnum = 0;
140 }
141 }
142 pmi2_init = 1;
143
144 rc = PMIX_SUCCESS;
145
146 error:
147 PMIX_INFO_DESTRUCT(&info[0]);
148
149 return convert_err(rc);
150 }
151
152 PMIX_EXPORT int PMI2_Initialized(void)
153 {
154 int initialized;
155 if (pmi2_singleton) {
156 return 1;
157 }
158
159 initialized = (int)PMIx_Initialized();
160 return initialized;
161 }
162
163 PMIX_EXPORT int PMI2_Finalize(void)
164 {
165 pmix_status_t rc = PMIX_SUCCESS;
166
167 PMI2_CHECK();
168
169 pmi2_init = 0;
170 if (pmi2_singleton) {
171 return PMI2_SUCCESS;
172 }
173
174 rc = PMIx_Finalize(NULL, 0);
175 return convert_err(rc);
176 }
177
178 PMIX_EXPORT int PMI2_Abort(int flag, const char msg[])
179 {
180 pmix_status_t rc = PMIX_SUCCESS;
181
182 PMI2_CHECK();
183
184 if (pmi2_singleton) {
185 return PMI2_SUCCESS;
186 }
187
188 rc = PMIx_Abort(flag, msg, NULL, 0);
189 return convert_err(rc);
190 }
191
192 PMIX_EXPORT int PMI2_Job_Spawn(int count, const char * cmds[],
193 int argcs[], const char ** argvs[],
194 const int maxprocs[],
195 const int info_keyval_sizes[],
196 const PMI_keyval_t *info_keyval_vectors[],
197 int preput_keyval_size,
198 const PMI_keyval_t *preput_keyval_vector[],
199 char jobId[], int jobIdSize,
200 int errors[])
201 {
202 pmix_status_t rc = PMIX_SUCCESS;
203 pmix_app_t *apps;
204 int i, k;
205 size_t j;
206 char *evar;
207
208 PMI2_CHECK();
209
210 if (NULL == cmds) {
211 return PMI2_ERR_INVALID_ARGS;
212 }
213
214 if (pmi2_singleton) {
215 return PMI2_FAIL;
216 }
217
218
219 PMIX_APP_CREATE(apps, count);
220 for (i=0; i < count; i++) {
221 apps[i].cmd = strdup(cmds[i]);
222 apps[i].maxprocs = maxprocs[i];
223 apps[i].argv = pmix_argv_copy((char**)argvs[i]);
224 apps[i].ninfo = info_keyval_sizes[i];
225 apps[i].info = (pmix_info_t*)malloc(apps[i].ninfo * sizeof(pmix_info_t));
226
227 for (j=0; j < apps[i].ninfo; j++) {
228 pmix_strncpy(apps[i].info[j].key, info_keyval_vectors[i][j].key, PMIX_MAX_KEYLEN);
229 apps[i].info[j].value.type = PMIX_STRING;
230 apps[i].info[j].value.data.string = strdup(info_keyval_vectors[i][j].val);
231 }
232
233 for (k=0; k < preput_keyval_size; k++) {
234 if (0 > asprintf(&evar, "%s=%s", preput_keyval_vector[j]->key, preput_keyval_vector[j]->val)) {
235 for (i = 0; i < count; i++) {
236 PMIX_APP_DESTRUCT(&apps[i]);
237 }
238 free(apps);
239 return PMIX_ERR_NOMEM;
240 }
241 pmix_argv_append_nosize(&apps[i].env, evar);
242 free(evar);
243 }
244 }
245
246 rc = PMIx_Spawn(NULL, 0, apps, count, NULL);
247
248 for (i=0; i < count; i++) {
249 PMIX_APP_DESTRUCT(&apps[i]);
250 }
251 free(apps);
252 if (NULL != errors) {
253 for (i=0; i < count; i++) {
254 errors[i] = convert_err(rc);
255 }
256 }
257
258 return convert_err(rc);
259 }
260
261 PMIX_EXPORT int PMI2_Job_GetId(char jobid[], int jobid_size)
262 {
263
264
265
266 PMI2_CHECK();
267
268
269 if (NULL == jobid) {
270 return PMI2_ERR_INVALID_ARGS;
271 }
272 pmix_strncpy(jobid, myproc.nspace, jobid_size-1);
273 return PMI2_SUCCESS;
274 }
275
276 PMIX_EXPORT int PMI2_Job_GetRank(int *rank)
277 {
278 PMI2_CHECK();
279
280 if (NULL == rank) {
281 return PMI2_ERR_INVALID_ARGS;
282 }
283 *rank = myproc.rank;
284 return PMI2_SUCCESS;
285 }
286
287 PMIX_EXPORT int PMI2_Info_GetSize(int *size)
288 {
289 pmix_status_t rc = PMIX_ERROR;
290 pmix_value_t *val;
291 pmix_info_t info[1];
292 bool val_optinal = 1;
293 pmix_proc_t proc = myproc;
294 proc.rank = PMIX_RANK_WILDCARD;
295
296
297 PMI2_CHECK();
298
299 if (NULL == size) {
300 return PMI2_ERR_INVALID_ARGS;
301 }
302
303 if (pmi2_singleton) {
304 *size = 1;
305 return PMI2_SUCCESS;
306 }
307
308
309
310
311 PMIX_INFO_CONSTRUCT(&info[0]);
312 PMIX_INFO_LOAD(&info[0], PMIX_OPTIONAL, &val_optinal, PMIX_BOOL);
313
314 if (PMIX_SUCCESS == PMIx_Get(&proc, PMIX_LOCAL_SIZE, info, 1, &val)) {
315 rc = convert_int(size, val);
316 PMIX_VALUE_RELEASE(val);
317 }
318
319 PMIX_INFO_DESTRUCT(&info[0]);
320
321 return convert_err(rc);
322 }
323
324 PMIX_EXPORT int PMI2_Job_Connect(const char jobid[], PMI2_Connect_comm_t *conn)
325 {
326 pmix_status_t rc = PMIX_SUCCESS;
327 pmix_proc_t proc;
328
329 PMI2_CHECK();
330
331 if (NULL == conn) {
332 return PMI2_ERR_INVALID_ARGS;
333 }
334
335 if (pmi2_singleton) {
336 return PMI2_FAIL;
337 }
338
339 memset(proc.nspace, 0, sizeof(proc.nspace));
340 pmix_strncpy(proc.nspace, (jobid ? jobid : proc.nspace), PMIX_MAX_NSLEN);
341 proc.rank = PMIX_RANK_WILDCARD;
342 rc = PMIx_Connect(&proc, 1, NULL, 0);
343 return convert_err(rc);
344 }
345
346 PMIX_EXPORT int PMI2_Job_Disconnect(const char jobid[])
347 {
348 pmix_status_t rc = PMIX_SUCCESS;
349 pmix_proc_t proc;
350
351 PMI2_CHECK();
352
353 if (pmi2_singleton) {
354 return PMI2_SUCCESS;
355 }
356
357 memset(proc.nspace, 0, sizeof(proc.nspace));
358 pmix_strncpy(proc.nspace, (jobid ? jobid : proc.nspace), PMIX_MAX_NSLEN);
359 proc.rank = PMIX_RANK_WILDCARD;
360 rc = PMIx_Disconnect(&proc, 1, NULL, 0);
361 return convert_err(rc);
362 }
363
364
365 PMIX_EXPORT int PMI2_KVS_Put(const char key[], const char value[])
366 {
367 pmix_status_t rc = PMIX_SUCCESS;
368 pmix_value_t val;
369
370 PMI2_CHECK();
371
372 if ((NULL == key) || (NULL == value)) {
373 return PMI2_ERR_INVALID_ARG;
374 }
375
376 if (pmi2_singleton) {
377 return PMI2_SUCCESS;
378 }
379
380 pmix_output_verbose(3, pmix_globals.debug_output,
381 "PMI2_KVS_Put: key=%s value=%s", key, value);
382
383 val.type = PMIX_STRING;
384 val.data.string = (char*)value;
385 if (PMIX_SUCCESS == (rc = PMIx_Put(PMIX_GLOBAL, key, &val))) {
386 commit_reqd = true;
387 }
388 return convert_err(rc);
389 }
390
391
392 PMIX_EXPORT int PMI2_KVS_Fence(void)
393 {
394 pmix_status_t rc = PMIX_SUCCESS;
395
396 PMI2_CHECK();
397
398 pmix_output_verbose(3, pmix_globals.debug_output, "PMI2_KVS_Fence");
399
400 if (pmi2_singleton) {
401 return PMI2_SUCCESS;
402 }
403
404 if (PMIX_SUCCESS != (rc = PMIx_Commit())) {
405 return convert_err(rc);
406 }
407 commit_reqd = false;
408
409
410 {
411 pmix_info_t info[1];
412 bool val_data = 1;
413
414
415
416
417 PMIX_INFO_CONSTRUCT(&info[0]);
418 PMIX_INFO_LOAD(&info[0], PMIX_COLLECT_DATA, &val_data, PMIX_BOOL);
419
420 rc = PMIx_Fence(NULL, 0, &info[0], 1);
421 PMIX_INFO_DESTRUCT(&info[0]);
422 }
423
424 return convert_err(rc);
425 }
426
427
428
429
430
431
432 PMIX_EXPORT int PMI2_KVS_Get(const char *jobid, int src_pmi_id,
433 const char key[], char value [],
434 int maxvalue, int *vallen)
435 {
436 pmix_status_t rc = PMIX_SUCCESS;
437 pmix_value_t *val;
438 pmix_proc_t proc;
439
440 PMI2_CHECK();
441
442 if (commit_reqd) {
443
444 return PMI2_FAIL;
445 }
446
447 *vallen = 0;
448
449 if ((NULL == key) || (NULL == value)) {
450 return PMI2_ERR_INVALID_ARG;
451 }
452
453 pmix_output_verbose(3, pmix_globals.debug_output,
454 "PMI2_KVS_Get: key=%s jobid=%s src_pmi_id=%d", key, (jobid ? jobid : "null"), src_pmi_id);
455
456 pmix_strncpy(proc.nspace, (jobid ? jobid : myproc.nspace), PMIX_MAX_NSLEN);
457 if (src_pmi_id == PMI2_ID_NULL) {
458
459 proc.rank = PMIX_RANK_UNDEF;
460 } else {
461 proc.rank = src_pmi_id;
462 }
463
464 rc = PMIx_Get(&proc, key, NULL, 0, &val);
465 if (PMIX_SUCCESS == rc && NULL != val) {
466 if (PMIX_STRING != val->type) {
467 rc = PMIX_ERROR;
468 } else if (NULL != val->data.string) {
469 pmix_strncpy(value, val->data.string, maxvalue-1);
470 *vallen = strlen(val->data.string);
471 }
472 PMIX_VALUE_RELEASE(val);
473 }
474
475 return convert_err(rc);
476 }
477
478 PMIX_EXPORT int PMI2_Info_GetNodeAttr(const char name[],
479 char value[], int valuelen,
480 int *found, int waitfor)
481 {
482 pmix_status_t rc = PMIX_SUCCESS;
483 pmix_value_t *val;
484 pmix_info_t info[1];
485 bool val_optinal = 1;
486 pmix_proc_t proc = myproc;
487 proc.rank = PMIX_RANK_UNDEF;
488
489 PMI2_CHECK();
490
491 if ((NULL == name) || (NULL == value) || (NULL == found)) {
492 return PMI2_ERR_INVALID_ARG;
493 }
494
495 if (pmi2_singleton) {
496 return PMI2_FAIL;
497 }
498
499
500
501
502 PMIX_INFO_CONSTRUCT(&info[0]);
503 PMIX_INFO_LOAD(&info[0], PMIX_OPTIONAL, &val_optinal, PMIX_BOOL);
504
505 *found = 0;
506
507 rc = PMIx_Get(&proc, name, info, 1, &val);
508 if (PMIX_SUCCESS == rc && NULL != val) {
509 if (PMIX_STRING != val->type) {
510 rc = PMIX_ERROR;
511 } else if (NULL != val->data.string) {
512 pmix_strncpy(value, val->data.string, valuelen-1);
513 *found = 1;
514 }
515 PMIX_VALUE_RELEASE(val);
516 } else if (PMIX_ERR_NOT_FOUND == rc) {
517 rc = PMIX_SUCCESS;
518 }
519
520 PMIX_INFO_DESTRUCT(&info[0]);
521
522 return convert_err(rc);
523 }
524
525 PMIX_EXPORT int PMI2_Info_GetNodeAttrIntArray(const char name[], int array[],
526 int arraylen, int *outlen, int *found)
527 {
528 return PMI2_FAIL;
529 }
530
531
532 PMIX_EXPORT int PMI2_Info_PutNodeAttr(const char name[], const char value[])
533 {
534 pmix_status_t rc = PMIX_SUCCESS;
535 pmix_value_t val;
536
537 PMI2_CHECK();
538
539 if ((NULL == name) || (NULL == value)) {
540 return PMI2_ERR_INVALID_ARG;
541 }
542
543 if (pmi2_singleton) {
544 return PMI2_SUCCESS;
545 }
546
547 val.type = PMIX_STRING;
548 val.data.string = (char*)value;
549 rc = PMIx_Put(PMIX_LOCAL, name, &val);
550 return convert_err(rc);
551 }
552
553 PMIX_EXPORT int PMI2_Info_GetJobAttr(const char name[], char value[], int valuelen, int *found)
554 {
555 pmix_status_t rc = PMIX_SUCCESS;
556 pmix_value_t *val;
557 pmix_info_t info[1];
558 bool val_optinal = 1;
559 pmix_proc_t proc = myproc;
560 proc.rank = PMIX_RANK_UNDEF;
561
562 PMI2_CHECK();
563
564 if ((NULL == name) || (NULL == value) || (NULL == found)) {
565 return PMI2_ERR_INVALID_ARG;
566 }
567
568 if (pmi2_singleton) {
569 return PMI2_FAIL;
570 }
571
572
573
574
575 PMIX_INFO_CONSTRUCT(&info[0]);
576 PMIX_INFO_LOAD(&info[0], PMIX_OPTIONAL, &val_optinal, PMIX_BOOL);
577
578
579
580 if (!strcmp(name, ANL_MAPPING)) {
581
582
583 proc = myproc;
584 proc.rank = PMIX_RANK_WILDCARD;
585 if (PMIX_SUCCESS == PMIx_Get(&proc, PMIX_ANL_MAP, NULL, 0, &val) &&
586 (NULL != val) && (PMIX_STRING == val->type)) {
587 pmix_strncpy(value, val->data.string, valuelen);
588 PMIX_VALUE_FREE(val, 1);
589 *found = 1;
590 return PMI2_SUCCESS;
591 } else {
592
593
594
595
596
597
598
599 *found = 1;
600 return PMI2_FAIL;
601 }
602 }
603
604
605 *found = 0;
606 rc = PMIx_Get(&proc, name, info, 1, &val);
607 if (PMIX_SUCCESS == rc && NULL != val) {
608 if (PMIX_STRING != val->type) {
609 rc = PMIX_ERROR;
610 } else if (NULL != val->data.string) {
611 pmix_strncpy(value, val->data.string, valuelen-1);
612 *found = 1;
613 }
614 PMIX_VALUE_RELEASE(val);
615 } else if (PMIX_ERR_NOT_FOUND == rc) {
616 rc = PMIX_SUCCESS;
617 }
618
619 PMIX_INFO_DESTRUCT(&info[0]);
620
621 return convert_err(rc);
622 }
623
624 PMIX_EXPORT int PMI2_Info_GetJobAttrIntArray(const char name[],
625 int array[], int arraylen,
626 int *outlen, int *found)
627 {
628 return PMI2_FAIL;
629 }
630
631 PMIX_EXPORT int PMI2_Nameserv_publish(const char service_name[],
632 const PMI_keyval_t *info_ptr, const char port[])
633 {
634 pmix_status_t rc = PMIX_SUCCESS;
635 int nvals;
636 pmix_info_t info[2];
637
638 PMI2_CHECK();
639
640 if (NULL == service_name || NULL == port) {
641 return PMI2_ERR_INVALID_ARG;
642 }
643
644 if (pmi2_singleton) {
645 return PMI2_FAIL;
646 }
647
648
649 pmix_strncpy(info[0].key, service_name, PMIX_MAX_KEYLEN);
650 info[0].value.type = PMIX_STRING;
651 info[0].value.data.string = (char*)port;
652 nvals = 1;
653
654
655 if (NULL != info_ptr) {
656 pmix_strncpy(info[1].key, info_ptr->key, PMIX_MAX_KEYLEN);
657 info[1].value.type = PMIX_STRING;
658 info[1].value.data.string = (char*)info_ptr->val;
659 nvals = 2;
660 }
661
662
663 rc = PMIx_Publish(info, nvals);
664
665 return convert_err(rc);
666 }
667
668 PMIX_EXPORT int PMI2_Nameserv_lookup(const char service_name[],
669 const PMI_keyval_t *info_ptr,
670 char port[], int portLen)
671 {
672 pmix_status_t rc = PMIX_SUCCESS;
673 int nvals;
674 pmix_pdata_t pdata[2];
675
676 PMI2_CHECK();
677
678 if (NULL == service_name || NULL == info_ptr || NULL == port) {
679 return PMI2_ERR_INVALID_ARG;
680 }
681
682 if (pmi2_singleton) {
683 return PMI2_FAIL;
684 }
685
686 PMIX_PDATA_CONSTRUCT(&pdata[0]);
687 PMIX_PDATA_CONSTRUCT(&pdata[1]);
688
689
690 pmix_strncpy(pdata[0].key, service_name, PMIX_MAX_KEYLEN);
691 nvals = 1;
692
693
694 if (NULL != info_ptr) {
695 pmix_strncpy(pdata[1].key, info_ptr->key, PMIX_MAX_KEYLEN);
696 pdata[1].value.type = PMIX_STRING;
697 pdata[1].value.data.string = info_ptr->val;
698 nvals = 2;
699 }
700
701
702 if (PMIX_SUCCESS != (rc = PMIx_Lookup(pdata, nvals, NULL, 0))) {
703 PMIX_PDATA_DESTRUCT(&pdata[0]);
704 PMIX_PDATA_DESTRUCT(&pdata[1]);
705 return convert_err(rc);
706 }
707
708
709 if (PMIX_STRING != pdata[0].value.type ||
710 NULL == pdata[0].value.data.string) {
711 PMIX_PDATA_DESTRUCT(&pdata[0]);
712 PMIX_PDATA_DESTRUCT(&pdata[1]);
713 return PMI2_FAIL;
714 }
715
716
717 pmix_strncpy(port, pdata[0].value.data.string, portLen-1);
718 PMIX_PDATA_DESTRUCT(&pdata[0]);
719
720 if (NULL != info_ptr) {
721 }
722 PMIX_PDATA_DESTRUCT(&pdata[1]);
723
724 return PMI2_SUCCESS;
725 }
726
727 PMIX_EXPORT int PMI2_Nameserv_unpublish(const char service_name[],
728 const PMI_keyval_t *info_ptr)
729 {
730 pmix_status_t rc = PMIX_SUCCESS;
731 char *keys[3];
732
733 PMI2_CHECK();
734
735 if (NULL == service_name || NULL == info_ptr) {
736 return PMI2_ERR_INVALID_ARG;
737 }
738
739 if (pmi2_singleton) {
740 return PMI2_FAIL;
741 }
742
743
744 keys[0] = (char*)service_name;
745 keys[1] = NULL;
746 keys[2] = NULL;
747
748
749 if (NULL != info_ptr) {
750 keys[1] = info_ptr->key;
751 }
752
753 rc = PMIx_Unpublish(keys, NULL, 0);
754 return convert_err(rc);
755 }
756
757
758 static pmix_status_t convert_int(int *value, pmix_value_t *kv)
759 {
760 switch(kv->type) {
761 case PMIX_INT:
762 *value = kv->data.integer;
763 break;
764 case PMIX_INT8:
765 *value = kv->data.int8;
766 break;
767 case PMIX_INT16:
768 *value = kv->data.int16;
769 break;
770 case PMIX_INT32:
771 *value = kv->data.int32;
772 break;
773 case PMIX_INT64:
774 *value = kv->data.int64;
775 break;
776 case PMIX_UINT:
777 *value = kv->data.uint;
778 break;
779 case PMIX_UINT8:
780 *value = kv->data.uint8;
781 break;
782 case PMIX_UINT16:
783 *value = kv->data.uint16;
784 break;
785 case PMIX_UINT32:
786 *value = kv->data.uint32;
787 break;
788 case PMIX_UINT64:
789 *value = kv->data.uint64;
790 break;
791 case PMIX_BYTE:
792 *value = kv->data.byte;
793 break;
794 case PMIX_SIZE:
795 *value = kv->data.size;
796 break;
797 case PMIX_BOOL:
798 *value = kv->data.flag;
799 break;
800 default:
801
802 return PMIX_ERR_BAD_PARAM;
803 }
804 return PMIX_SUCCESS;
805 }
806
807 static int convert_err(pmix_status_t rc)
808 {
809 switch(rc) {
810 case PMIX_ERR_INVALID_SIZE:
811 return PMI2_ERR_INVALID_SIZE;
812
813 case PMIX_ERR_INVALID_KEYVALP:
814 return PMI2_ERR_INVALID_KEYVALP;
815
816 case PMIX_ERR_INVALID_NUM_PARSED:
817 return PMI2_ERR_INVALID_NUM_PARSED;
818
819 case PMIX_ERR_INVALID_ARGS:
820 return PMI2_ERR_INVALID_ARGS;
821
822 case PMIX_ERR_INVALID_NUM_ARGS:
823 return PMI2_ERR_INVALID_NUM_ARGS;
824
825 case PMIX_ERR_INVALID_LENGTH:
826 return PMI2_ERR_INVALID_LENGTH;
827
828 case PMIX_ERR_INVALID_VAL_LENGTH:
829 return PMI2_ERR_INVALID_VAL_LENGTH;
830
831 case PMIX_ERR_INVALID_VAL:
832 return PMI2_ERR_INVALID_VAL;
833
834 case PMIX_ERR_INVALID_KEY_LENGTH:
835 return PMI2_ERR_INVALID_KEY_LENGTH;
836
837 case PMIX_ERR_INVALID_KEY:
838 return PMI2_ERR_INVALID_KEY;
839
840 case PMIX_ERR_INVALID_ARG:
841 return PMI2_ERR_INVALID_ARG;
842
843 case PMIX_ERR_NOMEM:
844 return PMI2_ERR_NOMEM;
845
846 case PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER:
847 case PMIX_ERR_LOST_CONNECTION_TO_SERVER:
848 case PMIX_ERR_LOST_PEER_CONNECTION:
849 case PMIX_ERR_LOST_CONNECTION_TO_CLIENT:
850 case PMIX_ERR_NOT_SUPPORTED:
851 case PMIX_ERR_NOT_FOUND:
852 case PMIX_ERR_SERVER_NOT_AVAIL:
853 case PMIX_ERR_INVALID_NAMESPACE:
854 case PMIX_ERR_DATA_VALUE_NOT_FOUND:
855 case PMIX_ERR_OUT_OF_RESOURCE:
856 case PMIX_ERR_RESOURCE_BUSY:
857 case PMIX_ERR_BAD_PARAM:
858 case PMIX_ERR_IN_ERRNO:
859 case PMIX_ERR_UNREACH:
860 case PMIX_ERR_TIMEOUT:
861 case PMIX_ERR_NO_PERMISSIONS:
862 case PMIX_ERR_PACK_MISMATCH:
863 case PMIX_ERR_PACK_FAILURE:
864 case PMIX_ERR_UNPACK_FAILURE:
865 case PMIX_ERR_UNPACK_INADEQUATE_SPACE:
866 case PMIX_ERR_TYPE_MISMATCH:
867 case PMIX_ERR_PROC_ENTRY_NOT_FOUND:
868 case PMIX_ERR_UNKNOWN_DATA_TYPE:
869 case PMIX_ERR_WOULD_BLOCK:
870 case PMIX_EXISTS:
871 case PMIX_ERROR:
872 return PMI2_FAIL;
873
874 case PMIX_ERR_INIT:
875 return PMI2_ERR_INIT;
876
877 case PMIX_SUCCESS:
878 return PMI2_SUCCESS;
879 default:
880 return PMI2_FAIL;
881 }
882 }