Avoid memory allocation with H5Sselect_hyperslab

Implement `HighFive::RegularHyperSlabNoMalloc<Rank>` that takes
hyperslab variables in stack space. Do not construct
`std::vector<hsize_t>`.

Similarly, implement `::select(RegularHyperSlabNoMalloc<>)` such that it
is free of `operator new[]` calls before invoking `H5Sselect_hyperslab`.

Ensure that when hyperslab offset and range are compile-time constants,
compiler (with arguments `-O3 -flto`) will inline everything without
any `operator new[]` statements.

Author: antonysigma

include/highfive/bits/H5Slice_traits.hpp

@@ -10,6 +10,9 @@
 
 #include <cstdlib>
 #include <vector>
+#if __cplusplus >= 201703L
+#include <optional>
+#endif
 
 #include "H5_definitions.hpp"
 #include "H5Utils.hpp"
@@ -108,6 +111,45 @@ struct RegularHyperSlab {
     std::vector<hsize_t> block;
 };
 
+#if __cplusplus >= 201703L
+template<size_t Rank>
+struct RegularHyperSlabNoMalloc {
+    constexpr size_t rank() const {
+        return Rank;
+    }
+
+    /// Dimensions when all gaps are removed.
+    constexpr std::array<size_t, Rank> packedDims() const {
+        auto dims = std::array<size_t, Rank>{};
+
+        for (size_t i = 0; i < Rank; ++i) {
+            (*dims)[i] = (*count)[i] * (block ? (*block)[i] : 1);
+        }
+
+        return dims;
+    }
+
+    DataSpace apply(const DataSpace& space_) const {
+        auto space = space_.clone();
+        const auto error_code = H5Sselect_hyperslab(space.getId(),
+                                                    H5S_SELECT_SET,
+                                                    offset ? offset->data() : nullptr,
+                                                    stride ? stride->data() : nullptr,
+                                                    count ? count->data() : nullptr,
+                                                    block ? block->data() : nullptr);
+
+        if (error_code < 0) {
+            HDF5ErrMapper::ToException<DataSpaceException>("Unable to select hyperslab");
+        }
+        return space;
+    }
+    std::optional<std::array<hsize_t, Rank>> offset{std::nullopt};
+    std::optional<std::array<hsize_t, Rank>> count{std::nullopt};
+    std::optional<std::array<hsize_t, Rank>> stride{std::nullopt};
+    std::optional<std::array<hsize_t, Rank>> block{std::nullopt};
+};
+#endif
+
 class HyperSlab {
   public:
     HyperSlab() {
@@ -416,6 +458,14 @@ class ProductSet {
     friend class SliceTraits;
 };
 
+#if __cplusplus >= 202002L
+template <class T>
+concept HyperSlabInterface = requires(const T& t, const DataSpace& ds) {
+    { t.apply(ds) } -> std::same_as<DataSpace>;
+};
+#else
+#define HyperSlabInterface class
+#endif
 
 template <typename Derivate>
 class SliceTraits {
@@ -428,7 +478,8 @@ class SliceTraits {
     /// nicely into a multi-dimensional array, but only a subset of such an array.
     ///
     /// Therefore, the only memspaces supported for general hyperslabs are one-dimensional arrays.
-    Selection select(const HyperSlab& hyper_slab) const;
+    template <HyperSlabInterface H>
+    Selection select(const H& hyper_slab) const;
 
     ///
     /// \brief Select an \p hyper_slab in the current Slice/Dataset.

include/highfive/bits/H5Slice_traits_misc.hpp

@@ -229,7 +229,8 @@ inline Selection SliceTraits<Derivate>::select(const HyperSlab& hyper_slab,
 }
 
 template <typename Derivate>
-inline Selection SliceTraits<Derivate>::select(const HyperSlab& hyper_slab) const {
+template <HyperSlabInterface H>
+inline Selection SliceTraits<Derivate>::select(const H& hyper_slab) const {
     const auto& slice = static_cast<const Derivate&>(*this);
     auto filespace = slice.getSpace();
     filespace = hyper_slab.apply(filespace);
@@ -240,7 +241,6 @@ inline Selection SliceTraits<Derivate>::select(const HyperSlab& hyper_slab) cons
     return detail::make_selection(memspace, filespace, details::get_dataset(slice));
 }
 
-
 template <typename Derivate>
 inline Selection SliceTraits<Derivate>::select(const std::vector<size_t>& offset,
                                                const std::vector<size_t>& count,

src/examples/select_partial_dataset_cpp11.cpp

@@ -7,43 +7,36 @@
  *
  */
 #include <functional>
-#include <iostream>
 #include <string>
 #include <vector>
 
 #include <highfive/highfive.hpp>
 
-const std::string file_name("select_partial_example.h5");
-const std::string dataset_name("dset");
-
 // Create a dataset name "dset" of double 4x6
 //
 int main(void) {
     using namespace HighFive;
 
+    constexpr char file_name[]{"select_partial_example.h5"};
+    constexpr char dataset_name[]{"dset"};
+
     // Create a new file using the default property lists.
     File file(file_name, File::ReadWrite | File::Create | File::Truncate);
 
-    // we have some example values in a 2D vector 2x5
-    std::vector<std::vector<double>> values = {{1.0, 2.0, 4.0, 8.0, 16.0},
-                                               {32.0, 64.0, 128.0, 256.0, 512.0}};
-
     // let's create a dataset of this size
-    DataSet dataset = file.createDataSet<double>(dataset_name, DataSpace::From(values));
+    constexpr size_t H = 2;
+    constexpr size_t W = 5;
+    constexpr std::array<double, W * H> values = {
+        1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0, 512.0};
+    DataSet dataset = file.createDataSet<double>(dataset_name, {H, W});
     // and write them
-    dataset.write(values);
+    dataset.write_raw(values.data());
 
     // now we read back 2x2 values after an offset of 0x2
-    std::vector<std::vector<double>> result;
-    dataset.select({0, 2}, {2, 2}).read(result);
-
-    // we print out 4 values
-    for (auto i: result) {
-        for (auto j: i) {
-            std::cout << " " << j;
-        }
-        std::cout << "\n";
-    }
+    using Slab = HighFive::RegularHyperSlabNoMalloc<2>;
+    using Slice = std::array<hsize_t, 2>;
+    std::vector<double> result(4);
+    dataset.select(Slab{Slice{0, 2}, Slice{2, 2}}).read_raw(result.data());
 
     return 0;  // successfully terminated
 }