OpenMPI 0.1.1

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List
- Globals

dss.h
Go to the documentation of this file.
1 /* -*- C -*-
2 *
3 * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
4 * University Research and Technology
5 * Corporation. All rights reserved.
6 * Copyright (c) 2004-2005 The University of Tennessee and The University
7 * of Tennessee Research Foundation. All rights
8 * reserved.
9 * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
10 * University of Stuttgart. All rights reserved.
11 * Copyright (c) 2004-2005 The Regents of the University of California.
12 * All rights reserved.
13 * $COPYRIGHT$
14 *
15 * Additional copyrights may follow
16 *
17 * $HEADER$
18 */
19 /**
20 * @file
21 *
22 * Data packing subsystem.
23 */
24
25 #ifndef OPAL_DSS_H_
26 #define OPAL_DSS_H_
27
28 #include "opal_config.h"
29
30
31 #include "opal/dss/dss_types.h"
32
33 BEGIN_C_DECLS
34
35 /**
36 * Set the buffer type.
37 *
38 * The pack/unpack functions can work with two types of buffer - fully
39 * described (i.e., every data object is preceeded by an identifier as
40 * to the type of the object) and non-described (i.e., no type
41 * identifier included). This function allows the caller to set the
42 * buffer type to the specified type - the function first checks to
43 * ensure the buffer is empty as the type cannot be changed once
44 * data has already entered the buffer.
45 *
46 * @param *buffer A pointer to the buffer
47 *
48 * @param type The new buffer type
49 *
50 * @retval OPAL_SUCCESS Operation successfully executed
51 *
52 * @retval OPAL_ERROR_VALUE An appropriate error code
53 */
54 typedef int (*opal_dss_set_buffer_type_fn_t)(opal_buffer_t *buffer, opal_dss_buffer_type_t type);
55
56 /**
57 * Top-level itnerface function to pack one or more values into a
58 * buffer.
59 *
60 * The pack function packs one or more values of a specified type into
61 * the specified buffer. The buffer must have already been
62 * initialized via an OBJ_NEW or OBJ_CONSTRUCT call - otherwise, the
63 * pack_value function will return an error. Providing an unsupported
64 * type flag will likewise be reported as an error.
65 *
66 * Note that any data to be packed that is not hard type cast (i.e.,
67 * not type cast to a specific size) may lose precision when unpacked
68 * by a non-homogeneous recipient. The DSS will do its best to deal
69 * with heterogeneity issues between the packer and unpacker in such
70 * cases. Sending a number larger than can be handled by the recipient
71 * will return an error code (generated by the DSS upon unpacking) via
72 * the RML upon transmission - the DSS cannot detect such errors
73 * during packing.
74 *
75 * @param *buffer A pointer to the buffer into which the value is to
76 * be packed.
77 *
78 * @param *src A void* pointer to the data that is to be packed. Note
79 * that strings are to be passed as (char **) - i.e., the caller must
80 * pass the address of the pointer to the string as the void*. This
81 * allows the DSS to use a single interface function, but still allow
82 * the caller to pass multiple strings in a single call.
83 *
84 * @param num A size_t value indicating the number of values that are
85 * to be packed, beginning at the location pointed to by src. A string
86 * value is counted as a single value regardless of length. The values
87 * must be contiguous in memory. Arrays of pointers (e.g., string
88 * arrays) should be contiguous, although (obviously) the data pointed
89 * to need not be contiguous across array entries.
90 *
91 * @param type The type of the data to be packed - must be one of the
92 * DSS defined data types.
93 *
94 * @retval OPAL_SUCCESS The data was packed as requested.
95 *
96 * @retval OPAL_ERROR(s) An appropriate OPAL error code indicating the
97 * problem encountered. This error code should be handled
98 * appropriately.
99 *
100 * @code
101 * opal_buffer_t *buffer;
102 * int32_t src;
103 *
104 * status_code = opal_dss.pack(buffer, &src, 1, OPAL_INT32);
105 * @endcode
106 */
107 typedef int (*opal_dss_pack_fn_t)(opal_buffer_t *buffer, const void *src,
108 int32_t num_values,
109 opal_data_type_t type);
110
111 /**
112 * Unpack values from a buffer.
113 *
114 * The unpack function unpacks the next value (or values) of a
115 * specified type from the specified buffer.
116 *
117 * The buffer must have already been initialized via an OBJ_NEW or
118 * OBJ_CONSTRUCT call (and assumedly filled with some data) -
119 * otherwise, the unpack_value function will return an
120 * error. Providing an unsupported type flag will likewise be reported
121 * as an error, as will specifying a data type that DOES NOT match the
122 * type of the next item in the buffer. An attempt to read beyond the
123 * end of the stored data held in the buffer will also return an
124 * error.
125 *
126 * NOTE: it is possible for the buffer to be corrupted and that
127 * the DSS will *think* there is a proper variable type at the
128 * beginning of an unpack region - but that the value is bogus (e.g., just
129 * a byte field in a string array that so happens to have a value that
130 * matches the specified data type flag). Therefore, the data type error check
131 * is NOT completely safe. This is true for ALL unpack functions.
132 *
133 *
134 * Unpacking values is a "destructive" process - i.e., the values are
135 * removed from the buffer, thus reducing the buffer size. It is
136 * therefore not possible for the caller to re-unpack a value from the
137 * same buffer.
138 *
139 * Warning: The caller is responsible for providing adequate memory
140 * storage for the requested data. The opal_dss_peek() function is
141 * provided to assist in meeting this requirement. As noted below, the user
142 * must provide a parameter indicating the maximum number of values that
143 * can be unpacked into the allocated memory. If more values exist in the
144 * buffer than can fit into the memory storage, then the dss will unpack
145 * what it can fit into that location and return an error code indicating
146 * that the buffer was only partially unpacked.
147 *
148 * Note that any data that was not hard type cast (i.e., not type cast
149 * to a specific size) when packed may lose precision when unpacked by
150 * a non-homogeneous recipient. The DSS will do its best to deal with
151 * heterogeneity issues between the packer and unpacker in such
152 * cases. Sending a number larger than can be handled by the recipient
153 * will return an error code (generated by the DSS upon unpacking) via
154 * the RML upon transmission - the DSS cannot detect such errors
155 * during packing.
156 *
157 * @param *buffer A pointer to the buffer from which the value will be
158 * extracted.
159 *
160 * @param *dest A void* pointer to the memory location into which the
161 * data is to be stored. Note that these values will be stored
162 * contiguously in memory. For strings, this pointer must be to (char
163 * **) to provide a means of supporting multiple string
164 * operations. The DSS unpack function will allocate memory for each
165 * string in the array - the caller must only provide adequate memory
166 * for the array of pointers.
167 *
168 * @param *num A pointer to a int32_t value indicating the maximum
169 * number of values that are to be unpacked, beginning at the location
170 * pointed to by src. This is provided to help protect the caller from
171 * memory overrun. Note that a string
172 * value is counted as a single value regardless of length.
173 *
174 * @note The unpack function will return the actual number of values
175 * unpacked in this location.
176 *
177 * @param type The type of the data to be unpacked - must be one of
178 * the DSS defined data types.
179 *
180 * @retval *max_num_values The number of values actually unpacked. In
181 * most cases, this should match the maximum number provided in the
182 * parameters - but in no case will it exceed the value of this
183 * parameter. Note that if you unpack fewer values than are actually
184 * available, the buffer will be in an unpackable state - the dss will
185 * return an error code to warn of this condition.
186 *
187 * @retval OPAL_SUCCESS The next item in the buffer was successfully
188 * unpacked.
189 *
190 * @retval OPAL_ERROR(s) The unpack function returns an error code
191 * under one of several conditions: (a) the number of values in the
192 * item exceeds the max num provided by the caller; (b) the type of
193 * the next item in the buffer does not match the type specified by
194 * the caller; or (c) the unpack failed due to either an error in the
195 * buffer or an attempt to read past the end of the buffer.
196 *
197 * @code
198 * opal_buffer_t *buffer;
199 * int32_t dest;
200 * char **string_array;
201 * int32_t num_values;
202 *
203 * num_values = 1;
204 * status_code = opal_dss.unpack(buffer, (void*)&dest, &num_values, OPAL_INT32);
205 *
206 * num_values = 5;
207 * string_array = malloc(num_values*sizeof(char *));
208 * status_code = opal_dss.unpack(buffer, (void*)(string_array), &num_values, OPAL_STRING);
209 *
210 * @endcode
211 */
212 typedef int (*opal_dss_unpack_fn_t)(opal_buffer_t *buffer, void *dest,
213 int32_t *max_num_values,
214 opal_data_type_t type);
215
216 /**
217 * Get the type and number of values of the next item in the buffer.
218 *
219 * The peek function looks at the next item in the buffer and returns
220 * both its type and the number of values in the item. This is a
221 * non-destructive function call that does not disturb the buffer, so
222 * it can be called multiple times if desired.
223 *
224 * @param buffer A pointer to the buffer in question.
225 *
226 * @param type A pointer to an opal_data_type_t variable where the
227 * type of the next item in the buffer is to be stored. Caller must
228 * have memory backing this location.
229 *
230 * @param number A pointer to a int32_t variable where the number of
231 * data values in the next item is to be stored. Caller must have
232 * memory backing this location.
233 *
234 * @retval OPAL_SUCCESS Requested info was successfully returned.
235 * @retval OPAL_ERROR(s) An appropriate error code indicating the
236 * problem will be returned. This should be handled appropriately by
237 * the caller.
238 *
239 */
240 typedef int (*opal_dss_peek_next_item_fn_t)(opal_buffer_t *buffer,
241 opal_data_type_t *type,
242 int32_t *number);
243
244 /**
245 * Unload the data payload from a buffer.
246 *
247 * The unload function provides the caller with a pointer to the data
248 * payload within the buffer and the size of that payload. This allows
249 * the user to directly access the payload - typically used in the RML
250 * to unload the payload from the buffer for transmission.
251 *
252 * @note This is a destructive operation. While the payload is
253 * undisturbed, the function will clear the buffer's pointers to the
254 * payload. Thus, the buffer and the payload are completely separated,
255 * leaving the caller free to OBJ_RELEASE the buffer.
256 *
257 * @param buffer A pointer to the buffer whose payload is to be
258 * unloaded.
259 *
260 * @param payload The address to a void* pointer that is to be loaded
261 * with the address of the data payload in the buffer.
262 *
263 * @param size The size (in bytes) of the data payload in the buffer.
264 *
265 * @retval OPAL_SUCCESS The request was succesfully completed.
266 *
267 * @retval OPAL_ERROR(s) An appropriate error code indicating the
268 * problem will be returned. This should be handled appropriately by
269 * the caller.
270 *
271 * @code
272 * opal_buffer_t *buffer;
273 * uint8_t *bytes;
274 * int32_t size;
275 *
276 * status_code = opal_dss.unload(buffer, (void**)(&bytes), &size);
277 * OBJ_RELEASE(buffer);
278 * @endcode
279 */
280 typedef int (*opal_dss_unload_fn_t)(opal_buffer_t *buffer,
281 void **payload,
282 int32_t *size);
283
284 /**
285 * Load a data payload into a buffer.
286 *
287 * The load function allows the caller to replace the payload in a
288 * buffer with one provided by the caller. If a payload already exists
289 * in the buffer, the function will "free" the existing data to
290 * release it, and then replace the data payload with the one provided
291 * by the caller.
292 *
293 * @note The buffer must be allocated in advance via the OBJ_NEW
294 * function call - failing to do so will cause the load function to
295 * return an error code.
296 *
297 * @note The caller is responsible for pre-packing the provided
298 * payload - the load function cannot convert to network byte order
299 * any data contained in the provided payload.
300 *
301 * @param buffer A pointer to the buffer into which lthe payload is to
302 * be loaded.
303 *
304 * @param payload A void* pointer to the payload to be loaded into the
305 * buffer.
306 *
307 * @param size The size (in bytes) of the provided payload.
308 *
309 * @retval OPAL_SUCCESS The request was successfully completed
310 *
311 * @retval OPAL_ERROR(s) An appropriate error code indicating the
312 * problem will be returned. This should be handled appropriately by
313 * the caller.
314 *
315 * @code
316 * opal_buffer_t *buffer;
317 * uint8_t bytes;
318 * int32_t size;
319 *
320 * buffer = OBJ_NEW(opal_buffer_t);
321 * status_code = opal_dss.load(buffer, (void*)(&bytes), size);
322 * @endcode
323 */
324 typedef int (*opal_dss_load_fn_t)(opal_buffer_t *buffer,
325 void *payload,
326 int32_t size);
327
328
329 /**
330 * Copy a payload from one buffer to another
331 * This function will append a copy of the payload in one buffer into
332 * another buffer. If the destination buffer is NOT empty, then the
333 * type of the two buffers MUST match or else an
334 * error will be returned. If the destination buffer IS empty, then
335 * its type will be set to that of the source buffer.
336 * NOTE: This is NOT a destructive procedure - the
337 * source buffer's payload will remain intact, as will any pre-existing
338 * payload in the destination's buffer.
339 */
340 typedef int (*opal_dss_copy_payload_fn_t)(opal_buffer_t *dest,
341 opal_buffer_t *src);
342
343 /**
344 * DSS initialization function.
345 *
346 * In dynamic libraries, declared objects and functions don't get
347 * loaded until called. We need to ensure that the opal_dss function
348 * structure gets loaded, so we provide an "open" call that is
349 * executed as part of the program startup.
350 */
351 OPAL_DECLSPEC int opal_dss_open(void);
352
353 /**
354 * DSS finalize function
355 */
356 OPAL_DECLSPEC int opal_dss_close(void);
357
358
359 /**
360 * Copy a data value from one location to another.
361 *
362 * Since registered data types can be complex structures, the system
363 * needs some way to know how to copy the data from one location to
364 * another (e.g., for storage in the registry). This function, which
365 * can call other copy functions to build up complex data types, defines
366 * the method for making a copy of the specified data type.
367 *
368 * @param **dest The address of a pointer into which the
369 * address of the resulting data is to be stored.
370 *
371 * @param *src A pointer to the memory location from which the
372 * data is to be copied.
373 *
374 * @param type The type of the data to be copied - must be one of
375 * the DSS defined data types.
376 *
377 * @retval OPAL_SUCCESS The value was successfully copied.
378 *
379 * @retval OPAL_ERROR(s) An appropriate error code.
380 *
381 */
382 typedef int (*opal_dss_copy_fn_t)(void **dest, void *src, opal_data_type_t type);
383
384 /**
385 * Compare two data values.
386 *
387 * Since registered data types can be complex structures, the system
388 * needs some way to know how to compare two data values (e.g., when
389 * trying to order them in some fashion). This function, which
390 * can call other compare functions to build up complex data types, defines
391 * the method for comparing two values of the specified data type.
392 *
393 * @retval -1 Indicates first value is greater than second value
394 * @retval 0 Indicates two values are equal
395 * @retval +1 Indicates second value is greater than first value
396 */
397 typedef int (*opal_dss_compare_fn_t)(const void *value1, const void *value2,
398 opal_data_type_t type);
399
400
401 /**
402 * Compute size of data value.
403 *
404 * Since registered data types can be complex structures, the system
405 * needs some way to compute its size. Some of these types, however, involve
406 * variable amounts of storage (e.g., a string!). Hence, a pointer to the
407 * actual object being "sized" needs to be passed as well.
408 *
409 * @param size Address of a size_t value where the size of the data value
410 * (in bytes) will be stored - set to zero in event of error.
411 *
412 * @param *src A pointer to the memory location of the data object. It is okay
413 * for this to be NULL - if NULL, the function must return the size of the object
414 * itself, not including any data contained in its fields.
415 *
416 * @param type The type of the data value - must be one of
417 * the DSS defined data types or an error will be returned.
418 *
419 * @retval OPAL_SUCCESS The value was successfully copied.
420 *
421 * @retval OPAL_ERROR(s) An appropriate error code.
422 */
423 typedef int (*opal_dss_size_fn_t)(size_t *size, void *src, opal_data_type_t type);
424
425
426 /**
427 * Print a data value.
428 *
429 * Since registered data types can be complex structures, the system
430 * needs some way to know how to print them (i.e., convert them to a string
431 * representation).
432 *
433 * @retval OPAL_SUCCESS The value was successfully printed.
434 *
435 * @retval OPAL_ERROR(s) An appropriate error code.
436 */
437 typedef int (*opal_dss_print_fn_t)(char **output, char *prefix, void *src, opal_data_type_t type);
438
439
440 /**
441 * Print a data value to an output stream for debugging purposes
442 *
443 * Uses the dss.print command to obtain a string version of the data value
444 * and prints it to the designated output stream.
445 *
446 * @retval OPAL_SUCCESS The value was successfully printed.
447 *
448 * @retval OPAL_ERROR(s) An appropriate error code.
449 */
450 typedef int (*opal_dss_dump_fn_t)(int output_stream, void *src, opal_data_type_t type);
451
452 /**
453 * Set a data value
454 *
455 * Since the data values are stored in an opaque manner, the system needs
456 * a function by which it can set the data value to a specific value. This
457 * is the equivalent to a C++ access function.
458 *
459 * NOTE: this function does NOT allocate any memory. It only sets the value pointer
460 * and type to the specified location and type. Use "copy" if you want dynamic allocation
461 * of storage.
462 *
463 * @retval OPAL_SUCCESS The value was successfully stored
464 *
465 * @retval OPAL_ERROR(s) An appropriate error code.
466 */
467 typedef int (*opal_dss_set_fn_t)(opal_dss_value_t *value, void *new_value, opal_data_type_t type);
468
469 /**
470 * Get a data value
471 *
472 * Since the data values are stored in an opaque manner, the system needs
473 * a function by which it can get the data value from within the data_value object. This
474 * is the equivalent to a C++ access function.
475 *
476 * NOTE: this function does NOT allocate any memory. It simply points the "data" location
477 * to that of the value, after ensuring that the value's type matches the specified one.
478 * Use "copy" if you want dynamic allocation of memory.
479 *
480 * @retval OPAL_SUCCESS The value was successfully retrieved
481 *
482 * @retval OPAL_ERROR(s) An appropriate error code - usually caused by the specified type
483 * not matching the data type within the stored object.
484 */
485 typedef int (*opal_dss_get_fn_t)(void **data, opal_dss_value_t *value, opal_data_type_t type);
486
487 /**
488 * Release the storage used by a data value
489 *
490 * Since the data values are stored in an opaque manner, the system needs
491 * a function by which it can release the storage associated with a value
492 * stored in a data value object.
493 */
494 typedef void (*opal_dss_release_fn_t)(opal_dss_value_t *value);
495
496 /**
497 * Register a set of data handling functions.
498 *
499 * * This function registers a set of data type functions for a specific
500 * type. An integer is returned that should be used a an argument to
501 * future invocations of opal_dss.pack(), opal_dss.unpack(), opal_dss.copy(),
502 * and opal_dss.compare, which
503 * will trigger calls to the appropriate functions. This
504 * is most useful when extending the datatypes that the dss can
505 * handle; pack and unpack functions can nest calls to opal_dss.pack()
506 * / opal_dss.unpack(), so defining small pack/unpack functions can be
507 * used recursively to build larger types (e.g., packing/unpacking
508 * structs can use calls to opal_dss.pack()/unpack() to serialize /
509 * deserialize individual members). This is likewise true for the copy
510 * and compare functions.
511 *
512 * @param release_fn [IN] Function pointer to the release routine
513 * @param pack_fn [IN] Function pointer to the pack routine
514 * @param unpack_fn [IN] Function pointer to the unpack routine
515 * @param copy_fn [IN] Function pointer to copy routine
516 * @param compare_fn [IN] Function pointer to compare routine
517 * @param size_fn [IN] Function pointer to size routine
518 * @param print_fn [IN] Function pointer to print routine
519 * @param structured [IN] Boolean indicator as to whether or not the data is structured. A true
520 * value indicates that this data type is always passed via reference (i.e., a pointer to the
521 * object is passed) as opposed to directly (e.g., the way an int32_t would appear)
522 * @param name [IN] String name for this pair (mainly for debugging)
523 * @param type [OUT] Type number for this registration
524 *
525 * @returns OPAL_SUCCESS upon success
526 *
527 */
528 typedef int (*opal_dss_register_fn_t)(opal_dss_pack_fn_t pack_fn,
529 opal_dss_unpack_fn_t unpack_fn,
530 opal_dss_copy_fn_t copy_fn,
531 opal_dss_compare_fn_t compare_fn,
532 opal_dss_size_fn_t size_fn,
533 opal_dss_print_fn_t print_fn,
534 opal_dss_release_fn_t release_fn,
535 bool structured,
536 const char *name, opal_data_type_t *type);
537 /*
538 * This function looks up the string name corresponding to the identified
539 * data type - used for debugging messages.
540 */
541 typedef char* (*opal_dss_lookup_data_type_fn_t)(opal_data_type_t type);
542
543 /*
544 * Dump the data type list - used for debugging to see what has been registered
545 */
546 typedef void (*opal_dss_dump_data_types_fn_t)(int output);
547
548
549 /**
550 * Base structure for the DSS
551 *
552 * Base module structure for the DSS - presents the required function
553 * pointers to the calling interface.
554 */
555 struct opal_dss_t {
556 opal_dss_set_fn_t set;
557 opal_dss_get_fn_t get;
558 opal_dss_set_buffer_type_fn_t set_buffer_type;
559 opal_dss_pack_fn_t pack;
560 opal_dss_unpack_fn_t unpack;
561 opal_dss_copy_fn_t copy;
562 opal_dss_compare_fn_t compare;
563 opal_dss_size_fn_t size;
564 opal_dss_print_fn_t print;
565 opal_dss_release_fn_t release;
566 opal_dss_peek_next_item_fn_t peek;
567 opal_dss_unload_fn_t unload;
568 opal_dss_load_fn_t load;
569 opal_dss_copy_payload_fn_t copy_payload;
570 opal_dss_register_fn_t register_type;
571 opal_dss_lookup_data_type_fn_t lookup_data_type;
572 opal_dss_dump_data_types_fn_t dump_data_types;
573 opal_dss_dump_fn_t dump;
574 };
575 typedef struct opal_dss_t opal_dss_t;
576
577 OPAL_DECLSPEC extern opal_dss_t opal_dss; /* holds dss function pointers */
578
579 END_C_DECLS
580
581 #endif /* OPAL_DSS_H */
opal_dss_register_fn_t
int(* opal_dss_register_fn_t)(opal_dss_pack_fn_t pack_fn, opal_dss_unpack_fn_t unpack_fn, opal_dss_copy_fn_t copy_fn, opal_dss_compare_fn_t compare_fn, opal_dss_size_fn_t size_fn, opal_dss_print_fn_t print_fn, opal_dss_release_fn_t release_fn, bool structured, const char *name, opal_data_type_t *type)
Register a set of data handling functions.
Definition: dss.h:528
opal_dss_copy_payload_fn_t
int(* opal_dss_copy_payload_fn_t)(opal_buffer_t *dest, opal_buffer_t *src)
Copy a payload from one buffer to another This function will append a copy of the payload in one buff...
Definition: dss.h:340
opal_dss_get_fn_t
int(* opal_dss_get_fn_t)(void **data, opal_dss_value_t *value, opal_data_type_t type)
Get a data value.
Definition: dss.h:485
opal_dss_open
OPAL_DECLSPEC int opal_dss_open(void)
DSS initialization function.
Definition: dss_open_close.c:180
opal_dss_copy_fn_t
int(* opal_dss_copy_fn_t)(void **dest, void *src, opal_data_type_t type)
Copy a data value from one location to another.
Definition: dss.h:382
opal_dss_set_fn_t
int(* opal_dss_set_fn_t)(opal_dss_value_t *value, void *new_value, opal_data_type_t type)
Set a data value.
Definition: dss.h:467
opal_dss_unload_fn_t
int(* opal_dss_unload_fn_t)(opal_buffer_t *buffer, void **payload, int32_t *size)
Unload the data payload from a buffer.
Definition: dss.h:280
opal_dss_set_buffer_type_fn_t
BEGIN_C_DECLS typedef int(* opal_dss_set_buffer_type_fn_t)(opal_buffer_t *buffer, opal_dss_buffer_type_t type)
Set the buffer type.
Definition: dss.h:54
opal_dss_load_fn_t
int(* opal_dss_load_fn_t)(opal_buffer_t *buffer, void *payload, int32_t size)
Load a data payload into a buffer.
Definition: dss.h:324
opal_dss_unpack_fn_t
int(* opal_dss_unpack_fn_t)(opal_buffer_t *buffer, void *dest, int32_t *max_num_values, opal_data_type_t type)
Unpack values from a buffer.
Definition: dss.h:212
opal_dss_value_t
Definition: dss_types.h:89
opal_dss_size_fn_t
int(* opal_dss_size_fn_t)(size_t *size, void *src, opal_data_type_t type)
Compute size of data value.
Definition: dss.h:423
opal_dss_release_fn_t
void(* opal_dss_release_fn_t)(opal_dss_value_t *value)
Release the storage used by a data value.
Definition: dss.h:494
opal_dss_compare_fn_t
int(* opal_dss_compare_fn_t)(const void *value1, const void *value2, opal_data_type_t type)
Compare two data values.
Definition: dss.h:397
dss_types.h
Buffer management types.
opal_dss_print_fn_t
int(* opal_dss_print_fn_t)(char **output, char *prefix, void *src, opal_data_type_t type)
Print a data value.
Definition: dss.h:437
opal_dss_t
Base structure for the DSS.
Definition: dss.h:555
opal_dss_buffer_type_t
uint8_t opal_dss_buffer_type_t
buffer type
Definition: dss_types.h:148
opal_buffer_t
Structure for holding a buffer to be used with the RML or OOB subsystems.
Definition: dss_types.h:159
opal_dss_dump_fn_t
int(* opal_dss_dump_fn_t)(int output_stream, void *src, opal_data_type_t type)
Print a data value to an output stream for debugging purposes.
Definition: dss.h:450
opal_dss_close
OPAL_DECLSPEC int opal_dss_close(void)
DSS finalize function.
Definition: dss_open_close.c:497
opal_dss_peek_next_item_fn_t
int(* opal_dss_peek_next_item_fn_t)(opal_buffer_t *buffer, opal_data_type_t *type, int32_t *number)
Get the type and number of values of the next item in the buffer.
Definition: dss.h:240
opal_dss_pack_fn_t
int(* opal_dss_pack_fn_t)(opal_buffer_t *buffer, const void *src, int32_t num_values, opal_data_type_t type)
Top-level itnerface function to pack one or more values into a buffer.
Definition: dss.h:107