This source file includes following definitions.
- opal_dss_unload
- opal_dss_load
- opal_dss_copy_payload
- opal_value_load
- opal_value_unload
- opal_value_xfer
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 "opal_config.h"
27
28 #include "opal/util/error.h"
29
30 #include "opal/dss/dss_internal.h"
31
32
33 int opal_dss_unload(opal_buffer_t *buffer, void **payload,
34 int32_t *bytes_used)
35 {
36
37 if (!buffer) {
38 return OPAL_ERR_BAD_PARAM;
39 }
40
41
42 if (NULL == payload) {
43 return OPAL_ERR_BAD_PARAM;
44 }
45
46
47 if (NULL == buffer->base_ptr || 0 == buffer->bytes_used) {
48 *payload = NULL;
49 *bytes_used = 0;
50 return OPAL_SUCCESS;
51 }
52
53
54
55
56 if (buffer->unpack_ptr == buffer->base_ptr) {
57 *payload = buffer->base_ptr;
58 *bytes_used = buffer->bytes_used;
59 buffer->base_ptr = NULL;
60 buffer->unpack_ptr = NULL;
61 buffer->pack_ptr = NULL;
62 buffer->bytes_used = 0;
63 return OPAL_SUCCESS;
64 }
65
66
67 *bytes_used = buffer->bytes_used - (buffer->unpack_ptr - buffer->base_ptr);
68 if (0 == (*bytes_used)) {
69 *payload = NULL;
70 } else {
71
72
73 *payload = (void*)malloc(*bytes_used);
74 memcpy(*payload, buffer->unpack_ptr, *bytes_used);
75 }
76
77
78
79 return OPAL_SUCCESS;
80 }
81
82
83 int opal_dss_load(opal_buffer_t *buffer, void *payload,
84 int32_t bytes_used)
85 {
86
87 if (NULL == buffer) {
88 return OPAL_ERR_BAD_PARAM;
89 }
90
91
92 if (NULL != buffer->base_ptr) {
93 free(buffer->base_ptr);
94 }
95
96
97 if (NULL == payload) {
98 buffer->base_ptr = NULL;
99 buffer->pack_ptr = buffer->base_ptr;
100 buffer->unpack_ptr = buffer->base_ptr;
101 buffer->bytes_used = 0;
102 buffer->bytes_allocated = 0;
103 return OPAL_SUCCESS;
104 }
105
106
107 buffer->base_ptr = (char*)payload;
108
109
110 buffer->pack_ptr = ((char*)buffer->base_ptr) + bytes_used;
111 buffer->unpack_ptr = buffer->base_ptr;
112
113
114 buffer->bytes_allocated = buffer->bytes_used = bytes_used;
115
116
117
118 return OPAL_SUCCESS;
119 }
120
121
122
123
124
125
126 int opal_dss_copy_payload(opal_buffer_t *dest, opal_buffer_t *src)
127 {
128 char *dst_ptr;
129 int32_t bytes_left;
130
131
132 if (NULL == dest || NULL == src) {
133 return OPAL_ERR_BAD_PARAM;
134 }
135
136
137
138
139 if (0 != dest->bytes_used) {
140 if (dest->type != src->type) {
141 return OPAL_ERR_BUFFER;
142 }
143 }
144
145
146
147
148 dest->type = src->type;
149
150
151
152
153
154
155
156
157 bytes_left = src->bytes_used - (src->unpack_ptr - src->base_ptr);
158
159
160 if (0 == bytes_left) {
161 return OPAL_SUCCESS;
162 }
163
164
165 if (NULL == (dst_ptr = opal_dss_buffer_extend(dest, bytes_left))) {
166 return OPAL_ERR_OUT_OF_RESOURCE;
167 }
168
169
170 memcpy(dst_ptr, src->unpack_ptr, bytes_left);
171
172
173 dest->bytes_used += bytes_left;
174 dest->pack_ptr = ((char*)dest->pack_ptr) + bytes_left;
175
176 return OPAL_SUCCESS;
177 }
178
179 int opal_value_load(opal_value_t *kv,
180 void *data, opal_data_type_t type)
181 {
182 opal_byte_object_t *boptr;
183 struct timeval *tv;
184
185 kv->type = type;
186 if (NULL == data && OPAL_STRING != type && OPAL_BYTE_OBJECT != type) {
187
188 memset(&kv->data, 0, sizeof(kv->data));
189 return OPAL_SUCCESS;
190 }
191
192 switch (type) {
193 case OPAL_BOOL:
194 kv->data.flag = *(bool*)(data);
195 break;
196 case OPAL_BYTE:
197 kv->data.byte = *(uint8_t*)(data);
198 break;
199 case OPAL_STRING:
200 if (NULL != kv->data.string) {
201 free(kv->data.string);
202 }
203 if (NULL != data) {
204 kv->data.string = strdup( (const char *) data);
205 } else {
206 kv->data.string = NULL;
207 }
208 break;
209 case OPAL_SIZE:
210 kv->data.size = *(size_t*)(data);
211 break;
212 case OPAL_PID:
213 kv->data.pid = *(pid_t*)(data);
214 break;
215
216 case OPAL_INT:
217 kv->data.integer = *(int*)(data);
218 break;
219 case OPAL_INT8:
220 kv->data.int8 = *(int8_t*)(data);
221 break;
222 case OPAL_INT16:
223 kv->data.int16 = *(int16_t*)(data);
224 break;
225 case OPAL_INT32:
226 kv->data.int32 = *(int32_t*)(data);
227 break;
228 case OPAL_INT64:
229 kv->data.int64 = *(int64_t*)(data);
230 break;
231
232 case OPAL_UINT:
233 kv->data.uint = *(unsigned int*)(data);
234 break;
235 case OPAL_UINT8:
236 kv->data.uint8 = *(uint8_t*)(data);
237 break;
238 case OPAL_UINT16:
239 kv->data.uint16 = *(uint16_t*)(data);
240 break;
241 case OPAL_UINT32:
242 kv->data.uint32 = *(uint32_t*)data;
243 break;
244 case OPAL_UINT64:
245 kv->data.uint64 = *(uint64_t*)(data);
246 break;
247
248 case OPAL_BYTE_OBJECT:
249 if (NULL != kv->data.bo.bytes) {
250 free(kv->data.bo.bytes);
251 }
252 boptr = (opal_byte_object_t*)data;
253 if (NULL != boptr && NULL != boptr->bytes && 0 < boptr->size) {
254 kv->data.bo.bytes = (uint8_t *) malloc(boptr->size);
255 memcpy(kv->data.bo.bytes, boptr->bytes, boptr->size);
256 kv->data.bo.size = boptr->size;
257 } else {
258 kv->data.bo.bytes = NULL;
259 kv->data.bo.size = 0;
260 }
261 break;
262
263 case OPAL_FLOAT:
264 kv->data.fval = *(float*)(data);
265 break;
266
267 case OPAL_TIMEVAL:
268 tv = (struct timeval*)data;
269 kv->data.tv.tv_sec = tv->tv_sec;
270 kv->data.tv.tv_usec = tv->tv_usec;
271 break;
272
273 case OPAL_PTR:
274 kv->data.ptr = data;
275 break;
276
277 default:
278 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
279 return OPAL_ERR_NOT_SUPPORTED;
280 }
281 return OPAL_SUCCESS;
282 }
283
284 int opal_value_unload(opal_value_t *kv,
285 void **data, opal_data_type_t type)
286 {
287 opal_byte_object_t *boptr;
288
289 if (type != kv->type) {
290 return OPAL_ERR_TYPE_MISMATCH;
291 }
292 if (NULL == data ||
293 (OPAL_STRING != type && OPAL_BYTE_OBJECT != type && NULL == *data)) {
294 OPAL_ERROR_LOG(OPAL_ERR_BAD_PARAM);
295 return OPAL_ERR_BAD_PARAM;
296 }
297
298 switch (type) {
299 case OPAL_BOOL:
300 memcpy(*data, &kv->data.flag, sizeof(bool));
301 break;
302 case OPAL_BYTE:
303 memcpy(*data, &kv->data.byte, sizeof(uint8_t));
304 break;
305 case OPAL_STRING:
306 if (NULL != kv->data.string) {
307 *data = strdup(kv->data.string);
308 } else {
309 *data = NULL;
310 }
311 break;
312 case OPAL_SIZE:
313 memcpy(*data, &kv->data.size, sizeof(size_t));
314 break;
315 case OPAL_PID:
316 memcpy(*data, &kv->data.pid, sizeof(pid_t));
317 break;
318
319 case OPAL_INT:
320 memcpy(*data, &kv->data.integer, sizeof(int));
321 break;
322 case OPAL_INT8:
323 memcpy(*data, &kv->data.int8, sizeof(int8_t));
324 break;
325 case OPAL_INT16:
326 memcpy(*data, &kv->data.int16, sizeof(int16_t));
327 break;
328 case OPAL_INT32:
329 memcpy(*data, &kv->data.int32, sizeof(int32_t));
330 break;
331 case OPAL_INT64:
332 memcpy(*data, &kv->data.int64, sizeof(int64_t));
333 break;
334
335 case OPAL_UINT:
336 memcpy(*data, &kv->data.uint, sizeof(unsigned int));
337 break;
338 case OPAL_UINT8:
339 memcpy(*data, &kv->data.uint8, 1);
340 break;
341 case OPAL_UINT16:
342 memcpy(*data, &kv->data.uint16, 2);
343 break;
344 case OPAL_UINT32:
345 memcpy(*data, &kv->data.uint32, 4);
346 break;
347 case OPAL_UINT64:
348 memcpy(*data, &kv->data.uint64, 8);
349 break;
350
351 case OPAL_BYTE_OBJECT:
352 boptr = (opal_byte_object_t*)malloc(sizeof(opal_byte_object_t));
353 if (NULL != kv->data.bo.bytes && 0 < kv->data.bo.size) {
354 boptr->bytes = (uint8_t *) malloc(kv->data.bo.size);
355 memcpy(boptr->bytes, kv->data.bo.bytes, kv->data.bo.size);
356 boptr->size = kv->data.bo.size;
357 } else {
358 boptr->bytes = NULL;
359 boptr->size = 0;
360 }
361 *data = boptr;
362 break;
363
364 case OPAL_FLOAT:
365 memcpy(*data, &kv->data.fval, sizeof(float));
366 break;
367
368 case OPAL_TIMEVAL:
369 memcpy(*data, &kv->data.tv, sizeof(struct timeval));
370 break;
371
372 case OPAL_PTR:
373 *data = kv->data.ptr;
374 break;
375
376 case OPAL_VPID:
377 memcpy(*data, &kv->data.name.vpid, sizeof(opal_vpid_t));
378 break;
379
380 default:
381 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
382 return OPAL_ERR_NOT_SUPPORTED;
383 }
384 return OPAL_SUCCESS;
385 }
386
387 int opal_value_xfer(opal_value_t *dest,
388 opal_value_t *src)
389 {
390 opal_byte_object_t *boptr;
391
392 if (NULL != src->key) {
393 dest->key = strdup(src->key);
394 }
395 dest->type = src->type;
396
397 switch (src->type) {
398 case OPAL_BOOL:
399 dest->data.flag = src->data.flag;
400 break;
401 case OPAL_BYTE:
402 dest->data.byte = src->data.byte;
403 break;
404 case OPAL_STRING:
405 if (NULL != dest->data.string) {
406 free(dest->data.string);
407 }
408 if (NULL != src->data.string) {
409 dest->data.string = strdup(src->data.string);
410 } else {
411 dest->data.string = NULL;
412 }
413 break;
414 case OPAL_SIZE:
415 dest->data.size = src->data.size;
416 break;
417 case OPAL_PID:
418 dest->data.pid = src->data.pid;
419 break;
420
421 case OPAL_INT:
422 dest->data.integer = src->data.integer;
423 break;
424 case OPAL_INT8:
425 dest->data.int8 = src->data.int8;
426 break;
427 case OPAL_INT16:
428 dest->data.int16 = src->data.int16;
429 break;
430 case OPAL_INT32:
431 dest->data.int32 = src->data.int32;
432 break;
433 case OPAL_INT64:
434 dest->data.int64 = src->data.int64;
435 break;
436
437 case OPAL_UINT:
438 dest->data.uint = src->data.uint;
439 break;
440 case OPAL_UINT8:
441 dest->data.uint8 = src->data.uint8;
442 break;
443 case OPAL_UINT16:
444 dest->data.uint16 = src->data.uint16;
445 break;
446 case OPAL_UINT32:
447 dest->data.uint32 = src->data.uint32;
448 break;
449 case OPAL_UINT64:
450 dest->data.uint64 = src->data.uint64;
451 break;
452
453 case OPAL_BYTE_OBJECT:
454 if (NULL != dest->data.bo.bytes) {
455 free(dest->data.bo.bytes);
456 }
457 boptr = &src->data.bo;
458 if (NULL != boptr && NULL != boptr->bytes && 0 < boptr->size) {
459 dest->data.bo.bytes = (uint8_t *) malloc(boptr->size);
460 memcpy(dest->data.bo.bytes, boptr->bytes, boptr->size);
461 dest->data.bo.size = boptr->size;
462 } else {
463 dest->data.bo.bytes = NULL;
464 dest->data.bo.size = 0;
465 }
466 break;
467
468 case OPAL_FLOAT:
469 dest->data.fval = src->data.fval;
470 break;
471
472 case OPAL_TIMEVAL:
473 dest->data.tv.tv_sec = src->data.tv.tv_sec;
474 dest->data.tv.tv_usec = src->data.tv.tv_usec;
475 break;
476
477 case OPAL_PTR:
478 dest->data.ptr = src->data.ptr;
479 break;
480
481 default:
482 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
483 return OPAL_ERR_NOT_SUPPORTED;
484 }
485 return OPAL_SUCCESS;
486 }