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.data(),
+                                                    stride ? stride->data() : nullptr,
+                                                    count.data(),
+                                                    block ? block->data() : nullptr);
+
+        if (error_code < 0) {
+            HDF5ErrMapper::ToException<DataSpaceException>("Unable to select hyperslab");
+        }
+        return space;
+    }
+    std::array<hsize_t, Rank> offset{};
+    std::array<hsize_t, Rank> count{};
+    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,7 +458,6 @@ class ProductSet {
     friend class SliceTraits;
 };
 
-
 template <typename Derivate>
 class SliceTraits {
   public:
@@ -430,6 +471,9 @@ class SliceTraits {
     /// Therefore, the only memspaces supported for general hyperslabs are one-dimensional arrays.
     Selection select(const HyperSlab& hyper_slab) const;
 
+    template <size_t Rank>
+    Selection select(const RegularHyperSlabNoMalloc<Rank>& hyper_slab) const;
+
     ///
     /// \brief Select an \p hyper_slab in the current Slice/Dataset.
     ///

include/highfive/bits/H5Slice_traits_misc.hpp

@@ -240,6 +240,24 @@ inline Selection SliceTraits<Derivate>::select(const HyperSlab& hyper_slab) cons
     return detail::make_selection(memspace, filespace, details::get_dataset(slice));
 }
 
+template <typename Derivate>
+template <size_t Rank>
+inline Selection SliceTraits<Derivate>::select(
+    const RegularHyperSlabNoMalloc<Rank>& hyper_slab) const {
+    const auto& slice = static_cast<const Derivate&>(*this);
+    auto filespace = slice.getSpace();
+    filespace = hyper_slab.apply(filespace);
+
+    const auto packed_dims = hyper_slab.packedDims();
+    const auto n_elements =
+        std::accumulate(packed_dims.begin(),
+                        packed_dims.end(),
+                        size_t{1},
+                        [](const size_t& a, const hsize_t& b) { return a * b; });
+    auto memspace = DataSpace(std::array<size_t, 1>{n_elements});
+
+    return detail::make_selection(memspace, filespace, details::get_dataset(slice));
+}
 
 template <typename Derivate>
 inline Selection SliceTraits<Derivate>::select(const std::vector<size_t>& offset,

src/examples/select_partial_dataset_cpp11.cpp

@@ -34,6 +34,11 @@ int main(void) {
     dataset.write(values);
 
     // now we read back 2x2 values after an offset of 0x2
+    {
+        std::vector<double> result;
+        dataset.select(RegularHyperSlabNoMalloc<2>{{0, 2}, {2, 2}}).read(result);
+    }
+
     std::vector<std::vector<double>> result;
     dataset.select({0, 2}, {2, 2}).read(result);