This source file includes following definitions.
- init
- finalize
- register_type
- data_type_string
- pmix20_v21_to_v20_datatype
- pmix20_bfrop_store_data_type
- pmix20_bfrop_get_data_type
- pmix20_bfrop_value_load
- pmix20_bfrop_value_unload
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 #include <src/include/pmix_config.h>
28
29 #include "src/util/error.h"
30 #include "src/include/pmix_globals.h"
31 #include "src/client/pmix_client_ops.h"
32 #include "src/mca/bfrops/base/base.h"
33 #include "bfrop_pmix20.h"
34 #include "internal.h"
35
36 static pmix_status_t init(void);
37 static void finalize(void);
38 static pmix_status_t register_type(const char *name,
39 pmix_data_type_t type,
40 pmix_bfrop_pack_fn_t pack,
41 pmix_bfrop_unpack_fn_t unpack,
42 pmix_bfrop_copy_fn_t copy,
43 pmix_bfrop_print_fn_t print);
44 static const char* data_type_string(pmix_data_type_t type);
45
46 pmix_bfrops_module_t pmix_bfrops_pmix20_module = {
47 .version = "v20",
48 .init = init,
49 .finalize = finalize,
50 .pack = pmix20_bfrop_pack,
51 .unpack = pmix20_bfrop_unpack,
52 .copy = pmix20_bfrop_copy,
53 .print = pmix20_bfrop_print,
54 .copy_payload = pmix20_bfrop_copy_payload,
55 .value_xfer = pmix20_bfrop_value_xfer,
56 .value_load = pmix20_bfrop_value_load,
57 .value_unload = pmix20_bfrop_value_unload,
58 .value_cmp = pmix20_bfrop_value_cmp,
59 .register_type = register_type,
60 .data_type_string = data_type_string
61 };
62
63 static pmix_status_t init(void)
64 {
65
66 PMIX_REGISTER_TYPE("PMIX_BOOL", PMIX_BOOL,
67 pmix20_bfrop_pack_bool,
68 pmix20_bfrop_unpack_bool,
69 pmix20_bfrop_std_copy,
70 pmix20_bfrop_print_bool,
71 &mca_bfrops_v20_component.types);
72
73 PMIX_REGISTER_TYPE("PMIX_BYTE", PMIX_BYTE,
74 pmix20_bfrop_pack_byte,
75 pmix20_bfrop_unpack_byte,
76 pmix20_bfrop_std_copy,
77 pmix20_bfrop_print_byte,
78 &mca_bfrops_v20_component.types);
79
80 PMIX_REGISTER_TYPE("PMIX_STRING", PMIX_STRING,
81 pmix20_bfrop_pack_string,
82 pmix20_bfrop_unpack_string,
83 pmix20_bfrop_copy_string,
84 pmix20_bfrop_print_string,
85 &mca_bfrops_v20_component.types);
86
87
88 PMIX_REGISTER_TYPE("PMIX_SIZE", PMIX_SIZE,
89 pmix20_bfrop_pack_sizet,
90 pmix20_bfrop_unpack_sizet,
91 pmix20_bfrop_std_copy,
92 pmix20_bfrop_print_size,
93 &mca_bfrops_v20_component.types);
94
95 PMIX_REGISTER_TYPE("PMIX_PID", PMIX_PID,
96 pmix20_bfrop_pack_pid,
97 pmix20_bfrop_unpack_pid,
98 pmix20_bfrop_std_copy,
99 pmix20_bfrop_print_pid,
100 &mca_bfrops_v20_component.types);
101
102 PMIX_REGISTER_TYPE("PMIX_INT", PMIX_INT,
103 pmix20_bfrop_pack_int,
104 pmix20_bfrop_unpack_int,
105 pmix20_bfrop_std_copy,
106 pmix20_bfrop_print_int,
107 &mca_bfrops_v20_component.types);
108
109
110 PMIX_REGISTER_TYPE("PMIX_INT8", PMIX_INT8,
111 pmix20_bfrop_pack_byte,
112 pmix20_bfrop_unpack_byte,
113 pmix20_bfrop_std_copy,
114 pmix20_bfrop_print_int8,
115 &mca_bfrops_v20_component.types);
116
117 PMIX_REGISTER_TYPE("PMIX_INT16", PMIX_INT16,
118 pmix20_bfrop_pack_int16,
119 pmix20_bfrop_unpack_int16,
120 pmix20_bfrop_std_copy,
121 pmix20_bfrop_print_int16,
122 &mca_bfrops_v20_component.types);
123
124 PMIX_REGISTER_TYPE("PMIX_INT32", PMIX_INT32,
125 pmix20_bfrop_pack_int32,
126 pmix20_bfrop_unpack_int32,
127 pmix20_bfrop_std_copy,
128 pmix20_bfrop_print_int32,
129 &mca_bfrops_v20_component.types);
130
131 PMIX_REGISTER_TYPE("PMIX_INT64", PMIX_INT64,
132 pmix20_bfrop_pack_int64,
133 pmix20_bfrop_unpack_int64,
134 pmix20_bfrop_std_copy,
135 pmix20_bfrop_print_int64,
136 &mca_bfrops_v20_component.types);
137
138 PMIX_REGISTER_TYPE("PMIX_UINT", PMIX_UINT,
139 pmix20_bfrop_pack_int,
140 pmix20_bfrop_unpack_int,
141 pmix20_bfrop_std_copy,
142 pmix20_bfrop_print_uint,
143 &mca_bfrops_v20_component.types);
144
145 PMIX_REGISTER_TYPE("PMIX_UINT8", PMIX_UINT8,
146 pmix20_bfrop_pack_byte,
147 pmix20_bfrop_unpack_byte,
148 pmix20_bfrop_std_copy,
149 pmix20_bfrop_print_uint8,
150 &mca_bfrops_v20_component.types);
151
152 PMIX_REGISTER_TYPE("PMIX_UINT16", PMIX_UINT16,
153 pmix20_bfrop_pack_int16,
154 pmix20_bfrop_unpack_int16,
155 pmix20_bfrop_std_copy,
156 pmix20_bfrop_print_uint16,
157 &mca_bfrops_v20_component.types);
158
159 PMIX_REGISTER_TYPE("PMIX_UINT32", PMIX_UINT32,
160 pmix20_bfrop_pack_int32,
161 pmix20_bfrop_unpack_int32,
162 pmix20_bfrop_std_copy,
163 pmix20_bfrop_print_uint32,
164 &mca_bfrops_v20_component.types);
165
166 PMIX_REGISTER_TYPE("PMIX_UINT64", PMIX_UINT64,
167 pmix20_bfrop_pack_int64,
168 pmix20_bfrop_unpack_int64,
169 pmix20_bfrop_std_copy,
170 pmix20_bfrop_print_uint64,
171 &mca_bfrops_v20_component.types);
172
173 PMIX_REGISTER_TYPE("PMIX_FLOAT", PMIX_FLOAT,
174 pmix20_bfrop_pack_float,
175 pmix20_bfrop_unpack_float,
176 pmix20_bfrop_std_copy,
177 pmix20_bfrop_print_float,
178 &mca_bfrops_v20_component.types);
179
180 PMIX_REGISTER_TYPE("PMIX_DOUBLE", PMIX_DOUBLE,
181 pmix20_bfrop_pack_double,
182 pmix20_bfrop_unpack_double,
183 pmix20_bfrop_std_copy,
184 pmix20_bfrop_print_double,
185 &mca_bfrops_v20_component.types);
186
187 PMIX_REGISTER_TYPE("PMIX_TIMEVAL", PMIX_TIMEVAL,
188 pmix20_bfrop_pack_timeval,
189 pmix20_bfrop_unpack_timeval,
190 pmix20_bfrop_std_copy,
191 pmix20_bfrop_print_timeval,
192 &mca_bfrops_v20_component.types);
193
194 PMIX_REGISTER_TYPE("PMIX_TIME", PMIX_TIME,
195 pmix20_bfrop_pack_time,
196 pmix20_bfrop_unpack_time,
197 pmix20_bfrop_std_copy,
198 pmix20_bfrop_print_time,
199 &mca_bfrops_v20_component.types);
200
201 PMIX_REGISTER_TYPE("PMIX_STATUS", PMIX_STATUS,
202 pmix20_bfrop_pack_status,
203 pmix20_bfrop_unpack_status,
204 pmix20_bfrop_std_copy,
205 pmix20_bfrop_print_status,
206 &mca_bfrops_v20_component.types);
207
208 PMIX_REGISTER_TYPE("PMIX_VALUE", PMIX_VALUE,
209 pmix20_bfrop_pack_value,
210 pmix20_bfrop_unpack_value,
211 pmix20_bfrop_copy_value,
212 pmix20_bfrop_print_value,
213 &mca_bfrops_v20_component.types);
214
215 PMIX_REGISTER_TYPE("PMIX_PROC", PMIX_PROC,
216 pmix20_bfrop_pack_proc,
217 pmix20_bfrop_unpack_proc,
218 pmix20_bfrop_copy_proc,
219 pmix20_bfrop_print_proc,
220 &mca_bfrops_v20_component.types);
221
222 PMIX_REGISTER_TYPE("PMIX_APP", PMIX_APP,
223 pmix20_bfrop_pack_app,
224 pmix20_bfrop_unpack_app,
225 pmix20_bfrop_copy_app,
226 pmix20_bfrop_print_app,
227 &mca_bfrops_v20_component.types);
228
229 PMIX_REGISTER_TYPE("PMIX_INFO", PMIX_INFO,
230 pmix20_bfrop_pack_info,
231 pmix20_bfrop_unpack_info,
232 pmix20_bfrop_copy_info,
233 pmix20_bfrop_print_info,
234 &mca_bfrops_v20_component.types);
235
236 PMIX_REGISTER_TYPE("PMIX_PDATA", PMIX_PDATA,
237 pmix20_bfrop_pack_pdata,
238 pmix20_bfrop_unpack_pdata,
239 pmix20_bfrop_copy_pdata,
240 pmix20_bfrop_print_pdata,
241 &mca_bfrops_v20_component.types);
242
243 PMIX_REGISTER_TYPE("PMIX_BUFFER", PMIX_BUFFER,
244 pmix20_bfrop_pack_buf,
245 pmix20_bfrop_unpack_buf,
246 pmix20_bfrop_copy_buf,
247 pmix20_bfrop_print_buf,
248 &mca_bfrops_v20_component.types);
249
250 PMIX_REGISTER_TYPE("PMIX_BYTE_OBJECT", PMIX_BYTE_OBJECT,
251 pmix20_bfrop_pack_bo,
252 pmix20_bfrop_unpack_bo,
253 pmix20_bfrop_copy_bo,
254 pmix20_bfrop_print_bo,
255 &mca_bfrops_v20_component.types);
256
257 PMIX_REGISTER_TYPE("PMIX_KVAL", PMIX_KVAL,
258 pmix20_bfrop_pack_kval,
259 pmix20_bfrop_unpack_kval,
260 pmix20_bfrop_copy_kval,
261 pmix20_bfrop_print_kval,
262 &mca_bfrops_v20_component.types);
263
264 PMIX_REGISTER_TYPE("PMIX_MODEX", PMIX_MODEX,
265 pmix20_bfrop_pack_modex,
266 pmix20_bfrop_unpack_modex,
267 pmix20_bfrop_copy_modex,
268 pmix20_bfrop_print_modex,
269 &mca_bfrops_v20_component.types);
270
271
272 PMIX_REGISTER_TYPE("PMIX_PERSIST", PMIX_PERSIST,
273 pmix20_bfrop_pack_persist,
274 pmix20_bfrop_unpack_persist,
275 pmix20_bfrop_std_copy,
276 pmix20_bfrop_print_persist,
277 &mca_bfrops_v20_component.types);
278
279 PMIX_REGISTER_TYPE("PMIX_POINTER", PMIX_POINTER,
280 pmix20_bfrop_pack_ptr,
281 pmix20_bfrop_unpack_ptr,
282 pmix20_bfrop_std_copy,
283 pmix20_bfrop_print_ptr,
284 &mca_bfrops_v20_component.types);
285
286 PMIX_REGISTER_TYPE("PMIX_SCOPE", PMIX_SCOPE,
287 pmix20_bfrop_pack_scope,
288 pmix20_bfrop_unpack_scope,
289 pmix20_bfrop_std_copy,
290 pmix20_bfrop_std_copy,
291 &mca_bfrops_v20_component.types);
292
293 PMIX_REGISTER_TYPE("PMIX_DATA_RANGE", PMIX_DATA_RANGE,
294 pmix20_bfrop_pack_range,
295 pmix20_bfrop_unpack_range,
296 pmix20_bfrop_std_copy,
297 pmix20_bfrop_print_ptr,
298 &mca_bfrops_v20_component.types);
299
300 PMIX_REGISTER_TYPE("PMIX_COMMAND", PMIX_COMMAND,
301 pmix20_bfrop_pack_cmd,
302 pmix20_bfrop_unpack_cmd,
303 pmix20_bfrop_std_copy,
304 pmix20_bfrop_print_cmd,
305 &mca_bfrops_v20_component.types);
306
307 PMIX_REGISTER_TYPE("PMIX_INFO_DIRECTIVES", PMIX_INFO_DIRECTIVES,
308 pmix20_bfrop_pack_infodirs,
309 pmix20_bfrop_unpack_infodirs,
310 pmix20_bfrop_std_copy,
311 pmix20_bfrop_print_infodirs,
312 &mca_bfrops_v20_component.types);
313
314 PMIX_REGISTER_TYPE("PMIX_DATA_TYPE", PMIX_DATA_TYPE,
315 pmix20_bfrop_pack_datatype,
316 pmix20_bfrop_unpack_datatype,
317 pmix20_bfrop_std_copy,
318 pmix_bfrops_base_print_datatype,
319 &mca_bfrops_v20_component.types);
320
321 PMIX_REGISTER_TYPE("PMIX_PROC_STATE", PMIX_PROC_STATE,
322 pmix20_bfrop_pack_pstate,
323 pmix20_bfrop_unpack_pstate,
324 pmix20_bfrop_std_copy,
325 pmix20_bfrop_print_pstate,
326 &mca_bfrops_v20_component.types);
327
328 PMIX_REGISTER_TYPE("PMIX_PROC_INFO", PMIX_PROC_INFO,
329 pmix20_bfrop_pack_pinfo,
330 pmix20_bfrop_unpack_pinfo,
331 pmix20_bfrop_copy_pinfo,
332 pmix20_bfrop_print_pinfo,
333 &mca_bfrops_v20_component.types);
334
335 PMIX_REGISTER_TYPE("PMIX_DATA_ARRAY", PMIX_DATA_ARRAY,
336 pmix20_bfrop_pack_darray,
337 pmix20_bfrop_unpack_darray,
338 pmix20_bfrop_copy_darray,
339 pmix20_bfrop_print_darray,
340 &mca_bfrops_v20_component.types);
341
342 PMIX_REGISTER_TYPE("PMIX_PROC_RANK", PMIX_PROC_RANK,
343 pmix20_bfrop_pack_rank,
344 pmix20_bfrop_unpack_rank,
345 pmix20_bfrop_std_copy,
346 pmix20_bfrop_print_rank,
347 &mca_bfrops_v20_component.types);
348
349 PMIX_REGISTER_TYPE("PMIX_QUERY", PMIX_QUERY,
350 pmix20_bfrop_pack_query,
351 pmix20_bfrop_unpack_query,
352 pmix20_bfrop_copy_query,
353 pmix20_bfrop_print_query,
354 &mca_bfrops_v20_component.types);
355
356 PMIX_REGISTER_TYPE("PMIX_COMPRESSED_STRING",
357 PMIX_COMPRESSED_STRING,
358 pmix20_bfrop_pack_bo,
359 pmix20_bfrop_unpack_bo,
360 pmix20_bfrop_copy_bo,
361 pmix20_bfrop_print_bo,
362 &mca_bfrops_v20_component.types);
363
364 PMIX_REGISTER_TYPE("PMIX_ALLOC_DIRECTIVE",
365 PMIX_ALLOC_DIRECTIVE,
366 pmix20_bfrop_pack_alloc_directive,
367 pmix20_bfrop_unpack_alloc_directive,
368 pmix20_bfrop_std_copy,
369 pmix20_bfrop_print_alloc_directive,
370 &mca_bfrops_v20_component.types);
371
372
373 PMIX_REGISTER_TYPE("PMIX_INFO_ARRAY", PMIX_INFO_ARRAY,
374 pmix20_bfrop_pack_array,
375 pmix20_bfrop_unpack_array,
376 pmix20_bfrop_copy_array,
377 pmix20_bfrop_print_array,
378 &mca_bfrops_v20_component.types);
379
380
381
382 return PMIX_SUCCESS;
383 }
384
385 static void finalize(void)
386 {
387 int n;
388 pmix_bfrop_type_info_t *info;
389
390 for (n=0; n < mca_bfrops_v20_component.types.size; n++) {
391 if (NULL != (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v20_component.types, n))) {
392 PMIX_RELEASE(info);
393 pmix_pointer_array_set_item(&mca_bfrops_v20_component.types, n, NULL);
394 }
395 }
396 }
397
398 static pmix_status_t register_type(const char *name, pmix_data_type_t type,
399 pmix_bfrop_pack_fn_t pack,
400 pmix_bfrop_unpack_fn_t unpack,
401 pmix_bfrop_copy_fn_t copy,
402 pmix_bfrop_print_fn_t print)
403 {
404 PMIX_REGISTER_TYPE(name, type,
405 pack, unpack,
406 copy, print,
407 &mca_bfrops_v20_component.types);
408 return PMIX_SUCCESS;
409 }
410
411 static const char* data_type_string(pmix_data_type_t type)
412 {
413 pmix_bfrop_type_info_t *info;
414
415 if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v20_component.types, type))) {
416 return NULL;
417 }
418 return info->odti_name;
419 }
420
421 pmix_data_type_t pmix20_v21_to_v20_datatype(pmix_data_type_t v21type)
422 {
423 pmix_data_type_t v20type;
424
425
426
427
428 switch(v21type) {
429 case PMIX_COMMAND:
430
431
432 v20type = PMIX_UINT32;
433 break;
434
435 default:
436 v20type = v21type;
437 }
438 return v20type;
439 }
440
441 pmix_status_t pmix20_bfrop_store_data_type(pmix_pointer_array_t *regtypes,
442 pmix_buffer_t *buffer, pmix_data_type_t type)
443 {
444 pmix_data_type_t v20type;
445
446 v20type = pmix20_v21_to_v20_datatype(type);
447 return pmix20_bfrop_pack_datatype(regtypes, buffer, &v20type, 1, PMIX_DATA_TYPE);
448 }
449
450 pmix_status_t pmix20_bfrop_get_data_type(pmix_pointer_array_t *regtypes,
451 pmix_buffer_t *buffer, pmix_data_type_t *type)
452 {
453 int32_t n=1;
454 pmix_status_t rc;
455
456 rc = pmix20_bfrop_unpack_datatype(regtypes, buffer, type, &n, PMIX_DATA_TYPE);
457
458 return rc;
459 }
460
461 void pmix20_bfrop_value_load(pmix_value_t *v,
462 const void *data,
463 pmix_data_type_t type)
464 {
465 pmix_byte_object_t *bo;
466 pmix_proc_info_t *pi;
467
468 v->type = type;
469 if (NULL == data) {
470
471 memset(&v->data, 0, sizeof(v->data));
472 if (PMIX_BOOL == type) {
473 v->data.flag = true;
474 }
475 } else {
476 switch(type) {
477 case PMIX_UNDEF:
478 break;
479 case PMIX_BOOL:
480 memcpy(&(v->data.flag), data, 1);
481 break;
482 case PMIX_BYTE:
483 memcpy(&(v->data.byte), data, 1);
484 break;
485 case PMIX_STRING:
486 v->data.string = strdup(data);
487 break;
488 case PMIX_SIZE:
489 memcpy(&(v->data.size), data, sizeof(size_t));
490 break;
491 case PMIX_PID:
492 memcpy(&(v->data.pid), data, sizeof(pid_t));
493 break;
494 case PMIX_INT:
495 memcpy(&(v->data.integer), data, sizeof(int));
496 break;
497 case PMIX_INT8:
498 memcpy(&(v->data.int8), data, 1);
499 break;
500 case PMIX_INT16:
501 memcpy(&(v->data.int16), data, 2);
502 break;
503 case PMIX_INT32:
504 memcpy(&(v->data.int32), data, 4);
505 break;
506 case PMIX_INT64:
507 memcpy(&(v->data.int64), data, 8);
508 break;
509 case PMIX_UINT:
510 memcpy(&(v->data.uint), data, sizeof(int));
511 break;
512 case PMIX_UINT8:
513 memcpy(&(v->data.uint8), data, 1);
514 break;
515 case PMIX_UINT16:
516 memcpy(&(v->data.uint16), data, 2);
517 break;
518 case PMIX_UINT32:
519 memcpy(&(v->data.uint32), data, 4);
520 break;
521 case PMIX_UINT64:
522 memcpy(&(v->data.uint64), data, 8);
523 break;
524 case PMIX_FLOAT:
525 memcpy(&(v->data.fval), data, sizeof(float));
526 break;
527 case PMIX_DOUBLE:
528 memcpy(&(v->data.dval), data, sizeof(double));
529 break;
530 case PMIX_TIMEVAL:
531 memcpy(&(v->data.tv), data, sizeof(struct timeval));
532 break;
533 case PMIX_TIME:
534 memcpy(&(v->data.time), data, sizeof(time_t));
535 break;
536 case PMIX_STATUS:
537 memcpy(&(v->data.status), data, sizeof(pmix_status_t));
538 break;
539 case PMIX_PROC_RANK:
540 memcpy(&(v->data.rank), data, sizeof(pmix_rank_t));
541 break;
542 case PMIX_PROC:
543 PMIX_PROC_CREATE(v->data.proc, 1);
544 if (NULL == v->data.proc) {
545 PMIX_ERROR_LOG(PMIX_ERR_NOMEM);
546 return;
547 }
548 memcpy(v->data.proc, data, sizeof(pmix_proc_t));
549 break;
550 case PMIX_BYTE_OBJECT:
551 bo = (pmix_byte_object_t*)data;
552 v->data.bo.bytes = bo->bytes;
553 memcpy(&(v->data.bo.size), &bo->size, sizeof(size_t));
554 break;
555 case PMIX_PERSIST:
556 memcpy(&(v->data.persist), data, sizeof(pmix_persistence_t));
557 break;
558 case PMIX_SCOPE:
559 memcpy(&(v->data.scope), data, sizeof(pmix_scope_t));
560 break;
561 case PMIX_DATA_RANGE:
562 memcpy(&(v->data.range), data, sizeof(pmix_data_range_t));
563 break;
564 case PMIX_PROC_STATE:
565 memcpy(&(v->data.state), data, sizeof(pmix_proc_state_t));
566 break;
567 case PMIX_PROC_INFO:
568 PMIX_PROC_INFO_CREATE(v->data.pinfo, 1);
569 if (NULL == v->data.pinfo) {
570 PMIX_ERROR_LOG(PMIX_ERR_NOMEM);
571 return;
572 }
573 pi = (pmix_proc_info_t*)data;
574 memcpy(&(v->data.pinfo->proc), &pi->proc, sizeof(pmix_proc_t));
575 if (NULL != pi->hostname) {
576 v->data.pinfo->hostname = strdup(pi->hostname);
577 }
578 if (NULL != pi->executable_name) {
579 v->data.pinfo->executable_name = strdup(pi->executable_name);
580 }
581 memcpy(&(v->data.pinfo->pid), &pi->pid, sizeof(pid_t));
582 memcpy(&(v->data.pinfo->exit_code), &pi->exit_code, sizeof(int));
583 break;
584 case PMIX_POINTER:
585 memcpy(&(v->data.ptr), data, sizeof(void*));
586 break;
587 default:
588
589 PMIX_ERROR_LOG(PMIX_ERR_UNKNOWN_DATA_TYPE);
590 break;
591 }
592 }
593 }
594
595 pmix_status_t pmix20_bfrop_value_unload(pmix_value_t *kv,
596 void **data,
597 size_t *sz)
598 {
599 pmix_status_t rc;
600 pmix_proc_t *pc;
601
602 rc = PMIX_SUCCESS;
603 if (NULL == data ||
604 (NULL == *data &&
605 PMIX_STRING != kv->type &&
606 PMIX_BYTE_OBJECT != kv->type)) {
607 rc = PMIX_ERR_BAD_PARAM;
608 } else {
609 switch(kv->type) {
610 case PMIX_UNDEF:
611 rc = PMIX_ERR_UNKNOWN_DATA_TYPE;
612 break;
613 case PMIX_BOOL:
614 memcpy(*data, &(kv->data.flag), 1);
615 *sz = 1;
616 break;
617 case PMIX_BYTE:
618 memcpy(*data, &(kv->data.byte), 1);
619 *sz = 1;
620 break;
621 case PMIX_STRING:
622 if (NULL != kv->data.string) {
623 *data = strdup(kv->data.string);
624 *sz = strlen(kv->data.string);
625 }
626 break;
627 case PMIX_SIZE:
628 memcpy(*data, &(kv->data.size), sizeof(size_t));
629 *sz = sizeof(size_t);
630 break;
631 case PMIX_PID:
632 memcpy(*data, &(kv->data.pid), sizeof(pid_t));
633 *sz = sizeof(pid_t);
634 break;
635 case PMIX_INT:
636 memcpy(*data, &(kv->data.integer), sizeof(int));
637 *sz = sizeof(int);
638 break;
639 case PMIX_INT8:
640 memcpy(*data, &(kv->data.int8), 1);
641 *sz = 1;
642 break;
643 case PMIX_INT16:
644 memcpy(*data, &(kv->data.int16), 2);
645 *sz = 2;
646 break;
647 case PMIX_INT32:
648 memcpy(*data, &(kv->data.int32), 4);
649 *sz = 4;
650 break;
651 case PMIX_INT64:
652 memcpy(*data, &(kv->data.int64), 8);
653 *sz = 8;
654 break;
655 case PMIX_UINT:
656 memcpy(*data, &(kv->data.uint), sizeof(int));
657 *sz = sizeof(int);
658 break;
659 case PMIX_UINT8:
660 memcpy(*data, &(kv->data.uint8), 1);
661 *sz = 1;
662 break;
663 case PMIX_UINT16:
664 memcpy(*data, &(kv->data.uint16), 2);
665 *sz = 2;
666 break;
667 case PMIX_UINT32:
668 memcpy(*data, &(kv->data.uint32), 4);
669 *sz = 4;
670 break;
671 case PMIX_UINT64:
672 memcpy(*data, &(kv->data.uint64), 8);
673 *sz = 8;
674 break;
675 case PMIX_FLOAT:
676 memcpy(*data, &(kv->data.fval), sizeof(float));
677 *sz = sizeof(float);
678 break;
679 case PMIX_DOUBLE:
680 memcpy(*data, &(kv->data.dval), sizeof(double));
681 *sz = sizeof(double);
682 break;
683 case PMIX_TIMEVAL:
684 memcpy(*data, &(kv->data.tv), sizeof(struct timeval));
685 *sz = sizeof(struct timeval);
686 break;
687 case PMIX_TIME:
688 memcpy(*data, &(kv->data.time), sizeof(time_t));
689 *sz = sizeof(time_t);
690 break;
691 case PMIX_STATUS:
692 memcpy(*data, &(kv->data.status), sizeof(pmix_status_t));
693 *sz = sizeof(pmix_status_t);
694 break;
695 case PMIX_PROC_RANK:
696 memcpy(*data, &(kv->data.rank), sizeof(pmix_rank_t));
697 *sz = sizeof(pmix_rank_t);
698 break;
699 case PMIX_PROC:
700 PMIX_PROC_CREATE(pc, 1);
701 if (NULL == pc) {
702 PMIX_ERROR_LOG(PMIX_ERR_NOMEM);
703 rc = PMIX_ERR_NOMEM;
704 break;
705 }
706 memcpy(pc, kv->data.proc, sizeof(pmix_proc_t));
707 *sz = sizeof(pmix_proc_t);
708 *data = pc;
709 break;
710 case PMIX_BYTE_OBJECT:
711 if (NULL != kv->data.bo.bytes && 0 < kv->data.bo.size) {
712 *data = kv->data.bo.bytes;
713 *sz = kv->data.bo.size;
714 } else {
715 *data = NULL;
716 *sz = 0;
717 }
718 break;
719 case PMIX_PERSIST:
720 memcpy(*data, &(kv->data.persist), sizeof(pmix_persistence_t));
721 *sz = sizeof(pmix_persistence_t);
722 break;
723 case PMIX_SCOPE:
724 memcpy(*data, &(kv->data.scope), sizeof(pmix_scope_t));
725 *sz = sizeof(pmix_scope_t);
726 break;
727 case PMIX_DATA_RANGE:
728 memcpy(*data, &(kv->data.range), sizeof(pmix_data_range_t));
729 *sz = sizeof(pmix_data_range_t);
730 break;
731 case PMIX_PROC_STATE:
732 memcpy(*data, &(kv->data.state), sizeof(pmix_proc_state_t));
733 *sz = sizeof(pmix_proc_state_t);
734 break;
735 case PMIX_POINTER:
736 memcpy(*data, &(kv->data.ptr), sizeof(void*));
737 *sz = sizeof(void*);
738 break;
739 default:
740
741 rc = PMIX_ERROR;
742 break;
743 }
744 }
745 return rc;
746 }