wip: unify common code into compiled functions

Author: franzpoeschel

include/openPMD/LoadStoreChunk.hpp

@@ -76,6 +76,7 @@ namespace core
         friend class compose::ConfigureLoadStore;
         template <typename ChildClass>
         friend class compose::ConfigureLoadStoreFromBuffer;
+        friend class openPMD::RecordComponent;
 
     protected:
         ConfigureLoadStore(RecordComponent &);
@@ -89,6 +90,21 @@ namespace core
 
         auto deferFlush(Attributable &);
 
+    private:
+        auto withSharedPtr_impl_mut(std::shared_ptr<void> data, Datatype)
+            -> openPMD::ConfigureLoadStoreFromBuffer;
+        auto
+        withSharedPtr_impl_const(std::shared_ptr<void const> data, Datatype)
+            -> openPMD::ConfigureStoreChunkFromBuffer;
+        auto withUniquePtr_impl_mut(UniquePtrWithLambda<void>, Datatype)
+            -> openPMD::ConfigureStoreChunkFromBuffer;
+        auto withUniquePtr_impl_const(UniquePtrWithLambda<void const>, Datatype)
+            -> openPMD::ConfigureStoreChunkFromBuffer;
+        auto withRawPtr_impl_mut(void *data, Datatype)
+            -> openPMD::ConfigureLoadStoreFromBuffer;
+        auto withRawPtr_impl_const(void const *data, Datatype)
+            -> openPMD::ConfigureStoreChunkFromBuffer;
+
     public:
         auto getOffset() -> Offset const &;
         auto getExtent() -> Extent const &;
@@ -99,7 +115,7 @@ namespace core
         template <typename T>
         struct shared_ptr_return_type_impl
         {
-            using return_type = ConfigureLoadStoreFromBuffer;
+            using return_type = openPMD::ConfigureLoadStoreFromBuffer;
             using normalize_pointer_type =
                 std::shared_ptr<std::remove_extent_t<T>>;
         };
@@ -110,7 +126,7 @@ namespace core
         template <typename T>
         struct shared_ptr_return_type_impl<T const>
         {
-            using return_type = ConfigureStoreChunkFromBuffer;
+            using return_type = openPMD::ConfigureStoreChunkFromBuffer;
             using normalize_pointer_type =
                 std::shared_ptr<std::remove_extent_t<T> const>;
         };
@@ -127,7 +143,7 @@ namespace core
          * simpler for unique pointers. Just remove the array extents here.
          */
         template <typename T>
-        using unique_ptr_return_type = ConfigureStoreChunkFromBuffer;
+        using unique_ptr_return_type = openPMD::ConfigureStoreChunkFromBuffer;
         template <typename T>
         using unique_ptr_normalized_type =
             UniquePtrWithLambda<std::remove_extent_t<T>>;

include/openPMD/RecordComponent.hpp

@@ -495,6 +495,8 @@ class RecordComponent : public BaseRecordComponent
         std::shared_ptr<void>, Datatype, internal::LoadStoreConfigWithBuffer);
     template <typename T>
     std::shared_ptr<T> loadChunkAllocate_impl(internal::LoadStoreConfig);
+    std::shared_ptr<void> loadChunkAllocate_impl(
+        Datatype, size_t dtype_size, internal::LoadStoreConfig);
 
     // clang-format off
 OPENPMD_protected

src/LoadStoreChunk.cpp

@@ -123,22 +123,84 @@ namespace core
         return *m_extent;
     }
 
+    auto ConfigureLoadStore::withSharedPtr_impl_mut(
+        std::shared_ptr<void> data, Datatype datatype)
+        -> openPMD::ConfigureLoadStoreFromBuffer
+    {
+        if (!data)
+        {
+            throw std::runtime_error(
+                "Unallocated pointer passed during chunk store.");
+        }
+        return openPMD::ConfigureLoadStoreFromBuffer(
+            auxiliary::WriteBuffer(std::move(data)),
+            datatype,
+            {std::move(*this)});
+    }
+    auto ConfigureLoadStore::withSharedPtr_impl_const(
+        std::shared_ptr<void const> data, Datatype datatype)
+        -> openPMD::ConfigureStoreChunkFromBuffer
+    {
+        if (!data)
+        {
+            throw std::runtime_error(
+                "Unallocated pointer passed during chunk store.");
+        }
+        return openPMD::ConfigureStoreChunkFromBuffer(
+            auxiliary::WriteBuffer(std::move(data)),
+            datatype,
+            {std::move(*this)});
+    }
+
     template <typename T>
     auto ConfigureLoadStore::withSharedPtr(std::shared_ptr<T> data)
         -> shared_ptr_return_type<T>
     {
         using T_decayed = std::remove_cv_t<std::remove_extent_t<T>>;
+        constexpr auto dtype = determineDatatype<T_decayed>();
+        if constexpr (std::is_const_v<T>)
+        {
+            return withSharedPtr_impl_const(data, dtype);
+        }
+        else
+        {
+            return withSharedPtr_impl_mut(data, dtype);
+        }
+    }
+
+    auto ConfigureLoadStore::withUniquePtr_impl_mut(
+        UniquePtrWithLambda<void> data, Datatype dtype)
+        -> openPMD::ConfigureStoreChunkFromBuffer
+
+    {
+        if (!data)
+        {
+            throw std::runtime_error(
+                "Unallocated pointer passed during chunk store.");
+        }
+
+        return openPMD::ConfigureStoreChunkFromBuffer(
+            auxiliary::WriteBuffer(std::move(data)), dtype, {std::move(*this)});
+    }
+    auto ConfigureLoadStore::withUniquePtr_impl_const(
+        UniquePtrWithLambda<void const> data, Datatype dtype)
+        -> openPMD::ConfigureStoreChunkFromBuffer
+
+    {
         if (!data)
         {
             throw std::runtime_error(
                 "Unallocated pointer passed during chunk store.");
         }
-        return shared_ptr_return_type<T>(
+
+        void const *raw_ptr = data.get();
+        return openPMD::ConfigureStoreChunkFromBuffer(
             auxiliary::WriteBuffer(
-                std::static_pointer_cast<
-                    std::conditional_t<std::is_const_v<T>, void const, void>>(
-                    std::move(data))),
-            determineDatatype<T_decayed>(),
+                std::shared_ptr<void const>(
+                    raw_ptr,
+                    [data_lambda =
+                         std::move(data)](auto const *) { /* no-op */ })),
+            dtype,
             {std::move(*this)});
     }
     template <typename T>
@@ -147,50 +209,63 @@ namespace core
 
     {
         using T_decayed = std::remove_cv_t<std::remove_extent_t<T>>;
-        if (!data)
-        {
-            throw std::runtime_error(
-                "Unallocated pointer passed during chunk store.");
-        }
+        constexpr auto dtype = determineDatatype<T_decayed>();
         if constexpr (std::is_const_v<T>)
         {
-            void const *raw_ptr = data.get();
-            return unique_ptr_return_type<T>(
-                auxiliary::WriteBuffer(
-                    std::shared_ptr<void const>(
-                        raw_ptr,
-                        [data_lambda =
-                             std::move(data)](auto const *) { /* no-op */ })),
-                determineDatatype<T_decayed>(),
-                {std::move(*this)});
+            return withUniquePtr_impl_const(
+                std::move(data).template static_cast_<void const>(), dtype);
         }
         else
         {
-            return unique_ptr_return_type<T>(
-                auxiliary::WriteBuffer(
-                    std::move(data).template static_cast_<void>()),
-                determineDatatype<T_decayed>(),
-                {std::move(*this)});
+            return withUniquePtr_impl_mut(
+                std::move(data).template static_cast_<void>(), dtype);
         }
     }
-    template <typename T>
-    auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type<T>
+
+    auto ConfigureLoadStore::withRawPtr_impl_mut(void *data, Datatype dtype)
+        -> openPMD::ConfigureLoadStoreFromBuffer
     {
-        using T_decayed = std::remove_cv_t<std::remove_extent_t<T>>;
         if (!data)
         {
             throw std::runtime_error(
                 "Unallocated pointer passed during chunk store.");
         }
-        return shared_ptr_return_type<T>(
-            auxiliary::WriteBuffer(
-                std::static_pointer_cast<
-                    std::conditional_t<std::is_const_v<T>, void const, void>>(
-                    auxiliary::shareRaw(data))),
-            determineDatatype<T_decayed>(),
+        return openPMD::ConfigureLoadStoreFromBuffer(
+            auxiliary::WriteBuffer(auxiliary::shareRaw(data)),
+            dtype,
+            {std::move(*this)});
+    }
+
+    auto
+    ConfigureLoadStore::withRawPtr_impl_const(void const *data, Datatype dtype)
+        -> openPMD::ConfigureStoreChunkFromBuffer
+    {
+        if (!data)
+        {
+            throw std::runtime_error(
+                "Unallocated pointer passed during chunk store.");
+        }
+        return openPMD::ConfigureStoreChunkFromBuffer(
+            auxiliary::WriteBuffer(auxiliary::shareRaw(data)),
+            dtype,
             {std::move(*this)});
     }
 
+    template <typename T>
+    auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type<T>
+    {
+        using T_decayed = std::remove_cv_t<std::remove_extent_t<T>>;
+        constexpr auto dtype = determineDatatype<T_decayed>();
+        if constexpr (std::is_const_v<T>)
+        {
+            return withRawPtr_impl_const(data, dtype);
+        }
+        else
+        {
+            return withRawPtr_impl_mut(data, dtype);
+        }
+    }
+
     template <typename T>
     auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView<T>
     {

src/RecordComponent.cpp

@@ -229,8 +229,15 @@ template <typename T_with_extent>
 std::shared_ptr<T_with_extent>
 RecordComponent::loadChunkAllocate_impl(internal::LoadStoreConfig cfg)
 {
-    using T = std::remove_extent_t<T_with_extent>;
-    // static_assert(!std::is_same_v<T, std::string>, "EVIL");
+    using T = std::remove_cv_t<std::remove_extent_t<T_with_extent>>;
+    auto res = loadChunkAllocate_impl(
+        determineDatatype<T>(), sizeof(T), std::move(cfg));
+    return std::static_pointer_cast<T_with_extent>(res);
+}
+
+std::shared_ptr<void> RecordComponent::loadChunkAllocate_impl(
+    Datatype dtype, size_t dtype_size, internal::LoadStoreConfig cfg)
+{
     auto [o, e] = std::move(cfg);
 
     size_t numPoints = 1;
@@ -239,25 +246,16 @@ RecordComponent::loadChunkAllocate_impl(internal::LoadStoreConfig cfg)
         numPoints *= val;
     }
 
-#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) ||                   \
-    (defined(__apple_build_version__) && __clang_major__ < 14)
-    auto newData = std::shared_ptr<T_with_extent>(
-        new T[numPoints], [](T *p) { delete[] p; });
+    auto newData =
+        std::shared_ptr<void>(new char[numPoints * dtype_size], [](void *p) {
+            delete[] (static_cast<char *>(p));
+        });
     prepareLoadStore()
         .offset(std::move(o))
         .extent(std::move(e))
-        .withSharedPtr(newData)
+        .withSharedPtr_impl_mut(newData, dtype)
         .load(EnqueuePolicy::Defer);
     return newData;
-#else
-    auto newData = std::shared_ptr<T[]>(new T[numPoints]);
-    prepareLoadStore()
-        .offset(std::move(o))
-        .extent(std::move(e))
-        .withSharedPtr(newData)
-        .load(EnqueuePolicy::Defer);
-    return std::static_pointer_cast<T_with_extent>(std::move(newData));
-#endif
 }
 
 RecordComponent::RecordComponent() : BaseRecordComponent(NoInit())

src/auxiliary/UniquePtr.cpp

@@ -58,7 +58,7 @@ namespace auxiliary
 
     OPENPMD_FOREACH_DATASET_DATATYPE(
         OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT)
-    OPENPMD_INSTANTIATE(void)
+    OPENPMD_INSTANTIATE(void) OPENPMD_INSTANTIATE(void const)
 #undef OPENPMD_INSTANTIATE
 #undef OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT
 
@@ -108,6 +108,7 @@ OPENPMD_FOREACH_NONVECTOR_DATATYPE(OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT)
 // Instantiate this directly, do not instantiate the
 // `std::unique_ptr<void>`-based constructor.
 template class UniquePtrWithLambda<void>;
+template class UniquePtrWithLambda<void const>;
 #undef OPENPMD_INSTANTIATE
 #undef OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT
 #undef OPENPMD_ARRAY