The Dataset Interface (H5D)

Example: Multiple Segments

This example shows how a contiguous, one-dimensional dataset is partitioned into three parts and each of those parts is stored in a segment of an external file. The top rectangle represents the logical address space of the dataset while the bottom rectangle represents an external file. plist = H5Pcreate (H5P_DATASET_CREATE); H5Pset_external (plist, "velocity.data", 3000, 1000); H5Pset_external (plist, "velocity.data", 0, 2500); H5Pset_external (plist, "velocity.data", 4500, 1500); One should note that the segments are defined in order of the logical addresses they represent, not their order within the external file. It would also have been possible to put the segments in separate files. Care should be taken when setting up segments in a single file since the library doesn't automatically check for segments that overlap.

Example: Multi-Dimensional

This example shows how a contiguous, two-dimensional dataset is partitioned into three parts and each of those parts is stored in a separate external file. The top rectangle represents the logical address space of the dataset while the bottom rectangles represent external files. plist = H5Pcreate (H5P_DATASET_CREATE); H5Pset_external (plist, "scan1.data", 0, 24); H5Pset_external (plist, "scan2.data", 0, 24); H5Pset_external (plist, "scan3.data", 0, 16); The library maps the multi-dimensional array onto a linear address space like normal, and then maps that address space into the segments defined in the external file list.

The segments of an external file can exist beyond the end of the file. The library reads that part of a segment as zeros. When writing to a segment that exists beyond the end of a file, the file is automatically extended. Using this feature, one can create a segment (or set of segments) which is larger than the current size of the dataset, which allows to dataset to be extended at a future time (provided the data space also allows the extension).

All referenced external data files must exist before performing raw data I/O on the dataset. This is normally not a problem since those files are being managed directly by the application, or indirectly through some other library.

5. Data Type

Raw data has a constant data type which describes the data type of the raw data stored in the file, and a memory data type that describes the data type stored in application memory. Both data types are manipulated with the H5T API.

The constant file data type is associated with the dataset when the dataset is created in a manner described below. Once assigned, the constant datatype can never be changed.

The memory data type is specified when data is transferred to/from application memory. In the name of data sharability, the memory data type must be specified, but can be the same type identifier as the constant data type.

During dataset I/O operations, the library translates the raw data from the constant data type to the memory data type or vice versa. Structured data types include member offsets to allow reordering of struct members and/or selection of a subset of members and array data types include index permutation information to allow things like transpose operations (the prototype does not support array reordering) Permutations are relative to some extrinsic descritpion of the dataset.

6. Data Space

The dataspace of a dataset defines the number of dimensions and the size of each dimension and is manipulated with the H5S API. The simple dataspace consists of maximum dimension sizes and actual dimension sizes, which are usually the same. However, maximum dimension sizes can be the constant H5D_UNLIMITED in which case the actual dimension size can be incremented with calls to H5Dextend(). The maximium dimension sizes are constant meta data while the actual dimension sizes are persistent meta data. Initial actual dimension sizes are supplied at the same time as the maximum dimension sizes when the dataset is created.

The dataspace can also be used to define partial I/O operations. Since I/O operations have two end-points, the raw data transfer functions take two data space arguments: one which describes the application memory data space or subset thereof and another which describes the file data space or subset thereof.

7. Setting Constant or Persistent Properties

Each dataset has a set of constant and persistent properties which describe the layout method, pre-compression transformation, compression method, data type, external storage, and data space. The constant properties are set as described above in a dataset creation property list whose identifier is passed to H5Dcreate().

hid_t H5Dcreate (hid_t file_id, const char *name, hid_t type_id, hid_t space_id, hid_t create_plist_id)

A dataset is created by calling H5Dcreate with a file identifier, a dataset name, a data type, a data space, and constant properties. The data type and data space are the type and space of the dataset as it will exist in the file, which may be different than in application memory. The create_plist_id is a H5P_DATASET_CREATE property list created with H5Pcreate() and initialized with the various functions described above. H5Dcreate() returns a dataset handle for success or negative for failure. The handle should eventually be closed by calling H5Dclose() to release resources it uses.

hid_t H5Dopen (hid_t file_id, const char *name)

An existing dataset can be opened for access by calling this function. A dataset handle is returned for success or a negative value is returned for failure. The handle should eventually be closed by calling H5Dclose() to release resources it uses.

herr_t H5Dclose (hid_t dataset_id)

This function closes a dataset handle and releases all resources it might have been using. The handle should not be used in subsequent calls to the library.

herr_t H5Dextend (hid_t dataset_id, hsize_t dim[])

This function extends a dataset by increasing the size in one or more dimensions. Not all datasets can be extended.

8. Querying Constant or Persistent Properties

Constant or persistent properties can be queried with a set of three functions. Each function returns an identifier for a copy of the requested properties. The identifier can be passed to various functions which modify the underlying object to derive a new object; the original dataset is completely unchanged. The return values from these functions should be properly destroyed when no longer needed.

hid_t H5Dget_type (hid_t dataset_id)

Returns an identifier for a copy of the dataset permanent data type or negative for failure.

hid_t H5Dget_space (hid_t dataset_id)

Returns an identifier for a copy of the dataset permanent data space, which also contains information about the current size of the dataset if the data set is extendable with H5Dextend().

hid_t H5Dget_create_plist (hid_t dataset_id)

Returns an identifier for a copy of the dataset creation property list. The new property list is created by examining various permanent properties of the dataset. This is mostly a catch-all for everything but type and space.

9. Setting Memory and Transfer Properties

A dataset also has memory properties which describe memory within the application, and transfer properties that control various aspects of the I/O operations. The memory can have a data type different than the permanent file data type (different number types, different struct member offsets, different array element orderings) and can also be a different size (memory is a subset of the permanent dataset elements, or vice versa). The transfer properties might provide caching hints or collective I/O information. Therefore, each I/O operation must specify memory and transfer properties.

The memory properties are specified with type_id and space_id arguments while the transfer properties are specified with the transfer_id property list for the H5Dread() and H5Dwrite() functions (these functions are described below).

herr_t H5Pset_buffer (hid_t xfer_plist, size_t max_buf_size, void *tconv_buf, void *bkg_buf)

size_t H5Pget_buffer (hid_t xfer_plist, void **tconv_buf, void **bkg_buf)

Sets or retrieves the maximum size in bytes of the temporary buffer used for data type conversion in the I/O pipeline. An application-defined buffer can also be supplied as the tconv_buf argument, otherwise a buffer will be allocated and freed on demand by the library. A second temporary buffer bkg_buf can also be supplied and should be the same size as the tconv_buf. The default values are 1MB for the maximum buffer size, and null pointers for each buffer indicating that they should be allocated on demand and freed when no longer needed. The H5Pget_buffer() function returns the maximum buffer size or zero on error.

If the maximum size of the temporary I/O pipeline buffers is too small to hold the entire I/O request, then the I/O request will be fragmented and the transfer operation will be strip mined. However, certain restrictions apply to the strip mining. For instance, when performing I/O on a hyperslab of a simple data space the strip mining is in terms of the slowest varying dimension. So if a 100x200x300 hyperslab is requested, the temporary buffer must be large enough to hold a 1x200x300 sub-hyperslab.

To prevent strip mining from happening, the application should use H5Pset_buffer() to set the size of the temporary buffer so it's large enough to hold the entire request.

 1 hid_t
 2 disable_strip_mining (hid_t xfer_plist, hid_t dataset,
 3                       hid_t space, hid_t mem_type)
 4 {
 5     hid_t file_type;          /* File data type */
 6     size_t type_size;         /* Sizeof larger type */
 7     size_t size;              /* Temp buffer size */
 8     hid_t xfer_plist;         /* Return value */
 9 
10     file_type = H5Dget_type (dataset);
11     type_size = MAX(H5Tget_size(file_type), H5Tget_size(mem_type));
12     H5Tclose (file_type);
13     size = H5Sget_npoints(space) * type_size;
14     if (xfer_plist<0) xfer_plist = H5Pcreate (H5P_DATASET_XFER);
15     H5Pset_buffer(xfer_plist, size, NULL, NULL);
16     return xfer_plist;
17 }
	      

10. Querying Memory or Transfer Properties

Unlike constant and persistent properties, a dataset cannot be queried for it's memory or transfer properties. Memory properties cannot be queried because the application already stores those properties separate from the buffer that holds the raw data, and the buffer may hold multiple segments from various datasets and thus have more than one set of memory properties. The transfer properties cannot be queried from the dataset because they're associated with the transfer itself and not with the dataset (but one can call H5Pget_property() to query transfer properties from a tempalate).

11. Raw Data I/O

All raw data I/O is accomplished through these functions which take a dataset handle, a memory data type, a memory data space, a file data space, transfer properties, and an application memory buffer. They translate data between the memory data type and space and the file data type and space. The data spaces can be used to describe partial I/O operations.

herr_t H5Dread (hid_t dataset_id, hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id, hid_t xfer_plist_id, void *buf/*out*/)

Reads raw data from the specified dataset into buf converting from file data type and space to memory data type and space.

herr_t H5Dwrite (hid_t dataset_id, hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id, hid_t xfer_plist_id, const void *buf)

Writes raw data from an application buffer buf to the specified dataset converting from memory data type and space to file data type and space.

In the name of sharability, the memory datatype must be supplied. However, it can be the same identifier as was used to create the dataset or as was returned by H5Dget_type(); the library will not implicitly derive memory data types from constant data types.

For complete reads of the dataset one may supply H5S_ALL as the argument for the file data space. If H5S_ALL is also supplied as the memory data space then no data space conversion is performed. This is a somewhat dangerous situation since the file data space might be different than what the application expects.

12. Examples

The examples in this section illustrate some common dataset practices.

This example shows how to create a dataset which is stored in memory as a two-dimensional array of native double values but is stored in the file in Cray float format using LZ77 compression. The dataset is written to the HDF5 file and then read back as a two-dimensional array of float values.

 1 hid_t file, data_space, dataset, properties;
 2 double dd[500][600];
 3 float ff[500][600];
 4 hsize_t dims[2], chunk_size[2];
 5 
 6 /* Describe the size of the array */
 7 dims[0] = 500;
 8 dims[1] = 600;
 9 data_space = H5Screate_simple (2, dims);
10 
11 
12 /*
13  * Create a new file using with read/write access,
14  * default file creation properties, and default file
15  * access properties.
16  */
17 file = H5Fcreate ("test.h5", H5F_ACC_RDWR, H5P_DEFAULT,
18                   H5P_DEFAULT);
19 
20 /* 
21  * Set the dataset creation plist to specify that
22  * the raw data is to be partitioned into 100x100 element
23  * chunks and that each chunk is to be compressed with
24  * LZ77.
25  */
26 chunk_size[0] = chunk_size[1] = 100;
27 properties = H5Pcreate (H5P_DATASET_CREATE);
28 H5Pset_chunk (properties, 2, chunk_size);
29 H5Pset_compression (properties, H5D_COMPRESS_LZ77);
30 
31 /*
32  * Create a new dataset within the file.  The data type
33  * and data space describe the data on disk, which may
34  * be different than the format used in the application's
35  * memory.
36  */
37 dataset = H5Dcreate (file, "dataset", H5T_CRAY_FLOAT,
38                      data_space, properties);
39 
40 /*
41  * Write the array to the file.  The data type and data
42  * space describe the format of the data in the `dd'
43  * buffer.  The raw data is translated to the format
44  * required on disk defined above.  We use default raw
45  * data transfer properties.
46  */
47 H5Dwrite (dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
48           H5P_DEFAULT, dd);
49 
50 /*
51  * Read the array as floats.  This is similar to writing
52  * data except the data flows in the opposite direction.
53  */
54 H5Dread (dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL,
55          H5P_DEFAULT, ff);
56 
64 H5Dclose (dataset);
65 H5Sclose (data_space);
66 H5Pclose (properties);
67 H5Fclose (file);
	      

This example uses the file created in Example 1 and reads a hyperslab of the 500x600 file dataset. The hyperslab size is 100x200 and it is located beginning at element <200,200>. We read the hyperslab into an 200x400 array in memory beginning at element <0,0> in memory. Visually, the transfer looks something like this:

 1 hid_t file, mem_space, file_space, dataset;
 2 double dd[200][400];
 3 hssize_t offset[2];
 4 hsize size[2];
 5 
 6 /*
 7  * Open an existing file and its dataset.
 8  */
 9 file = H5Fopen ("test.h5", H5F_ACC_RDONLY, H5P_DEFAULT);
10 dataset = H5Dopen (file, "dataset");
11 
12 /*
13  * Describe the file data space.
14  */
15 offset[0] = 200; /*offset of hyperslab in file*/
16 offset[1] = 200;
17 size[0] = 100;   /*size of hyperslab*/
18 size[1] = 200;
19 file_space = H5Dget_space (dataset);
20 H5Sset_hyperslab (file_space, 2, offset, size);
21 
22 /*
23  * Describe the memory data space.
24  */
25 size[0] = 200;  /*size of memory array*/
26 size[1] = 400;
27 mem_space = H5Screate_simple (2, size);
28 
29 offset[0] = 0;  /*offset of hyperslab in memory*/
30 offset[1] = 0;
31 size[0] = 100;  /*size of hyperslab*/
32 size[1] = 200;
33 H5Sset_hyperslab (mem_space, 2, offset, size);
34 
35 /*
36  * Read the dataset.
37  */
38 H5Dread (dataset, H5T_NATIVE_DOUBLE, mem_space,
39          file_space, H5P_DEFAULT, dd);
40 
41 /*
42  * Close/release resources.
43  */
44 H5Dclose (dataset);
45 H5Sclose (mem_space);
46 H5Sclose (file_space);
47 H5Fclose (file);
	      

If the file contains a compound data structure one of whose members is a floating point value (call it "delta") but the application is interested in reading an array of floating point values which are just the "delta" values, then the application should cast the floating point array as a struct with a single "delta" member.

 1 hid_t file, dataset, type;
 2 double delta[200];
 3 
 4 /*
 5  * Open an existing file and its dataset.
 6  */
 7 file = H5Fopen ("test.h5", H5F_ACC_RDONLY, H5P_DEFAULT);
 8 dataset = H5Dopen (file, "dataset");
 9 
10 /*
11  * Describe the memory data type, a struct with a single
12  * "delta" member.
13  */
14 type = H5Tcreate (H5T_COMPOUND, sizeof(double));
15 H5Tinsert (type, "delta", 0, H5T_NATIVE_DOUBLE);
16 
17 /*
18  * Read the dataset.
19  */
20 H5Dread (dataset, type, H5S_ALL, H5S_ALL,
21          H5P_DEFAULT, dd);
22 
23 /*
24  * Close/release resources.
25  */
26 H5Dclose (dataset);
27 H5Tclose (type);
28 H5Fclose (file);