This source file includes following definitions.
- pmix12_bfrop_copy
- pmix12_bfrop_copy_payload
- pmix12_bfrop_std_copy
- pmix12_bfrop_copy_string
- pmix12_bfrop_value_cmp
- pmix12_bfrop_value_xfer
- pmix12_bfrop_copy_value
- pmix12_bfrop_copy_info
- pmix12_bfrop_copy_buf
- pmix12_bfrop_copy_app
- pmix12_bfrop_copy_kval
- pmix12_bfrop_copy_array
- pmix12_bfrop_copy_proc
- pmix12_bfrop_copy_modex
- pmix12_bfrop_copy_persist
- pmix12_bfrop_copy_bo
- pmix12_bfrop_copy_pdata
- pmix12_bfrop_copy_darray
- pmix12_bfrop_copy_proc_info
- pmix12_bfrop_copy_query
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_v12.h"
31 #include "internal.h"
32
33 pmix_status_t pmix12_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_v12_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 pmix12_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 pmix12_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 default:
143 return PMIX_ERR_UNKNOWN_DATA_TYPE;
144 }
145
146 val = (uint8_t*)malloc(datasize);
147 if (NULL == val) {
148 return PMIX_ERR_OUT_OF_RESOURCE;
149 }
150
151 memcpy(val, src, datasize);
152 *dest = val;
153
154 return PMIX_SUCCESS;
155 }
156
157
158
159
160
161
162 pmix_status_t pmix12_bfrop_copy_string(char **dest, char *src, pmix_data_type_t type)
163 {
164 if (NULL == src) {
165 *dest = NULL;
166 } else {
167 *dest = strdup(src);
168 }
169
170 return PMIX_SUCCESS;
171 }
172
173 pmix_value_cmp_t pmix12_bfrop_value_cmp(pmix_value_t *p, pmix_value_t *p1)
174 {
175 bool rc = false;
176 switch (p->type) {
177 case PMIX_BOOL:
178 rc = (p->data.flag == p1->data.flag);
179 break;
180 case PMIX_BYTE:
181 rc = (p->data.byte == p1->data.byte);
182 break;
183 case PMIX_SIZE:
184 rc = (p->data.size == p1->data.size);
185 break;
186 case PMIX_INT:
187 rc = (p->data.integer == p1->data.integer);
188 break;
189 case PMIX_INT8:
190 rc = (p->data.int8 == p1->data.int8);
191 break;
192 case PMIX_INT16:
193 rc = (p->data.int16 == p1->data.int16);
194 break;
195 case PMIX_INT32:
196 rc = (p->data.int32 == p1->data.int32);
197 break;
198 case PMIX_INT64:
199 rc = (p->data.int64 == p1->data.int64);
200 break;
201 case PMIX_UINT:
202 rc = (p->data.uint == p1->data.uint);
203 break;
204 case PMIX_UINT8:
205 rc = (p->data.uint8 == p1->data.int8);
206 break;
207 case PMIX_UINT16:
208 rc = (p->data.uint16 == p1->data.uint16);
209 break;
210 case PMIX_UINT32:
211 rc = (p->data.uint32 == p1->data.uint32);
212 break;
213 case PMIX_UINT64:
214 rc = (p->data.uint64 == p1->data.uint64);
215 break;
216 case PMIX_STRING:
217 rc = strcmp(p->data.string, p1->data.string);
218 break;
219 default:
220 pmix_output(0, "COMPARE-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
221 }
222 if (rc) {
223 return PMIX_EQUAL;
224 }
225 return PMIX_VALUE1_GREATER;
226 }
227
228 pmix_status_t pmix12_bfrop_value_xfer(pmix_value_t *p, const pmix_value_t *src)
229 {
230
231 p->type = src->type;
232 switch (src->type) {
233 case PMIX_BOOL:
234 p->data.flag = src->data.flag;
235 break;
236 case PMIX_BYTE:
237 p->data.byte = src->data.byte;
238 break;
239 case PMIX_STRING:
240 if (NULL != src->data.string) {
241 p->data.string = strdup(src->data.string);
242 } else {
243 p->data.string = NULL;
244 }
245 break;
246 case PMIX_SIZE:
247 p->data.size = src->data.size;
248 break;
249 case PMIX_PID:
250 p->data.pid = src->data.pid;
251 break;
252 case PMIX_INT:
253
254 memcpy(&p->data.integer, &src->data.integer, sizeof(int));
255 break;
256 case PMIX_INT8:
257 p->data.int8 = src->data.int8;
258 break;
259 case PMIX_INT16:
260
261 memcpy(&p->data.int16, &src->data.int16, 2);
262 break;
263 case PMIX_INT32:
264
265 memcpy(&p->data.int32, &src->data.int32, 4);
266 break;
267 case PMIX_INT64:
268
269 memcpy(&p->data.int64, &src->data.int64, 8);
270 break;
271 case PMIX_UINT:
272
273 memcpy(&p->data.uint, &src->data.uint, sizeof(unsigned int));
274 break;
275 case PMIX_UINT8:
276 p->data.uint8 = src->data.uint8;
277 break;
278 case PMIX_UINT16:
279
280 memcpy(&p->data.uint16, &src->data.uint16, 2);
281 break;
282 case PMIX_UINT32:
283
284 memcpy(&p->data.uint32, &src->data.uint32, 4);
285 break;
286 case PMIX_UINT64:
287
288 memcpy(&p->data.uint64, &src->data.uint64, 8);
289 break;
290 case PMIX_FLOAT:
291 p->data.fval = src->data.fval;
292 break;
293 case PMIX_DOUBLE:
294 p->data.dval = src->data.dval;
295 break;
296 case PMIX_TIMEVAL:
297 p->data.tv.tv_sec = src->data.tv.tv_sec;
298 p->data.tv.tv_usec = src->data.tv.tv_usec;
299 break;
300 case PMIX_INFO_ARRAY:
301 return PMIX_ERR_NOT_SUPPORTED;
302 case PMIX_BYTE_OBJECT:
303 if (NULL != src->data.bo.bytes && 0 < src->data.bo.size) {
304 p->data.bo.bytes = malloc(src->data.bo.size);
305 memcpy(p->data.bo.bytes, src->data.bo.bytes, src->data.bo.size);
306 p->data.bo.size = src->data.bo.size;
307 } else {
308 p->data.bo.bytes = NULL;
309 p->data.bo.size = 0;
310 }
311 break;
312 default:
313 pmix_output(0, "COPY-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)src->type);
314 return PMIX_ERROR;
315 }
316 return PMIX_SUCCESS;
317 }
318
319
320 pmix_status_t pmix12_bfrop_copy_value(pmix_value_t **dest, pmix_value_t *src,
321 pmix_data_type_t type)
322 {
323 pmix_value_t *p;
324
325
326 *dest = (pmix_value_t*)malloc(sizeof(pmix_value_t));
327 if (NULL == *dest) {
328 return PMIX_ERR_OUT_OF_RESOURCE;
329 }
330 p = *dest;
331
332
333 p->type = src->type;
334
335 return pmix_value_xfer(p, src);
336 }
337
338 pmix_status_t pmix12_bfrop_copy_info(pmix_info_t **dest, pmix_info_t *src,
339 pmix_data_type_t type)
340 {
341 *dest = (pmix_info_t*)malloc(sizeof(pmix_info_t));
342 pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
343 return pmix_value_xfer(&(*dest)->value, &src->value);
344 }
345
346 pmix_status_t pmix12_bfrop_copy_buf(pmix_buffer_t **dest, pmix_buffer_t *src,
347 pmix_data_type_t type)
348 {
349 *dest = PMIX_NEW(pmix_buffer_t);
350 pmix_bfrops_base_copy_payload(*dest, src);
351 return PMIX_SUCCESS;
352 }
353
354 pmix_status_t pmix12_bfrop_copy_app(pmix_app_t **dest, pmix_app_t *src,
355 pmix_data_type_t type)
356 {
357 size_t j;
358
359 *dest = (pmix_app_t*)malloc(sizeof(pmix_app_t));
360 (*dest)->cmd = strdup(src->cmd);
361 (*dest)->argv = pmix_argv_copy(src->argv);
362 (*dest)->env = pmix_argv_copy(src->env);
363 (*dest)->maxprocs = src->maxprocs;
364 (*dest)->ninfo = src->ninfo;
365 (*dest)->info = (pmix_info_t*)malloc(src->ninfo * sizeof(pmix_info_t));
366 for (j=0; j < src->ninfo; j++) {
367 pmix_strncpy((*dest)->info[j].key, src->info[j].key, PMIX_MAX_KEYLEN);
368 pmix_value_xfer(&(*dest)->info[j].value, &src->info[j].value);
369 }
370 return PMIX_SUCCESS;
371 }
372
373 pmix_status_t pmix12_bfrop_copy_kval(pmix_kval_t **dest, pmix_kval_t *src,
374 pmix_data_type_t type)
375 {
376 pmix_kval_t *p;
377
378
379 *dest = PMIX_NEW(pmix_kval_t);
380 if (NULL == *dest) {
381 return PMIX_ERR_OUT_OF_RESOURCE;
382 }
383 p = *dest;
384
385
386 p->value->type = src->value->type;
387
388 return pmix_value_xfer(p->value, src->value);
389 }
390
391 pmix_status_t pmix12_bfrop_copy_array(pmix_info_array_t **dest,
392 pmix_info_array_t *src,
393 pmix_data_type_t type)
394 {
395 pmix_info_t *d1, *s1;
396
397 *dest = (pmix_info_array_t*)malloc(sizeof(pmix_info_array_t));
398 (*dest)->size = src->size;
399 (*dest)->array = (pmix_info_t*)malloc(src->size * sizeof(pmix_info_t));
400 d1 = (pmix_info_t*)(*dest)->array;
401 s1 = (pmix_info_t*)src->array;
402 memcpy(d1, s1, src->size * sizeof(pmix_info_t));
403 return PMIX_SUCCESS;
404 }
405
406 pmix_status_t pmix12_bfrop_copy_proc(pmix_proc_t **dest, pmix_proc_t *src,
407 pmix_data_type_t type)
408 {
409 *dest = (pmix_proc_t*)malloc(sizeof(pmix_proc_t));
410 if (NULL == *dest) {
411 return PMIX_ERR_OUT_OF_RESOURCE;
412 }
413 pmix_strncpy((*dest)->nspace, src->nspace, PMIX_MAX_NSLEN);
414 (*dest)->rank = src->rank;
415 return PMIX_SUCCESS;
416 }
417
418 pmix_status_t pmix12_bfrop_copy_modex(pmix_modex_data_t **dest,
419 pmix_modex_data_t *src,
420 pmix_data_type_t type)
421 {
422 *dest = (pmix_modex_data_t*)malloc(sizeof(pmix_modex_data_t));
423 if (NULL == *dest) {
424 return PMIX_ERR_OUT_OF_RESOURCE;
425 }
426 (*dest)->blob = NULL;
427 (*dest)->size = 0;
428 if (NULL != src->blob) {
429 (*dest)->blob = (uint8_t*)malloc(src->size * sizeof(uint8_t));
430 if (NULL == (*dest)->blob) {
431 return PMIX_ERR_OUT_OF_RESOURCE;
432 }
433 memcpy((*dest)->blob, src->blob, src->size * sizeof(uint8_t));
434 (*dest)->size = src->size;
435 }
436 return PMIX_SUCCESS;
437 }
438
439 pmix_status_t pmix12_bfrop_copy_persist(pmix_persistence_t **dest,
440 pmix_persistence_t *src,
441 pmix_data_type_t type)
442 {
443 *dest = (pmix_persistence_t*)malloc(sizeof(pmix_persistence_t));
444 if (NULL == *dest) {
445 return PMIX_ERR_OUT_OF_RESOURCE;
446 }
447 memcpy(*dest, src, sizeof(pmix_persistence_t));
448 return PMIX_SUCCESS;
449 }
450
451 pmix_status_t pmix12_bfrop_copy_bo(pmix_byte_object_t **dest,
452 pmix_byte_object_t *src,
453 pmix_data_type_t type)
454 {
455 *dest = (pmix_byte_object_t*)malloc(sizeof(pmix_byte_object_t));
456 if (NULL == *dest) {
457 return PMIX_ERR_OUT_OF_RESOURCE;
458 }
459 (*dest)->bytes = (char*)malloc(src->size);
460 memcpy((*dest)->bytes, src->bytes, src->size);
461 (*dest)->size = src->size;
462 return PMIX_SUCCESS;
463 }
464
465 pmix_status_t pmix12_bfrop_copy_pdata(pmix_pdata_t **dest,
466 pmix_pdata_t *src,
467 pmix_data_type_t type)
468 {
469 *dest = (pmix_pdata_t*)malloc(sizeof(pmix_pdata_t));
470 pmix_strncpy((*dest)->proc.nspace, src->proc.nspace, PMIX_MAX_NSLEN);
471 (*dest)->proc.rank = src->proc.rank;
472 pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
473 return pmix_value_xfer(&(*dest)->value, &src->value);
474 }
475
476 pmix_status_t pmix12_bfrop_copy_darray(pmix_pdata_t **dest, pmix_data_array_t *src,
477 pmix_data_type_t type)
478 {
479 return PMIX_ERR_NOT_SUPPORTED;
480 }
481
482 pmix_status_t pmix12_bfrop_copy_proc_info(pmix_pdata_t **dest, pmix_proc_info_t *src,
483 pmix_data_type_t type)
484 {
485 return PMIX_ERR_NOT_SUPPORTED;
486 }
487
488 pmix_status_t pmix12_bfrop_copy_query(pmix_pdata_t **dest, pmix_query_t *src,
489 pmix_data_type_t type)
490 {
491 return PMIX_ERR_NOT_SUPPORTED;
492 }