This source file includes following definitions.
- pmix12_bfrop_pack
- pmix12_bfrop_pack_buffer
- pmix12_bfrop_pack_bool
- pmix12_bfrop_pack_int
- pmix12_bfrop_pack_sizet
- pmix12_bfrop_pack_pid
- pmix12_bfrop_pack_byte
- pmix12_bfrop_pack_int16
- pmix12_bfrop_pack_int32
- pmix12_bfrop_pack_datatype
- pmix12_bfrop_pack_int64
- pmix12_bfrop_pack_string
- pmix12_bfrop_pack_float
- pmix12_bfrop_pack_double
- pmix12_bfrop_pack_timeval
- pmix12_bfrop_pack_time
- pack_val
- pmix12_bfrop_pack_value
- pmix12_bfrop_pack_info
- pmix12_bfrop_pack_pdata
- pmix12_bfrop_pack_buf
- pmix12_bfrop_pack_proc
- pmix12_bfrop_pack_app
- pmix12_bfrop_pack_kval
- pmix12_bfrop_pack_array
- pmix12_bfrop_pack_modex
- pmix12_bfrop_pack_persist
- pmix12_bfrop_pack_bo
- pmix12_bfrop_pack_ptr
- pmix12_bfrop_pack_scope
- pmix12_bfrop_pack_status
- pmix12_bfrop_pack_range
- pmix12_bfrop_pack_cmd
- pmix12_bfrop_pack_info_directives
- pmix12_bfrop_pack_proc_state
- pmix12_bfrop_pack_darray
- pmix12_bfrop_pack_proc_info
- pmix12_bfrop_pack_query
- pmix12_bfrop_pack_rank
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 #include <src/include/pmix_config.h>
27
28 #ifdef HAVE_ARPA_INET_H
29 #include <arpa/inet.h>
30 #endif
31
32 #include "src/util/argv.h"
33 #include "src/util/error.h"
34 #include "src/util/output.h"
35 #include "bfrop_v12.h"
36 #include "internal.h"
37
38 pmix_status_t pmix12_bfrop_pack(pmix_buffer_t *buffer,
39 const void *src, int32_t num_vals,
40 pmix_data_type_t type)
41 {
42 pmix_status_t rc;
43 pmix_pointer_array_t *regtypes = &mca_bfrops_v12_component.types;
44
45
46 if (NULL == buffer) {
47 return PMIX_ERR_BAD_PARAM;
48 }
49
50
51 if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
52 if (PMIX_SUCCESS != (rc = pmix12_bfrop_store_data_type(regtypes, buffer, PMIX_INT32))) {
53 return rc;
54 }
55 }
56 if (PMIX_SUCCESS != (rc = pmix12_bfrop_pack_int32(regtypes, buffer, &num_vals, 1, PMIX_INT32))) {
57 return rc;
58 }
59
60
61 return pmix12_bfrop_pack_buffer(regtypes, buffer, src, num_vals, type);
62 }
63
64 pmix_status_t pmix12_bfrop_pack_buffer(pmix_pointer_array_t *regtypes,
65 pmix_buffer_t *buffer,
66 const void *src, int32_t num_vals,
67 pmix_data_type_t type)
68 {
69 pmix_status_t rc;
70 pmix_bfrop_type_info_t *info;
71 int v1type;
72
73 pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_buffer( %p, %p, %lu, %d )\n",
74 (void*)buffer, src, (long unsigned int)num_vals, (int)type);
75
76
77 switch (type) {
78 case PMIX_COMMAND:
79 v1type = PMIX_UINT32;
80 break;
81 case PMIX_SCOPE:
82 case PMIX_DATA_RANGE:
83 v1type = PMIX_UINT;
84 break;
85 case PMIX_PROC_RANK:
86 case PMIX_PERSIST:
87 v1type = PMIX_INT;
88 break;
89 case PMIX_INFO_ARRAY:
90 v1type = 22;
91 break;
92 default:
93 v1type = type;
94 }
95
96
97 if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
98 if (PMIX_SUCCESS != (rc = pmix12_bfrop_store_data_type(regtypes, buffer, v1type))) {
99 return rc;
100 }
101 }
102
103
104 if (PMIX_INFO_ARRAY == type) {
105 v1type = PMIX_INFO_ARRAY;
106 }
107
108
109
110 if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v12_component.types, v1type))) {
111 return PMIX_ERR_PACK_FAILURE;
112 }
113
114 return info->odti_pack_fn(regtypes, buffer, src, num_vals, v1type);
115 }
116
117
118
119
120
121
122
123 pmix_status_t pmix12_bfrop_pack_bool(pmix_pointer_array_t *regtypes,
124 pmix_buffer_t *buffer, const void *src,
125 int32_t num_vals, pmix_data_type_t type)
126 {
127 uint8_t *dst;
128 int32_t i;
129 bool *s = (bool*)src;
130
131 pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_bool * %d\n", num_vals);
132
133 if (NULL == (dst = (uint8_t*)pmix_bfrop_buffer_extend(buffer, num_vals))) {
134 return PMIX_ERR_OUT_OF_RESOURCE;
135 }
136
137
138 for (i=0; i < num_vals; i++) {
139 if (s[i]) {
140 dst[i] = 1;
141 } else {
142 dst[i] = 0;
143 }
144 }
145
146
147 buffer->pack_ptr += num_vals;
148 buffer->bytes_used += num_vals;
149
150 return PMIX_SUCCESS;
151 }
152
153
154
155
156 pmix_status_t pmix12_bfrop_pack_int(pmix_pointer_array_t *regtypes,
157 pmix_buffer_t *buffer, const void *src,
158 int32_t num_vals, pmix_data_type_t type)
159 {
160 pmix_status_t ret;
161
162
163
164 if (PMIX_SUCCESS != (ret = pmix12_bfrop_store_data_type(regtypes, buffer, BFROP_TYPE_INT))) {
165 return ret;
166 }
167
168
169 return pmix12_bfrop_pack_buffer(regtypes, buffer, src, num_vals, BFROP_TYPE_INT);
170 }
171
172
173
174
175 pmix_status_t pmix12_bfrop_pack_sizet(pmix_pointer_array_t *regtypes,
176 pmix_buffer_t *buffer, const void *src,
177 int32_t num_vals, pmix_data_type_t type)
178 {
179 pmix_status_t ret;
180
181
182
183 if (PMIX_SUCCESS != (ret = pmix12_bfrop_store_data_type(regtypes, buffer, BFROP_TYPE_SIZE_T))) {
184 return ret;
185 }
186
187 return pmix12_bfrop_pack_buffer(regtypes, buffer, src, num_vals, BFROP_TYPE_SIZE_T);
188 }
189
190
191
192
193 pmix_status_t pmix12_bfrop_pack_pid(pmix_pointer_array_t *regtypes,
194 pmix_buffer_t *buffer, const void *src,
195 int32_t num_vals, pmix_data_type_t type)
196 {
197 pmix_status_t ret;
198
199
200
201 if (PMIX_SUCCESS != (ret = pmix12_bfrop_store_data_type(regtypes, buffer, BFROP_TYPE_PID_T))) {
202 return ret;
203 }
204
205
206 return pmix12_bfrop_pack_buffer(regtypes, buffer, src, num_vals, BFROP_TYPE_PID_T);
207 }
208
209
210
211
212
213
214
215 pmix_status_t pmix12_bfrop_pack_byte(pmix_pointer_array_t *regtypes,
216 pmix_buffer_t *buffer, const void *src,
217 int32_t num_vals, pmix_data_type_t type)
218 {
219 char *dst;
220
221 pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_byte * %d\n", num_vals);
222
223 if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, num_vals))) {
224 return PMIX_ERR_OUT_OF_RESOURCE;
225 }
226
227
228 memcpy(dst, src, num_vals);
229
230
231 buffer->pack_ptr += num_vals;
232 buffer->bytes_used += num_vals;
233
234 return PMIX_SUCCESS;
235 }
236
237
238
239
240 pmix_status_t pmix12_bfrop_pack_int16(pmix_pointer_array_t *regtypes,
241 pmix_buffer_t *buffer, const void *src,
242 int32_t num_vals, pmix_data_type_t type)
243 {
244 int32_t i;
245 uint16_t tmp, *srctmp = (uint16_t*) src;
246 char *dst;
247
248 pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_int16 * %d\n", num_vals);
249
250 if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, num_vals*sizeof(tmp)))) {
251 return PMIX_ERR_OUT_OF_RESOURCE;
252 }
253
254 for (i = 0; i < num_vals; ++i) {
255 tmp = pmix_htons(srctmp[i]);
256 memcpy(dst, &tmp, sizeof(tmp));
257 dst += sizeof(tmp);
258 }
259 buffer->pack_ptr += num_vals * sizeof(tmp);
260 buffer->bytes_used += num_vals * sizeof(tmp);
261
262 return PMIX_SUCCESS;
263 }
264
265
266
267
268 pmix_status_t pmix12_bfrop_pack_int32(pmix_pointer_array_t *regtypes,
269 pmix_buffer_t *buffer, const void *src,
270 int32_t num_vals, pmix_data_type_t type)
271 {
272 int32_t i;
273 uint32_t tmp, *srctmp = (uint32_t*) src;
274 char *dst;
275
276 pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_int32 * %d\n", num_vals);
277
278 if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, num_vals*sizeof(tmp)))) {
279 return PMIX_ERR_OUT_OF_RESOURCE;
280 }
281
282 for (i = 0; i < num_vals; ++i) {
283 tmp = htonl(srctmp[i]);
284 memcpy(dst, &tmp, sizeof(tmp));
285 dst += sizeof(tmp);
286 }
287 buffer->pack_ptr += num_vals * sizeof(tmp);
288 buffer->bytes_used += num_vals * sizeof(tmp);
289
290 return PMIX_SUCCESS;
291 }
292
293 pmix_status_t pmix12_bfrop_pack_datatype(pmix_pointer_array_t *regtypes,
294 pmix_buffer_t *buffer, const void *src,
295 int32_t num_vals, pmix_data_type_t type)
296 {
297 return pmix12_bfrop_pack_int32(regtypes, buffer, src, num_vals, type);
298 }
299
300
301
302
303 pmix_status_t pmix12_bfrop_pack_int64(pmix_pointer_array_t *regtypes,
304 pmix_buffer_t *buffer, const void *src,
305 int32_t num_vals, pmix_data_type_t type)
306 {
307 int32_t i;
308 uint64_t tmp, tmp2;
309 char *dst;
310 size_t bytes_packed = num_vals * sizeof(tmp);
311
312 pmix_output_verbose(20, pmix_globals.debug_output, "pmix12_bfrop_pack_int64 * %d\n", num_vals);
313
314 if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, bytes_packed))) {
315 return PMIX_ERR_OUT_OF_RESOURCE;
316 }
317
318 for (i = 0; i < num_vals; ++i) {
319 memcpy(&tmp2, (char *)src+i*sizeof(uint64_t), sizeof(uint64_t));
320 tmp = pmix_hton64(tmp2);
321 memcpy(dst, &tmp, sizeof(tmp));
322 dst += sizeof(tmp);
323 }
324 buffer->pack_ptr += bytes_packed;
325 buffer->bytes_used += bytes_packed;
326
327 return PMIX_SUCCESS;
328 }
329
330
331
332
333 pmix_status_t pmix12_bfrop_pack_string(pmix_pointer_array_t *regtypes,
334 pmix_buffer_t *buffer, const void *src,
335 int32_t num_vals, pmix_data_type_t type)
336 {
337 int ret = PMIX_SUCCESS;
338 int32_t i, len;
339 char **ssrc = (char**) src;
340
341 for (i = 0; i < num_vals; ++i) {
342 if (NULL == ssrc[i]) {
343 len = 0;
344 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int32(regtypes, buffer, &len, 1, PMIX_INT32))) {
345 return ret;
346 }
347 } else {
348 len = (int32_t)strlen(ssrc[i]) + 1;
349 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int32(regtypes, buffer, &len, 1, PMIX_INT32))) {
350 return ret;
351 }
352 if (PMIX_SUCCESS != (ret =
353 pmix12_bfrop_pack_byte(regtypes, buffer, ssrc[i], len, PMIX_BYTE))) {
354 return ret;
355 }
356 }
357 }
358
359 return PMIX_SUCCESS;
360 }
361
362
363 pmix_status_t pmix12_bfrop_pack_float(pmix_pointer_array_t *regtypes,
364 pmix_buffer_t *buffer, const void *src,
365 int32_t num_vals, pmix_data_type_t type)
366 {
367 pmix_status_t ret = PMIX_SUCCESS;
368 int32_t i;
369 float *ssrc = (float*)src;
370 char *convert;
371
372 for (i = 0; i < num_vals; ++i) {
373 if (0 > asprintf(&convert, "%f", ssrc[i])) {
374 return PMIX_ERR_NOMEM;
375 }
376 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &convert, 1, PMIX_STRING))) {
377 free(convert);
378 return ret;
379 }
380 free(convert);
381 }
382
383 return PMIX_SUCCESS;
384 }
385
386
387 pmix_status_t pmix12_bfrop_pack_double(pmix_pointer_array_t *regtypes,
388 pmix_buffer_t *buffer, const void *src,
389 int32_t num_vals, pmix_data_type_t type)
390 {
391 pmix_status_t ret = PMIX_SUCCESS;
392 int32_t i;
393 double *ssrc = (double*)src;
394 char *convert;
395
396 for (i = 0; i < num_vals; ++i) {
397 if (0 > asprintf(&convert, "%f", ssrc[i])) {
398 return PMIX_ERR_NOMEM;
399 }
400 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &convert, 1, PMIX_STRING))) {
401 free(convert);
402 return ret;
403 }
404 free(convert);
405 }
406
407 return PMIX_SUCCESS;
408 }
409
410
411 pmix_status_t pmix12_bfrop_pack_timeval(pmix_pointer_array_t *regtypes,
412 pmix_buffer_t *buffer, const void *src,
413 int32_t num_vals, pmix_data_type_t type)
414 {
415 int64_t tmp[2];
416 pmix_status_t ret = PMIX_SUCCESS;
417 int32_t i;
418 struct timeval *ssrc = (struct timeval *)src;
419
420 for (i = 0; i < num_vals; ++i) {
421 tmp[0] = (int64_t)ssrc[i].tv_sec;
422 tmp[1] = (int64_t)ssrc[i].tv_usec;
423 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int64(regtypes, buffer, tmp, 2, PMIX_INT64))) {
424 return ret;
425 }
426 }
427
428 return PMIX_SUCCESS;
429 }
430
431
432 pmix_status_t pmix12_bfrop_pack_time(pmix_pointer_array_t *regtypes,
433 pmix_buffer_t *buffer, const void *src,
434 int32_t num_vals, pmix_data_type_t type)
435 {
436 pmix_status_t ret = PMIX_SUCCESS;
437 int32_t i;
438 time_t *ssrc = (time_t *)src;
439 uint64_t ui64;
440
441
442
443
444 for (i = 0; i < num_vals; ++i) {
445 ui64 = (uint64_t)ssrc[i];
446 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int64(regtypes, buffer, &ui64, 1, PMIX_UINT64))) {
447 return ret;
448 }
449 }
450
451 return PMIX_SUCCESS;
452 }
453
454
455
456 static pmix_status_t pack_val(pmix_pointer_array_t *regtypes,
457 pmix_buffer_t *buffer,
458 pmix_value_t *p)
459 {
460 pmix_status_t ret;
461 pmix_info_array_t array;
462 int rank;
463
464 switch (p->type) {
465 case PMIX_BOOL:
466 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.flag, 1, PMIX_BOOL))) {
467 return ret;
468 }
469 break;
470 case PMIX_BYTE:
471 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.byte, 1, PMIX_BYTE))) {
472 return ret;
473 }
474 break;
475 case PMIX_STRING:
476 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.string, 1, PMIX_STRING))) {
477 return ret;
478 }
479 break;
480 case PMIX_SIZE:
481 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.size, 1, PMIX_SIZE))) {
482 return ret;
483 }
484 break;
485 case PMIX_PID:
486 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.pid, 1, PMIX_PID))) {
487 return ret;
488 }
489 break;
490 case PMIX_INT:
491 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.integer, 1, PMIX_INT))) {
492 return ret;
493 }
494 break;
495 case PMIX_INT8:
496 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.int8, 1, PMIX_INT8))) {
497 return ret;
498 }
499 break;
500 case PMIX_INT16:
501 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.int16, 1, PMIX_INT16))) {
502 return ret;
503 }
504 break;
505 case PMIX_INT32:
506 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.int32, 1, PMIX_INT32))) {
507 return ret;
508 }
509 break;
510 case PMIX_INT64:
511 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.int64, 1, PMIX_INT64))) {
512 return ret;
513 }
514 break;
515 case PMIX_UINT:
516 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint, 1, PMIX_UINT))) {
517 return ret;
518 }
519 break;
520 case PMIX_UINT8:
521 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint8, 1, PMIX_UINT8))) {
522 return ret;
523 }
524 break;
525 case PMIX_UINT16:
526 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint16, 1, PMIX_UINT16))) {
527 return ret;
528 }
529 break;
530 case PMIX_UINT32:
531 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint32, 1, PMIX_UINT32))) {
532 return ret;
533 }
534 break;
535 case PMIX_UINT64:
536 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.uint64, 1, PMIX_UINT64))) {
537 return ret;
538 }
539 break;
540 case PMIX_FLOAT:
541 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.fval, 1, PMIX_FLOAT))) {
542 return ret;
543 }
544 break;
545 case PMIX_DOUBLE:
546 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.dval, 1, PMIX_DOUBLE))) {
547 return ret;
548 }
549 break;
550 case PMIX_TIMEVAL:
551 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.tv, 1, PMIX_TIMEVAL))) {
552 return ret;
553 }
554 break;
555 case PMIX_BYTE_OBJECT:
556 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &p->data.bo, 1, PMIX_BYTE_OBJECT))) {
557 return ret;
558 }
559 break;
560 case PMIX_DATA_ARRAY:
561
562 if (PMIX_INFO != p->data.darray->type) {
563 return PMIX_ERR_NOT_SUPPORTED;
564 }
565 array.size = p->data.darray->size;
566 array.array = (pmix_info_t*)p->data.darray->array;
567 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &array, 1, PMIX_INFO_ARRAY))) {
568 return ret;
569 }
570 break;
571
572 case PMIX_PROC_RANK:
573
574 rank = p->data.rank;
575 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_buffer(regtypes, buffer, &rank, 1, PMIX_INT))) {
576 return ret;
577 }
578 break;
579
580 default:
581 pmix_output(0, "PACK-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
582 return PMIX_ERROR;
583 }
584 return PMIX_SUCCESS;
585 }
586
587
588
589
590 pmix_status_t pmix12_bfrop_pack_value(pmix_pointer_array_t *regtypes,
591 pmix_buffer_t *buffer, const void *src,
592 int32_t num_vals, pmix_data_type_t type)
593 {
594 pmix_value_t *ptr;
595 int32_t i;
596 pmix_status_t ret;
597 int v1type;
598
599 ptr = (pmix_value_t *) src;
600
601 for (i = 0; i < num_vals; ++i) {
602
603
604
605 v1type = pmix12_v2_to_v1_datatype(ptr[i].type);
606 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &v1type, 1, PMIX_INT))) {
607 return ret;
608 }
609
610 if (PMIX_SUCCESS != (ret = pack_val(regtypes, buffer, &ptr[i]))) {
611 return ret;
612 }
613 }
614
615 return PMIX_SUCCESS;
616 }
617
618
619 pmix_status_t pmix12_bfrop_pack_info(pmix_pointer_array_t *regtypes,
620 pmix_buffer_t *buffer, const void *src,
621 int32_t num_vals, pmix_data_type_t type)
622 {
623 pmix_info_t *info;
624 int32_t i;
625 pmix_status_t ret;
626 char *foo;
627 int v1type;
628
629 info = (pmix_info_t *) src;
630
631 for (i = 0; i < num_vals; ++i) {
632
633 foo = info[i].key;
634 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &foo, 1, PMIX_STRING))) {
635 return ret;
636 }
637
638
639
640 v1type = pmix12_v2_to_v1_datatype(info[i].value.type);
641 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &v1type, 1, PMIX_INT))) {
642 return ret;
643 }
644
645 if (PMIX_SUCCESS != (ret = pack_val(regtypes, buffer, &info[i].value))) {
646 return ret;
647 }
648 }
649 return PMIX_SUCCESS;
650 }
651
652 pmix_status_t pmix12_bfrop_pack_pdata(pmix_pointer_array_t *regtypes,
653 pmix_buffer_t *buffer, const void *src,
654 int32_t num_vals, pmix_data_type_t type)
655 {
656 pmix_pdata_t *pdata;
657 int32_t i;
658 pmix_status_t ret;
659 char *foo;
660 int v1type;
661
662 pdata = (pmix_pdata_t *) src;
663
664 for (i = 0; i < num_vals; ++i) {
665
666 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_proc(regtypes, buffer, &pdata[i].proc, 1, PMIX_PROC))) {
667 return ret;
668 }
669
670 foo = pdata[i].key;
671 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &foo, 1, PMIX_STRING))) {
672 return ret;
673 }
674
675
676
677 v1type = pmix12_v2_to_v1_datatype(pdata[i].value.type);
678 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &v1type, 1, PMIX_INT))) {
679 return ret;
680 }
681
682 if (PMIX_SUCCESS != (ret = pack_val(regtypes, buffer, &pdata[i].value))) {
683 return ret;
684 }
685 }
686 return PMIX_SUCCESS;
687 }
688
689 pmix_status_t pmix12_bfrop_pack_buf(pmix_pointer_array_t *regtypes,
690 pmix_buffer_t *buffer, const void *src,
691 int32_t num_vals, pmix_data_type_t type)
692 {
693 pmix_buffer_t *ptr;
694 int32_t i;
695 pmix_status_t ret;
696
697 ptr = (pmix_buffer_t *) src;
698
699 for (i = 0; i < num_vals; ++i) {
700
701 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &ptr[i].bytes_used, 1, PMIX_SIZE))) {
702 return ret;
703 }
704
705 if (0 < ptr[i].bytes_used) {
706 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_byte(regtypes, buffer, ptr[i].base_ptr, ptr[i].bytes_used, PMIX_BYTE))) {
707 return ret;
708 }
709 }
710 }
711 return PMIX_SUCCESS;
712 }
713
714 pmix_status_t pmix12_bfrop_pack_proc(pmix_pointer_array_t *regtypes,
715 pmix_buffer_t *buffer, const void *src,
716 int32_t num_vals, pmix_data_type_t type)
717 {
718 pmix_proc_t *proc;
719 int32_t i;
720 pmix_status_t ret;
721
722 proc = (pmix_proc_t *) src;
723
724 for (i = 0; i < num_vals; ++i) {
725 char *ptr = proc[i].nspace;
726 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &ptr, 1, PMIX_STRING))) {
727 return ret;
728 }
729 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &proc[i].rank, 1, PMIX_INT))) {
730 return ret;
731 }
732 }
733 return PMIX_SUCCESS;
734 }
735
736 pmix_status_t pmix12_bfrop_pack_app(pmix_pointer_array_t *regtypes,
737 pmix_buffer_t *buffer, const void *src,
738 int32_t num_vals, pmix_data_type_t type)
739 {
740 pmix_app_t *app;
741 int32_t i, j, nvals;
742 pmix_status_t ret;
743 int argc;
744
745 app = (pmix_app_t *) src;
746
747 for (i = 0; i < num_vals; ++i) {
748 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &app[i].cmd, 1, PMIX_STRING))) {
749 return ret;
750 }
751
752 argc = pmix_argv_count(app[i].argv);
753 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &argc, 1, PMIX_INT))) {
754 return ret;
755 }
756 for (j=0; j < argc; j++) {
757 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &app[i].argv[j], 1, PMIX_STRING))) {
758 return ret;
759 }
760 }
761
762 nvals = pmix_argv_count(app[i].env);
763 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int32(regtypes, buffer, &nvals, 1, PMIX_INT32))) {
764 return ret;
765 }
766 for (j=0; j < nvals; j++) {
767 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &app[i].env[j], 1, PMIX_STRING))) {
768 return ret;
769 }
770 }
771
772 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_int(regtypes, buffer, &app[i].maxprocs, 1, PMIX_INT))) {
773 return ret;
774 }
775
776 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &app[i].ninfo, 1, PMIX_SIZE))) {
777 return ret;
778 }
779 if (0 < app[i].ninfo) {
780 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_info(regtypes, buffer, app[i].info, app[i].ninfo, PMIX_INFO))) {
781 return ret;
782 }
783 }
784 }
785 return PMIX_SUCCESS;
786 }
787
788
789 pmix_status_t pmix12_bfrop_pack_kval(pmix_pointer_array_t *regtypes,
790 pmix_buffer_t *buffer, const void *src,
791 int32_t num_vals, pmix_data_type_t type)
792 {
793 pmix_kval_t *ptr;
794 int32_t i;
795 pmix_status_t ret;
796
797 ptr = (pmix_kval_t *) src;
798
799 for (i = 0; i < num_vals; ++i) {
800
801 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_string(regtypes, buffer, &ptr[i].key, 1, PMIX_STRING))) {
802 return ret;
803 }
804
805 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_value(regtypes, buffer, ptr[i].value, 1, ptr[i].value->type))) {
806 return ret;
807 }
808 }
809
810 return PMIX_SUCCESS;
811 }
812
813 pmix_status_t pmix12_bfrop_pack_array(pmix_pointer_array_t *regtypes,
814 pmix_buffer_t *buffer, const void *src,
815 int32_t num_vals, pmix_data_type_t type)
816 {
817 pmix_info_array_t *ptr;
818 int32_t i;
819 pmix_status_t ret;
820
821 ptr = (pmix_info_array_t *) src;
822
823 for (i = 0; i < num_vals; ++i) {
824
825 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &ptr[i].size, 1, PMIX_SIZE))) {
826 return ret;
827 }
828 if (0 < ptr[i].size) {
829
830 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_info(regtypes, buffer, ptr[i].array, ptr[i].size, PMIX_INFO))) {
831 return ret;
832 }
833 }
834 }
835
836 return PMIX_SUCCESS;
837 }
838
839 pmix_status_t pmix12_bfrop_pack_modex(pmix_pointer_array_t *regtypes,
840 pmix_buffer_t *buffer, const void *src,
841 int32_t num_vals, pmix_data_type_t type)
842 {
843 pmix_modex_data_t *ptr;
844 int32_t i;
845 pmix_status_t ret;
846
847 ptr = (pmix_modex_data_t *) src;
848
849 for (i = 0; i < num_vals; ++i) {
850 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &ptr[i].size, 1, PMIX_SIZE))) {
851 return ret;
852 }
853 if( 0 < ptr[i].size){
854 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_byte(regtypes, buffer, ptr[i].blob, ptr[i].size, PMIX_UINT8))) {
855 return ret;
856 }
857 }
858 }
859 return PMIX_SUCCESS;
860 }
861
862 pmix_status_t pmix12_bfrop_pack_persist(pmix_pointer_array_t *regtypes,
863 pmix_buffer_t *buffer, const void *src,
864 int32_t num_vals, pmix_data_type_t type)
865 {
866 return pmix12_bfrop_pack_int(regtypes, buffer, src, num_vals, PMIX_INT);
867 }
868
869 pmix_status_t pmix12_bfrop_pack_bo(pmix_pointer_array_t *regtypes,
870 pmix_buffer_t *buffer, const void *src,
871 int32_t num_vals, pmix_data_type_t type)
872 {
873 pmix_status_t ret;
874 int i;
875 pmix_byte_object_t *bo;
876
877 bo = (pmix_byte_object_t*)src;
878 for (i=0; i < num_vals; i++) {
879 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_sizet(regtypes, buffer, &bo[i].size, 1, PMIX_SIZE))) {
880 return ret;
881 }
882 if (0 < bo[i].size) {
883 if (PMIX_SUCCESS != (ret = pmix12_bfrop_pack_byte(regtypes, buffer, bo[i].bytes, bo[i].size, PMIX_BYTE))) {
884 return ret;
885 }
886 }
887 }
888 return PMIX_SUCCESS;
889 }
890
891 pmix_status_t pmix12_bfrop_pack_ptr(pmix_pointer_array_t *regtypes,
892 pmix_buffer_t *buffer, const void *src,
893 int32_t num_vals, pmix_data_type_t type)
894 {
895
896 return PMIX_SUCCESS;
897 }
898
899 pmix_status_t pmix12_bfrop_pack_scope(pmix_pointer_array_t *regtypes,
900 pmix_buffer_t *buffer, const void *src,
901 int32_t num_vals, pmix_data_type_t type)
902 {
903 pmix_scope_t *scope = (pmix_scope_t*)src;
904 unsigned int *v1scope;
905 pmix_status_t ret;
906 int i;
907
908
909 v1scope = (unsigned int*)malloc(num_vals * sizeof(unsigned int));
910 if (NULL == v1scope) {
911 return PMIX_ERR_NOMEM;
912 }
913 for (i=0; i < num_vals; i++) {
914 v1scope[i] = (unsigned int)scope[i];
915 }
916 ret = pmix12_bfrop_pack_int(regtypes, buffer, (void*)v1scope, num_vals, PMIX_UINT);
917 free(v1scope);
918 return ret;
919 }
920
921 pmix_status_t pmix12_bfrop_pack_status(pmix_pointer_array_t *regtypes,
922 pmix_buffer_t *buffer, const void *src,
923 int32_t num_vals, pmix_data_type_t type)
924 {
925
926
927 return pmix12_bfrop_pack_int(regtypes, buffer, src, num_vals, PMIX_INT);
928 }
929
930 pmix_status_t pmix12_bfrop_pack_range(pmix_pointer_array_t *regtypes,
931 pmix_buffer_t *buffer, const void *src,
932 int32_t num_vals, pmix_data_type_t type)
933 {
934 pmix_data_range_t *range = (pmix_data_range_t*)src;
935 unsigned int *v1range;
936 pmix_status_t ret;
937 int i;
938
939
940 v1range = (unsigned int*)malloc(num_vals * sizeof(unsigned int));
941 if (NULL == v1range) {
942 return PMIX_ERR_NOMEM;
943 }
944 for (i=0; i < num_vals; i++) {
945 v1range[i] = (unsigned int)range[i];
946 }
947 ret = pmix12_bfrop_pack_int(regtypes, buffer, (void*)v1range, num_vals, PMIX_UINT);
948 free(v1range);
949 return ret;
950 }
951
952 pmix_status_t pmix12_bfrop_pack_cmd(pmix_pointer_array_t *regtypes,
953 pmix_buffer_t *buffer, const void *src,
954 int32_t num_vals, pmix_data_type_t type)
955 {
956 pmix_cmd_t *cmd = (pmix_cmd_t*)src;
957 int *v1cmd;
958 pmix_status_t ret;
959 int i;
960
961
962 v1cmd = (int*)malloc(num_vals * sizeof(int));
963 if (NULL == v1cmd) {
964 return PMIX_ERR_NOMEM;
965 }
966 for (i=0; i < num_vals; i++) {
967 v1cmd[i] = cmd[i];
968 }
969 ret = pmix12_bfrop_pack_int(regtypes, buffer, (void*)v1cmd, num_vals, PMIX_INT);
970 free(v1cmd);
971 return ret;
972 }
973
974 pmix_status_t pmix12_bfrop_pack_info_directives(pmix_pointer_array_t *regtypes,
975 pmix_buffer_t *buffer, const void *src,
976 int32_t num_vals, pmix_data_type_t type)
977 {
978
979 return PMIX_SUCCESS;
980 }
981
982 pmix_status_t pmix12_bfrop_pack_proc_state(pmix_pointer_array_t *regtypes,
983 pmix_buffer_t *buffer, const void *src,
984 int32_t num_vals, pmix_data_type_t type)
985 {
986
987 return PMIX_SUCCESS;
988 }
989
990 pmix_status_t pmix12_bfrop_pack_darray(pmix_pointer_array_t *regtypes,
991 pmix_buffer_t *buffer, const void *src,
992 int32_t num_vals, pmix_data_type_t type)
993 {
994 return PMIX_ERR_NOT_SUPPORTED;
995 }
996
997 pmix_status_t pmix12_bfrop_pack_proc_info(pmix_pointer_array_t *regtypes,
998 pmix_buffer_t *buffer, const void *src,
999 int32_t num_vals, pmix_data_type_t type)
1000 {
1001 return PMIX_ERR_NOT_SUPPORTED;
1002
1003 }
1004
1005 pmix_status_t pmix12_bfrop_pack_query(pmix_pointer_array_t *regtypes,
1006 pmix_buffer_t *buffer, const void *src,
1007 int32_t num_vals, pmix_data_type_t type)
1008 {
1009 return PMIX_ERR_NOT_SUPPORTED;
1010 }
1011
1012 pmix_status_t pmix12_bfrop_pack_rank(pmix_pointer_array_t *regtypes,
1013 pmix_buffer_t *buffer, const void *src,
1014 int32_t num_vals, pmix_data_type_t type)
1015 {
1016
1017
1018 return pmix12_bfrop_pack_int(regtypes, buffer, src, num_vals, PMIX_INT);
1019 }