This source file includes following definitions.
- legacy_get
- pmix1_get_nspace
- pmix1_register_jobid
- pmix1_convert_opalrc
- pmix1_convert_rc
- pmix1_convert_opalscope
- pmix1_value_load
- pmix1_value_unload
- opcon
- opdes
- ocadcon
- ocaddes
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/dss/dss.h"
28 #include "opal/mca/event/event.h"
29 #include "opal/mca/hwloc/base/base.h"
30 #include "opal/runtime/opal.h"
31 #include "opal/runtime/opal_progress_threads.h"
32 #include "opal/util/argv.h"
33 #include "opal/util/error.h"
34 #include "opal/util/output.h"
35 #include "opal/util/proc.h"
36 #include "opal/util/show_help.h"
37 #include "opal/util/string_copy.h"
38
39 #include "pmix1x.h"
40 #include "opal/mca/pmix/base/base.h"
41 #include "opal/mca/pmix/pmix_types.h"
42
43 #include <pmix/pmix_common.h>
44
45
46
47
48
49
50 static const char *pmix1_get_nspace(opal_jobid_t jobid);
51 static void pmix1_register_jobid(opal_jobid_t jobid, const char *nspace);
52 static bool legacy_get(void)
53 {
54 return true;
55 }
56
57 const opal_pmix_base_module_t opal_pmix_ext1x_module = {
58 .legacy_get = legacy_get,
59
60 .init = pmix1_client_init,
61 .finalize = pmix1_client_finalize,
62 .initialized = pmix1_initialized,
63 .abort = pmix1_abort,
64 .commit = pmix1_commit,
65 .fence = pmix1_fence,
66 .fence_nb = pmix1_fencenb,
67 .put = pmix1_put,
68 .get = pmix1_get,
69 .get_nb = pmix1_getnb,
70 .publish = pmix1_publish,
71 .publish_nb = pmix1_publishnb,
72 .lookup = pmix1_lookup,
73 .lookup_nb = pmix1_lookupnb,
74 .unpublish = pmix1_unpublish,
75 .unpublish_nb = pmix1_unpublishnb,
76 .spawn = pmix1_spawn,
77 .spawn_nb = pmix1_spawnnb,
78 .connect = pmix1_connect,
79 .connect_nb = pmix1_connectnb,
80 .disconnect = pmix1_disconnect,
81 .disconnect_nb = pmix1_disconnectnb,
82 .resolve_peers = pmix1_resolve_peers,
83 .resolve_nodes = pmix1_resolve_nodes,
84
85 .server_init = pmix1_server_init,
86 .server_finalize = pmix1_server_finalize,
87 .generate_regex = pmix1_server_gen_regex,
88 .generate_ppn = pmix1_server_gen_ppn,
89 .server_register_nspace = pmix1_server_register_nspace,
90 .server_deregister_nspace = pmix1_server_deregister_nspace,
91 .server_register_client = pmix1_server_register_client,
92 .server_deregister_client = pmix1_server_deregister_client,
93 .server_setup_fork = pmix1_server_setup_fork,
94 .server_dmodex_request = pmix1_server_dmodex,
95 .server_notify_event = pmix1_server_notify_error,
96
97 .get_version = PMIx_Get_version,
98 .register_evhandler = opal_pmix_base_register_handler,
99 .deregister_evhandler = opal_pmix_base_deregister_handler,
100 .store_local = pmix1_store_local,
101 .get_nspace = pmix1_get_nspace,
102 .register_jobid = pmix1_register_jobid
103 };
104
105 static const char *pmix1_get_nspace(opal_jobid_t jobid)
106 {
107 opal_pmix1_jobid_trkr_t *jptr;
108
109 OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
110 if (jptr->jobid == jobid) {
111 return jptr->nspace;
112 }
113 }
114 return NULL;
115 }
116
117 static void pmix1_register_jobid(opal_jobid_t jobid, const char *nspace)
118 {
119 opal_pmix1_jobid_trkr_t *jptr;
120
121
122 OPAL_LIST_FOREACH(jptr, &mca_pmix_ext1x_component.jobids, opal_pmix1_jobid_trkr_t) {
123 if (jptr->jobid == jobid) {
124 return;
125 }
126 }
127 jptr = OBJ_NEW(opal_pmix1_jobid_trkr_t);
128 (void)opal_string_copy(jptr->nspace, nspace, PMIX_MAX_NSLEN);
129 jptr->jobid = jobid;
130 opal_list_append(&mca_pmix_ext1x_component.jobids, &jptr->super);
131 }
132
133 pmix_status_t pmix1_convert_opalrc(int rc)
134 {
135 switch (rc) {
136 case OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER:
137 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
138 case OPAL_ERR_COMM_FAILURE:
139 return PMIX_ERR_COMM_FAILURE;
140 case OPAL_ERR_NOT_IMPLEMENTED:
141 return PMIX_ERR_NOT_IMPLEMENTED;
142 case OPAL_ERR_NOT_SUPPORTED:
143 return PMIX_ERR_NOT_SUPPORTED;
144 case OPAL_ERR_NOT_FOUND:
145 return PMIX_ERR_NOT_FOUND;
146 case OPAL_ERR_SERVER_NOT_AVAIL:
147 return PMIX_ERR_SERVER_NOT_AVAIL;
148
149 case OPAL_ERR_BAD_PARAM:
150 return PMIX_ERR_BAD_PARAM;
151 case OPAL_ERR_OUT_OF_RESOURCE:
152 return PMIX_ERR_NOMEM;
153
154 case OPAL_ERR_DATA_VALUE_NOT_FOUND:
155 return PMIX_ERR_DATA_VALUE_NOT_FOUND;
156 case OPAL_ERR_IN_ERRNO:
157 return PMIX_ERR_IN_ERRNO;
158 case OPAL_ERR_UNREACH:
159 return PMIX_ERR_UNREACH;
160 case OPAL_ERR_TIMEOUT:
161 return PMIX_ERR_TIMEOUT;
162 case OPAL_ERR_PERM:
163 return PMIX_ERR_NO_PERMISSIONS;
164 case OPAL_ERR_PACK_MISMATCH:
165 return PMIX_ERR_PACK_MISMATCH;
166 case OPAL_ERR_PACK_FAILURE:
167 return PMIX_ERR_PACK_FAILURE;
168
169 case OPAL_ERR_UNPACK_FAILURE:
170 return PMIX_ERR_UNPACK_FAILURE;
171 case OPAL_ERR_UNPACK_INADEQUATE_SPACE:
172 return PMIX_ERR_UNPACK_INADEQUATE_SPACE;
173 case OPAL_ERR_TYPE_MISMATCH:
174 return PMIX_ERR_TYPE_MISMATCH;
175 case OPAL_ERR_PROC_ENTRY_NOT_FOUND:
176 return PMIX_ERR_PROC_ENTRY_NOT_FOUND;
177 case OPAL_ERR_UNKNOWN_DATA_TYPE:
178 return PMIX_ERR_UNKNOWN_DATA_TYPE;
179 case OPAL_ERR_WOULD_BLOCK:
180 return PMIX_ERR_WOULD_BLOCK;
181 case OPAL_EXISTS:
182 return PMIX_EXISTS;
183
184 case OPAL_ERR_SILENT:
185 return PMIX_ERR_SILENT;
186 case OPAL_ERROR:
187 return PMIX_ERROR;
188 case OPAL_SUCCESS:
189 case OPAL_OPERATION_SUCCEEDED:
190 return PMIX_SUCCESS;
191 default:
192 return PMIX_ERROR;
193 }
194 }
195
196 int pmix1_convert_rc(pmix_status_t rc)
197 {
198 switch (rc) {
199 case PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER:
200 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
201 case PMIX_ERR_COMM_FAILURE:
202 return OPAL_ERR_COMM_FAILURE;
203 case PMIX_ERR_NOT_IMPLEMENTED:
204 return OPAL_ERR_NOT_IMPLEMENTED;
205 case PMIX_ERR_NOT_SUPPORTED:
206 return OPAL_ERR_NOT_SUPPORTED;
207 case PMIX_ERR_NOT_FOUND:
208 return OPAL_ERR_NOT_FOUND;
209 case PMIX_ERR_SERVER_NOT_AVAIL:
210 return OPAL_ERR_SERVER_NOT_AVAIL;
211
212 case PMIX_ERR_INVALID_NAMESPACE:
213 case PMIX_ERR_INVALID_SIZE:
214 case PMIX_ERR_INVALID_KEYVALP:
215 case PMIX_ERR_INVALID_NUM_PARSED:
216 case PMIX_ERR_INVALID_ARGS:
217 case PMIX_ERR_INVALID_NUM_ARGS:
218 case PMIX_ERR_INVALID_LENGTH:
219 case PMIX_ERR_INVALID_VAL_LENGTH:
220 case PMIX_ERR_INVALID_VAL:
221 case PMIX_ERR_INVALID_KEY_LENGTH:
222 case PMIX_ERR_INVALID_KEY:
223 case PMIX_ERR_INVALID_ARG:
224 return OPAL_ERR_BAD_PARAM;
225 case PMIX_ERR_NOMEM:
226 return OPAL_ERR_OUT_OF_RESOURCE;
227 case PMIX_ERR_INIT:
228 return OPAL_ERROR;
229
230 case PMIX_ERR_DATA_VALUE_NOT_FOUND:
231 return OPAL_ERR_DATA_VALUE_NOT_FOUND;
232 case PMIX_ERR_OUT_OF_RESOURCE:
233 return OPAL_ERR_OUT_OF_RESOURCE;
234 case PMIX_ERR_RESOURCE_BUSY:
235 return OPAL_ERR_TEMP_OUT_OF_RESOURCE;
236 case PMIX_ERR_BAD_PARAM:
237 return OPAL_ERR_BAD_PARAM;
238 case PMIX_ERR_IN_ERRNO:
239 return OPAL_ERR_IN_ERRNO;
240 case PMIX_ERR_UNREACH:
241 return OPAL_ERR_UNREACH;
242 case PMIX_ERR_TIMEOUT:
243 return OPAL_ERR_TIMEOUT;
244 case PMIX_ERR_NO_PERMISSIONS:
245 return OPAL_ERR_PERM;
246 case PMIX_ERR_PACK_MISMATCH:
247 return OPAL_ERR_PACK_MISMATCH;
248 case PMIX_ERR_PACK_FAILURE:
249 return OPAL_ERR_PACK_FAILURE;
250
251 case PMIX_ERR_UNPACK_FAILURE:
252 return OPAL_ERR_UNPACK_FAILURE;
253 case PMIX_ERR_UNPACK_INADEQUATE_SPACE:
254 return OPAL_ERR_UNPACK_INADEQUATE_SPACE;
255 case PMIX_ERR_TYPE_MISMATCH:
256 return OPAL_ERR_TYPE_MISMATCH;
257 case PMIX_ERR_PROC_ENTRY_NOT_FOUND:
258 return OPAL_ERR_PROC_ENTRY_NOT_FOUND;
259 case PMIX_ERR_UNKNOWN_DATA_TYPE:
260 return OPAL_ERR_UNKNOWN_DATA_TYPE;
261 case PMIX_ERR_WOULD_BLOCK:
262 return OPAL_ERR_WOULD_BLOCK;
263 case PMIX_ERR_READY_FOR_HANDSHAKE:
264 case PMIX_ERR_HANDSHAKE_FAILED:
265 case PMIX_ERR_INVALID_CRED:
266 return OPAL_ERR_COMM_FAILURE;
267 case PMIX_EXISTS:
268 return OPAL_EXISTS;
269
270 case PMIX_ERR_SILENT:
271 return OPAL_ERR_SILENT;
272 case PMIX_ERROR:
273 return OPAL_ERROR;
274 case PMIX_SUCCESS:
275 return OPAL_SUCCESS;
276 default:
277 return OPAL_ERROR;
278 }
279 }
280
281 pmix_scope_t pmix1_convert_opalscope(opal_pmix_scope_t scope) {
282 switch(scope) {
283 case OPAL_PMIX_LOCAL:
284 return PMIX_LOCAL;
285 case OPAL_PMIX_REMOTE:
286 return PMIX_REMOTE;
287 case OPAL_PMIX_GLOBAL:
288 return PMIX_GLOBAL;
289 default:
290 return PMIX_SCOPE_UNDEF;
291 }
292 }
293
294 void pmix1_value_load(pmix_value_t *v,
295 opal_value_t *kv)
296 {
297 int ival;
298 unsigned int ui;
299
300 switch(kv->type) {
301 case OPAL_UNDEF:
302 v->type = PMIX_UNDEF;
303 break;
304 case OPAL_BOOL:
305 v->type = PMIX_BOOL;
306 memcpy(&(v->data.flag), &kv->data.flag, 1);
307 break;
308 case OPAL_BYTE:
309 v->type = PMIX_BYTE;
310 memcpy(&(v->data.byte), &kv->data.byte, 1);
311 break;
312 case OPAL_STRING:
313 v->type = PMIX_STRING;
314 if (NULL != kv->data.string) {
315 v->data.string = strdup(kv->data.string);
316 } else {
317 v->data.string = NULL;
318 }
319 break;
320 case OPAL_SIZE:
321 v->type = PMIX_SIZE;
322 v->data.size = (size_t)kv->data.size;
323 break;
324 case OPAL_PID:
325 v->type = PMIX_PID;
326 memcpy(&(v->data.pid), &kv->data.pid, sizeof(pid_t));
327 break;
328 case OPAL_INT:
329 case OPAL_STATUS:
330 v->type = PMIX_INT;
331 memcpy(&(v->data.integer), &kv->data.integer, sizeof(int));
332 break;
333 case OPAL_INT8:
334 v->type = PMIX_INT8;
335 memcpy(&(v->data.int8), &kv->data.int8, 1);
336 break;
337 case OPAL_INT16:
338 v->type = PMIX_INT16;
339 memcpy(&(v->data.int16), &kv->data.int16, 2);
340 break;
341 case OPAL_INT32:
342 v->type = PMIX_INT32;
343 memcpy(&(v->data.int32), &kv->data.int32, 4);
344 break;
345 case OPAL_INT64:
346 v->type = PMIX_INT64;
347 memcpy(&(v->data.int64), &kv->data.int64, 8);
348 break;
349 case OPAL_UINT:
350 v->type = PMIX_UINT;
351 memcpy(&(v->data.uint), &kv->data.uint, sizeof(int));
352 break;
353 case OPAL_UINT8:
354 case OPAL_PROC_STATE:
355 v->type = PMIX_UINT8;
356 memcpy(&(v->data.uint8), &kv->data.uint8, 1);
357 break;
358 case OPAL_UINT16:
359 v->type = PMIX_UINT16;
360 memcpy(&(v->data.uint16), &kv->data.uint16, 2);
361 break;
362 case OPAL_UINT32:
363 case OPAL_INFO_DIRECTIVES:
364 v->type = PMIX_UINT32;
365 memcpy(&(v->data.uint32), &kv->data.uint32, 4);
366 break;
367 case OPAL_UINT64:
368 v->type = PMIX_UINT64;
369 memcpy(&(v->data.uint64), &kv->data.uint64, 8);
370 break;
371 case OPAL_FLOAT:
372 v->type = PMIX_FLOAT;
373 memcpy(&(v->data.fval), &kv->data.fval, sizeof(float));
374 break;
375 case OPAL_DOUBLE:
376 v->type = PMIX_DOUBLE;
377 memcpy(&(v->data.dval), &kv->data.dval, sizeof(double));
378 break;
379 case OPAL_TIMEVAL:
380 v->type = PMIX_TIMEVAL;
381 memcpy(&(v->data.tv), &kv->data.tv, sizeof(struct timeval));
382 break;
383 case OPAL_BYTE_OBJECT:
384 v->type = PMIX_BYTE_OBJECT;
385 if (NULL != kv->data.bo.bytes) {
386 v->data.bo.bytes = (char*)malloc(kv->data.bo.size);
387 memcpy(v->data.bo.bytes, kv->data.bo.bytes, kv->data.bo.size);
388 v->data.bo.size = (size_t)kv->data.bo.size;
389 } else {
390 v->data.bo.bytes = NULL;
391 v->data.bo.size = 0;
392 }
393 break;
394 case OPAL_VPID:
395 v->type = PMIX_UINT32;
396 memcpy(&(v->data.uint32), &kv->data.name.vpid, 4);
397 break;
398 case OPAL_PERSIST:
399 v->type = PMIX_INT;
400
401 ival = (int)kv->data.uint8;
402 memcpy(&(v->data.integer), &ival, sizeof(int));
403 break;
404 case OPAL_SCOPE:
405 case OPAL_DATA_RANGE:
406 v->type = PMIX_UINT;
407 ui = (unsigned int)kv->data.uint8;
408 memcpy(&(v->data.uint), &ui, sizeof(unsigned int));
409 break;
410 default:
411
412 v->type = PMIX_UNDEF;
413 break;
414 }
415 }
416
417 int pmix1_value_unload(opal_value_t *kv,
418 const pmix_value_t *v)
419 {
420 int rc=OPAL_SUCCESS;
421
422
423 switch(v->type) {
424 case PMIX_UNDEF:
425 rc = OPAL_ERR_UNKNOWN_DATA_TYPE;
426 break;
427 case PMIX_BOOL:
428 kv->type = OPAL_BOOL;
429 memcpy(&kv->data.flag, &(v->data.flag), 1);
430 break;
431 case PMIX_BYTE:
432 kv->type = OPAL_BYTE;
433 memcpy(&kv->data.byte, &(v->data.byte), 1);
434 break;
435 case PMIX_STRING:
436 kv->type = OPAL_STRING;
437 if (NULL != v->data.string) {
438 kv->data.string = strdup(v->data.string);
439 }
440 break;
441 case PMIX_SIZE:
442 kv->type = OPAL_SIZE;
443 kv->data.size = (int)v->data.size;
444 break;
445 case PMIX_PID:
446 kv->type = OPAL_PID;
447 memcpy(&kv->data.pid, &(v->data.pid), sizeof(pid_t));
448 break;
449 case PMIX_INT:
450 kv->type = OPAL_INT;
451 memcpy(&kv->data.integer, &(v->data.integer), sizeof(int));
452 break;
453 case PMIX_INT8:
454 kv->type = OPAL_INT8;
455 memcpy(&kv->data.int8, &(v->data.int8), 1);
456 break;
457 case PMIX_INT16:
458 kv->type = OPAL_INT16;
459 memcpy(&kv->data.int16, &(v->data.int16), 2);
460 break;
461 case PMIX_INT32:
462 kv->type = OPAL_INT32;
463 memcpy(&kv->data.int32, &(v->data.int32), 4);
464 break;
465 case PMIX_INT64:
466 kv->type = OPAL_INT64;
467 memcpy(&kv->data, &(v->data.int64), 8);
468 break;
469 case PMIX_UINT:
470 kv->type = OPAL_UINT;
471 memcpy(&kv->data, &(v->data.uint), sizeof(int));
472 break;
473 case PMIX_UINT8:
474 kv->type = OPAL_UINT8;
475 memcpy(&kv->data, &(v->data.uint8), 1);
476 break;
477 case PMIX_UINT16:
478 kv->type = OPAL_UINT16;
479 memcpy(&kv->data, &(v->data.uint16), 2);
480 break;
481 case PMIX_UINT32:
482 kv->type = OPAL_UINT32;
483 memcpy(&kv->data, &(v->data.uint32), 4);
484 break;
485 case PMIX_UINT64:
486 kv->type = OPAL_UINT64;
487 memcpy(&kv->data, &(v->data.uint64), 8);
488 break;
489 case PMIX_FLOAT:
490 kv->type = OPAL_FLOAT;
491 memcpy(&kv->data, &(v->data.fval), sizeof(float));
492 break;
493 case PMIX_DOUBLE:
494 kv->type = OPAL_DOUBLE;
495 memcpy(&kv->data, &(v->data.dval), sizeof(double));
496 break;
497 case PMIX_TIMEVAL:
498 kv->type = OPAL_TIMEVAL;
499 memcpy(&kv->data, &(v->data.tv), sizeof(struct timeval));
500 break;
501 case PMIX_BYTE_OBJECT:
502 kv->type = OPAL_BYTE_OBJECT;
503 if (NULL != v->data.bo.bytes && 0 < v->data.bo.size) {
504 kv->data.bo.bytes = (uint8_t*)malloc(v->data.bo.size);
505 memcpy(kv->data.bo.bytes, v->data.bo.bytes, v->data.bo.size);
506 kv->data.bo.size = (int)v->data.bo.size;
507 } else {
508 kv->data.bo.bytes = NULL;
509 kv->data.bo.size = 0;
510 }
511 break;
512 default:
513
514 rc = OPAL_ERROR;
515 break;
516 }
517 return rc;
518 }
519
520
521
522 OBJ_CLASS_INSTANCE(opal_pmix1_jobid_trkr_t,
523 opal_list_item_t,
524 NULL, NULL);
525
526 static void opcon(pmix1_opcaddy_t *p)
527 {
528 memset(&p->p, 0, sizeof(pmix_proc_t));
529 p->procs = NULL;
530 p->nprocs = 0;
531 p->error_procs = NULL;
532 p->nerror_procs = 0;
533 p->info = NULL;
534 p->ninfo = 0;
535 p->apps = NULL;
536 p->sz = 0;
537 p->active = false;
538 p->opcbfunc = NULL;
539 p->mdxcbfunc = NULL;
540 p->valcbfunc = NULL;
541 p->lkcbfunc = NULL;
542 p->spcbfunc = NULL;
543 p->cbdata = NULL;
544 }
545 static void opdes(pmix1_opcaddy_t *p)
546 {
547 if (NULL != p->procs) {
548 PMIX_PROC_FREE(p->procs, p->nprocs);
549 }
550 if (NULL != p->error_procs) {
551 PMIX_PROC_FREE(p->error_procs, p->nerror_procs);
552 }
553 if (NULL != p->info) {
554 PMIX_INFO_FREE(p->info, p->sz);
555 }
556 if (NULL != p->apps) {
557 PMIX_APP_FREE(p->apps, p->sz);
558 }
559 }
560 OBJ_CLASS_INSTANCE(pmix1_opcaddy_t,
561 opal_object_t,
562 opcon, opdes);
563
564 static void ocadcon(pmix1_opalcaddy_t *p)
565 {
566 OBJ_CONSTRUCT(&p->procs, opal_list_t);
567 OBJ_CONSTRUCT(&p->info, opal_list_t);
568 OBJ_CONSTRUCT(&p->apps, opal_list_t);
569 p->opcbfunc = NULL;
570 p->dmdxfunc = NULL;
571 p->mdxcbfunc = NULL;
572 p->lkupcbfunc = NULL;
573 p->spwncbfunc = NULL;
574 p->cbdata = NULL;
575 p->odmdxfunc = NULL;
576 p->ocbdata = NULL;
577 }
578 static void ocaddes(pmix1_opalcaddy_t *p)
579 {
580 OPAL_LIST_DESTRUCT(&p->procs);
581 OPAL_LIST_DESTRUCT(&p->info);
582 OPAL_LIST_DESTRUCT(&p->apps);
583 }
584 OBJ_CLASS_INSTANCE(pmix1_opalcaddy_t,
585 opal_object_t,
586 ocadcon, ocaddes);