This source file includes following definitions.
- pmix20_bfrop_copy
- pmix20_bfrop_copy_payload
- pmix20_bfrop_std_copy
- pmix20_bfrop_value_cmp
- pmix20_bfrop_copy_string
- pmix_value_cmp
- pmix20_bfrop_value_xfer
- pmix20_bfrop_copy_value
- pmix20_bfrop_copy_info
- pmix20_bfrop_copy_buf
- pmix20_bfrop_copy_app
- pmix20_bfrop_copy_kval
- pmix20_bfrop_copy_proc
- pmix20_bfrop_copy_modex
- pmix20_bfrop_copy_persist
- pmix20_bfrop_copy_bo
- pmix20_bfrop_copy_pdata
- pmix20_bfrop_copy_pinfo
- pmix20_bfrop_copy_darray
- pmix20_bfrop_copy_query
- pmix20_bfrop_copy_array
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 #include <src/include/pmix_config.h>
24
25
26 #include "src/util/argv.h"
27 #include "src/util/error.h"
28 #include "src/util/output.h"
29 #include "src/mca/bfrops/base/base.h"
30 #include "bfrop_pmix20.h"
31 #include "internal.h"
32
33 pmix_status_t pmix20_bfrop_copy(void **dest, void *src, pmix_data_type_t type)
34 {
35 pmix_bfrop_type_info_t *info;
36
37
38 if (NULL == dest) {
39 PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
40 return PMIX_ERR_BAD_PARAM;
41 }
42 if (NULL == src) {
43 PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
44 return PMIX_ERR_BAD_PARAM;
45 }
46
47
48
49 if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v20_component.types, type))) {
50 PMIX_ERROR_LOG(PMIX_ERR_UNKNOWN_DATA_TYPE);
51 return PMIX_ERR_UNKNOWN_DATA_TYPE;
52 }
53
54 return info->odti_copy_fn(dest, src, type);
55 }
56
57 pmix_status_t pmix20_bfrop_copy_payload(pmix_buffer_t *dest, pmix_buffer_t *src)
58 {
59 size_t to_copy = 0;
60 char *ptr;
61
62 if( NULL == dest->base_ptr ){
63
64 dest->type = src->type;
65 } else if( dest->type != src->type ){
66
67 PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
68 return PMIX_ERR_BAD_PARAM;
69 }
70
71 to_copy = src->pack_ptr - src->unpack_ptr;
72 if( NULL == (ptr = pmix_bfrop_buffer_extend(dest, to_copy)) ){
73 PMIX_ERROR_LOG(PMIX_ERR_OUT_OF_RESOURCE);
74 return PMIX_ERR_OUT_OF_RESOURCE;
75 }
76 memcpy(ptr,src->unpack_ptr, to_copy);
77 dest->bytes_used += to_copy;
78 dest->pack_ptr += to_copy;
79 return PMIX_SUCCESS;
80 }
81
82
83
84
85
86 pmix_status_t pmix20_bfrop_std_copy(void **dest, void *src, pmix_data_type_t type)
87 {
88 size_t datasize;
89 uint8_t *val = NULL;
90
91 switch(type) {
92 case PMIX_BOOL:
93 datasize = sizeof(bool);
94 break;
95
96 case PMIX_INT:
97 case PMIX_UINT:
98 datasize = sizeof(int);
99 break;
100
101 case PMIX_SIZE:
102 datasize = sizeof(size_t);
103 break;
104
105 case PMIX_PID:
106 datasize = sizeof(pid_t);
107 break;
108
109 case PMIX_BYTE:
110 case PMIX_INT8:
111 case PMIX_UINT8:
112 datasize = 1;
113 break;
114
115 case PMIX_INT16:
116 case PMIX_UINT16:
117 datasize = 2;
118 break;
119
120 case PMIX_INT32:
121 case PMIX_UINT32:
122 datasize = 4;
123 break;
124
125 case PMIX_INT64:
126 case PMIX_UINT64:
127 datasize = 8;
128 break;
129
130 case PMIX_FLOAT:
131 datasize = sizeof(float);
132 break;
133
134 case PMIX_TIMEVAL:
135 datasize = sizeof(struct timeval);
136 break;
137
138 case PMIX_TIME:
139 datasize = sizeof(time_t);
140 break;
141
142 case PMIX_STATUS:
143 datasize = sizeof(pmix_status_t);
144 break;
145
146 case PMIX_PROC_RANK:
147 datasize = sizeof(pmix_rank_t);
148 break;
149
150 case PMIX_PERSIST:
151 datasize = sizeof(pmix_persistence_t);
152 break;
153
154 case PMIX_POINTER:
155 datasize = sizeof(char*);
156 break;
157
158 case PMIX_SCOPE:
159 datasize = sizeof(pmix_scope_t);
160 break;
161
162 case PMIX_DATA_RANGE:
163 datasize = sizeof(pmix_data_range_t);
164 break;
165
166 case PMIX_COMMAND:
167 datasize = sizeof(pmix_cmd_t);
168 break;
169
170 case PMIX_INFO_DIRECTIVES:
171 datasize = sizeof(pmix_info_directives_t);
172 break;
173
174 case PMIX_PROC_STATE:
175 datasize = sizeof(pmix_proc_state_t);
176 break;
177
178 case PMIX_ALLOC_DIRECTIVE:
179 datasize = sizeof(pmix_alloc_directive_t);
180 break;
181
182 default:
183 return PMIX_ERR_UNKNOWN_DATA_TYPE;
184 }
185
186 val = (uint8_t*)malloc(datasize);
187 if (NULL == val) {
188 return PMIX_ERR_OUT_OF_RESOURCE;
189 }
190
191 memcpy(val, src, datasize);
192 *dest = val;
193
194 return PMIX_SUCCESS;
195 }
196
197
198 pmix_value_cmp_t pmix20_bfrop_value_cmp(pmix_value_t *p, pmix_value_t *p1)
199 {
200 bool rc = false;
201 switch (p->type) {
202 case PMIX_BOOL:
203 rc = (p->data.flag == p1->data.flag);
204 break;
205 case PMIX_BYTE:
206 rc = (p->data.byte == p1->data.byte);
207 break;
208 case PMIX_SIZE:
209 rc = (p->data.size == p1->data.size);
210 break;
211 case PMIX_INT:
212 rc = (p->data.integer == p1->data.integer);
213 break;
214 case PMIX_INT8:
215 rc = (p->data.int8 == p1->data.int8);
216 break;
217 case PMIX_INT16:
218 rc = (p->data.int16 == p1->data.int16);
219 break;
220 case PMIX_INT32:
221 rc = (p->data.int32 == p1->data.int32);
222 break;
223 case PMIX_INT64:
224 rc = (p->data.int64 == p1->data.int64);
225 break;
226 case PMIX_UINT:
227 rc = (p->data.uint == p1->data.uint);
228 break;
229 case PMIX_UINT8:
230 rc = (p->data.uint8 == p1->data.int8);
231 break;
232 case PMIX_UINT16:
233 rc = (p->data.uint16 == p1->data.uint16);
234 break;
235 case PMIX_UINT32:
236 rc = (p->data.uint32 == p1->data.uint32);
237 break;
238 case PMIX_UINT64:
239 rc = (p->data.uint64 == p1->data.uint64);
240 break;
241 case PMIX_STRING:
242 rc = strcmp(p->data.string, p1->data.string);
243 break;
244 default:
245 pmix_output(0, "COMPARE-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
246 }
247 if (rc) {
248 return PMIX_EQUAL;
249 }
250 return PMIX_VALUE1_GREATER;
251 }
252
253
254
255
256
257
258 pmix_status_t pmix20_bfrop_copy_string(char **dest, char *src, pmix_data_type_t type)
259 {
260 if (NULL == src) {
261 *dest = NULL;
262 } else {
263 *dest = strdup(src);
264 }
265
266 return PMIX_SUCCESS;
267 }
268
269 bool pmix_value_cmp(pmix_value_t *p, pmix_value_t *p1)
270 {
271 bool rc = false;
272
273 if (p->type != p1->type) {
274 return rc;
275 }
276
277 switch (p->type) {
278 case PMIX_UNDEF:
279 rc = true;
280 break;
281 case PMIX_BOOL:
282 rc = (p->data.flag == p1->data.flag);
283 break;
284 case PMIX_BYTE:
285 rc = (p->data.byte == p1->data.byte);
286 break;
287 case PMIX_SIZE:
288 rc = (p->data.size == p1->data.size);
289 break;
290 case PMIX_INT:
291 rc = (p->data.integer == p1->data.integer);
292 break;
293 case PMIX_INT8:
294 rc = (p->data.int8 == p1->data.int8);
295 break;
296 case PMIX_INT16:
297 rc = (p->data.int16 == p1->data.int16);
298 break;
299 case PMIX_INT32:
300 rc = (p->data.int32 == p1->data.int32);
301 break;
302 case PMIX_INT64:
303 rc = (p->data.int64 == p1->data.int64);
304 break;
305 case PMIX_UINT:
306 rc = (p->data.uint == p1->data.uint);
307 break;
308 case PMIX_UINT8:
309 rc = (p->data.uint8 == p1->data.int8);
310 break;
311 case PMIX_UINT16:
312 rc = (p->data.uint16 == p1->data.uint16);
313 break;
314 case PMIX_UINT32:
315 rc = (p->data.uint32 == p1->data.uint32);
316 break;
317 case PMIX_UINT64:
318 rc = (p->data.uint64 == p1->data.uint64);
319 break;
320 case PMIX_STRING:
321 rc = strcmp(p->data.string, p1->data.string);
322 break;
323 case PMIX_COMPRESSED_STRING:
324 if (p->data.bo.size != p1->data.bo.size) {
325 return false;
326 } else {
327 return true;
328 }
329 case PMIX_STATUS:
330 rc = (p->data.status == p1->data.status);
331 break;
332 default:
333 pmix_output(0, "COMPARE-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
334 }
335 return rc;
336 }
337
338
339
340 pmix_status_t pmix20_bfrop_value_xfer(pmix_value_t *p, const pmix_value_t *src)
341 {
342 size_t n, m;
343 pmix_status_t rc;
344 char **prarray, **strarray;
345 pmix_value_t *pv, *sv;
346 pmix_info_t *p1, *s1;
347 pmix_app_t *pa, *sa;
348 pmix_pdata_t *pd, *sd;
349 pmix_buffer_t *pb, *sb;
350 pmix_byte_object_t *pbo, *sbo;
351 pmix_kval_t *pk, *sk;
352 pmix_modex_data_t *pm, *sm;
353 pmix_proc_info_t *pi, *si;
354 pmix_query_t *pq, *sq;
355
356
357 p->type = src->type;
358 switch (src->type) {
359 case PMIX_UNDEF:
360 break;
361 case PMIX_BOOL:
362 p->data.flag = src->data.flag;
363 break;
364 case PMIX_BYTE:
365 p->data.byte = src->data.byte;
366 break;
367 case PMIX_STRING:
368 if (NULL != src->data.string) {
369 p->data.string = strdup(src->data.string);
370 } else {
371 p->data.string = NULL;
372 }
373 break;
374 case PMIX_SIZE:
375 p->data.size = src->data.size;
376 break;
377 case PMIX_PID:
378 p->data.pid = src->data.pid;
379 break;
380 case PMIX_INT:
381
382 memcpy(&p->data.integer, &src->data.integer, sizeof(int));
383 break;
384 case PMIX_INT8:
385 p->data.int8 = src->data.int8;
386 break;
387 case PMIX_INT16:
388
389 memcpy(&p->data.int16, &src->data.int16, 2);
390 break;
391 case PMIX_INT32:
392
393 memcpy(&p->data.int32, &src->data.int32, 4);
394 break;
395 case PMIX_INT64:
396
397 memcpy(&p->data.int64, &src->data.int64, 8);
398 break;
399 case PMIX_UINT:
400
401 memcpy(&p->data.uint, &src->data.uint, sizeof(unsigned int));
402 break;
403 case PMIX_UINT8:
404 p->data.uint8 = src->data.uint8;
405 break;
406 case PMIX_UINT16:
407
408 memcpy(&p->data.uint16, &src->data.uint16, 2);
409 break;
410 case PMIX_UINT32:
411
412 memcpy(&p->data.uint32, &src->data.uint32, 4);
413 break;
414 case PMIX_UINT64:
415
416 memcpy(&p->data.uint64, &src->data.uint64, 8);
417 break;
418 case PMIX_FLOAT:
419 p->data.fval = src->data.fval;
420 break;
421 case PMIX_DOUBLE:
422 p->data.dval = src->data.dval;
423 break;
424 case PMIX_TIMEVAL:
425 memcpy(&p->data.tv, &src->data.tv, sizeof(struct timeval));
426 break;
427 case PMIX_TIME:
428 memcpy(&p->data.time, &src->data.time, sizeof(time_t));
429 break;
430 case PMIX_STATUS:
431 memcpy(&p->data.status, &src->data.status, sizeof(pmix_status_t));
432 break;
433 case PMIX_PROC:
434 memcpy(&p->data.proc, &src->data.proc, sizeof(pmix_proc_t));
435 break;
436 case PMIX_PROC_RANK:
437 memcpy(&p->data.proc, &src->data.rank, sizeof(pmix_rank_t));
438 break;
439 case PMIX_BYTE_OBJECT:
440 case PMIX_COMPRESSED_STRING:
441 memset(&p->data.bo, 0, sizeof(pmix_byte_object_t));
442 if (NULL != src->data.bo.bytes && 0 < src->data.bo.size) {
443 p->data.bo.bytes = malloc(src->data.bo.size);
444 memcpy(p->data.bo.bytes, src->data.bo.bytes, src->data.bo.size);
445 p->data.bo.size = src->data.bo.size;
446 } else {
447 p->data.bo.bytes = NULL;
448 p->data.bo.size = 0;
449 }
450 break;
451 case PMIX_PERSIST:
452 memcpy(&p->data.persist, &src->data.persist, sizeof(pmix_persistence_t));
453 break;
454 case PMIX_SCOPE:
455 memcpy(&p->data.scope, &src->data.scope, sizeof(pmix_scope_t));
456 break;
457 case PMIX_DATA_RANGE:
458 memcpy(&p->data.range, &src->data.range, sizeof(pmix_data_range_t));
459 break;
460 case PMIX_PROC_STATE:
461 memcpy(&p->data.state, &src->data.state, sizeof(pmix_proc_state_t));
462 break;
463 case PMIX_PROC_INFO:
464 PMIX_PROC_INFO_CREATE(p->data.pinfo, 1);
465 if (NULL != src->data.pinfo->hostname) {
466 p->data.pinfo->hostname = strdup(src->data.pinfo->hostname);
467 }
468 if (NULL != src->data.pinfo->executable_name) {
469 p->data.pinfo->executable_name = strdup(src->data.pinfo->executable_name);
470 }
471 memcpy(&p->data.pinfo->pid, &src->data.pinfo->pid, sizeof(pid_t));
472 memcpy(&p->data.pinfo->exit_code, &src->data.pinfo->exit_code, sizeof(int));
473 memcpy(&p->data.pinfo->state, &src->data.pinfo->state, sizeof(pmix_proc_state_t));
474 break;
475 case PMIX_DATA_ARRAY:
476 p->data.darray = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
477 p->data.darray->type = src->data.darray->type;
478 p->data.darray->size = src->data.darray->size;
479 if (0 == p->data.darray->size || NULL == src->data.darray->array) {
480 p->data.darray->array = NULL;
481 p->data.darray->size = 0;
482 break;
483 }
484
485 switch (src->data.darray->type) {
486 case PMIX_UINT8:
487 case PMIX_INT8:
488 case PMIX_BYTE:
489 p->data.darray->array = (char*)malloc(src->data.darray->size);
490 if (NULL == p->data.darray->array) {
491 return PMIX_ERR_NOMEM;
492 }
493 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size);
494 break;
495 case PMIX_UINT16:
496 case PMIX_INT16:
497 p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint16_t));
498 if (NULL == p->data.darray->array) {
499 return PMIX_ERR_NOMEM;
500 }
501 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint16_t));
502 break;
503 case PMIX_UINT32:
504 case PMIX_INT32:
505 p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint32_t));
506 if (NULL == p->data.darray->array) {
507 return PMIX_ERR_NOMEM;
508 }
509 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint32_t));
510 break;
511 case PMIX_UINT64:
512 case PMIX_INT64:
513 p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint64_t));
514 if (NULL == p->data.darray->array) {
515 return PMIX_ERR_NOMEM;
516 }
517 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint64_t));
518 break;
519 case PMIX_BOOL:
520 p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(bool));
521 if (NULL == p->data.darray->array) {
522 return PMIX_ERR_NOMEM;
523 }
524 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(bool));
525 break;
526 case PMIX_SIZE:
527 p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(size_t));
528 if (NULL == p->data.darray->array) {
529 return PMIX_ERR_NOMEM;
530 }
531 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(size_t));
532 break;
533 case PMIX_PID:
534 p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(pid_t));
535 if (NULL == p->data.darray->array) {
536 return PMIX_ERR_NOMEM;
537 }
538 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pid_t));
539 break;
540 case PMIX_STRING:
541 p->data.darray->array = (char**)malloc(src->data.darray->size * sizeof(char*));
542 if (NULL == p->data.darray->array) {
543 return PMIX_ERR_NOMEM;
544 }
545 prarray = (char**)p->data.darray->array;
546 strarray = (char**)src->data.darray->array;
547 for (n=0; n < src->data.darray->size; n++) {
548 if (NULL != strarray[n]) {
549 prarray[n] = strdup(strarray[n]);
550 }
551 }
552 break;
553 case PMIX_INT:
554 case PMIX_UINT:
555 p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(int));
556 if (NULL == p->data.darray->array) {
557 return PMIX_ERR_NOMEM;
558 }
559 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(int));
560 break;
561 case PMIX_FLOAT:
562 p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(float));
563 if (NULL == p->data.darray->array) {
564 return PMIX_ERR_NOMEM;
565 }
566 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(float));
567 break;
568 case PMIX_DOUBLE:
569 p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(double));
570 if (NULL == p->data.darray->array) {
571 return PMIX_ERR_NOMEM;
572 }
573 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(double));
574 break;
575 case PMIX_TIMEVAL:
576 p->data.darray->array = (struct timeval*)malloc(src->data.darray->size * sizeof(struct timeval));
577 if (NULL == p->data.darray->array) {
578 return PMIX_ERR_NOMEM;
579 }
580 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(struct timeval));
581 break;
582 case PMIX_TIME:
583 p->data.darray->array = (time_t*)malloc(src->data.darray->size * sizeof(time_t));
584 if (NULL == p->data.darray->array) {
585 return PMIX_ERR_NOMEM;
586 }
587 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(time_t));
588 break;
589 case PMIX_STATUS:
590 p->data.darray->array = (pmix_status_t*)malloc(src->data.darray->size * sizeof(pmix_status_t));
591 if (NULL == p->data.darray->array) {
592 return PMIX_ERR_NOMEM;
593 }
594 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_status_t));
595 break;
596 case PMIX_VALUE:
597 PMIX_VALUE_CREATE(p->data.darray->array, src->data.darray->size);
598 if (NULL == p->data.darray->array) {
599 return PMIX_ERR_NOMEM;
600 }
601 pv = (pmix_value_t*)p->data.darray->array;
602 sv = (pmix_value_t*)src->data.darray->array;
603 for (n=0; n < src->data.darray->size; n++) {
604 if (PMIX_SUCCESS != (rc = pmix20_bfrop_value_xfer(&pv[n], &sv[n]))) {
605 PMIX_VALUE_FREE(pv, src->data.darray->size);
606 return rc;
607 }
608 }
609 break;
610 case PMIX_PROC:
611 PMIX_PROC_CREATE(p->data.darray->array, src->data.darray->size);
612 if (NULL == p->data.darray->array) {
613 return PMIX_ERR_NOMEM;
614 }
615 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_proc_t));
616 break;
617 case PMIX_APP:
618 PMIX_APP_CREATE(p->data.darray->array, src->data.darray->size);
619 if (NULL == p->data.darray->array) {
620 return PMIX_ERR_NOMEM;
621 }
622 pa = (pmix_app_t*)p->data.darray->array;
623 sa = (pmix_app_t*)src->data.darray->array;
624 for (n=0; n < src->data.darray->size; n++) {
625 if (NULL != sa[n].cmd) {
626 pa[n].cmd = strdup(sa[n].cmd);
627 }
628 if (NULL != sa[n].argv) {
629 pa[n].argv = pmix_argv_copy(sa[n].argv);
630 }
631 if (NULL != sa[n].env) {
632 pa[n].env = pmix_argv_copy(sa[n].env);
633 }
634 if (NULL != sa[n].cwd) {
635 pa[n].cwd = strdup(sa[n].cwd);
636 }
637 pa[n].maxprocs = sa[n].maxprocs;
638 if (0 < sa[n].ninfo && NULL != sa[n].info) {
639 PMIX_INFO_CREATE(pa[n].info, sa[n].ninfo);
640 if (NULL == pa[n].info) {
641 PMIX_APP_FREE(pa, src->data.darray->size);
642 return PMIX_ERR_NOMEM;
643 }
644 pa[n].ninfo = sa[n].ninfo;
645 for (m=0; m < pa[n].ninfo; m++) {
646 PMIX_INFO_XFER(&pa[n].info[m], &sa[n].info[m]);
647 }
648 }
649 }
650 break;
651 case PMIX_INFO:
652 PMIX_INFO_CREATE(p->data.darray->array, src->data.darray->size);
653 p1 = (pmix_info_t*)p->data.darray->array;
654 s1 = (pmix_info_t*)src->data.darray->array;
655 for (n=0; n < src->data.darray->size; n++) {
656 PMIX_INFO_LOAD(&p1[n], s1[n].key, &s1[n].value.data.flag, s1[n].value.type);
657 }
658 break;
659 case PMIX_PDATA:
660 PMIX_PDATA_CREATE(p->data.darray->array, src->data.darray->size);
661 if (NULL == p->data.darray->array) {
662 return PMIX_ERR_NOMEM;
663 }
664 pd = (pmix_pdata_t*)p->data.darray->array;
665 sd = (pmix_pdata_t*)src->data.darray->array;
666 for (n=0; n < src->data.darray->size; n++) {
667 PMIX_PDATA_LOAD(&pd[n], &sd[n].proc, sd[n].key, &sd[n].value.data.flag, sd[n].value.type);
668 }
669 break;
670 case PMIX_BUFFER:
671 p->data.darray->array = (pmix_buffer_t*)malloc(src->data.darray->size * sizeof(pmix_buffer_t));
672 if (NULL == p->data.darray->array) {
673 return PMIX_ERR_NOMEM;
674 }
675 pb = (pmix_buffer_t*)p->data.darray->array;
676 sb = (pmix_buffer_t*)src->data.darray->array;
677 for (n=0; n < src->data.darray->size; n++) {
678 PMIX_CONSTRUCT(&pb[n], pmix_buffer_t);
679 pmix20_bfrop_copy_payload(&pb[n], &sb[n]);
680 }
681 break;
682 case PMIX_BYTE_OBJECT:
683 case PMIX_COMPRESSED_STRING:
684 p->data.darray->array = (pmix_byte_object_t*)malloc(src->data.darray->size * sizeof(pmix_byte_object_t));
685 if (NULL == p->data.darray->array) {
686 return PMIX_ERR_NOMEM;
687 }
688 pbo = (pmix_byte_object_t*)p->data.darray->array;
689 sbo = (pmix_byte_object_t*)src->data.darray->array;
690 for (n=0; n < src->data.darray->size; n++) {
691 if (NULL != sbo[n].bytes && 0 < sbo[n].size) {
692 pbo[n].size = sbo[n].size;
693 pbo[n].bytes = (char*)malloc(pbo[n].size);
694 memcpy(pbo[n].bytes, sbo[n].bytes, pbo[n].size);
695 } else {
696 pbo[n].bytes = NULL;
697 pbo[n].size = 0;
698 }
699 }
700 break;
701 case PMIX_KVAL:
702 p->data.darray->array = (pmix_kval_t*)calloc(src->data.darray->size , sizeof(pmix_kval_t));
703 if (NULL == p->data.darray->array) {
704 return PMIX_ERR_NOMEM;
705 }
706 pk = (pmix_kval_t*)p->data.darray->array;
707 sk = (pmix_kval_t*)src->data.darray->array;
708 for (n=0; n < src->data.darray->size; n++) {
709 if (NULL != sk[n].key) {
710 pk[n].key = strdup(sk[n].key);
711 }
712 if (NULL != sk[n].value) {
713 PMIX_VALUE_CREATE(pk[n].value, 1);
714 if (NULL == pk[n].value) {
715 free(p->data.darray->array);
716 return PMIX_ERR_NOMEM;
717 }
718 if (PMIX_SUCCESS != (rc = pmix20_bfrop_value_xfer(pk[n].value, sk[n].value))) {
719 return rc;
720 }
721 }
722 }
723 break;
724 case PMIX_MODEX:
725 PMIX_MODEX_CREATE(p->data.darray->array, src->data.darray->size);
726 if (NULL == p->data.darray->array) {
727 return PMIX_ERR_NOMEM;
728 }
729 pm = (pmix_modex_data_t*)p->data.darray->array;
730 sm = (pmix_modex_data_t*)src->data.darray->array;
731 for (n=0; n < src->data.darray->size; n++) {
732 memcpy(&pm[n], &sm[n], sizeof(pmix_modex_data_t));
733 if (NULL != sm[n].blob && 0 < sm[n].size) {
734 pm[n].blob = (uint8_t*)malloc(sm[n].size);
735 if (NULL == pm[n].blob) {
736 return PMIX_ERR_NOMEM;
737 }
738 memcpy(pm[n].blob, sm[n].blob, sm[n].size);
739 pm[n].size = sm[n].size;
740 } else {
741 pm[n].blob = NULL;
742 pm[n].size = 0;
743 }
744 }
745 break;
746 case PMIX_PERSIST:
747 p->data.darray->array = (pmix_persistence_t*)malloc(src->data.darray->size * sizeof(pmix_persistence_t));
748 if (NULL == p->data.darray->array) {
749 return PMIX_ERR_NOMEM;
750 }
751 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_persistence_t));
752 break;
753 case PMIX_POINTER:
754 p->data.darray->array = (char**)malloc(src->data.darray->size * sizeof(char*));
755 if (NULL == p->data.darray->array) {
756 return PMIX_ERR_NOMEM;
757 }
758 prarray = (char**)p->data.darray->array;
759 strarray = (char**)src->data.darray->array;
760 for (n=0; n < src->data.darray->size; n++) {
761 prarray[n] = strarray[n];
762 }
763 break;
764 case PMIX_SCOPE:
765 p->data.darray->array = (pmix_scope_t*)malloc(src->data.darray->size * sizeof(pmix_scope_t));
766 if (NULL == p->data.darray->array) {
767 return PMIX_ERR_NOMEM;
768 }
769 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_scope_t));
770 break;
771 case PMIX_DATA_RANGE:
772 p->data.darray->array = (pmix_data_range_t*)malloc(src->data.darray->size * sizeof(pmix_data_range_t));
773 if (NULL == p->data.darray->array) {
774 return PMIX_ERR_NOMEM;
775 }
776 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_data_range_t));
777 break;
778 case PMIX_COMMAND:
779 p->data.darray->array = (pmix_cmd_t*)malloc(src->data.darray->size * sizeof(pmix_cmd_t));
780 if (NULL == p->data.darray->array) {
781 return PMIX_ERR_NOMEM;
782 }
783 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_cmd_t));
784 break;
785 case PMIX_INFO_DIRECTIVES:
786 p->data.darray->array = (pmix_info_directives_t*)malloc(src->data.darray->size * sizeof(pmix_info_directives_t));
787 if (NULL == p->data.darray->array) {
788 return PMIX_ERR_NOMEM;
789 }
790 memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_info_directives_t));
791 break;
792 case PMIX_PROC_INFO:
793 PMIX_PROC_INFO_CREATE(p->data.darray->array, src->data.darray->size);
794 if (NULL == p->data.darray->array) {
795 return PMIX_ERR_NOMEM;
796 }
797 pi = (pmix_proc_info_t*)p->data.darray->array;
798 si = (pmix_proc_info_t*)src->data.darray->array;
799 for (n=0; n < src->data.darray->size; n++) {
800 memcpy(&pi[n].proc, &si[n].proc, sizeof(pmix_proc_t));
801 if (NULL != si[n].hostname) {
802 pi[n].hostname = strdup(si[n].hostname);
803 } else {
804 pi[n].hostname = NULL;
805 }
806 if (NULL != si[n].executable_name) {
807 pi[n].executable_name = strdup(si[n].executable_name);
808 } else {
809 pi[n].executable_name = NULL;
810 }
811 pi[n].pid = si[n].pid;
812 pi[n].exit_code = si[n].exit_code;
813 pi[n].state = si[n].state;
814 }
815 break;
816 case PMIX_DATA_ARRAY:
817 return PMIX_ERR_NOT_SUPPORTED;
818 case PMIX_QUERY:
819 PMIX_QUERY_CREATE(p->data.darray->array, src->data.darray->size);
820 if (NULL == p->data.darray->array) {
821 return PMIX_ERR_NOMEM;
822 }
823 pq = (pmix_query_t*)p->data.darray->array;
824 sq = (pmix_query_t*)src->data.darray->array;
825 for (n=0; n < src->data.darray->size; n++) {
826 if (NULL != sq[n].keys) {
827 pq[n].keys = pmix_argv_copy(sq[n].keys);
828 }
829 if (NULL != sq[n].qualifiers && 0 < sq[n].nqual) {
830 PMIX_INFO_CREATE(pq[n].qualifiers, sq[n].nqual);
831 if (NULL == pq[n].qualifiers) {
832 PMIX_QUERY_FREE(pq, src->data.darray->size);
833 return PMIX_ERR_NOMEM;
834 }
835 for (m=0; m < sq[n].nqual; m++) {
836 PMIX_INFO_XFER(&pq[n].qualifiers[m], &sq[n].qualifiers[m]);
837 }
838 pq[n].nqual = sq[n].nqual;
839 } else {
840 pq[n].qualifiers = NULL;
841 pq[n].nqual = 0;
842 }
843 }
844 break;
845 default:
846 return PMIX_ERR_UNKNOWN_DATA_TYPE;
847 }
848 break;
849 case PMIX_POINTER:
850 memcpy(&p->data.ptr, &src->data.ptr, sizeof(void*));
851 break;
852
853 case PMIX_INFO_ARRAY:
854 return PMIX_ERR_NOT_SUPPORTED;
855
856 default:
857 pmix_output(0, "COPY-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)src->type);
858 return PMIX_ERROR;
859 }
860 return PMIX_SUCCESS;
861 }
862
863
864 pmix_status_t pmix20_bfrop_copy_value(pmix_value_t **dest, pmix_value_t *src,
865 pmix_data_type_t type)
866 {
867 pmix_value_t *p;
868
869
870 *dest = (pmix_value_t*)malloc(sizeof(pmix_value_t));
871 if (NULL == *dest) {
872 return PMIX_ERR_OUT_OF_RESOURCE;
873 }
874 p = *dest;
875
876
877 p->type = src->type;
878
879 return pmix20_bfrop_value_xfer(p, src);
880 }
881
882 pmix_status_t pmix20_bfrop_copy_info(pmix_info_t **dest, pmix_info_t *src,
883 pmix_data_type_t type)
884 {
885 *dest = (pmix_info_t*)malloc(sizeof(pmix_info_t));
886 pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
887 (*dest)->flags = src->flags;
888 return pmix20_bfrop_value_xfer(&(*dest)->value, &src->value);
889 }
890
891 pmix_status_t pmix20_bfrop_copy_buf(pmix_buffer_t **dest, pmix_buffer_t *src,
892 pmix_data_type_t type)
893 {
894 *dest = PMIX_NEW(pmix_buffer_t);
895 pmix20_bfrop_copy_payload(*dest, src);
896 return PMIX_SUCCESS;
897 }
898
899 pmix_status_t pmix20_bfrop_copy_app(pmix_app_t **dest, pmix_app_t *src,
900 pmix_data_type_t type)
901 {
902 size_t j;
903
904 *dest = (pmix_app_t*)malloc(sizeof(pmix_app_t));
905 (*dest)->cmd = strdup(src->cmd);
906 (*dest)->argv = pmix_argv_copy(src->argv);
907 (*dest)->env = pmix_argv_copy(src->env);
908 if (NULL != src->cwd) {
909 (*dest)->cwd = strdup(src->cwd);
910 }
911 (*dest)->maxprocs = src->maxprocs;
912 (*dest)->ninfo = src->ninfo;
913 (*dest)->info = (pmix_info_t*)malloc(src->ninfo * sizeof(pmix_info_t));
914 for (j=0; j < src->ninfo; j++) {
915 pmix_strncpy((*dest)->info[j].key, src->info[j].key, PMIX_MAX_KEYLEN);
916 pmix20_bfrop_value_xfer(&(*dest)->info[j].value, &src->info[j].value);
917 }
918 return PMIX_SUCCESS;
919 }
920
921 pmix_status_t pmix20_bfrop_copy_kval(pmix_kval_t **dest, pmix_kval_t *src,
922 pmix_data_type_t type)
923 {
924 pmix_kval_t *p;
925
926
927 *dest = PMIX_NEW(pmix_kval_t);
928 if (NULL == *dest) {
929 return PMIX_ERR_OUT_OF_RESOURCE;
930 }
931 p = *dest;
932
933
934 p->value->type = src->value->type;
935
936 return pmix20_bfrop_value_xfer(p->value, src->value);
937 }
938
939 pmix_status_t pmix20_bfrop_copy_proc(pmix_proc_t **dest, pmix_proc_t *src,
940 pmix_data_type_t type)
941 {
942 *dest = (pmix_proc_t*)malloc(sizeof(pmix_proc_t));
943 if (NULL == *dest) {
944 return PMIX_ERR_OUT_OF_RESOURCE;
945 }
946 pmix_strncpy((*dest)->nspace, src->nspace, PMIX_MAX_NSLEN);
947 (*dest)->rank = src->rank;
948 return PMIX_SUCCESS;
949 }
950
951 pmix_status_t pmix20_bfrop_copy_modex(pmix_modex_data_t **dest, pmix_modex_data_t *src,
952 pmix_data_type_t type)
953 {
954 *dest = (pmix_modex_data_t*)malloc(sizeof(pmix_modex_data_t));
955 if (NULL == *dest) {
956 return PMIX_ERR_OUT_OF_RESOURCE;
957 }
958 (*dest)->blob = NULL;
959 (*dest)->size = 0;
960 if (NULL != src->blob) {
961 (*dest)->blob = (uint8_t*)malloc(src->size * sizeof(uint8_t));
962 if (NULL == (*dest)->blob) {
963 return PMIX_ERR_OUT_OF_RESOURCE;
964 }
965 memcpy((*dest)->blob, src->blob, src->size * sizeof(uint8_t));
966 (*dest)->size = src->size;
967 }
968 return PMIX_SUCCESS;
969 }
970
971 pmix_status_t pmix20_bfrop_copy_persist(pmix_persistence_t **dest, pmix_persistence_t *src,
972 pmix_data_type_t type)
973 {
974 *dest = (pmix_persistence_t*)malloc(sizeof(pmix_persistence_t));
975 if (NULL == *dest) {
976 return PMIX_ERR_OUT_OF_RESOURCE;
977 }
978 memcpy(*dest, src, sizeof(pmix_persistence_t));
979 return PMIX_SUCCESS;
980 }
981
982 pmix_status_t pmix20_bfrop_copy_bo(pmix_byte_object_t **dest, pmix_byte_object_t *src,
983 pmix_data_type_t type)
984 {
985 *dest = (pmix_byte_object_t*)malloc(sizeof(pmix_byte_object_t));
986 if (NULL == *dest) {
987 return PMIX_ERR_OUT_OF_RESOURCE;
988 }
989 (*dest)->bytes = (char*)malloc(src->size);
990 memcpy((*dest)->bytes, src->bytes, src->size);
991 (*dest)->size = src->size;
992 return PMIX_SUCCESS;
993 }
994
995 pmix_status_t pmix20_bfrop_copy_pdata(pmix_pdata_t **dest, pmix_pdata_t *src,
996 pmix_data_type_t type)
997 {
998 *dest = (pmix_pdata_t*)malloc(sizeof(pmix_pdata_t));
999 pmix_strncpy((*dest)->proc.nspace, src->proc.nspace, PMIX_MAX_NSLEN);
1000 (*dest)->proc.rank = src->proc.rank;
1001 pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
1002 return pmix20_bfrop_value_xfer(&(*dest)->value, &src->value);
1003 }
1004
1005 pmix_status_t pmix20_bfrop_copy_pinfo(pmix_proc_info_t **dest, pmix_proc_info_t *src,
1006 pmix_data_type_t type)
1007 {
1008 *dest = (pmix_proc_info_t*)malloc(sizeof(pmix_proc_info_t));
1009 pmix_strncpy((*dest)->proc.nspace, src->proc.nspace, PMIX_MAX_NSLEN);
1010 (*dest)->proc.rank = src->proc.rank;
1011 if (NULL != src->hostname) {
1012 (*dest)->hostname = strdup(src->hostname);
1013 }
1014 if (NULL != src->executable_name) {
1015 (*dest)->executable_name = strdup(src->executable_name);
1016 }
1017 (*dest)->pid = src->pid;
1018 (*dest)->exit_code = src->exit_code;
1019 (*dest)->state = src->state;
1020 return PMIX_SUCCESS;
1021 }
1022
1023
1024
1025
1026 pmix_status_t pmix20_bfrop_copy_darray(pmix_data_array_t **dest,
1027 pmix_data_array_t *src,
1028 pmix_data_type_t type)
1029 {
1030 pmix_data_array_t *p;
1031 size_t n, m;
1032 pmix_status_t rc;
1033 char **prarray, **strarray;
1034 pmix_value_t *pv, *sv;
1035 pmix_app_t *pa, *sa;
1036 pmix_info_t *p1, *s1;
1037 pmix_pdata_t *pd, *sd;
1038 pmix_buffer_t *pb, *sb;
1039 pmix_byte_object_t *pbo, *sbo;
1040 pmix_kval_t *pk, *sk;
1041 pmix_modex_data_t *pm, *sm;
1042 pmix_proc_info_t *pi, *si;
1043 pmix_query_t *pq, *sq;
1044
1045 p = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
1046 if (NULL == p) {
1047 return PMIX_ERR_NOMEM;
1048 }
1049 p->type = src->type;
1050 p->size = src->size;
1051 if (0 == p->size || NULL == src->array) {
1052 *dest = p;
1053 return PMIX_SUCCESS;
1054 }
1055
1056
1057 switch (src->type) {
1058 case PMIX_UINT8:
1059 case PMIX_INT8:
1060 case PMIX_BYTE:
1061 p->array = (char*)malloc(src->size);
1062 if (NULL == p->array) {
1063 free(p);
1064 return PMIX_ERR_NOMEM;
1065 }
1066 memcpy(p->array, src->array, src->size);
1067 break;
1068 case PMIX_UINT16:
1069 case PMIX_INT16:
1070 p->array = (char*)malloc(src->size * sizeof(uint16_t));
1071 if (NULL == p->array) {
1072 free(p);
1073 return PMIX_ERR_NOMEM;
1074 }
1075 memcpy(p->array, src->array, src->size * sizeof(uint16_t));
1076 break;
1077 case PMIX_UINT32:
1078 case PMIX_INT32:
1079 p->array = (char*)malloc(src->size * sizeof(uint32_t));
1080 if (NULL == p->array) {
1081 free(p);
1082 return PMIX_ERR_NOMEM;
1083 }
1084 memcpy(p->array, src->array, src->size * sizeof(uint32_t));
1085 break;
1086 case PMIX_UINT64:
1087 case PMIX_INT64:
1088 p->array = (char*)malloc(src->size * sizeof(uint64_t));
1089 if (NULL == p->array) {
1090 free(p);
1091 return PMIX_ERR_NOMEM;
1092 }
1093 memcpy(p->array, src->array, src->size * sizeof(uint64_t));
1094 break;
1095 case PMIX_BOOL:
1096 p->array = (char*)malloc(src->size * sizeof(bool));
1097 if (NULL == p->array) {
1098 free(p);
1099 return PMIX_ERR_NOMEM;
1100 }
1101 memcpy(p->array, src->array, src->size * sizeof(bool));
1102 break;
1103 case PMIX_SIZE:
1104 p->array = (char*)malloc(src->size * sizeof(size_t));
1105 if (NULL == p->array) {
1106 free(p);
1107 return PMIX_ERR_NOMEM;
1108 }
1109 memcpy(p->array, src->array, src->size * sizeof(size_t));
1110 break;
1111 case PMIX_PID:
1112 p->array = (char*)malloc(src->size * sizeof(pid_t));
1113 if (NULL == p->array) {
1114 free(p);
1115 return PMIX_ERR_NOMEM;
1116 }
1117 memcpy(p->array, src->array, src->size * sizeof(pid_t));
1118 break;
1119 case PMIX_STRING:
1120 p->array = (char**)malloc(src->size * sizeof(char*));
1121 if (NULL == p->array) {
1122 free(p);
1123 return PMIX_ERR_NOMEM;
1124 }
1125 prarray = (char**)p->array;
1126 strarray = (char**)src->array;
1127 for (n=0; n < src->size; n++) {
1128 if (NULL != strarray[n]) {
1129 prarray[n] = strdup(strarray[n]);
1130 }
1131 }
1132 break;
1133 case PMIX_INT:
1134 case PMIX_UINT:
1135 p->array = (char*)malloc(src->size * sizeof(int));
1136 if (NULL == p->array) {
1137 free(p);
1138 return PMIX_ERR_NOMEM;
1139 }
1140 memcpy(p->array, src->array, src->size * sizeof(int));
1141 break;
1142 case PMIX_FLOAT:
1143 p->array = (char*)malloc(src->size * sizeof(float));
1144 if (NULL == p->array) {
1145 free(p);
1146 return PMIX_ERR_NOMEM;
1147 }
1148 memcpy(p->array, src->array, src->size * sizeof(float));
1149 break;
1150 case PMIX_DOUBLE:
1151 p->array = (char*)malloc(src->size * sizeof(double));
1152 if (NULL == p->array) {
1153 free(p);
1154 return PMIX_ERR_NOMEM;
1155 }
1156 memcpy(p->array, src->array, src->size * sizeof(double));
1157 break;
1158 case PMIX_TIMEVAL:
1159 p->array = (struct timeval*)malloc(src->size * sizeof(struct timeval));
1160 if (NULL == p->array) {
1161 free(p);
1162 return PMIX_ERR_NOMEM;
1163 }
1164 memcpy(p->array, src->array, src->size * sizeof(struct timeval));
1165 break;
1166 case PMIX_TIME:
1167 p->array = (time_t*)malloc(src->size * sizeof(time_t));
1168 if (NULL == p->array) {
1169 free(p);
1170 return PMIX_ERR_NOMEM;
1171 }
1172 memcpy(p->array, src->array, src->size * sizeof(time_t));
1173 break;
1174 case PMIX_STATUS:
1175 p->array = (pmix_status_t*)malloc(src->size * sizeof(pmix_status_t));
1176 if (NULL == p->array) {
1177 free(p);
1178 return PMIX_ERR_NOMEM;
1179 }
1180 memcpy(p->array, src->array, src->size * sizeof(pmix_status_t));
1181 break;
1182 case PMIX_VALUE:
1183 PMIX_VALUE_CREATE(p->array, src->size);
1184 if (NULL == p->array) {
1185 free(p);
1186 return PMIX_ERR_NOMEM;
1187 }
1188 pv = (pmix_value_t*)p->array;
1189 sv = (pmix_value_t*)src->array;
1190 for (n=0; n < src->size; n++) {
1191 if (PMIX_SUCCESS != (rc = pmix20_bfrop_value_xfer(&pv[n], &sv[n]))) {
1192 PMIX_VALUE_FREE(pv, src->size);
1193 free(p);
1194 return rc;
1195 }
1196 }
1197 break;
1198 case PMIX_PROC:
1199 PMIX_PROC_CREATE(p->array, src->size);
1200 if (NULL == p->array) {
1201 free(p);
1202 return PMIX_ERR_NOMEM;
1203 }
1204 memcpy(p->array, src->array, src->size * sizeof(pmix_proc_t));
1205 break;
1206 case PMIX_PROC_RANK:
1207 p->array = (char*)malloc(src->size * sizeof(pmix_rank_t));
1208 if (NULL == p->array) {
1209 free(p);
1210 return PMIX_ERR_NOMEM;
1211 }
1212 memcpy(p->array, src->array, src->size * sizeof(pmix_proc_t));
1213 break;
1214 case PMIX_APP:
1215 PMIX_APP_CREATE(p->array, src->size);
1216 if (NULL == p->array) {
1217 free(p);
1218 return PMIX_ERR_NOMEM;
1219 }
1220 pa = (pmix_app_t*)p->array;
1221 sa = (pmix_app_t*)src->array;
1222 for (n=0; n < src->size; n++) {
1223 if (NULL != sa[n].cmd) {
1224 pa[n].cmd = strdup(sa[n].cmd);
1225 }
1226 if (NULL != sa[n].argv) {
1227 pa[n].argv = pmix_argv_copy(sa[n].argv);
1228 }
1229 if (NULL != sa[n].env) {
1230 pa[n].env = pmix_argv_copy(sa[n].env);
1231 }
1232 if (NULL != sa[n].cwd) {
1233 pa[n].cwd = strdup(sa[n].cwd);
1234 }
1235 pa[n].maxprocs = sa[n].maxprocs;
1236 if (0 < sa[n].ninfo && NULL != sa[n].info) {
1237 PMIX_INFO_CREATE(pa[n].info, sa[n].ninfo);
1238 if (NULL == pa[n].info) {
1239 PMIX_APP_FREE(pa, p->size);
1240 free(p);
1241 return PMIX_ERR_NOMEM;
1242 }
1243 pa[n].ninfo = sa[n].ninfo;
1244 for (m=0; m < pa[n].ninfo; m++) {
1245 PMIX_INFO_XFER(&pa[n].info[m], &sa[n].info[m]);
1246 }
1247 }
1248 }
1249 break;
1250 case PMIX_INFO:
1251 PMIX_INFO_CREATE(p->array, src->size);
1252 if (NULL == p->array) {
1253 free(p);
1254 return PMIX_ERR_NOMEM;
1255 }
1256 p1 = (pmix_info_t*)p->array;
1257 s1 = (pmix_info_t*)src->array;
1258 for (n=0; n < src->size; n++) {
1259 PMIX_INFO_LOAD(&p1[n], s1[n].key, &s1[n].value.data.flag, s1[n].value.type);
1260 }
1261 break;
1262 case PMIX_PDATA:
1263 PMIX_PDATA_CREATE(p->array, src->size);
1264 if (NULL == p->array) {
1265 free(p);
1266 return PMIX_ERR_NOMEM;
1267 }
1268 pd = (pmix_pdata_t*)p->array;
1269 sd = (pmix_pdata_t*)src->array;
1270 for (n=0; n < src->size; n++) {
1271 PMIX_PDATA_LOAD(&pd[n], &sd[n].proc, sd[n].key, &sd[n].value.data, sd[n].value.type);
1272 }
1273 break;
1274 case PMIX_BUFFER:
1275 p->array = (pmix_buffer_t*)malloc(src->size * sizeof(pmix_buffer_t));
1276 if (NULL == p->array) {
1277 free(p);
1278 return PMIX_ERR_NOMEM;
1279 }
1280 pb = (pmix_buffer_t*)p->array;
1281 sb = (pmix_buffer_t*)src->array;
1282 for (n=0; n < src->size; n++) {
1283 PMIX_CONSTRUCT(&pb[n], pmix_buffer_t);
1284 pmix20_bfrop_copy_payload(&pb[n], &sb[n]);
1285 }
1286 break;
1287 case PMIX_BYTE_OBJECT:
1288 case PMIX_COMPRESSED_STRING:
1289 p->array = (pmix_byte_object_t*)malloc(src->size * sizeof(pmix_byte_object_t));
1290 if (NULL == p->array) {
1291 free(p);
1292 return PMIX_ERR_NOMEM;
1293 }
1294 pbo = (pmix_byte_object_t*)p->array;
1295 sbo = (pmix_byte_object_t*)src->array;
1296 for (n=0; n < src->size; n++) {
1297 if (NULL != sbo[n].bytes && 0 < sbo[n].size) {
1298 pbo[n].size = sbo[n].size;
1299 pbo[n].bytes = (char*)malloc(pbo[n].size);
1300 memcpy(pbo[n].bytes, sbo[n].bytes, pbo[n].size);
1301 } else {
1302 pbo[n].bytes = NULL;
1303 pbo[n].size = 0;
1304 }
1305 }
1306 break;
1307 case PMIX_KVAL:
1308 p->array = (pmix_kval_t*)calloc(src->size , sizeof(pmix_kval_t));
1309 if (NULL == p->array) {
1310 free(p);
1311 return PMIX_ERR_NOMEM;
1312 }
1313 pk = (pmix_kval_t*)p->array;
1314 sk = (pmix_kval_t*)src->array;
1315 for (n=0; n < src->size; n++) {
1316 if (NULL != sk[n].key) {
1317 pk[n].key = strdup(sk[n].key);
1318 }
1319 if (NULL != sk[n].value) {
1320 PMIX_VALUE_CREATE(pk[n].value, 1);
1321 if (NULL == pk[n].value) {
1322 PMIX_VALUE_FREE(pk[n].value, 1);
1323 free(p);
1324 return PMIX_ERR_NOMEM;
1325 }
1326 if (PMIX_SUCCESS != (rc = pmix20_bfrop_value_xfer(pk[n].value, sk[n].value))) {
1327 PMIX_VALUE_FREE(pk[n].value, 1);
1328 free(p);
1329 return rc;
1330 }
1331 }
1332 }
1333 break;
1334 case PMIX_MODEX:
1335 PMIX_MODEX_CREATE(p->array, src->size);
1336 if (NULL == p->array) {
1337 free(p);
1338 return PMIX_ERR_NOMEM;
1339 }
1340 pm = (pmix_modex_data_t*)p->array;
1341 sm = (pmix_modex_data_t*)src->array;
1342 for (n=0; n < src->size; n++) {
1343 memcpy(&pm[n], &sm[n], sizeof(pmix_modex_data_t));
1344 if (NULL != sm[n].blob && 0 < sm[n].size) {
1345 pm[n].blob = (uint8_t*)malloc(sm[n].size);
1346 if (NULL == pm[n].blob) {
1347 PMIX_MODEX_FREE(pm, src->size);
1348 free(p);
1349 return PMIX_ERR_NOMEM;
1350 }
1351 memcpy(pm[n].blob, sm[n].blob, sm[n].size);
1352 pm[n].size = sm[n].size;
1353 } else {
1354 pm[n].blob = NULL;
1355 pm[n].size = 0;
1356 }
1357 }
1358 break;
1359 case PMIX_PERSIST:
1360 p->array = (pmix_persistence_t*)malloc(src->size * sizeof(pmix_persistence_t));
1361 if (NULL == p->array) {
1362 free(p);
1363 return PMIX_ERR_NOMEM;
1364 }
1365 memcpy(p->array, src->array, src->size * sizeof(pmix_persistence_t));
1366 break;
1367 case PMIX_POINTER:
1368 p->array = (char**)malloc(src->size * sizeof(char*));
1369 prarray = (char**)p->array;
1370 strarray = (char**)src->array;
1371 for (n=0; n < src->size; n++) {
1372 prarray[n] = strarray[n];
1373 }
1374 break;
1375 case PMIX_SCOPE:
1376 p->array = (pmix_scope_t*)malloc(src->size * sizeof(pmix_scope_t));
1377 if (NULL == p->array) {
1378 free(p);
1379 return PMIX_ERR_NOMEM;
1380 }
1381 memcpy(p->array, src->array, src->size * sizeof(pmix_scope_t));
1382 break;
1383 case PMIX_DATA_RANGE:
1384 p->array = (pmix_data_range_t*)malloc(src->size * sizeof(pmix_data_range_t));
1385 if (NULL == p->array) {
1386 free(p);
1387 return PMIX_ERR_NOMEM;
1388 }
1389 memcpy(p->array, src->array, src->size * sizeof(pmix_data_range_t));
1390 break;
1391 case PMIX_COMMAND:
1392 p->array = (pmix_cmd_t*)malloc(src->size * sizeof(pmix_cmd_t));
1393 if (NULL == p->array) {
1394 free(p);
1395 return PMIX_ERR_NOMEM;
1396 }
1397 memcpy(p->array, src->array, src->size * sizeof(pmix_cmd_t));
1398 break;
1399 case PMIX_INFO_DIRECTIVES:
1400 p->array = (pmix_info_directives_t*)malloc(src->size * sizeof(pmix_info_directives_t));
1401 if (NULL == p->array) {
1402 free(p);
1403 return PMIX_ERR_NOMEM;
1404 }
1405 memcpy(p->array, src->array, src->size * sizeof(pmix_info_directives_t));
1406 break;
1407 case PMIX_PROC_INFO:
1408 PMIX_PROC_INFO_CREATE(p->array, src->size);
1409 if (NULL == p->array) {
1410 free(p);
1411 return PMIX_ERR_NOMEM;
1412 }
1413 pi = (pmix_proc_info_t*)p->array;
1414 si = (pmix_proc_info_t*)src->array;
1415 for (n=0; n < src->size; n++) {
1416 memcpy(&pi[n].proc, &si[n].proc, sizeof(pmix_proc_t));
1417 if (NULL != si[n].hostname) {
1418 pi[n].hostname = strdup(si[n].hostname);
1419 } else {
1420 pi[n].hostname = NULL;
1421 }
1422 if (NULL != si[n].executable_name) {
1423 pi[n].executable_name = strdup(si[n].executable_name);
1424 } else {
1425 pi[n].executable_name = NULL;
1426 }
1427 pi[n].pid = si[n].pid;
1428 pi[n].exit_code = si[n].exit_code;
1429 pi[n].state = si[n].state;
1430 }
1431 break;
1432 case PMIX_DATA_ARRAY:
1433 free(p);
1434 return PMIX_ERR_NOT_SUPPORTED;
1435 case PMIX_QUERY:
1436 PMIX_QUERY_CREATE(p->array, src->size);
1437 if (NULL == p->array) {
1438 free(p);
1439 return PMIX_ERR_NOMEM;
1440 }
1441 pq = (pmix_query_t*)p->array;
1442 sq = (pmix_query_t*)src->array;
1443 for (n=0; n < src->size; n++) {
1444 if (NULL != sq[n].keys) {
1445 pq[n].keys = pmix_argv_copy(sq[n].keys);
1446 }
1447 if (NULL != sq[n].qualifiers && 0 < sq[n].nqual) {
1448 PMIX_INFO_CREATE(pq[n].qualifiers, sq[n].nqual);
1449 if (NULL == pq[n].qualifiers) {
1450 PMIX_INFO_FREE(pq[n].qualifiers, sq[n].nqual);
1451 free(p);
1452 return PMIX_ERR_NOMEM;
1453 }
1454 for (m=0; m < sq[n].nqual; m++) {
1455 PMIX_INFO_XFER(&pq[n].qualifiers[m], &sq[n].qualifiers[m]);
1456 }
1457 pq[n].nqual = sq[n].nqual;
1458 } else {
1459 pq[n].qualifiers = NULL;
1460 pq[n].nqual = 0;
1461 }
1462 }
1463 break;
1464 default:
1465 free(p);
1466 return PMIX_ERR_UNKNOWN_DATA_TYPE;
1467 }
1468
1469 (*dest) = p;
1470 return PMIX_SUCCESS;
1471 }
1472
1473 pmix_status_t pmix20_bfrop_copy_query(pmix_query_t **dest,
1474 pmix_query_t *src,
1475 pmix_data_type_t type)
1476 {
1477 pmix_status_t rc;
1478
1479 *dest = (pmix_query_t*)malloc(sizeof(pmix_query_t));
1480 if (NULL != src->keys) {
1481 (*dest)->keys = pmix_argv_copy(src->keys);
1482 }
1483 (*dest)->nqual = src->nqual;
1484 if (NULL != src->qualifiers) {
1485 if (PMIX_SUCCESS != (rc = pmix20_bfrop_copy_info(&((*dest)->qualifiers), src->qualifiers, PMIX_INFO))) {
1486 free(*dest);
1487 return rc;
1488 }
1489 }
1490 return PMIX_SUCCESS;
1491 }
1492
1493
1494 pmix_status_t pmix20_bfrop_copy_array(pmix_info_array_t **dest,
1495 pmix_info_array_t *src,
1496 pmix_data_type_t type)
1497 {
1498 pmix_info_t *d1, *s1;
1499
1500 *dest = (pmix_info_array_t*)malloc(sizeof(pmix_info_array_t));
1501 (*dest)->size = src->size;
1502 (*dest)->array = (pmix_info_t*)malloc(src->size * sizeof(pmix_info_t));
1503 d1 = (pmix_info_t*)(*dest)->array;
1504 s1 = (pmix_info_t*)src->array;
1505 memcpy(d1, s1, src->size * sizeof(pmix_info_t));
1506 return PMIX_SUCCESS;
1507 }
1508