This source file includes following definitions.
- legacy_get
- opcbfunc
- ext3x_get_nspace
- ext3x_register_jobid
- event_hdlr_complete
- return_local_event_hdlr
- process_event
- ext3x_event_hdlr
- ext3x_register_cleanup
- ext3x_convert_rank
- ext3x_convert_opalrank
- ext3x_convert_opalrc
- ext3x_convert_rc
- ext3x_convert_scope
- ext3x_convert_opalscope
- ext3x_convert_opalrange
- ext3x_convert_range
- ext3x_convert_persist
- ext3x_convert_opalpersist
- ext3x_convert_jobid
- ext3x_value_load
- ext3x_value_unload
- errreg_cbfunc
- register_handler
- deregister_handler
- notify_complete
- notify_event
- relcbfunc
- infocbfunc
- ext3x_query
- ext3x_log
- ext3x_convert_allocdir
- ext3x_convert_state
- ext3x_convert_opalstate
- evcon
- evdes
- opcon
- opdes
- ocadcon
- ocaddes
- tscon
- tsdes
- dmcon
- dmdes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 #include "opal_config.h"
19 #include "opal/constants.h"
20 #include "opal/types.h"
21
22 #ifdef HAVE_STRING_H
23 #include <string.h>
24 #endif
25 #ifdef HAVE_UNISTD_H
26 #include <unistd.h>
27 #endif
28 #ifdef HAVE_SYS_STAT_H
29 #include <sys/stat.h>
30 #endif
31
32 #include "opal/dss/dss.h"
33 #include "opal/mca/event/event.h"
34 #include "opal/mca/hwloc/base/base.h"
35 #include "opal/runtime/opal.h"
36 #include "opal/runtime/opal_progress_threads.h"
37 #include "opal/threads/threads.h"
38 #include "opal/util/argv.h"
39 #include "opal/util/error.h"
40 #include "opal/util/opal_environ.h"
41 #include "opal/util/output.h"
42 #include "opal/util/proc.h"
43 #include "opal/util/show_help.h"
44 #include "opal/util/string_copy.h"
45
46 #include "ext3x.h"
47 #include "opal/mca/pmix/base/base.h"
48 #include "opal/mca/pmix/pmix_types.h"
49
50 #include <pmix_common.h>
51 #include <pmix.h>
52
53
54
55
56
57 static bool legacy_get(void);
58 static const char *ext3x_get_nspace(opal_jobid_t jobid);
59 static void ext3x_register_jobid(opal_jobid_t jobid, const char *nspace);
60 static void register_handler(opal_list_t *event_codes,
61 opal_list_t *info,
62 opal_pmix_notification_fn_t evhandler,
63 opal_pmix_evhandler_reg_cbfunc_t cbfunc,
64 void *cbdata);
65 static void deregister_handler(size_t evhandler,
66 opal_pmix_op_cbfunc_t cbfunc,
67 void *cbdata);
68 static int notify_event(int status,
69 const opal_process_name_t *source,
70 opal_pmix_data_range_t range,
71 opal_list_t *info,
72 opal_pmix_op_cbfunc_t cbfunc, void *cbdata);
73 static void ext3x_query(opal_list_t *queries,
74 opal_pmix_info_cbfunc_t cbfunc, void *cbdata);
75 static void ext3x_log(opal_list_t *info,
76 opal_pmix_op_cbfunc_t cbfunc, void *cbdata);
77
78 static int ext3x_register_cleanup(char *path, bool directory, bool ignore, bool jobscope);
79
80 const opal_pmix_base_module_t opal_pmix_ext3x_module = {
81 .legacy_get = legacy_get,
82
83 .init = ext3x_client_init,
84 .finalize = ext3x_client_finalize,
85 .initialized = ext3x_initialized,
86 .abort = ext3x_abort,
87 .commit = ext3x_commit,
88 .fence = ext3x_fence,
89 .fence_nb = ext3x_fencenb,
90 .put = ext3x_put,
91 .get = ext3x_get,
92 .get_nb = ext3x_getnb,
93 .publish = ext3x_publish,
94 .publish_nb = ext3x_publishnb,
95 .lookup = ext3x_lookup,
96 .lookup_nb = ext3x_lookupnb,
97 .unpublish = ext3x_unpublish,
98 .unpublish_nb = ext3x_unpublishnb,
99 .spawn = ext3x_spawn,
100 .spawn_nb = ext3x_spawnnb,
101 .connect = ext3x_connect,
102 .connect_nb = ext3x_connectnb,
103 .disconnect = ext3x_disconnect,
104 .disconnect_nb = ext3x_disconnectnb,
105 .resolve_peers = ext3x_resolve_peers,
106 .resolve_nodes = ext3x_resolve_nodes,
107 .query = ext3x_query,
108 .log = ext3x_log,
109 .allocate = ext3x_allocate,
110 .job_control = ext3x_job_control,
111 .register_cleanup = ext3x_register_cleanup,
112
113 .server_init = ext3x_server_init,
114 .server_finalize = ext3x_server_finalize,
115 .generate_regex = ext3x_server_gen_regex,
116 .generate_ppn = ext3x_server_gen_ppn,
117 .server_register_nspace = ext3x_server_register_nspace,
118 .server_deregister_nspace = ext3x_server_deregister_nspace,
119 .server_register_client = ext3x_server_register_client,
120 .server_deregister_client = ext3x_server_deregister_client,
121 .server_setup_fork = ext3x_server_setup_fork,
122 .server_dmodex_request = ext3x_server_dmodex,
123 .server_notify_event = ext3x_server_notify_event,
124 .server_iof_push = ext3x_server_iof_push,
125 .server_setup_application = ext3x_server_setup_application,
126 .server_setup_local_support = ext3x_server_setup_local_support,
127
128 .tool_init = ext3x_tool_init,
129 .tool_finalize = ext3x_tool_fini,
130
131 .get_version = PMIx_Get_version,
132 .register_evhandler = register_handler,
133 .deregister_evhandler = deregister_handler,
134 .notify_event = notify_event,
135 .store_local = ext3x_store_local,
136 .get_nspace = ext3x_get_nspace,
137 .register_jobid = ext3x_register_jobid
138 };
139
140 static bool legacy_get(void)
141 {
142 return false;
143 }
144
145 static void opcbfunc(pmix_status_t status, void *cbdata)
146 {
147 ext3x_opcaddy_t *op = (ext3x_opcaddy_t*)cbdata;
148
149 OPAL_ACQUIRE_OBJECT(op);
150
151 if (NULL != op->opcbfunc) {
152 op->opcbfunc(ext3x_convert_rc(status), op->cbdata);
153 }
154 OBJ_RELEASE(op);
155 }
156
157
158 static const char *ext3x_get_nspace(opal_jobid_t jobid)
159 {
160 opal_ext3x_jobid_trkr_t *jptr;
161
162 OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
163
164 OPAL_LIST_FOREACH(jptr, &mca_pmix_ext3x_component.jobids, opal_ext3x_jobid_trkr_t) {
165 if (jptr->jobid == jobid) {
166 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
167 return jptr->nspace;
168 }
169 }
170 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
171 return NULL;
172 }
173
174 static void ext3x_register_jobid(opal_jobid_t jobid, const char *nspace)
175 {
176 opal_ext3x_jobid_trkr_t *jptr;
177
178 OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
179
180
181 OPAL_LIST_FOREACH(jptr, &mca_pmix_ext3x_component.jobids, opal_ext3x_jobid_trkr_t) {
182 if (jptr->jobid == jobid) {
183 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
184 return;
185 }
186 }
187 jptr = OBJ_NEW(opal_ext3x_jobid_trkr_t);
188 (void)opal_string_copy(jptr->nspace, nspace, PMIX_MAX_NSLEN);
189 jptr->jobid = jobid;
190 opal_list_append(&mca_pmix_ext3x_component.jobids, &jptr->super);
191 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
192 }
193
194 static void event_hdlr_complete(pmix_status_t status, void *cbdata)
195 {
196 ext3x_opcaddy_t *op = (ext3x_opcaddy_t*)cbdata;
197
198 OBJ_RELEASE(op);
199 }
200
201 static void return_local_event_hdlr(int status, opal_list_t *results,
202 opal_pmix_op_cbfunc_t cbfunc, void *thiscbdata,
203 void *notification_cbdata)
204 {
205 ext3x_threadshift_t *cd = (ext3x_threadshift_t*)notification_cbdata;
206 ext3x_opcaddy_t *op;
207 opal_value_t *kv;
208 pmix_status_t pstatus;
209 size_t n;
210
211 OPAL_ACQUIRE_OBJECT(cd);
212 if (NULL != cd->pmixcbfunc) {
213 op = OBJ_NEW(ext3x_opcaddy_t);
214
215 if (NULL != results && 0 < (op->ninfo = opal_list_get_size(results))) {
216
217 PMIX_INFO_CREATE(op->info, op->ninfo);
218 n=0;
219 OPAL_LIST_FOREACH(kv, cd->info, opal_value_t) {
220 (void)opal_string_copy(op->info[n].key, kv->key, PMIX_MAX_KEYLEN);
221 ext3x_value_load(&op->info[n].value, kv);
222 ++n;
223 }
224 }
225
226 pstatus = ext3x_convert_opalrc(status);
227
228 cd->pmixcbfunc(pstatus, op->info, op->ninfo, event_hdlr_complete, op, cd->cbdata);
229 }
230
231
232 if (NULL != cd->info) {
233 OPAL_LIST_RELEASE(cd->info);
234 }
235 OBJ_RELEASE(cd);
236
237
238 if (NULL != cbfunc) {
239 cbfunc(OPAL_SUCCESS, thiscbdata);
240 }
241 }
242
243
244 static void process_event(int sd, short args, void *cbdata)
245 {
246 ext3x_threadshift_t *cd = (ext3x_threadshift_t*)cbdata;
247 opal_ext3x_event_t *event;
248
249 OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
250
251
252 OPAL_LIST_FOREACH(event, &mca_pmix_ext3x_component.events, opal_ext3x_event_t) {
253 if (cd->id == event->index) {
254
255
256 opal_output_verbose(2, opal_pmix_base_framework.framework_output,
257 "%s _EVENT_HDLR CALLING EVHDLR",
258 OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
259 if (NULL != event->handler) {
260 OBJ_RETAIN(event);
261 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
262 event->handler(cd->status, &cd->pname,
263 cd->info, &cd->results,
264 return_local_event_hdlr, cd);
265 OBJ_RELEASE(event);
266 return;
267 }
268 }
269 }
270
271 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
272
273
274 if (NULL != cd->pmixcbfunc) {
275 cd->pmixcbfunc(PMIX_SUCCESS, NULL, 0, NULL, NULL, cd->cbdata);
276 }
277 OPAL_LIST_RELEASE(cd->info);
278 OBJ_RELEASE(cd);
279 return;
280
281 }
282
283
284
285
286
287
288 void ext3x_event_hdlr(size_t evhdlr_registration_id,
289 pmix_status_t status, const pmix_proc_t *source,
290 pmix_info_t info[], size_t ninfo,
291 pmix_info_t results[], size_t nresults,
292 pmix_event_notification_cbfunc_fn_t cbfunc,
293 void *cbdata)
294 {
295 ext3x_threadshift_t *cd;
296 int rc;
297 opal_value_t *iptr;
298 size_t n;
299
300 opal_output_verbose(2, opal_pmix_base_framework.framework_output,
301 "%s RECEIVED NOTIFICATION OF STATUS %d ON HDLR %lu",
302 OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), status,
303 (unsigned long)evhdlr_registration_id);
304
305 OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
306
307 cd = OBJ_NEW(ext3x_threadshift_t);
308 cd->id = evhdlr_registration_id;
309 cd->pmixcbfunc = cbfunc;
310 cd->cbdata = cbdata;
311
312
313 cd->status = ext3x_convert_rc(status);
314 opal_output_verbose(2, opal_pmix_base_framework.framework_output,
315 "%s CONVERTED STATUS %d TO STATUS %d",
316 OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), status, cd->status);
317
318
319 if (NULL == source) {
320 cd->pname.jobid = OPAL_NAME_INVALID->jobid;
321 cd->pname.vpid = OPAL_NAME_INVALID->vpid;
322 } else {
323 if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&cd->pname.jobid, source->nspace))) {
324 OPAL_ERROR_LOG(rc);
325 cd->pname.jobid = OPAL_NAME_INVALID->jobid;
326 }
327 cd->pname.vpid = ext3x_convert_rank(source->rank);
328 }
329
330
331 if (NULL != info) {
332 cd->info = OBJ_NEW(opal_list_t);
333 for (n=0; n < ninfo; n++) {
334 iptr = OBJ_NEW(opal_value_t);
335 iptr->key = strdup(info[n].key);
336 if (OPAL_SUCCESS != (rc = ext3x_value_unload(iptr, &info[n].value))) {
337 OPAL_ERROR_LOG(rc);
338 OBJ_RELEASE(iptr);
339 continue;
340 }
341 opal_list_append(cd->info, &iptr->super);
342 }
343 }
344
345
346 if (NULL != results) {
347 for (n=0; n < nresults; n++) {
348 iptr = OBJ_NEW(opal_value_t);
349 iptr->key = strdup(results[n].key);
350 if (OPAL_SUCCESS != (rc = ext3x_value_unload(iptr, &results[n].value))) {
351 OPAL_ERROR_LOG(rc);
352 OBJ_RELEASE(iptr);
353 continue;
354 }
355 opal_list_append(&cd->results, &iptr->super);
356 }
357 }
358
359 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
360
361
362
363
364 OPAL_PMIX2X_THREADSHIFT(cd, process_event);
365 return;
366 }
367
368 static int ext3x_register_cleanup(char *path, bool directory, bool ignore, bool jobscope)
369 {
370 pmix_info_t pinfo[3];
371 size_t n, ninfo=0;
372 pmix_status_t rc;
373 int ret;
374
375 if (ignore) {
376
377 PMIX_INFO_LOAD(&pinfo[ninfo], PMIX_CLEANUP_IGNORE, path, PMIX_STRING);
378 ++ninfo;
379 } else {
380 if (directory) {
381 PMIX_INFO_LOAD(&pinfo[ninfo], PMIX_REGISTER_CLEANUP_DIR, path, PMIX_STRING);
382 ++ninfo;
383
384 PMIX_INFO_LOAD(&pinfo[ninfo], PMIX_CLEANUP_RECURSIVE, NULL, PMIX_BOOL);
385 ++ninfo;
386 } else {
387
388 PMIX_INFO_LOAD(&pinfo[ninfo], PMIX_REGISTER_CLEANUP, path, PMIX_STRING);
389 ++ninfo;
390 }
391 }
392
393
394 if (jobscope) {
395 rc = PMIx_Job_control_nb(NULL, 0, pinfo, ninfo, NULL, NULL);
396 } else {
397
398 rc = PMIx_Job_control_nb(&mca_pmix_ext3x_component.myproc, 1, pinfo, ninfo, NULL, NULL);
399 }
400 ret = ext3x_convert_rc(rc);
401 for (n=0; n < ninfo; n++) {
402 PMIX_INFO_DESTRUCT(&pinfo[n]);
403 }
404 return ret;
405 }
406
407 opal_vpid_t ext3x_convert_rank(pmix_rank_t rank)
408 {
409 switch(rank) {
410 case PMIX_RANK_UNDEF:
411 return OPAL_VPID_INVALID;
412 case PMIX_RANK_WILDCARD:
413 return OPAL_VPID_WILDCARD;
414 default:
415 return (opal_vpid_t)rank;
416 }
417 }
418
419 pmix_rank_t ext3x_convert_opalrank(opal_vpid_t vpid)
420 {
421 switch(vpid) {
422 case OPAL_VPID_WILDCARD:
423 return PMIX_RANK_WILDCARD;
424 case OPAL_VPID_INVALID:
425 return PMIX_RANK_UNDEF;
426 default:
427 return (pmix_rank_t)vpid;
428 }
429 }
430
431 pmix_status_t ext3x_convert_opalrc(int rc)
432 {
433 switch (rc) {
434 case OPAL_ERR_DEBUGGER_RELEASE:
435 return PMIX_ERR_DEBUGGER_RELEASE;
436
437 case OPAL_ERR_HANDLERS_COMPLETE:
438 return PMIX_EVENT_ACTION_COMPLETE;
439
440 case OPAL_ERR_PROC_ABORTED:
441 return PMIX_ERR_PROC_ABORTED;
442
443 case OPAL_ERR_PROC_REQUESTED_ABORT:
444 return PMIX_ERR_PROC_REQUESTED_ABORT;
445
446 case OPAL_ERR_PROC_ABORTING:
447 return PMIX_ERR_PROC_ABORTING;
448
449 case OPAL_ERR_NODE_DOWN:
450 return PMIX_ERR_NODE_DOWN;
451
452 case OPAL_ERR_NODE_OFFLINE:
453 return PMIX_ERR_NODE_OFFLINE;
454
455 case OPAL_ERR_JOB_TERMINATED:
456 return PMIX_ERR_JOB_TERMINATED;
457
458 case OPAL_ERR_PROC_RESTART:
459 return PMIX_ERR_PROC_RESTART;
460
461 case OPAL_ERR_PROC_CHECKPOINT:
462 return PMIX_ERR_PROC_CHECKPOINT;
463
464 case OPAL_ERR_PROC_MIGRATE:
465 return PMIX_ERR_PROC_MIGRATE;
466
467 case OPAL_ERR_EVENT_REGISTRATION:
468 return PMIX_ERR_EVENT_REGISTRATION;
469
470 case OPAL_ERR_NOT_IMPLEMENTED:
471 case OPAL_ERR_NOT_SUPPORTED:
472 return PMIX_ERR_NOT_SUPPORTED;
473
474 case OPAL_ERR_NOT_FOUND:
475 return PMIX_ERR_NOT_FOUND;
476
477 case OPAL_ERR_PERM:
478 case OPAL_ERR_UNREACH:
479 case OPAL_ERR_SERVER_NOT_AVAIL:
480 return PMIX_ERR_UNREACH;
481
482 case OPAL_ERR_BAD_PARAM:
483 return PMIX_ERR_BAD_PARAM;
484
485 case OPAL_ERR_OUT_OF_RESOURCE:
486 return PMIX_ERR_OUT_OF_RESOURCE;
487
488 case OPAL_ERR_DATA_VALUE_NOT_FOUND:
489 return PMIX_ERR_DATA_VALUE_NOT_FOUND;
490
491 case OPAL_ERR_TIMEOUT:
492 return PMIX_ERR_TIMEOUT;
493
494 case OPAL_ERR_WOULD_BLOCK:
495 return PMIX_ERR_WOULD_BLOCK;
496
497 case OPAL_EXISTS:
498 return PMIX_EXISTS;
499
500 case OPAL_ERR_PARTIAL_SUCCESS:
501 return PMIX_QUERY_PARTIAL_SUCCESS;
502
503 case OPAL_ERR_MODEL_DECLARED:
504 return PMIX_MODEL_DECLARED;
505
506 case OPAL_ERROR:
507 return PMIX_ERROR;
508 case OPAL_SUCCESS:
509 return PMIX_SUCCESS;
510
511 case OPAL_OPERATION_SUCCEEDED:
512 return PMIX_OPERATION_SUCCEEDED;
513
514 default:
515 return rc;
516 }
517 }
518
519 int ext3x_convert_rc(pmix_status_t rc)
520 {
521 switch (rc) {
522 case PMIX_ERR_DEBUGGER_RELEASE:
523 return OPAL_ERR_DEBUGGER_RELEASE;
524
525 case PMIX_EVENT_ACTION_COMPLETE:
526 return OPAL_ERR_HANDLERS_COMPLETE;
527
528 case PMIX_ERR_PROC_ABORTED:
529 return OPAL_ERR_PROC_ABORTED;
530
531 case PMIX_ERR_PROC_REQUESTED_ABORT:
532 return OPAL_ERR_PROC_REQUESTED_ABORT;
533
534 case PMIX_ERR_PROC_ABORTING:
535 return OPAL_ERR_PROC_ABORTING;
536
537 case PMIX_ERR_NODE_DOWN:
538 return OPAL_ERR_NODE_DOWN;
539
540 case PMIX_ERR_NODE_OFFLINE:
541 return OPAL_ERR_NODE_OFFLINE;
542
543 case PMIX_ERR_JOB_TERMINATED:
544 return OPAL_ERR_JOB_TERMINATED;
545
546 case PMIX_ERR_PROC_RESTART:
547 return OPAL_ERR_PROC_RESTART;
548
549 case PMIX_ERR_PROC_CHECKPOINT:
550 return OPAL_ERR_PROC_CHECKPOINT;
551
552 case PMIX_ERR_PROC_MIGRATE:
553 return OPAL_ERR_PROC_MIGRATE;
554
555 case PMIX_ERR_EVENT_REGISTRATION:
556 return OPAL_ERR_EVENT_REGISTRATION;
557
558 case PMIX_ERR_NOT_SUPPORTED:
559 return OPAL_ERR_NOT_SUPPORTED;
560
561 case PMIX_ERR_NOT_FOUND:
562 return OPAL_ERR_NOT_FOUND;
563
564 case PMIX_ERR_OUT_OF_RESOURCE:
565 return OPAL_ERR_OUT_OF_RESOURCE;
566
567 case PMIX_ERR_INIT:
568 return OPAL_ERROR;
569
570 case PMIX_ERR_BAD_PARAM:
571 return OPAL_ERR_BAD_PARAM;
572
573 case PMIX_ERR_UNREACH:
574 case PMIX_ERR_NO_PERMISSIONS:
575 return OPAL_ERR_UNREACH;
576
577 case PMIX_ERR_TIMEOUT:
578 return OPAL_ERR_TIMEOUT;
579
580 case PMIX_ERR_WOULD_BLOCK:
581 return OPAL_ERR_WOULD_BLOCK;
582
583 case PMIX_ERR_LOST_CONNECTION_TO_SERVER:
584 case PMIX_ERR_LOST_PEER_CONNECTION:
585 case PMIX_ERR_LOST_CONNECTION_TO_CLIENT:
586 return OPAL_ERR_COMM_FAILURE;
587
588 case PMIX_EXISTS:
589 return OPAL_EXISTS;
590
591 case PMIX_QUERY_PARTIAL_SUCCESS:
592 return OPAL_ERR_PARTIAL_SUCCESS;
593
594 case PMIX_MONITOR_HEARTBEAT_ALERT:
595 return OPAL_ERR_HEARTBEAT_ALERT;
596
597 case PMIX_MONITOR_FILE_ALERT:
598 return OPAL_ERR_FILE_ALERT;
599
600 case PMIX_MODEL_DECLARED:
601 return OPAL_ERR_MODEL_DECLARED;
602
603 case PMIX_ERROR:
604 return OPAL_ERROR;
605 case PMIX_SUCCESS:
606 return OPAL_SUCCESS;
607
608 case PMIX_OPERATION_SUCCEEDED:
609 return OPAL_OPERATION_SUCCEEDED;
610
611 default:
612 return rc;
613 }
614 }
615
616 opal_pmix_scope_t ext3x_convert_scope(pmix_scope_t scope)
617 {
618 switch(scope) {
619 case PMIX_SCOPE_UNDEF:
620 return OPAL_PMIX_SCOPE_UNDEF;
621 case PMIX_LOCAL:
622 return OPAL_PMIX_LOCAL;
623 case PMIX_REMOTE:
624 return OPAL_PMIX_REMOTE;
625 case PMIX_GLOBAL:
626 return OPAL_PMIX_GLOBAL;
627 default:
628 return OPAL_PMIX_SCOPE_UNDEF;
629 }
630 }
631
632 pmix_scope_t ext3x_convert_opalscope(opal_pmix_scope_t scope) {
633 switch(scope) {
634 case OPAL_PMIX_LOCAL:
635 return PMIX_LOCAL;
636 case OPAL_PMIX_REMOTE:
637 return PMIX_REMOTE;
638 case OPAL_PMIX_GLOBAL:
639 return PMIX_GLOBAL;
640 default:
641 return PMIX_SCOPE_UNDEF;
642 }
643 }
644
645 pmix_data_range_t ext3x_convert_opalrange(opal_pmix_data_range_t range) {
646 switch(range) {
647 case OPAL_PMIX_RANGE_UNDEF:
648 return PMIX_RANGE_UNDEF;
649 case OPAL_PMIX_RANGE_LOCAL:
650 return PMIX_RANGE_LOCAL;
651 case OPAL_PMIX_RANGE_NAMESPACE:
652 return PMIX_RANGE_NAMESPACE;
653 case OPAL_PMIX_RANGE_SESSION:
654 return PMIX_RANGE_SESSION;
655 case OPAL_PMIX_RANGE_GLOBAL:
656 return PMIX_RANGE_GLOBAL;
657 case OPAL_PMIX_RANGE_CUSTOM:
658 return PMIX_RANGE_CUSTOM;
659 case OPAL_PMIX_RANGE_PROC_LOCAL:
660 return PMIX_RANGE_PROC_LOCAL;
661 default:
662 return PMIX_SCOPE_UNDEF;
663 }
664 }
665
666 opal_pmix_data_range_t ext3x_convert_range(pmix_data_range_t range) {
667 switch(range) {
668 case PMIX_RANGE_UNDEF:
669 return OPAL_PMIX_RANGE_UNDEF;
670 case PMIX_RANGE_LOCAL:
671 return OPAL_PMIX_RANGE_LOCAL;
672 case PMIX_RANGE_NAMESPACE:
673 return OPAL_PMIX_RANGE_NAMESPACE;
674 case PMIX_RANGE_SESSION:
675 return OPAL_PMIX_RANGE_SESSION;
676 case PMIX_RANGE_GLOBAL:
677 return OPAL_PMIX_RANGE_GLOBAL;
678 case PMIX_RANGE_CUSTOM:
679 return OPAL_PMIX_RANGE_CUSTOM;
680 default:
681 return OPAL_PMIX_RANGE_UNDEF;
682 }
683 }
684
685 opal_pmix_persistence_t ext3x_convert_persist(pmix_persistence_t persist)
686 {
687 switch(persist) {
688 case PMIX_PERSIST_INDEF:
689 return OPAL_PMIX_PERSIST_INDEF;
690 case PMIX_PERSIST_FIRST_READ:
691 return OPAL_PMIX_PERSIST_FIRST_READ;
692 case PMIX_PERSIST_PROC:
693 return OPAL_PMIX_PERSIST_PROC;
694 case PMIX_PERSIST_APP:
695 return OPAL_PMIX_PERSIST_APP;
696 case PMIX_PERSIST_SESSION:
697 return OPAL_PMIX_PERSIST_SESSION;
698 default:
699 return OPAL_PMIX_PERSIST_INDEF;
700 }
701 }
702
703 pmix_persistence_t ext3x_convert_opalpersist(opal_pmix_persistence_t persist)
704 {
705 switch(persist) {
706 case OPAL_PMIX_PERSIST_INDEF:
707 return PMIX_PERSIST_INDEF;
708 case OPAL_PMIX_PERSIST_FIRST_READ:
709 return PMIX_PERSIST_FIRST_READ;
710 case OPAL_PMIX_PERSIST_PROC:
711 return PMIX_PERSIST_PROC;
712 case OPAL_PMIX_PERSIST_APP:
713 return PMIX_PERSIST_APP;
714 case OPAL_PMIX_PERSIST_SESSION:
715 return PMIX_PERSIST_SESSION;
716 default:
717 return PMIX_PERSIST_INDEF;
718 }
719 }
720
721 char* ext3x_convert_jobid(opal_jobid_t jobid)
722 {
723 opal_ext3x_jobid_trkr_t *jptr;
724
725
726
727 OPAL_LIST_FOREACH(jptr, &mca_pmix_ext3x_component.jobids, opal_ext3x_jobid_trkr_t) {
728 if (jptr->jobid == jobid) {
729 return jptr->nspace;
730 }
731 }
732 return NULL;
733 }
734
735
736
737
738 void ext3x_value_load(pmix_value_t *v,
739 opal_value_t *kv)
740 {
741 opal_ext3x_jobid_trkr_t *job;
742 bool found;
743 opal_list_t *list;
744 opal_value_t *val;
745 pmix_info_t *info;
746 size_t n;
747
748 switch(kv->type) {
749 case OPAL_UNDEF:
750 v->type = PMIX_UNDEF;
751 break;
752 case OPAL_BOOL:
753 v->type = PMIX_BOOL;
754 memcpy(&(v->data.flag), &kv->data.flag, 1);
755 break;
756 case OPAL_BYTE:
757 v->type = PMIX_BYTE;
758 memcpy(&(v->data.byte), &kv->data.byte, 1);
759 break;
760 case OPAL_STRING:
761 v->type = PMIX_STRING;
762 if (NULL != kv->data.string) {
763 v->data.string = strdup(kv->data.string);
764 } else {
765 v->data.string = NULL;
766 }
767 break;
768 case OPAL_SIZE:
769 v->type = PMIX_SIZE;
770 memcpy(&(v->data.size), &kv->data.size, sizeof(size_t));
771 break;
772 case OPAL_PID:
773 v->type = PMIX_PID;
774 memcpy(&(v->data.pid), &kv->data.pid, sizeof(pid_t));
775 break;
776 case OPAL_INT:
777 v->type = PMIX_INT;
778 memcpy(&(v->data.integer), &kv->data.integer, sizeof(int));
779 break;
780 case OPAL_INT8:
781 v->type = PMIX_INT8;
782 memcpy(&(v->data.int8), &kv->data.int8, 1);
783 break;
784 case OPAL_INT16:
785 v->type = PMIX_INT16;
786 memcpy(&(v->data.int16), &kv->data.int16, 2);
787 break;
788 case OPAL_INT32:
789 v->type = PMIX_INT32;
790 memcpy(&(v->data.int32), &kv->data.int32, 4);
791 break;
792 case OPAL_INT64:
793 v->type = PMIX_INT64;
794 memcpy(&(v->data.int64), &kv->data.int64, 8);
795 break;
796 case OPAL_UINT:
797 v->type = PMIX_UINT;
798 memcpy(&(v->data.uint), &kv->data.uint, sizeof(int));
799 break;
800 case OPAL_UINT8:
801 v->type = PMIX_UINT8;
802 memcpy(&(v->data.uint8), &kv->data.uint8, 1);
803 break;
804 case OPAL_UINT16:
805 v->type = PMIX_UINT16;
806 memcpy(&(v->data.uint16), &kv->data.uint16, 2);
807 break;
808 case OPAL_UINT32:
809 v->type = PMIX_UINT32;
810 memcpy(&(v->data.uint32), &kv->data.uint32, 4);
811 break;
812 case OPAL_UINT64:
813 v->type = PMIX_UINT64;
814 memcpy(&(v->data.uint64), &kv->data.uint64, 8);
815 break;
816 case OPAL_FLOAT:
817 v->type = PMIX_FLOAT;
818 memcpy(&(v->data.fval), &kv->data.fval, sizeof(float));
819 break;
820 case OPAL_DOUBLE:
821 v->type = PMIX_DOUBLE;
822 memcpy(&(v->data.dval), &kv->data.dval, sizeof(double));
823 break;
824 case OPAL_TIMEVAL:
825 v->type = PMIX_TIMEVAL;
826 memcpy(&(v->data.tv), &kv->data.tv, sizeof(struct timeval));
827 break;
828 case OPAL_TIME:
829 v->type = PMIX_TIME;
830 memcpy(&(v->data.time), &kv->data.time, sizeof(time_t));
831 break;
832 case OPAL_STATUS:
833 v->type = PMIX_STATUS;
834 v->data.status = ext3x_convert_opalrc(kv->data.status);
835 break;
836 case OPAL_VPID:
837 v->type = PMIX_PROC_RANK;
838 v->data.rank = ext3x_convert_opalrank(kv->data.name.vpid);
839 break;
840 case OPAL_NAME:
841 v->type = PMIX_PROC;
842
843 PMIX_PROC_CREATE(v->data.proc, 1);
844
845 found = false;
846 OPAL_LIST_FOREACH(job, &mca_pmix_ext3x_component.jobids, opal_ext3x_jobid_trkr_t) {
847 if (job->jobid == kv->data.name.jobid) {
848 (void)opal_string_copy(v->data.proc->nspace, job->nspace, PMIX_MAX_NSLEN);
849 found = true;
850 break;
851 }
852 }
853 if (!found) {
854 (void)opal_snprintf_jobid(v->data.proc->nspace, PMIX_MAX_NSLEN, kv->data.name.jobid);
855 }
856 v->data.proc->rank = ext3x_convert_opalrank(kv->data.name.vpid);
857 break;
858 case OPAL_BYTE_OBJECT:
859 v->type = PMIX_BYTE_OBJECT;
860 if (NULL != kv->data.bo.bytes) {
861 v->data.bo.bytes = (char*)malloc(kv->data.bo.size);
862 memcpy(v->data.bo.bytes, kv->data.bo.bytes, kv->data.bo.size);
863 v->data.bo.size = (size_t)kv->data.bo.size;
864 } else {
865 v->data.bo.bytes = NULL;
866 v->data.bo.size = 0;
867 }
868 break;
869 case OPAL_PERSIST:
870 v->type = PMIX_PERSIST;
871 v->data.persist = ext3x_convert_opalpersist((opal_pmix_persistence_t)kv->data.uint8);
872 break;
873 case OPAL_SCOPE:
874 v->type = PMIX_SCOPE;
875 v->data.scope = ext3x_convert_opalscope((opal_pmix_scope_t)kv->data.uint8);
876 break;
877 case OPAL_DATA_RANGE:
878 v->type = PMIX_DATA_RANGE;
879 v->data.range = ext3x_convert_opalrange((opal_pmix_data_range_t)kv->data.uint8);
880 break;
881 case OPAL_PROC_STATE:
882 v->type = PMIX_PROC_STATE;
883
884
885 memcpy(&v->data.state, &kv->data.uint8, sizeof(uint8_t));
886 break;
887 case OPAL_PTR:
888
889
890 if (0 == strcmp(kv->key, OPAL_PMIX_EVENT_RETURN_OBJECT)) {
891 v->type = PMIX_POINTER;
892 v->data.ptr = kv->data.ptr;
893 break;
894 }
895
896
897
898 list = (opal_list_t*)kv->data.ptr;
899 v->type = PMIX_DATA_ARRAY;
900 v->data.darray = (pmix_data_array_t*)malloc(sizeof(pmix_data_array_t));
901 v->data.darray->type = PMIX_INFO;
902 v->data.darray->size = opal_list_get_size(list);
903 if (0 < v->data.darray->size) {
904 PMIX_INFO_CREATE(info, v->data.darray->size);
905 v->data.darray->array = info;
906 n=0;
907 OPAL_LIST_FOREACH(val, list, opal_value_t) {
908 if (NULL != val->key) {
909 (void)opal_string_copy(info[n].key, val->key, PMIX_MAX_KEYLEN);
910 }
911 ext3x_value_load(&info[n].value, val);
912 ++n;
913 }
914 } else {
915 v->data.darray->array = NULL;
916 }
917 break;
918 case OPAL_PROC_INFO:
919 v->type = PMIX_PROC_INFO;
920 PMIX_PROC_INFO_CREATE(v->data.pinfo, 1);
921
922 found = false;
923 OPAL_LIST_FOREACH(job, &mca_pmix_ext3x_component.jobids, opal_ext3x_jobid_trkr_t) {
924 if (job->jobid == kv->data.pinfo.name.jobid) {
925 (void)opal_string_copy(v->data.pinfo->proc.nspace, job->nspace, PMIX_MAX_NSLEN);
926 found = true;
927 break;
928 }
929 }
930 if (!found) {
931 (void)opal_snprintf_jobid(v->data.pinfo->proc.nspace, PMIX_MAX_NSLEN, kv->data.pinfo.name.jobid);
932 }
933 v->data.pinfo->proc.rank = ext3x_convert_opalrank(kv->data.pinfo.name.vpid);
934 if (NULL != kv->data.pinfo.hostname) {
935 v->data.pinfo->hostname = strdup(kv->data.pinfo.hostname);
936 }
937 if (NULL != kv->data.pinfo.executable_name) {
938 v->data.pinfo->executable_name = strdup(kv->data.pinfo.executable_name);
939 }
940 v->data.pinfo->pid = kv->data.pinfo.pid;
941 v->data.pinfo->exit_code = kv->data.pinfo.exit_code;
942 v->data.pinfo->state = ext3x_convert_opalstate(kv->data.pinfo.state);
943 break;
944 case OPAL_ENVAR:
945 v->type = PMIX_ENVAR;
946 PMIX_ENVAR_CONSTRUCT(&v->data.envar);
947 if (NULL != kv->data.envar.envar) {
948 v->data.envar.envar = strdup(kv->data.envar.envar);
949 }
950 if (NULL != kv->data.envar.value) {
951 v->data.envar.value = strdup(kv->data.envar.value);
952 }
953 v->data.envar.separator = kv->data.envar.separator;
954 break;
955 default:
956
957 break;
958 }
959 }
960
961 int ext3x_value_unload(opal_value_t *kv,
962 const pmix_value_t *v)
963 {
964 int rc=OPAL_SUCCESS;
965 bool found;
966 opal_ext3x_jobid_trkr_t *job;
967 opal_list_t *lt;
968 opal_value_t *ival;
969 size_t n;
970
971 switch(v->type) {
972 case PMIX_UNDEF:
973 kv->type = OPAL_UNDEF;
974 break;
975 case PMIX_BOOL:
976 kv->type = OPAL_BOOL;
977 memcpy(&kv->data.flag, &(v->data.flag), 1);
978 break;
979 case PMIX_BYTE:
980 kv->type = OPAL_BYTE;
981 memcpy(&kv->data.byte, &(v->data.byte), 1);
982 break;
983 case PMIX_STRING:
984 kv->type = OPAL_STRING;
985 if (NULL != v->data.string) {
986 kv->data.string = strdup(v->data.string);
987 }
988 break;
989 case PMIX_SIZE:
990 kv->type = OPAL_SIZE;
991 memcpy(&kv->data.size, &(v->data.size), sizeof(size_t));
992 break;
993 case PMIX_PID:
994 kv->type = OPAL_PID;
995 memcpy(&kv->data.pid, &(v->data.pid), sizeof(pid_t));
996 break;
997 case PMIX_INT:
998 kv->type = OPAL_INT;
999 memcpy(&kv->data.integer, &(v->data.integer), sizeof(int));
1000 break;
1001 case PMIX_INT8:
1002 kv->type = OPAL_INT8;
1003 memcpy(&kv->data.int8, &(v->data.int8), 1);
1004 break;
1005 case PMIX_INT16:
1006 kv->type = OPAL_INT16;
1007 memcpy(&kv->data.int16, &(v->data.int16), 2);
1008 break;
1009 case PMIX_INT32:
1010 kv->type = OPAL_INT32;
1011 memcpy(&kv->data.int32, &(v->data.int32), 4);
1012 break;
1013 case PMIX_INT64:
1014 kv->type = OPAL_INT64;
1015 memcpy(&kv->data.int64, &(v->data.int64), 8);
1016 break;
1017 case PMIX_UINT:
1018 kv->type = OPAL_UINT;
1019 memcpy(&kv->data.uint, &(v->data.uint), sizeof(int));
1020 break;
1021 case PMIX_UINT8:
1022 kv->type = OPAL_UINT8;
1023 memcpy(&kv->data.uint8, &(v->data.uint8), 1);
1024 break;
1025 case PMIX_UINT16:
1026 kv->type = OPAL_UINT16;
1027 memcpy(&kv->data.uint16, &(v->data.uint16), 2);
1028 break;
1029 case PMIX_UINT32:
1030 kv->type = OPAL_UINT32;
1031 memcpy(&kv->data.uint32, &(v->data.uint32), 4);
1032 break;
1033 case PMIX_UINT64:
1034 kv->type = OPAL_UINT64;
1035 memcpy(&kv->data.uint64, &(v->data.uint64), 8);
1036 break;
1037 case PMIX_FLOAT:
1038 kv->type = OPAL_FLOAT;
1039 memcpy(&kv->data.fval, &(v->data.fval), sizeof(float));
1040 break;
1041 case PMIX_DOUBLE:
1042 kv->type = OPAL_DOUBLE;
1043 memcpy(&kv->data.dval, &(v->data.dval), sizeof(double));
1044 break;
1045 case PMIX_TIMEVAL:
1046 kv->type = OPAL_TIMEVAL;
1047 memcpy(&kv->data.tv, &(v->data.tv), sizeof(struct timeval));
1048 break;
1049 case PMIX_TIME:
1050 kv->type = OPAL_TIME;
1051 memcpy(&kv->data.time, &(v->data.time), sizeof(time_t));
1052 break;
1053 case PMIX_STATUS:
1054 kv->type = OPAL_STATUS;
1055 kv->data.status = ext3x_convert_rc(v->data.status);
1056 break;
1057 case PMIX_VALUE:
1058 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1059 rc = OPAL_ERR_NOT_SUPPORTED;
1060 break;
1061 case PMIX_PROC:
1062 kv->type = OPAL_NAME;
1063
1064 found = false;
1065 OPAL_LIST_FOREACH(job, &mca_pmix_ext3x_component.jobids, opal_ext3x_jobid_trkr_t) {
1066 if (0 == strncmp(job->nspace, v->data.proc->nspace, PMIX_MAX_NSLEN)) {
1067 kv->data.name.jobid = job->jobid;
1068 found = true;
1069 break;
1070 }
1071 }
1072 if (!found) {
1073 if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&kv->data.name.jobid, v->data.proc->nspace))) {
1074 return ext3x_convert_opalrc(rc);
1075 }
1076 }
1077 kv->data.name.vpid = ext3x_convert_rank(v->data.proc->rank);
1078 break;
1079 case PMIX_APP:
1080 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1081 rc = OPAL_ERR_NOT_SUPPORTED;
1082 break;
1083 case PMIX_INFO:
1084 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1085 rc = OPAL_ERR_NOT_SUPPORTED;
1086 break;
1087 case PMIX_PDATA:
1088 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1089 rc = OPAL_ERR_NOT_SUPPORTED;
1090 break;
1091 case PMIX_BUFFER:
1092 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1093 rc = OPAL_ERR_NOT_SUPPORTED;
1094 break;
1095 case PMIX_BYTE_OBJECT:
1096 kv->type = OPAL_BYTE_OBJECT;
1097 if (NULL != v->data.bo.bytes && 0 < v->data.bo.size) {
1098 kv->data.bo.bytes = (uint8_t*)malloc(v->data.bo.size);
1099 memcpy(kv->data.bo.bytes, v->data.bo.bytes, v->data.bo.size);
1100 kv->data.bo.size = (int)v->data.bo.size;
1101 } else {
1102 kv->data.bo.bytes = NULL;
1103 kv->data.bo.size = 0;
1104 }
1105 break;
1106 case PMIX_KVAL:
1107 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1108 rc = OPAL_ERR_NOT_SUPPORTED;
1109 break;
1110 #ifdef PMIX_MODEX
1111 case PMIX_MODEX:
1112 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1113 rc = OPAL_ERR_NOT_SUPPORTED;
1114 break;
1115 #endif
1116 case PMIX_PERSIST:
1117 kv->type = OPAL_PERSIST;
1118 kv->data.uint8 = ext3x_convert_persist(v->data.persist);
1119 break;
1120 case PMIX_POINTER:
1121 kv->type = OPAL_PTR;
1122 kv->data.ptr = v->data.ptr;
1123 break;
1124 case PMIX_SCOPE:
1125 kv->type = OPAL_SCOPE;
1126 kv->data.uint8 = ext3x_convert_scope(v->data.scope);
1127 break;
1128 case PMIX_DATA_RANGE:
1129 kv->type = OPAL_DATA_RANGE;
1130 kv->data.uint8 = ext3x_convert_range(v->data.range);
1131 break;
1132 case PMIX_COMMAND:
1133 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1134 rc = OPAL_ERR_NOT_SUPPORTED;
1135 break;
1136 case PMIX_INFO_DIRECTIVES:
1137 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1138 rc = OPAL_ERR_NOT_SUPPORTED;
1139 break;
1140 case PMIX_DATA_TYPE:
1141 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1142 rc = OPAL_ERR_NOT_SUPPORTED;
1143 break;
1144 case PMIX_PROC_STATE:
1145 kv->type = OPAL_PROC_STATE;
1146
1147
1148 memcpy(&kv->data.uint8, &v->data.state, sizeof(uint8_t));
1149 break;
1150 case PMIX_PROC_INFO:
1151 kv->type = OPAL_PROC_INFO;
1152 if (NULL == v->data.pinfo) {
1153 rc = OPAL_ERR_BAD_PARAM;
1154 break;
1155 }
1156
1157 found = false;
1158 OPAL_LIST_FOREACH(job, &mca_pmix_ext3x_component.jobids, opal_ext3x_jobid_trkr_t) {
1159 if (0 == strncmp(job->nspace, v->data.pinfo->proc.nspace, PMIX_MAX_NSLEN)) {
1160 kv->data.pinfo.name.jobid = job->jobid;
1161 found = true;
1162 break;
1163 }
1164 }
1165 if (!found) {
1166 if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&kv->data.pinfo.name.jobid, v->data.pinfo->proc.nspace))) {
1167 return ext3x_convert_opalrc(rc);
1168 }
1169 }
1170 kv->data.pinfo.name.vpid = ext3x_convert_rank(v->data.pinfo->proc.rank);
1171 if (NULL != v->data.pinfo->hostname) {
1172 kv->data.pinfo.hostname = strdup(v->data.pinfo->hostname);
1173 }
1174 if (NULL != v->data.pinfo->executable_name) {
1175 kv->data.pinfo.executable_name = strdup(v->data.pinfo->executable_name);
1176 }
1177 kv->data.pinfo.pid = v->data.pinfo->pid;
1178 kv->data.pinfo.exit_code = v->data.pinfo->exit_code;
1179 kv->data.pinfo.state = ext3x_convert_state(v->data.pinfo->state);
1180 break;
1181 case PMIX_DATA_ARRAY:
1182 if (NULL == v->data.darray || NULL == v->data.darray->array) {
1183 kv->data.ptr = NULL;
1184 break;
1185 }
1186 lt = OBJ_NEW(opal_list_t);
1187 kv->type = OPAL_PTR;
1188 kv->data.ptr = (void*)lt;
1189 for (n=0; n < v->data.darray->size; n++) {
1190 ival = OBJ_NEW(opal_value_t);
1191 opal_list_append(lt, &ival->super);
1192
1193 if (PMIX_INFO == v->data.darray->type) {
1194 pmix_info_t *iptr = (pmix_info_t*)v->data.darray->array;
1195 if (NULL == iptr) {
1196 rc = OPAL_ERR_BAD_PARAM;
1197 break;
1198 }
1199 ival->key = strdup(iptr[n].key);
1200 rc = ext3x_value_unload(ival, &iptr[n].value);
1201 if (OPAL_SUCCESS != rc) {
1202 OPAL_LIST_RELEASE(lt);
1203 kv->type = OPAL_UNDEF;
1204 kv->data.ptr = NULL;
1205 break;
1206 }
1207 }
1208 }
1209 break;
1210 case PMIX_PROC_RANK:
1211 kv->type = OPAL_VPID;
1212 kv->data.name.vpid = ext3x_convert_rank(v->data.rank);
1213 break;
1214 case PMIX_QUERY:
1215 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1216 rc = OPAL_ERR_NOT_SUPPORTED;
1217 break;
1218 case PMIX_COMPRESSED_STRING:
1219 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1220 rc = OPAL_ERR_NOT_SUPPORTED;
1221 break;
1222 case PMIX_ALLOC_DIRECTIVE:
1223 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1224 rc = OPAL_ERR_NOT_SUPPORTED;
1225 break;
1226 #ifdef PMIX_INFO_ARRAY
1227 case PMIX_INFO_ARRAY:
1228 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1229 rc = OPAL_ERR_NOT_SUPPORTED;
1230 break;
1231 #endif
1232 case PMIX_IOF_CHANNEL:
1233 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1234 rc = OPAL_ERR_NOT_SUPPORTED;
1235 break;
1236 case PMIX_ENVAR:
1237 kv->type = OPAL_ENVAR;
1238 OBJ_CONSTRUCT(&kv->data.envar, opal_envar_t);
1239 if (NULL != v->data.envar.envar) {
1240 kv->data.envar.envar = strdup(v->data.envar.envar);
1241 }
1242 if (NULL != v->data.envar.value) {
1243 kv->data.envar.value = strdup(v->data.envar.value);
1244 }
1245 kv->data.envar.separator = v->data.envar.separator;
1246 break;
1247 default:
1248
1249 rc = OPAL_ERROR;
1250 break;
1251 }
1252 return rc;
1253 }
1254
1255 static void errreg_cbfunc (pmix_status_t status,
1256 size_t errhandler_ref,
1257 void *cbdata)
1258 {
1259 ext3x_opcaddy_t *op = (ext3x_opcaddy_t*)cbdata;
1260
1261 OPAL_ACQUIRE_OBJECT(op);
1262 op->event->index = errhandler_ref;
1263 opal_output_verbose(5, opal_pmix_base_framework.framework_output,
1264 "PMIX3x errreg_cbfunc - error handler registered status=%d, reference=%lu",
1265 status, (unsigned long)errhandler_ref);
1266 if (NULL != op->evregcbfunc) {
1267 op->evregcbfunc(ext3x_convert_rc(status), errhandler_ref, op->cbdata);
1268 }
1269 OBJ_RELEASE(op);
1270 }
1271
1272 static void register_handler(opal_list_t *event_codes,
1273 opal_list_t *info,
1274 opal_pmix_notification_fn_t evhandler,
1275 opal_pmix_evhandler_reg_cbfunc_t cbfunc,
1276 void *cbdata)
1277 {
1278 ext3x_opcaddy_t *op = (ext3x_opcaddy_t*)cbdata;
1279 size_t n;
1280 opal_value_t *kv;
1281
1282 OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1283 if (0 >= opal_pmix_base.initialized) {
1284 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1285 if (NULL != cbfunc) {
1286 cbfunc(OPAL_ERR_NOT_INITIALIZED, 0, cbdata);
1287 }
1288 return;
1289 }
1290
1291 op = OBJ_NEW(ext3x_opcaddy_t);
1292 op->evregcbfunc = cbfunc;
1293 op->cbdata = cbdata;
1294
1295
1296 if (NULL != event_codes) {
1297 op->ncodes = opal_list_get_size(event_codes);
1298 op->pcodes = (pmix_status_t*)malloc(op->ncodes * sizeof(pmix_status_t));
1299 n=0;
1300 OPAL_LIST_FOREACH(kv, event_codes, opal_value_t) {
1301 op->pcodes[n] = ext3x_convert_opalrc(kv->data.integer);
1302 ++n;
1303 }
1304 }
1305
1306
1307 if (NULL != info && 0 < (op->ninfo = opal_list_get_size(info))) {
1308 PMIX_INFO_CREATE(op->info, op->ninfo);
1309 n=0;
1310 OPAL_LIST_FOREACH(kv, info, opal_value_t) {
1311 (void)opal_string_copy(op->info[n].key, kv->key, PMIX_MAX_KEYLEN);
1312 ext3x_value_load(&op->info[n].value, kv);
1313 ++n;
1314 }
1315 }
1316
1317
1318 op->event = OBJ_NEW(opal_ext3x_event_t);
1319 op->event->handler = evhandler;
1320 opal_list_append(&mca_pmix_ext3x_component.events, &op->event->super);
1321 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1322
1323 PMIx_Register_event_handler(op->pcodes, op->ncodes,
1324 op->info, op->ninfo,
1325 ext3x_event_hdlr, errreg_cbfunc, op);
1326 return;
1327 }
1328
1329 static void deregister_handler(size_t evhandler,
1330 opal_pmix_op_cbfunc_t cbfunc,
1331 void *cbdata)
1332 {
1333 ext3x_opcaddy_t *op;
1334 opal_ext3x_event_t *event;
1335
1336 OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1337 if (0 >= opal_pmix_base.initialized) {
1338 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1339 if (NULL != cbfunc) {
1340 cbfunc(OPAL_ERR_NOT_INITIALIZED, cbdata);
1341 }
1342 return;
1343 }
1344
1345
1346 OPAL_LIST_FOREACH(event, &mca_pmix_ext3x_component.events, opal_ext3x_event_t) {
1347 if (evhandler == event->index) {
1348 opal_list_remove_item(&mca_pmix_ext3x_component.events, &event->super);
1349 OBJ_RELEASE(event);
1350 break;
1351 }
1352 }
1353
1354 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1355
1356 op = OBJ_NEW(ext3x_opcaddy_t);
1357 op->opcbfunc = cbfunc;
1358 op->cbdata = cbdata;
1359
1360
1361 PMIx_Deregister_event_handler(evhandler, opcbfunc, op);
1362 return;
1363 }
1364
1365 static void notify_complete(pmix_status_t status, void *cbdata)
1366 {
1367 ext3x_opcaddy_t *op = (ext3x_opcaddy_t*)cbdata;
1368 if (NULL != op->opcbfunc) {
1369 op->opcbfunc(ext3x_convert_rc(status), op->cbdata);
1370 }
1371 OBJ_RELEASE(op);
1372 }
1373
1374 static int notify_event(int status,
1375 const opal_process_name_t *source,
1376 opal_pmix_data_range_t range,
1377 opal_list_t *info,
1378 opal_pmix_op_cbfunc_t cbfunc, void *cbdata)
1379 {
1380 ext3x_opcaddy_t *op;
1381 opal_value_t *kv;
1382 pmix_proc_t p, *pptr;
1383 pmix_status_t pstatus;
1384 size_t n;
1385 pmix_data_range_t prange;
1386 char *nsptr;
1387
1388 OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1389 if (0 >= opal_pmix_base.initialized) {
1390 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1391 return OPAL_ERR_NOT_INITIALIZED;
1392 }
1393
1394 op = OBJ_NEW(ext3x_opcaddy_t);
1395 op->opcbfunc = cbfunc;
1396 op->cbdata = cbdata;
1397
1398
1399 pstatus = ext3x_convert_opalrc(status);
1400
1401
1402 if (NULL == source) {
1403 pptr = NULL;
1404 } else {
1405 if (NULL == (nsptr = ext3x_convert_jobid(source->jobid))) {
1406 OBJ_RELEASE(op);
1407 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1408 return OPAL_ERR_NOT_FOUND;
1409 }
1410 (void)opal_string_copy(p.nspace, nsptr, PMIX_MAX_NSLEN);
1411 p.rank = ext3x_convert_opalrank(source->vpid);
1412 pptr = &p;
1413 }
1414 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1415
1416
1417 prange = ext3x_convert_opalrange(range);
1418
1419
1420 if (NULL != info && 0 < (op->ninfo = opal_list_get_size(info))) {
1421 PMIX_INFO_CREATE(op->info, op->ninfo);
1422 n=0;
1423 OPAL_LIST_FOREACH(kv, info, opal_value_t) {
1424 (void)opal_string_copy(op->info[n].key, kv->key, PMIX_MAX_KEYLEN);
1425
1426
1427 if (0 == strcmp(kv->key, OPAL_PMIX_JOB_TERM_STATUS)) {
1428 op->info[n].value.type = PMIX_STATUS;
1429 op->info[n].value.data.status = ext3x_convert_opalrc(kv->data.integer);
1430 } else {
1431 ext3x_value_load(&op->info[n].value, kv);
1432 }
1433 ++n;
1434 }
1435 }
1436
1437
1438 pstatus = PMIx_Notify_event(pstatus, pptr, prange, op->info, op->ninfo, notify_complete, op);
1439
1440 return ext3x_convert_rc(pstatus);
1441 }
1442
1443 static void relcbfunc(void *cbdata)
1444 {
1445 opal_list_t *results = (opal_list_t*)cbdata;
1446 if (NULL != results) {
1447 OPAL_LIST_RELEASE(results);
1448 }
1449 }
1450
1451 static void infocbfunc(pmix_status_t status,
1452 pmix_info_t *info, size_t ninfo,
1453 void *cbdata,
1454 pmix_release_cbfunc_t release_fn,
1455 void *release_cbdata)
1456 {
1457 ext3x_opcaddy_t *cd = (ext3x_opcaddy_t*)cbdata;
1458 int rc = OPAL_SUCCESS;
1459 opal_list_t *results = NULL;
1460 opal_value_t *iptr;
1461 size_t n;
1462
1463 OPAL_ACQUIRE_OBJECT(cd);
1464
1465
1466 if (NULL != info) {
1467 results = OBJ_NEW(opal_list_t);
1468 for (n=0; n < ninfo; n++) {
1469 iptr = OBJ_NEW(opal_value_t);
1470 opal_list_append(results, &iptr->super);
1471 iptr->key = strdup(info[n].key);
1472 if (OPAL_SUCCESS != (rc = ext3x_value_unload(iptr, &info[n].value))) {
1473 OPAL_ERROR_LOG(rc);
1474 OPAL_LIST_RELEASE(results);
1475 results = NULL;
1476 break;
1477 }
1478 }
1479 }
1480
1481 if (NULL != release_fn) {
1482 release_fn(release_cbdata);
1483 }
1484
1485
1486 if (NULL != cd->qcbfunc) {
1487 cd->qcbfunc(rc, results, cd->cbdata, relcbfunc, results);
1488 }
1489 OBJ_RELEASE(cd);
1490 }
1491
1492 static void ext3x_query(opal_list_t *queries,
1493 opal_pmix_info_cbfunc_t cbfunc, void *cbdata)
1494 {
1495 int rc;
1496 opal_value_t *ival;
1497 size_t n, nqueries, nq;
1498 ext3x_opcaddy_t *cd;
1499 pmix_status_t prc;
1500 opal_pmix_query_t *q;
1501
1502 OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1503 if (0 >= opal_pmix_base.initialized) {
1504 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1505 if (NULL != cbfunc) {
1506 cbfunc(OPAL_ERR_NOT_INITIALIZED, NULL, cbdata, NULL, NULL);
1507 }
1508 return;
1509 }
1510 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1511
1512
1513 cd = OBJ_NEW(ext3x_opcaddy_t);
1514
1515
1516 if (NULL == queries || 0 == (nqueries = opal_list_get_size(queries))) {
1517 rc = OPAL_ERR_BAD_PARAM;
1518 goto CLEANUP;
1519 }
1520
1521
1522 cd->qcbfunc = cbfunc;
1523 cd->cbdata = cbdata;
1524 cd->nqueries = nqueries;
1525
1526
1527 PMIX_QUERY_CREATE(cd->queries, cd->nqueries);
1528 n=0;
1529 OPAL_LIST_FOREACH(q, queries, opal_pmix_query_t) {
1530 cd->queries[n].keys = opal_argv_copy(q->keys);
1531 cd->queries[n].nqual = opal_list_get_size(&q->qualifiers);
1532 if (0 < cd->queries[n].nqual) {
1533 PMIX_INFO_CREATE(cd->queries[n].qualifiers, cd->queries[n].nqual);
1534 nq = 0;
1535 OPAL_LIST_FOREACH(ival, &q->qualifiers, opal_value_t) {
1536 (void)opal_string_copy(cd->queries[n].qualifiers[nq].key, ival->key, PMIX_MAX_KEYLEN);
1537 ext3x_value_load(&cd->queries[n].qualifiers[nq].value, ival);
1538 ++nq;
1539 }
1540 }
1541 ++n;
1542 }
1543
1544
1545 if (PMIX_SUCCESS != (prc = PMIx_Query_info_nb(cd->queries, cd->nqueries,
1546 infocbfunc, cd))) {
1547
1548 rc = ext3x_convert_rc(prc);
1549 goto CLEANUP;
1550 }
1551
1552 return;
1553
1554 CLEANUP:
1555 if (NULL != cbfunc) {
1556 cbfunc(rc, NULL, cbdata, NULL, NULL);
1557 }
1558 OBJ_RELEASE(cd);
1559 return;
1560 }
1561
1562 static void ext3x_log(opal_list_t *info,
1563 opal_pmix_op_cbfunc_t cbfunc, void *cbdata)
1564 {
1565 int rc;
1566 opal_value_t *ival;
1567 size_t n, ninfo;
1568 ext3x_opcaddy_t *cd;
1569 pmix_status_t prc;
1570
1571 OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1572 if (0 >= opal_pmix_base.initialized) {
1573 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1574 if (NULL != cbfunc) {
1575 cbfunc(OPAL_ERR_NOT_INITIALIZED, cbdata);
1576 }
1577 return;
1578 }
1579 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1580
1581
1582 cd = OBJ_NEW(ext3x_opcaddy_t);
1583
1584
1585 if (NULL == info || 0 == (ninfo = opal_list_get_size(info))) {
1586 rc = OPAL_ERR_BAD_PARAM;
1587 goto CLEANUP;
1588 }
1589
1590
1591 cd->opcbfunc = cbfunc;
1592 cd->cbdata = cbdata;
1593 cd->ninfo = ninfo;
1594
1595
1596 PMIX_INFO_CREATE(cd->info, cd->ninfo);
1597 n=0;
1598 OPAL_LIST_FOREACH(ival, info, opal_value_t) {
1599 (void)opal_string_copy(cd->info[n].key, ival->key, PMIX_MAX_KEYLEN);
1600 ext3x_value_load(&cd->info[n].value, ival);
1601 ++n;
1602 }
1603
1604
1605 if (PMIX_SUCCESS != (prc = PMIx_Log_nb(cd->info, cd->ninfo, NULL, 0,
1606 opcbfunc, cd))) {
1607
1608 rc = ext3x_convert_rc(prc);
1609 goto CLEANUP;
1610 }
1611
1612 return;
1613
1614 CLEANUP:
1615 if (NULL != cbfunc) {
1616 cbfunc(rc, cbdata);
1617 }
1618 OBJ_RELEASE(cd);
1619 }
1620
1621 opal_pmix_alloc_directive_t ext3x_convert_allocdir(pmix_alloc_directive_t dir)
1622 {
1623 switch (dir) {
1624 case PMIX_ALLOC_NEW:
1625 return OPAL_PMIX_ALLOC_NEW;
1626 case PMIX_ALLOC_EXTEND:
1627 return OPAL_PMIX_ALLOC_EXTEND;
1628 case PMIX_ALLOC_RELEASE:
1629 return OPAL_PMIX_ALLOC_RELEASE;
1630 case PMIX_ALLOC_REAQUIRE:
1631 return OPAL_PMIX_ALLOC_REAQCUIRE;
1632 default:
1633 return OPAL_PMIX_ALLOC_UNDEF;
1634 }
1635 }
1636
1637 int ext3x_convert_state(pmix_proc_state_t state)
1638 {
1639 switch(state) {
1640 case PMIX_PROC_STATE_UNDEF:
1641 return 0;
1642 case PMIX_PROC_STATE_PREPPED:
1643 case PMIX_PROC_STATE_LAUNCH_UNDERWAY:
1644 return 1;
1645 case PMIX_PROC_STATE_RESTART:
1646 return 2;
1647 case PMIX_PROC_STATE_TERMINATE:
1648 return 3;
1649 case PMIX_PROC_STATE_RUNNING:
1650 return 4;
1651 case PMIX_PROC_STATE_CONNECTED:
1652 return 5;
1653 case PMIX_PROC_STATE_UNTERMINATED:
1654 return 15;
1655 case PMIX_PROC_STATE_TERMINATED:
1656 return 20;
1657 case PMIX_PROC_STATE_KILLED_BY_CMD:
1658 return 51;
1659 case PMIX_PROC_STATE_ABORTED:
1660 return 52;
1661 case PMIX_PROC_STATE_FAILED_TO_START:
1662 return 53;
1663 case PMIX_PROC_STATE_ABORTED_BY_SIG:
1664 return 54;
1665 case PMIX_PROC_STATE_TERM_WO_SYNC:
1666 return 55;
1667 case PMIX_PROC_STATE_COMM_FAILED:
1668 return 56;
1669 case PMIX_PROC_STATE_CALLED_ABORT:
1670 return 58;
1671 case PMIX_PROC_STATE_MIGRATING:
1672 return 60;
1673 case PMIX_PROC_STATE_CANNOT_RESTART:
1674 return 61;
1675 case PMIX_PROC_STATE_TERM_NON_ZERO:
1676 return 62;
1677 case PMIX_PROC_STATE_FAILED_TO_LAUNCH:
1678 return 63;
1679 default:
1680 return 0;
1681 }
1682 }
1683
1684 pmix_proc_state_t ext3x_convert_opalstate(int state)
1685 {
1686 switch(state) {
1687 case 0:
1688 return PMIX_PROC_STATE_UNDEF;
1689 case 1:
1690 return PMIX_PROC_STATE_LAUNCH_UNDERWAY;
1691 case 2:
1692 return PMIX_PROC_STATE_RESTART;
1693 case 3:
1694 return PMIX_PROC_STATE_TERMINATE;
1695 case 4:
1696 return PMIX_PROC_STATE_RUNNING;
1697 case 5:
1698 return PMIX_PROC_STATE_CONNECTED;
1699 case 51:
1700 return PMIX_PROC_STATE_KILLED_BY_CMD;
1701 case 52:
1702 return PMIX_PROC_STATE_ABORTED;
1703 case 53:
1704 return PMIX_PROC_STATE_FAILED_TO_START;
1705 case 54:
1706 return PMIX_PROC_STATE_ABORTED_BY_SIG;
1707 case 55:
1708 return PMIX_PROC_STATE_TERM_WO_SYNC;
1709 case 56:
1710 return PMIX_PROC_STATE_COMM_FAILED;
1711 case 58:
1712 return PMIX_PROC_STATE_CALLED_ABORT;
1713 case 59:
1714 return PMIX_PROC_STATE_MIGRATING;
1715 case 61:
1716 return PMIX_PROC_STATE_CANNOT_RESTART;
1717 case 62:
1718 return PMIX_PROC_STATE_TERM_NON_ZERO;
1719 case 63:
1720 return PMIX_PROC_STATE_FAILED_TO_LAUNCH;
1721 default:
1722 return PMIX_PROC_STATE_UNDEF;
1723 }
1724 }
1725
1726
1727 OBJ_CLASS_INSTANCE(opal_ext3x_jobid_trkr_t,
1728 opal_list_item_t,
1729 NULL, NULL);
1730
1731 static void evcon(opal_ext3x_event_t *p)
1732 {
1733 OPAL_PMIX_CONSTRUCT_LOCK(&p->lock);
1734 p->handler = NULL;
1735 p->cbdata = NULL;
1736 }
1737 static void evdes(opal_ext3x_event_t *p)
1738 {
1739 OPAL_PMIX_DESTRUCT_LOCK(&p->lock);
1740 }
1741 OBJ_CLASS_INSTANCE(opal_ext3x_event_t,
1742 opal_list_item_t,
1743 evcon, evdes);
1744
1745 static void opcon(ext3x_opcaddy_t *p)
1746 {
1747 memset(&p->p, 0, sizeof(pmix_proc_t));
1748 p->nspace = NULL;
1749 p->procs = NULL;
1750 p->nprocs = 0;
1751 p->pdata = NULL;
1752 p->npdata = 0;
1753 p->error_procs = NULL;
1754 p->nerror_procs = 0;
1755 p->info = NULL;
1756 p->ninfo = 0;
1757 p->apps = NULL;
1758 p->sz = 0;
1759 OPAL_PMIX_CONSTRUCT_LOCK(&p->lock);
1760 p->codes = NULL;
1761 p->pcodes = NULL;
1762 p->ncodes = 0;
1763 p->queries = NULL;
1764 p->nqueries = 0;
1765 p->event = NULL;
1766 p->opcbfunc = NULL;
1767 p->mdxcbfunc = NULL;
1768 p->valcbfunc = NULL;
1769 p->lkcbfunc = NULL;
1770 p->spcbfunc = NULL;
1771 p->evregcbfunc = NULL;
1772 p->qcbfunc = NULL;
1773 p->cbdata = NULL;
1774 }
1775 static void opdes(ext3x_opcaddy_t *p)
1776 {
1777 OPAL_PMIX_DESTRUCT_LOCK(&p->lock);
1778 if (NULL != p->nspace) {
1779 free(p->nspace);
1780 }
1781 if (NULL != p->procs) {
1782 PMIX_PROC_FREE(p->procs, p->nprocs);
1783 }
1784 if (NULL != p->pdata) {
1785 PMIX_PDATA_FREE(p->pdata, p->npdata);
1786 }
1787 if (NULL != p->error_procs) {
1788 PMIX_PROC_FREE(p->error_procs, p->nerror_procs);
1789 }
1790 if (NULL != p->info) {
1791 PMIX_INFO_FREE(p->info, p->ninfo);
1792 }
1793 if (NULL != p->apps) {
1794 PMIX_APP_FREE(p->apps, p->sz);
1795 }
1796 if (NULL != p->pcodes) {
1797 free(p->pcodes);
1798 }
1799 if (NULL != p->queries) {
1800 PMIX_QUERY_FREE(p->queries, p->nqueries);
1801 }
1802 }
1803 OBJ_CLASS_INSTANCE(ext3x_opcaddy_t,
1804 opal_object_t,
1805 opcon, opdes);
1806
1807 static void ocadcon(ext3x_opalcaddy_t *p)
1808 {
1809 OBJ_CONSTRUCT(&p->procs, opal_list_t);
1810 OBJ_CONSTRUCT(&p->info, opal_list_t);
1811 OBJ_CONSTRUCT(&p->apps, opal_list_t);
1812 p->opcbfunc = NULL;
1813 p->dmdxfunc = NULL;
1814 p->mdxcbfunc = NULL;
1815 p->lkupcbfunc = NULL;
1816 p->spwncbfunc = NULL;
1817 p->cbdata = NULL;
1818 p->odmdxfunc = NULL;
1819 p->infocbfunc = NULL;
1820 p->toolcbfunc = NULL;
1821 p->ocbdata = NULL;
1822 }
1823 static void ocaddes(ext3x_opalcaddy_t *p)
1824 {
1825 OPAL_LIST_DESTRUCT(&p->procs);
1826 OPAL_LIST_DESTRUCT(&p->info);
1827 OPAL_LIST_DESTRUCT(&p->apps);
1828 }
1829 OBJ_CLASS_INSTANCE(ext3x_opalcaddy_t,
1830 opal_object_t,
1831 ocadcon, ocaddes);
1832
1833 static void tscon(ext3x_threadshift_t *p)
1834 {
1835 OPAL_PMIX_CONSTRUCT_LOCK(&p->lock);
1836 p->msg = NULL;
1837 p->strings = NULL;
1838 p->source = NULL;
1839 p->event_codes = NULL;
1840 p->info = NULL;
1841 OBJ_CONSTRUCT(&p->results, opal_list_t);
1842 p->evhandler = NULL;
1843 p->nondefault = false;
1844 p->cbfunc = NULL;
1845 p->opcbfunc = NULL;
1846 p->cbdata = NULL;
1847 }
1848 static void tsdes(ext3x_threadshift_t *p)
1849 {
1850 OPAL_PMIX_DESTRUCT_LOCK(&p->lock);
1851 if (NULL != p->strings) {
1852 free(p->strings);
1853 }
1854 OPAL_LIST_DESTRUCT(&p->results);
1855 }
1856 OBJ_CLASS_INSTANCE(ext3x_threadshift_t,
1857 opal_object_t,
1858 tscon, tsdes);
1859
1860 static void dmcon(opal_ext3x_dmx_trkr_t *p)
1861 {
1862 p->nspace = NULL;
1863 p->cbfunc = NULL;
1864 p->cbdata = NULL;
1865 }
1866 static void dmdes(opal_ext3x_dmx_trkr_t *p)
1867 {
1868 if (NULL != p->nspace) {
1869 free(p->nspace);
1870 }
1871 }
1872 OBJ_CLASS_INSTANCE(opal_ext3x_dmx_trkr_t,
1873 opal_list_item_t,
1874 dmcon, dmdes);