This source file includes following definitions.
- pmix_value_load
- pmix_value_unload
- pmix_value_xfer
- pmix_bfrops_base_value_load
- pmix_bfrops_base_value_unload
- pmix_bfrops_base_value_cmp
- pmix_bfrops_base_value_xfer
- pmix_bfrop_buffer_extend
- pmix_bfrop_too_small
- pmix_bfrop_store_data_type
- pmix_bfrop_get_data_type
- pmix_bfrops_base_data_type_string
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 #include <src/include/pmix_config.h>
23
24
25 #include <stdio.h>
26 #ifdef HAVE_UNISTD_H
27 #include <unistd.h>
28 #endif
29
30 #include "src/util/argv.h"
31 #include "src/util/error.h"
32 #include "src/include/pmix_globals.h"
33
34 #include "src/mca/bfrops/base/base.h"
35
36
37 PMIX_EXPORT void pmix_value_load(pmix_value_t *v, const void *data,
38 pmix_data_type_t type)
39 {
40 pmix_bfrops_base_value_load(v, data, type);
41 }
42
43 PMIX_EXPORT pmix_status_t pmix_value_unload(pmix_value_t *kv,
44 void **data,
45 size_t *sz)
46 {
47 return pmix_bfrops_base_value_unload(kv, data, sz);
48 }
49
50 PMIX_EXPORT pmix_status_t pmix_value_xfer(pmix_value_t *dest,
51 const pmix_value_t *src)
52 {
53 return pmix_bfrops_base_value_xfer(dest, src);
54 }
55
56 void pmix_bfrops_base_value_load(pmix_value_t *v, const void *data,
57 pmix_data_type_t type)
58 {
59 pmix_byte_object_t *bo;
60 pmix_proc_info_t *pi;
61 pmix_envar_t *envar;
62 pmix_data_array_t *darray;
63 pmix_status_t rc;
64 pmix_coord_t *coord;
65 pmix_regattr_t *regattr;
66
67 v->type = type;
68 if (NULL == data) {
69
70 memset(&v->data, 0, sizeof(v->data));
71 if (PMIX_BOOL == type) {
72 v->data.flag = true;
73 }
74 } else {
75 switch(type) {
76 case PMIX_UNDEF:
77 break;
78 case PMIX_BOOL:
79 memcpy(&(v->data.flag), data, 1);
80 break;
81 case PMIX_BYTE:
82 memcpy(&(v->data.byte), data, 1);
83 break;
84 case PMIX_STRING:
85 v->data.string = strdup(data);
86 break;
87 case PMIX_SIZE:
88 memcpy(&(v->data.size), data, sizeof(size_t));
89 break;
90 case PMIX_PID:
91 memcpy(&(v->data.pid), data, sizeof(pid_t));
92 break;
93 case PMIX_INT:
94 memcpy(&(v->data.integer), data, sizeof(int));
95 break;
96 case PMIX_INT8:
97 memcpy(&(v->data.int8), data, 1);
98 break;
99 case PMIX_INT16:
100 memcpy(&(v->data.int16), data, 2);
101 break;
102 case PMIX_INT32:
103 memcpy(&(v->data.int32), data, 4);
104 break;
105 case PMIX_INT64:
106 memcpy(&(v->data.int64), data, 8);
107 break;
108 case PMIX_UINT:
109 memcpy(&(v->data.uint), data, sizeof(int));
110 break;
111 case PMIX_UINT8:
112 memcpy(&(v->data.uint8), data, 1);
113 break;
114 case PMIX_UINT16:
115 memcpy(&(v->data.uint16), data, 2);
116 break;
117 case PMIX_UINT32:
118 memcpy(&(v->data.uint32), data, 4);
119 break;
120 case PMIX_UINT64:
121 memcpy(&(v->data.uint64), data, 8);
122 break;
123 case PMIX_FLOAT:
124 memcpy(&(v->data.fval), data, sizeof(float));
125 break;
126 case PMIX_DOUBLE:
127 memcpy(&(v->data.dval), data, sizeof(double));
128 break;
129 case PMIX_TIMEVAL:
130 memcpy(&(v->data.tv), data, sizeof(struct timeval));
131 break;
132 case PMIX_TIME:
133 memcpy(&(v->data.time), data, sizeof(time_t));
134 break;
135 case PMIX_STATUS:
136 memcpy(&(v->data.status), data, sizeof(pmix_status_t));
137 break;
138 case PMIX_PROC_RANK:
139 memcpy(&(v->data.rank), data, sizeof(pmix_rank_t));
140 break;
141 case PMIX_PROC:
142 PMIX_PROC_CREATE(v->data.proc, 1);
143 if (NULL == v->data.proc) {
144 PMIX_ERROR_LOG(PMIX_ERR_NOMEM);
145 return;
146 }
147 memcpy(v->data.proc, data, sizeof(pmix_proc_t));
148 break;
149 case PMIX_BYTE_OBJECT:
150 bo = (pmix_byte_object_t*)data;
151 v->data.bo.bytes = (char*)malloc(bo->size);
152 if (NULL == v->data.bo.bytes) {
153 PMIX_ERROR_LOG(PMIX_ERR_NOMEM);
154 return;
155 }
156 memcpy(v->data.bo.bytes, bo->bytes, bo->size);
157 memcpy(&(v->data.bo.size), &bo->size, sizeof(size_t));
158 break;
159 case PMIX_PERSIST:
160 memcpy(&(v->data.persist), data, sizeof(pmix_persistence_t));
161 break;
162 case PMIX_SCOPE:
163 memcpy(&(v->data.scope), data, sizeof(pmix_scope_t));
164 break;
165 case PMIX_DATA_RANGE:
166 memcpy(&(v->data.range), data, sizeof(pmix_data_range_t));
167 break;
168 case PMIX_PROC_STATE:
169 memcpy(&(v->data.state), data, sizeof(pmix_proc_state_t));
170 break;
171 case PMIX_PROC_INFO:
172 PMIX_PROC_INFO_CREATE(v->data.pinfo, 1);
173 if (NULL == v->data.pinfo) {
174 PMIX_ERROR_LOG(PMIX_ERR_NOMEM);
175 return;
176 }
177 pi = (pmix_proc_info_t*)data;
178 memcpy(&(v->data.pinfo->proc), &pi->proc, sizeof(pmix_proc_t));
179 if (NULL != pi->hostname) {
180 v->data.pinfo->hostname = strdup(pi->hostname);
181 }
182 if (NULL != pi->executable_name) {
183 v->data.pinfo->executable_name = strdup(pi->executable_name);
184 }
185 memcpy(&(v->data.pinfo->pid), &pi->pid, sizeof(pid_t));
186 memcpy(&(v->data.pinfo->exit_code), &pi->exit_code, sizeof(int));
187 break;
188 case PMIX_POINTER:
189 v->data.ptr = (void*)data;
190 break;
191 case PMIX_ENVAR:
192 envar = (pmix_envar_t*)data;
193 if (NULL != envar->envar) {
194 v->data.envar.envar = strdup(envar->envar);
195 }
196 if (NULL != envar->value) {
197 v->data.envar.value = strdup(envar->value);
198 }
199 v->data.envar.separator = envar->separator;
200 break;
201 case PMIX_DATA_ARRAY:
202 darray = (pmix_data_array_t*)data;
203 rc = pmix_bfrops_base_copy_darray(&v->data.darray, darray, PMIX_DATA_ARRAY);
204 if (PMIX_SUCCESS != rc) {
205 PMIX_ERROR_LOG(rc);
206 }
207 break;
208 case PMIX_COORD:
209 coord = (pmix_coord_t*)data;
210 rc = pmix_bfrops_base_copy_coord(&v->data.coord, coord, PMIX_COORD);
211 if (PMIX_SUCCESS != rc) {
212 PMIX_ERROR_LOG(rc);
213 }
214 break;
215 case PMIX_REGATTR:
216 regattr = (pmix_regattr_t*)data;
217 rc = pmix_bfrops_base_copy_regattr((pmix_regattr_t**)&v->data.ptr, regattr, PMIX_REGATTR);
218 if (PMIX_SUCCESS != rc) {
219 PMIX_ERROR_LOG(rc);
220 }
221 break;
222
223 default:
224
225 break;
226 }
227 }
228 return;
229 }
230
231 pmix_status_t pmix_bfrops_base_value_unload(pmix_value_t *kv,
232 void **data,
233 size_t *sz)
234 {
235 pmix_status_t rc;
236 pmix_envar_t *envar;
237 pmix_data_array_t **darray;
238 pmix_coord_t *coord;
239 pmix_regattr_t *regattr, *r;
240
241 rc = PMIX_SUCCESS;
242 if (NULL == data ||
243 (NULL == *data && PMIX_STRING != kv->type && PMIX_BYTE_OBJECT != kv->type)) {
244 rc = PMIX_ERR_BAD_PARAM;
245 } else {
246 switch(kv->type) {
247 case PMIX_UNDEF:
248 rc = PMIX_ERR_UNKNOWN_DATA_TYPE;
249 break;
250 case PMIX_BOOL:
251 memcpy(*data, &(kv->data.flag), 1);
252 *sz = 1;
253 break;
254 case PMIX_BYTE:
255 memcpy(*data, &(kv->data.byte), 1);
256 *sz = 1;
257 break;
258 case PMIX_STRING:
259 if (NULL != kv->data.string) {
260 *data = strdup(kv->data.string);
261 *sz = strlen(kv->data.string);
262 }
263 break;
264 case PMIX_SIZE:
265 memcpy(*data, &(kv->data.size), sizeof(size_t));
266 *sz = sizeof(size_t);
267 break;
268 case PMIX_PID:
269 memcpy(*data, &(kv->data.pid), sizeof(pid_t));
270 *sz = sizeof(pid_t);
271 break;
272 case PMIX_INT:
273 memcpy(*data, &(kv->data.integer), sizeof(int));
274 *sz = sizeof(int);
275 break;
276 case PMIX_INT8:
277 memcpy(*data, &(kv->data.int8), 1);
278 *sz = 1;
279 break;
280 case PMIX_INT16:
281 memcpy(*data, &(kv->data.int16), 2);
282 *sz = 2;
283 break;
284 case PMIX_INT32:
285 memcpy(*data, &(kv->data.int32), 4);
286 *sz = 4;
287 break;
288 case PMIX_INT64:
289 memcpy(*data, &(kv->data.int64), 8);
290 *sz = 8;
291 break;
292 case PMIX_UINT:
293 memcpy(*data, &(kv->data.uint), sizeof(int));
294 *sz = sizeof(int);
295 break;
296 case PMIX_UINT8:
297 memcpy(*data, &(kv->data.uint8), 1);
298 *sz = 1;
299 break;
300 case PMIX_UINT16:
301 memcpy(*data, &(kv->data.uint16), 2);
302 *sz = 2;
303 break;
304 case PMIX_UINT32:
305 memcpy(*data, &(kv->data.uint32), 4);
306 *sz = 4;
307 break;
308 case PMIX_UINT64:
309 memcpy(*data, &(kv->data.uint64), 8);
310 *sz = 8;
311 break;
312 case PMIX_FLOAT:
313 memcpy(*data, &(kv->data.fval), sizeof(float));
314 *sz = sizeof(float);
315 break;
316 case PMIX_DOUBLE:
317 memcpy(*data, &(kv->data.dval), sizeof(double));
318 *sz = sizeof(double);
319 break;
320 case PMIX_TIMEVAL:
321 memcpy(*data, &(kv->data.tv), sizeof(struct timeval));
322 *sz = sizeof(struct timeval);
323 break;
324 case PMIX_TIME:
325 memcpy(*data, &(kv->data.time), sizeof(time_t));
326 *sz = sizeof(time_t);
327 break;
328 case PMIX_BYTE_OBJECT:
329 if (NULL != kv->data.bo.bytes && 0 < kv->data.bo.size) {
330 *data = kv->data.bo.bytes;
331 *sz = kv->data.bo.size;
332 } else {
333 *data = NULL;
334 *sz = 0;
335 }
336 break;
337 case PMIX_PERSIST:
338 memcpy(*data, &(kv->data.persist), sizeof(pmix_persistence_t));
339 *sz = sizeof(pmix_persistence_t);
340 break;
341 case PMIX_SCOPE:
342 memcpy(*data, &(kv->data.scope), sizeof(pmix_scope_t));
343 *sz = sizeof(pmix_scope_t);
344 break;
345 case PMIX_DATA_RANGE:
346 memcpy(*data, &(kv->data.range), sizeof(pmix_data_range_t));
347 *sz = sizeof(pmix_data_range_t);
348 break;
349 case PMIX_PROC_STATE:
350 memcpy(*data, &(kv->data.state), sizeof(pmix_proc_state_t));
351 *sz = sizeof(pmix_proc_state_t);
352 break;
353 case PMIX_POINTER:
354 *data = (void*)kv->data.ptr;
355 *sz = sizeof(void*);
356 break;
357 case PMIX_DATA_ARRAY:
358 darray = (pmix_data_array_t**)data;
359 rc = pmix_bfrops_base_copy_darray(darray, kv->data.darray, PMIX_DATA_ARRAY);
360 *sz = sizeof(pmix_data_array_t);
361 break;
362 case PMIX_ENVAR:
363 PMIX_ENVAR_CREATE(envar, 1);
364 if (NULL == envar) {
365 return PMIX_ERR_NOMEM;
366 }
367 if (NULL != kv->data.envar.envar) {
368 envar->envar = strdup(kv->data.envar.envar);
369 }
370 if (NULL != kv->data.envar.value) {
371 envar->value = strdup(kv->data.envar.value);
372 }
373 envar->separator = kv->data.envar.separator;
374 *data = envar;
375 *sz = sizeof(pmix_envar_t);
376 break;
377 case PMIX_COORD:
378 coord = (pmix_coord_t*)malloc(sizeof(pmix_coord_t));
379 if (NULL == coord) {
380 return PMIX_ERR_NOMEM;
381 }
382 memcpy(coord, kv->data.coord, sizeof(pmix_coord_t));
383 *data = coord;
384 break;
385 case PMIX_REGATTR:
386 PMIX_REGATTR_CREATE(regattr, 1);
387 if (NULL == regattr) {
388 return PMIX_ERR_NOMEM;
389 }
390 r = (pmix_regattr_t*)kv->data.ptr;
391 if (NULL != r->name) {
392 regattr->name = strdup(r->name);
393 }
394 PMIX_LOAD_KEY(regattr->string, r->string);
395 regattr->type = r->type;
396 if (NULL != r->info) {
397 PMIX_INFO_XFER(regattr->info, r->info);
398 }
399 regattr->ninfo = r->ninfo;
400 regattr->description = pmix_argv_copy(r->description);
401 *data = regattr;
402 break;
403 default:
404
405 rc = PMIX_ERROR;
406 break;
407 }
408 }
409 return rc;
410 }
411
412
413 pmix_value_cmp_t pmix_bfrops_base_value_cmp(pmix_value_t *p,
414 pmix_value_t *p1)
415 {
416 pmix_value_cmp_t rc = PMIX_VALUE1_GREATER;
417 int ret;
418
419 if (p->type != p1->type) {
420 return rc;
421 }
422
423 switch (p->type) {
424 case PMIX_UNDEF:
425 rc = PMIX_EQUAL;
426 break;
427 case PMIX_BOOL:
428 if (p->data.flag == p1->data.flag) {
429 rc = PMIX_EQUAL;
430 }
431 break;
432 case PMIX_BYTE:
433 if (p->data.byte == p1->data.byte) {
434 rc = PMIX_EQUAL;
435 }
436 break;
437 case PMIX_SIZE:
438 if (p->data.size == p1->data.size) {
439 rc = PMIX_EQUAL;
440 }
441 break;
442 case PMIX_INT:
443 if (p->data.integer == p1->data.integer) {
444 rc = PMIX_EQUAL;
445 }
446 break;
447 case PMIX_INT8:
448 if (p->data.int8 == p1->data.int8) {
449 rc = PMIX_EQUAL;
450 }
451 break;
452 case PMIX_INT16:
453 if (p->data.int16 == p1->data.int16) {
454 rc = PMIX_EQUAL;
455 }
456 break;
457 case PMIX_INT32:
458 if (p->data.int32 == p1->data.int32) {
459 rc = PMIX_EQUAL;
460 }
461 break;
462 case PMIX_INT64:
463 if (p->data.int64 == p1->data.int64) {
464 rc = PMIX_EQUAL;
465 }
466 break;
467 case PMIX_UINT:
468 if (p->data.uint == p1->data.uint) {
469 rc = PMIX_EQUAL;
470 }
471 break;
472 case PMIX_UINT8:
473 if (p->data.uint8 == p1->data.int8) {
474 rc = PMIX_EQUAL;
475 }
476 break;
477 case PMIX_UINT16:
478 if (p->data.uint16 == p1->data.uint16) {
479 rc = PMIX_EQUAL;
480 }
481 break;
482 case PMIX_UINT32:
483 if (p->data.uint32 == p1->data.uint32) {
484 rc = PMIX_EQUAL;
485 }
486 break;
487 case PMIX_UINT64:
488 if (p->data.uint64 == p1->data.uint64) {
489 rc = PMIX_EQUAL;
490 }
491 break;
492 case PMIX_STRING:
493 if (0 == strcmp(p->data.string, p1->data.string)) {
494 rc = PMIX_EQUAL;
495 }
496 break;
497 case PMIX_COMPRESSED_STRING:
498 if (p->data.bo.size > p1->data.bo.size) {
499 return PMIX_VALUE2_GREATER;
500 } else {
501 return PMIX_VALUE1_GREATER;
502 }
503 break;
504 case PMIX_STATUS:
505 if (p->data.status == p1->data.status) {
506 rc = PMIX_EQUAL;
507 }
508 break;
509 case PMIX_ENVAR:
510 if (NULL != p->data.envar.envar) {
511 if (NULL == p1->data.envar.envar) {
512 return PMIX_VALUE1_GREATER;
513 }
514 ret = strcmp(p->data.envar.envar, p1->data.envar.envar);
515 if (ret < 0) {
516 return PMIX_VALUE2_GREATER;
517 } else if (0 < ret) {
518 return PMIX_VALUE1_GREATER;
519 }
520 } else if (NULL != p1->data.envar.envar) {
521
522 return PMIX_VALUE2_GREATER;
523 }
524
525
526 if (NULL != p->data.envar.value) {
527 if (NULL == p1->data.envar.value) {
528 return PMIX_VALUE1_GREATER;
529 }
530 ret = strcmp(p->data.envar.value, p1->data.envar.value);
531 if (ret < 0) {
532 return PMIX_VALUE2_GREATER;
533 } else if (0 < ret) {
534 return PMIX_VALUE1_GREATER;
535 }
536 } else if (NULL != p1->data.envar.value) {
537
538 return PMIX_VALUE2_GREATER;
539 }
540
541
542 if (p->data.envar.separator < p1->data.envar.separator) {
543 return PMIX_VALUE2_GREATER;
544 }
545 if (p1->data.envar.separator < p->data.envar.separator) {
546 return PMIX_VALUE1_GREATER;
547 }
548 rc = PMIX_EQUAL;
549 break;
550 case PMIX_COORD:
551 rc = memcmp(p->data.coord, p1->data.coord, sizeof(pmix_coord_t));
552 if (0 > rc) {
553 rc = PMIX_VALUE2_GREATER;
554 } else if (0 < rc) {
555 rc = PMIX_VALUE1_GREATER;
556 } else {
557 rc = PMIX_EQUAL;
558 }
559 break;
560 case PMIX_REGATTR:
561 rc = memcmp(p->data.ptr, p1->data.ptr, sizeof(pmix_regattr_t));
562 if (0 > rc) {
563 rc = PMIX_VALUE2_GREATER;
564 } else if (0 < rc) {
565 rc = PMIX_VALUE1_GREATER;
566 } else {
567 rc = PMIX_EQUAL;
568 }
569 break;
570
571 default:
572 pmix_output(0, "COMPARE-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
573 }
574 return rc;
575 }
576
577
578 pmix_status_t pmix_bfrops_base_value_xfer(pmix_value_t *p,
579 const pmix_value_t *src)
580 {
581
582 p->type = src->type;
583 switch (src->type) {
584 case PMIX_UNDEF:
585 break;
586 case PMIX_BOOL:
587 p->data.flag = src->data.flag;
588 break;
589 case PMIX_BYTE:
590 p->data.byte = src->data.byte;
591 break;
592 case PMIX_STRING:
593 if (NULL != src->data.string) {
594 p->data.string = strdup(src->data.string);
595 } else {
596 p->data.string = NULL;
597 }
598 break;
599 case PMIX_SIZE:
600 p->data.size = src->data.size;
601 break;
602 case PMIX_PID:
603 p->data.pid = src->data.pid;
604 break;
605 case PMIX_INT:
606
607 memcpy(&p->data.integer, &src->data.integer, sizeof(int));
608 break;
609 case PMIX_INT8:
610 p->data.int8 = src->data.int8;
611 break;
612 case PMIX_INT16:
613
614 memcpy(&p->data.int16, &src->data.int16, 2);
615 break;
616 case PMIX_INT32:
617
618 memcpy(&p->data.int32, &src->data.int32, 4);
619 break;
620 case PMIX_INT64:
621
622 memcpy(&p->data.int64, &src->data.int64, 8);
623 break;
624 case PMIX_UINT:
625
626 memcpy(&p->data.uint, &src->data.uint, sizeof(unsigned int));
627 break;
628 case PMIX_UINT8:
629 p->data.uint8 = src->data.uint8;
630 break;
631 case PMIX_UINT16:
632
633 memcpy(&p->data.uint16, &src->data.uint16, 2);
634 break;
635 case PMIX_UINT32:
636
637 memcpy(&p->data.uint32, &src->data.uint32, 4);
638 break;
639 case PMIX_UINT64:
640
641 memcpy(&p->data.uint64, &src->data.uint64, 8);
642 break;
643 case PMIX_FLOAT:
644 p->data.fval = src->data.fval;
645 break;
646 case PMIX_DOUBLE:
647 p->data.dval = src->data.dval;
648 break;
649 case PMIX_TIMEVAL:
650 memcpy(&p->data.tv, &src->data.tv, sizeof(struct timeval));
651 break;
652 case PMIX_TIME:
653 memcpy(&p->data.time, &src->data.time, sizeof(time_t));
654 break;
655 case PMIX_STATUS:
656 memcpy(&p->data.status, &src->data.status, sizeof(pmix_status_t));
657 break;
658 case PMIX_PROC:
659 PMIX_PROC_CREATE(p->data.proc, 1);
660 if (NULL == p->data.proc) {
661 return PMIX_ERR_NOMEM;
662 }
663 memcpy(p->data.proc, src->data.proc, sizeof(pmix_proc_t));
664 break;
665 case PMIX_PROC_RANK:
666 memcpy(&p->data.rank, &src->data.rank, sizeof(pmix_rank_t));
667 break;
668 case PMIX_BYTE_OBJECT:
669 case PMIX_COMPRESSED_STRING:
670 memset(&p->data.bo, 0, sizeof(pmix_byte_object_t));
671 if (NULL != src->data.bo.bytes && 0 < src->data.bo.size) {
672 p->data.bo.bytes = malloc(src->data.bo.size);
673 memcpy(p->data.bo.bytes, src->data.bo.bytes, src->data.bo.size);
674 p->data.bo.size = src->data.bo.size;
675 } else {
676 p->data.bo.bytes = NULL;
677 p->data.bo.size = 0;
678 }
679 break;
680 case PMIX_PERSIST:
681 memcpy(&p->data.persist, &src->data.persist, sizeof(pmix_persistence_t));
682 break;
683 case PMIX_SCOPE:
684 memcpy(&p->data.scope, &src->data.scope, sizeof(pmix_scope_t));
685 break;
686 case PMIX_DATA_RANGE:
687 memcpy(&p->data.range, &src->data.range, sizeof(pmix_data_range_t));
688 break;
689 case PMIX_PROC_STATE:
690 memcpy(&p->data.state, &src->data.state, sizeof(pmix_proc_state_t));
691 break;
692 case PMIX_PROC_INFO:
693 return pmix_bfrops_base_copy_pinfo(&p->data.pinfo, src->data.pinfo, PMIX_PROC_INFO);
694 case PMIX_DATA_ARRAY:
695 return pmix_bfrops_base_copy_darray(&p->data.darray, src->data.darray, PMIX_DATA_ARRAY);
696 case PMIX_POINTER:
697 p->data.ptr = src->data.ptr;
698 break;
699 case PMIX_ENVAR:
700 PMIX_ENVAR_CONSTRUCT(&p->data.envar);
701 if (NULL != src->data.envar.envar) {
702 p->data.envar.envar = strdup(src->data.envar.envar);
703 }
704 if (NULL != src->data.envar.value) {
705 p->data.envar.value = strdup(src->data.envar.value);
706 }
707 p->data.envar.separator = src->data.envar.separator;
708 break;
709 case PMIX_COORD:
710 pmix_bfrops_base_copy_coord(&p->data.coord, src->data.coord, PMIX_COORD);
711 break;
712 case PMIX_REGATTR:
713 pmix_bfrops_base_copy_regattr((pmix_regattr_t**)&p->data.ptr, src->data.ptr, PMIX_REGATTR);
714 break;
715 default:
716 pmix_output(0, "PMIX-XFER-VALUE: UNSUPPORTED TYPE %d", (int)src->type);
717 return PMIX_ERROR;
718 }
719 return PMIX_SUCCESS;
720 }
721
722
723
724
725
726
727 char* pmix_bfrop_buffer_extend(pmix_buffer_t *buffer, size_t bytes_to_add)
728 {
729 size_t required, to_alloc;
730 size_t pack_offset, unpack_offset;
731
732
733
734
735 if ((buffer->bytes_allocated - buffer->bytes_used) >= bytes_to_add) {
736 return buffer->pack_ptr;
737 }
738
739 required = buffer->bytes_used + bytes_to_add;
740 if (required >= pmix_bfrops_globals.threshold_size) {
741 to_alloc = ((required + pmix_bfrops_globals.threshold_size - 1)
742 / pmix_bfrops_globals.threshold_size) * pmix_bfrops_globals.threshold_size;
743 } else {
744 to_alloc = buffer->bytes_allocated;
745 if (0 == to_alloc) {
746 to_alloc = pmix_bfrops_globals.initial_size;
747 }
748 while (to_alloc < required) {
749 to_alloc <<= 1;
750 }
751 }
752
753 if (NULL != buffer->base_ptr) {
754 pack_offset = ((char*) buffer->pack_ptr) - ((char*) buffer->base_ptr);
755 unpack_offset = ((char*) buffer->unpack_ptr) -
756 ((char*) buffer->base_ptr);
757 buffer->base_ptr = (char*)realloc(buffer->base_ptr, to_alloc);
758 memset(buffer->base_ptr + pack_offset, 0, to_alloc - buffer->bytes_allocated);
759 } else {
760 pack_offset = 0;
761 unpack_offset = 0;
762 buffer->bytes_used = 0;
763 buffer->base_ptr = (char*)malloc(to_alloc);
764 memset(buffer->base_ptr, 0, to_alloc);
765 }
766
767 if (NULL == buffer->base_ptr) {
768 return NULL;
769 }
770 buffer->pack_ptr = ((char*) buffer->base_ptr) + pack_offset;
771 buffer->unpack_ptr = ((char*) buffer->base_ptr) + unpack_offset;
772 buffer->bytes_allocated = to_alloc;
773
774
775 return buffer->pack_ptr;
776 }
777
778
779
780
781
782 bool pmix_bfrop_too_small(pmix_buffer_t *buffer, size_t bytes_reqd)
783 {
784 size_t bytes_remaining_packed;
785
786 if (buffer->pack_ptr < buffer->unpack_ptr) {
787 return true;
788 }
789
790 bytes_remaining_packed = buffer->pack_ptr - buffer->unpack_ptr;
791
792 if (bytes_remaining_packed < bytes_reqd) {
793
794
795
796 return true;
797 }
798
799 return false;
800 }
801
802 pmix_status_t pmix_bfrop_store_data_type(pmix_pointer_array_t *regtypes,
803 pmix_buffer_t *buffer, pmix_data_type_t type)
804 {
805 pmix_status_t ret;
806
807 PMIX_BFROPS_PACK_TYPE(ret, buffer, &type, 1, PMIX_UINT16, regtypes);
808 return ret;
809 }
810
811 pmix_status_t pmix_bfrop_get_data_type(pmix_pointer_array_t *regtypes,
812 pmix_buffer_t *buffer, pmix_data_type_t *type)
813 {
814 pmix_status_t ret;
815 int32_t m = 1;
816
817 PMIX_BFROPS_UNPACK_TYPE(ret, buffer, type, &m, PMIX_UINT16, regtypes);
818 return ret;
819 }
820
821 const char* pmix_bfrops_base_data_type_string(pmix_pointer_array_t *regtypes,
822 pmix_data_type_t type)
823 {
824 pmix_bfrop_type_info_t *info;
825
826
827 if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(regtypes, type))) {
828 return NULL;
829 }
830
831 return info->odti_name;
832 }