dash::io::hdf5::StoreHDF Class Reference

DASH wrapper to store an dash::Array or dash::Matrix in an HDF5 file using parallel IO. More...

#include <StorageDriver.h>

Classes
struct	hdf5_filespace_spec
	hdf5 pattern specification for parallel IO More...
struct	hdf5_hyperslab_spec
struct	hdf5_pattern_spec
	hdf5 pattern specification for parallel IO More...

Static Public Member Functions
template<typename View_t >
static void	write (View_t &array, std::string filename, std::string datapath, hdf5_options foptions=hdf5_options(), type_converter_fun_type to_h5_dt_converter=get_h5_datatype< typename dash::view_traits< View_t >::origin_type::value_type >)
	Store all dash::Matrix values in an HDF5 file using parallel IO. More...
template<typename Container_t >
static std::enable_if< _compatible_pattern< typename Container_t::pattern_type >) &&_is_origin_view< Container_t >), void >::type	read (Container_t &matrix, std::string filename, std::string datapath, hdf5_options foptions=hdf5_options(), type_converter_fun_type to_h5_dt_converter=get_h5_datatype< typename Container_t::value_type >)
	Read an HDF5 dataset into a dash container using parallel IO if the matrix is already allocated, the sizes have to match the HDF5 dataset sizes and all data will be overwritten. More...
template<class Container_t >
static std::enable_if< !(_compatible_pattern< typename Container_t::pattern_type >) &&_is_origin_view< Container_t >)), void >::type	read (Container_t &matrix, std::string filename, std::string datapath, hdf5_options foptions=hdf5_options(), type_converter_fun_type to_h5_dt_converter=get_h5_datatype< typename Container_t::value_type >)

Detailed Description

DASH wrapper to store an dash::Array or dash::Matrix in an HDF5 file using parallel IO.

All operations are collective.

Examples:

ex.08.io-hdf5/main.cpp.

Definition at line 77 of file StorageDriver.h.

Member Function Documentation

read() [1/2]

template<typename Container_t >

static std::enable_if< _compatible_pattern<typename Container_t::pattern_type>) && _is_origin_view<Container_t>), void>:: type dash::io::hdf5::StoreHDF::read ( Container_t &  matrix, std::string  filename, std::string  datapath, hdf5_options  foptions = hdf5_options(), type_converter_fun_type  to_h5_dt_converter = get_h5_datatype<typename Container_t::value_type>  )

inlinestatic

Read an HDF5 dataset into a dash container using parallel IO if the matrix is already allocated, the sizes have to match the HDF5 dataset sizes and all data will be overwritten.

Otherwise the matrix will be allocated.

Collective operation.

Parameters

matrix	Import data in this Container
filename	Filename of HDF5 file including extension
datapath	HDF5 Dataset in which the data is stored
foptions	options how to open and modify data
to_h5_dt_converter	std::function to convert native type into h5 type

Definition at line 269 of file StorageDriver.h.

References dash::Team::All(), dart__io__hdf5__prep_mpio(), DART_OK, dash::ndim(), and dash::rank().

                                                               {
    using pattern_t = typename Container_t::pattern_type;
    using extent_t = typename pattern_t::size_type;
    using index_t = typename Container_t::index_type;
    using value_t = typename Container_t::value_type;

    constexpr auto ndim = pattern_t::ndim();

    static_assert(std::is_same<index_t, typename pattern_t::index_type>::value,
                  "Specified index_t differs from pattern_t::index_type");

    // HDF5 definition
    hid_t file_id;
    hid_t h5dset;
    hid_t internal_type;
    hid_t plist_id;  // property list identifier
    hid_t filespace;
    // global data dims
    hsize_t data_dimsf[ndim];
    herr_t status;
    // Map native types to HDF5 types
    hid_t h5datatype;
    // rank of hdf5 dataset
    int rank;

    // Check if matrix is already allocated
    bool is_alloc = (matrix.size() != 0);

    // Setup MPI IO
    plist_id = H5Pcreate(H5P_FILE_ACCESS);
    if (is_alloc) {
      DASH_ASSERT_RETURNS(
          dart__io__hdf5__prep_mpio(plist_id, matrix.team().dart_id()),
          DART_OK);
    } else {
      DASH_ASSERT_RETURNS(
          dart__io__hdf5__prep_mpio(plist_id, dash::Team::All().dart_id()),
          DART_OK);
    }

    // HD5 create file
    file_id = H5Fopen(filename.c_str(), H5P_DEFAULT, plist_id);

    // close property list
    H5Pclose(plist_id);

    // Create dataset
    h5dset = H5Dopen(file_id, datapath.c_str(), H5P_DEFAULT);

    // Get dimensions of data
    filespace = H5Dget_space(h5dset);
    rank = H5Sget_simple_extent_ndims(filespace);

    DASH_ASSERT_EQ(rank, ndim,
                   "Data dimension of HDF5 dataset does not match matrix "
                   "dimension");

    status = H5Sget_simple_extent_dims(filespace, data_dimsf, NULL);

    std::array<extent_t, ndim> size_extents;

    // set matrix size according to hdf5 dataset dimensions
    for (int i = 0; i < ndim; ++i) {
      size_extents[i] = data_dimsf[i];
    }

    // Check if file contains DASH metadata and recreate the pattern
    auto pat_key = foptions.pattern_metadata_key.c_str();

    if (!is_alloc                       // not allocated
        && foptions.restore_pattern     // pattern should be restored
        && H5Aexists(h5dset, pat_key))  // hdf5 contains pattern
    {
      _restore_pattern(matrix, h5dset, foptions);
    } else if (is_alloc) {
      DASH_LOG_DEBUG("Matrix already allocated");
      // Check if matrix extents match data extents
      auto container_extents = _get_container_extents(matrix);
      for (int i = 0; i < ndim; ++i) {
        DASH_ASSERT_EQ(size_extents[i], container_extents.extent[i],
                       "Container extents do not match data extents");
      }
    } else {
      // Auto deduce pattern
      const pattern_t pattern(dash::SizeSpec<ndim, typename pattern_t::size_type>(size_extents),
                              dash::DistributionSpec<ndim>(),
                              dash::TeamSpec<ndim, typename pattern_t::index_type>(), dash::Team::All());

      matrix.allocate(pattern);
    }

    h5datatype = to_h5_dt_converter();
    internal_type = H5Tcopy(h5datatype);

    // ----------- prepare and read dataset ------------------

    _read_dataset_impl(matrix, h5dset, internal_type);

    // ----------- end prepare and read dataset --------------

    // Close all
    H5Dclose(h5dset);
    H5Tclose(internal_type);
    H5Fclose(file_id);

    matrix.team().barrier();
  }

read() [2/2]

template<class Container_t >

static std::enable_if< !(_compatible_pattern<typename Container_t::pattern_type>) && _is_origin_view<Container_t>)), void>:: type dash::io::hdf5::StoreHDF::read ( Container_t &  matrix, std::string  filename, std::string  datapath, hdf5_options  foptions = hdf5_options(), type_converter_fun_type  to_h5_dt_converter = get_h5_datatype<typename Container_t::value_type>  )

inlinestatic

Parameters

matrix	Import data in this Container
filename	Filename of HDF5 file including extension
datapath	HDF5 Dataset in which the data is stored
foptions	options how to open and modify data
to_h5_dt_converter	std::function to convert native type into h5 type

Definition at line 393 of file StorageDriver.h.

                                                               {}

write()

template<typename View_t >

static void dash::io::hdf5::StoreHDF::write ( View_t &  array, std::string  filename, std::string  datapath, hdf5_options  foptions = hdf5_options(), type_converter_fun_type  to_h5_dt_converter = get_h5_datatype< typename dash::view_traits<View_t>::origin_type::value_type>  )

inlinestatic

Store all dash::Matrix values in an HDF5 file using parallel IO.

Collective operation.

Parameters

array	Array to store
filename	Filename of HDF5 file including extension
datapath	HDF5 Dataset in which the data is stored
foptions

Parameters

array	Import data in this Container
filename	Filename of HDF5 file including extension
datapath	HDF5 Dataset in which the data is stored
foptions	options how to open and modify data
to_h5_dt_converter	std::function to convert native type into h5 type

Definition at line 122 of file StorageDriver.h.

References dart__io__hdf5__prep_mpio(), dash::Team::dart_id(), DART_OK, dash::for_each(), dash::Shared< ElementType >::get(), dash::ndim(), and dash::Shared< ElementType >::set().

                                                                  {
    using Container_t = typename dash::view_traits<View_t>::origin_type;
    using pattern_t = typename Container_t::pattern_type;
    using extent_t = typename pattern_t::size_type;
    using index_t = typename Container_t::index_type;
    using value_t = typename Container_t::value_type;

    constexpr auto ndim = pattern_t::ndim();

    // Check if container dims match pattern dims
    _verify_container_dims(array);
    static_assert(std::is_same<index_t, typename pattern_t::index_type>::value,
                  "Specified index_t differs from pattern_t::index_type");

    const dash::Team& team = array.team();

    // Map native types to HDF5 types
    auto h5datatype = to_h5_dt_converter();
    // for tracking opened groups
    std::list<hid_t> open_groups;
    // Split path in groups and dataset
    auto path_vec = _split_string(datapath, '/');
    auto dataset = path_vec.back();
    // remove dataset from path
    path_vec.pop_back();

    /* HDF5 definition */
    hid_t file_id;
    hid_t h5dset;
    hid_t internal_type;
    hid_t plist_id;  // property list identifier
    hid_t filespace;
    hid_t loc_id;

    // setup mpi access
    plist_id = H5Pcreate(H5P_FILE_ACCESS);
    DASH_ASSERT_RETURNS(dart__io__hdf5__prep_mpio(plist_id, team.dart_id()),
                        DART_OK);

    dash::Shared<int> f_exists;
    if (team.myid() == 0) {
      if (access(filename.c_str(), F_OK) != -1) {
        // check if file exists
        f_exists.set(static_cast<int>(H5Fis_hdf5(filename.c_str())));
      } else {
        f_exists.set(-1);
      }
    }
    team.barrier();

    if (foptions.overwrite_file || (f_exists.get() <= 0)) {
      // HD5 create file
      file_id =
          H5Fcreate(filename.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, plist_id);
    } else {
      // Open file in RW mode
      file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, plist_id);
    }

    // close property list
    H5Pclose(plist_id);

    // Traverse path
    loc_id = file_id;
    for (std::string elem : path_vec) {
      if (H5Lexists(loc_id, elem.c_str(), H5P_DEFAULT)) {
        // open group
        DASH_LOG_DEBUG("Open Group", elem);
        loc_id = H5Gopen2(loc_id, elem.c_str(), H5P_DEFAULT);
      } else {
        // create group
        DASH_LOG_DEBUG("Create Group", elem);
        loc_id = H5Gcreate2(loc_id, elem.c_str(), H5P_DEFAULT, H5P_DEFAULT,
                            H5P_DEFAULT);
      }
      if (loc_id != file_id) {
        open_groups.push_back(loc_id);
      }
    }

    // view extents are relevant (instead of pattern extents)
    auto filespace_extents = _get_container_extents(array);

    // Create dataspace
    filespace = H5Screate_simple(ndim, filespace_extents.extent, NULL);
    internal_type = H5Tcopy(h5datatype);

    if (foptions.modify_dataset) {
      // Open dataset in RW mode
      h5dset = H5Dopen(loc_id, dataset.c_str(), H5P_DEFAULT);
    } else {
      // Create dataset
      h5dset = H5Dcreate(loc_id, dataset.c_str(), internal_type, filespace,
                         H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
    }

    // Close global dataspace
    H5Sclose(filespace);

    // ----------- prepare and write dataset --------------

    _write_dataset_impl(array, h5dset, internal_type);

    // ----------- end prepare and write dataset --------------

    // Add Attributes
    if (foptions.store_pattern && _is_origin_view<Container_t>()) {
      DASH_LOG_DEBUG("store pattern in hdf5 file");
      _store_pattern(array, h5dset, foptions);
    }

    // Close all
    H5Dclose(h5dset);
    H5Tclose(internal_type);

    std::for_each(open_groups.rbegin(), open_groups.rend(),
                  [](hid_t& group_id) { H5Gclose(group_id); });

    H5Fclose(file_id);

    team.barrier();
  }

---

The documentation for this class was generated from the following file:

• /tmp/tmporruphar/dash/include/dash/io/hdf5/StorageDriver.h