Merge pull request #46877 from fwyzard/edm_Wraper_AllocateForOverwrite

Let `edm::Wrapper<T>` use the constructor `T{kUninitialized}`

Author: cmsbuild

DataFormats/Common/interface/DeviceProduct.h

@@ -4,6 +4,8 @@
 #include <cassert>
 #include <memory>
 
+#include "DataFormats/Common/interface/Uninitialized.h"
+
 namespace edm {
   class DeviceProductBase {
   public:
@@ -45,7 +47,13 @@ namespace edm {
   template <typename T>
   class DeviceProduct : public DeviceProductBase {
   public:
-    DeviceProduct() = default;
+    DeviceProduct()
+      requires(requires { T(); })
+    = default;
+
+    explicit DeviceProduct(edm::Uninitialized)
+      requires(requires { T(edm::kUninitialized); })
+        : data_{edm::kUninitialized} {}
 
     template <typename M, typename... Args>
     explicit DeviceProduct(std::shared_ptr<M> metadata, Args&&... args)

DataFormats/Common/interface/Uninitialized.h

@@ -0,0 +1,19 @@
+#ifndef DataFormats_Common_interface_Uninitialized_h
+#define DataFormats_Common_interface_Uninitialized_h
+
+/* Uninitialized
+ *
+ * This is an empty struct used as a tag to signal that a constructor will leave an object (partially) uninitialised,
+ * with the assumption that it will be overwritten before being used.
+ * One expected use case is to replace the default constructor used when deserialising objects from a ROOT file.
+ */
+
+namespace edm {
+
+  struct Uninitialized {};
+
+  constexpr inline Uninitialized kUninitialized;
+
+}  // namespace edm
+
+#endif  // DataFormats_Common_interface_Uninitialized_h

DataFormats/Common/interface/Wrapper.h

@@ -7,9 +7,10 @@ Wrapper: A template wrapper around EDProducts to hold the product ID.
 
 ----------------------------------------------------------------------*/
 
+#include "DataFormats/Common/interface/Uninitialized.h"
+#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
 #include "DataFormats/Common/interface/WrapperBase.h"
 #include "DataFormats/Common/interface/WrapperDetail.h"
-#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
 #include "DataFormats/Provenance/interface/ProductID.h"
 #include "FWCore/Utilities/interface/Visibility.h"
 
@@ -25,7 +26,7 @@ namespace edm {
   public:
     typedef T value_type;
     typedef T wrapped_type;  // used with the dictionary to identify Wrappers
-    Wrapper() : WrapperBase(), obj(), present(false) {}
+    Wrapper() : WrapperBase(), obj{construct_()}, present(false) {}
     explicit Wrapper(std::unique_ptr<T> ptr);
     Wrapper(Wrapper<T> const& rh) = delete;             // disallow copy construction
     Wrapper<T>& operator=(Wrapper<T> const&) = delete;  // disallow assignment
@@ -49,6 +50,14 @@ namespace edm {
     CMS_CLASS_VERSION(4)
 
   private:
+    constexpr T construct_() {
+      if constexpr (requires { T(); }) {
+        return T();
+      } else {
+        return T(edm::kUninitialized);
+      }
+    }
+
     bool isPresent_() const override { return present; }
     std::type_info const& dynamicTypeInfo_() const override { return typeid(T); }
     std::type_info const& wrappedTypeInfo_() const override { return typeid(Wrapper<T>); }
@@ -78,7 +87,7 @@ namespace edm {
   };
 
   template <typename T>
-  Wrapper<T>::Wrapper(std::unique_ptr<T> ptr) : WrapperBase(), obj(), present(ptr.get() != nullptr) {
+  Wrapper<T>::Wrapper(std::unique_ptr<T> ptr) : WrapperBase(), obj{construct_()}, present(ptr.get() != nullptr) {
     if (present) {
       obj = std::move(*ptr);
     }
@@ -89,7 +98,7 @@ namespace edm {
   Wrapper<T>::Wrapper(Emplace, Args&&... args) : WrapperBase(), obj(std::forward<Args>(args)...), present(true) {}
 
   template <typename T>
-  Wrapper<T>::Wrapper(T* ptr) : WrapperBase(), present(ptr != 0), obj() {
+  Wrapper<T>::Wrapper(T* ptr) : WrapperBase(), present(ptr != 0), obj{construct_()} {
     std::unique_ptr<T> temp(ptr);
     if (present) {
       obj = std::move(*ptr);

DataFormats/Common/test/Wrapper_t.cpp

@@ -1,34 +1,32 @@
-/*
- *  CMSSW
- *
- */
-
 #include <cassert>
 #include <iostream>
 #include <memory>
 #include <vector>
-#include "catch.hpp"
+
+#include <catch.hpp>
 
 #include "DataFormats/Common/interface/Wrapper.h"
 
 class CopyNoMove {
 public:
-  CopyNoMove() {}
+  CopyNoMove() = default;
   CopyNoMove(CopyNoMove const&) { /* std::cout << "copied\n"; */ }
   CopyNoMove& operator=(CopyNoMove const&) { /*std::cout << "assigned\n";*/ return *this; }
-
-private:
 };
 
 class MoveNoCopy {
 public:
-  MoveNoCopy() {}
+  MoveNoCopy() = default;
   MoveNoCopy(MoveNoCopy const&) = delete;
   MoveNoCopy& operator=(MoveNoCopy const&) = delete;
   MoveNoCopy(MoveNoCopy&&) { /* std::cout << "moved\n";*/ }
   MoveNoCopy& operator=(MoveNoCopy&&) { /* std::cout << "moved\n";*/ return *this; }
+};
 
-private:
+class NoDefaultCtor {
+public:
+  NoDefaultCtor() = delete;
+  NoDefaultCtor(edm::Uninitialized) {}
 };
 
 TEST_CASE("test Wrapper", "[Wrapper]") {
@@ -44,4 +42,7 @@ TEST_CASE("test Wrapper", "[Wrapper]") {
   edm::Wrapper<std::vector<double>> wrap3(std::move(thing3));
   REQUIRE(wrap3->size() == 10);
   REQUIRE(thing3.get() == 0);
+
+  auto thing4 = std::make_unique<NoDefaultCtor>(edm::kUninitialized);
+  edm::Wrapper<NoDefaultCtor> wrap4(std::move(thing4));
 }

DataFormats/Portable/interface/PortableDeviceCollection.h

@@ -7,9 +7,10 @@
 
 #include <alpaka/alpaka.hpp>
 
+#include "DataFormats/Common/interface/Uninitialized.h"
+#include "DataFormats/Portable/interface/PortableCollectionCommon.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/config.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/memory.h"
-#include "DataFormats/Portable/interface/PortableCollectionCommon.h"
 
 // generic SoA-based product in device memory
 template <typename T, typename TDev, typename = std::enable_if_t<alpaka::isDevice<TDev>>>
@@ -24,7 +25,9 @@ class PortableDeviceCollection {
   using Buffer = cms::alpakatools::device_buffer<TDev, std::byte[]>;
   using ConstBuffer = cms::alpakatools::const_device_buffer<TDev, std::byte[]>;
 
-  PortableDeviceCollection() = default;
+  PortableDeviceCollection() = delete;
+
+  explicit PortableDeviceCollection(edm::Uninitialized) noexcept {}
 
   PortableDeviceCollection(int32_t elements, TDev const& device)
       : buffer_{cms::alpakatools::make_device_buffer<std::byte[]>(device, Layout::computeDataSize(elements))},
@@ -144,7 +147,9 @@ class PortableDeviceMultiCollection {
   }
 
 public:
-  PortableDeviceMultiCollection() = default;
+  PortableDeviceMultiCollection() = delete;
+
+  explicit PortableDeviceMultiCollection(edm::Uninitialized) noexcept {};
 
   PortableDeviceMultiCollection(int32_t elements, TDev const& device)
       : buffer_{cms::alpakatools::make_device_buffer<std::byte[]>(device, Layout<>::computeDataSize(elements))},

DataFormats/Portable/interface/PortableDeviceObject.h

@@ -7,6 +7,7 @@
 
 #include <alpaka/alpaka.hpp>
 
+#include "DataFormats/Common/interface/Uninitialized.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/config.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/memory.h"
 
@@ -21,7 +22,9 @@ class PortableDeviceObject {
   using Buffer = cms::alpakatools::device_buffer<TDev, Product>;
   using ConstBuffer = cms::alpakatools::const_device_buffer<TDev, Product>;
 
-  PortableDeviceObject() = default;
+  PortableDeviceObject() = delete;
+
+  PortableDeviceObject(edm::Uninitialized) {}
 
   PortableDeviceObject(TDev const& device)
       // allocate global device memory

DataFormats/Portable/interface/PortableHostCollection.h

@@ -6,10 +6,11 @@
 
 #include <alpaka/alpaka.hpp>
 
+#include "DataFormats/Common/interface/Uninitialized.h"
+#include "DataFormats/Portable/interface/PortableCollectionCommon.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/config.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/host.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/memory.h"
-#include "DataFormats/Portable/interface/PortableCollectionCommon.h"
 
 // generic SoA-based product in host memory
 template <typename T>
@@ -21,7 +22,9 @@ class PortableHostCollection {
   using Buffer = cms::alpakatools::host_buffer<std::byte[]>;
   using ConstBuffer = cms::alpakatools::const_host_buffer<std::byte[]>;
 
-  PortableHostCollection() = default;
+  PortableHostCollection() = delete;
+
+  explicit PortableHostCollection(edm::Uninitialized) noexcept {};
 
   PortableHostCollection(int32_t elements, alpaka_common::DevHost const& host)
       // allocate pageable host memory
@@ -154,7 +157,9 @@ class PortableHostMultiCollection {
   }
 
 public:
-  PortableHostMultiCollection() = default;
+  PortableHostMultiCollection() = delete;
+
+  explicit PortableHostMultiCollection(edm::Uninitialized) noexcept {};
 
   PortableHostMultiCollection(int32_t elements, alpaka_common::DevHost const& host)
       // allocate pageable host memory

DataFormats/Portable/interface/PortableHostObject.h

@@ -7,6 +7,7 @@
 
 #include <alpaka/alpaka.hpp>
 
+#include "DataFormats/Common/interface/Uninitialized.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/config.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/host.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/memory.h"
@@ -19,7 +20,9 @@ class PortableHostObject {
   using Buffer = cms::alpakatools::host_buffer<Product>;
   using ConstBuffer = cms::alpakatools::const_host_buffer<Product>;
 
-  PortableHostObject() = default;
+  PortableHostObject() = delete;
+
+  PortableHostObject(edm::Uninitialized) noexcept {}
 
   PortableHostObject(alpaka_common::DevHost const& host)
       // allocate pageable host memory

DataFormats/SiPixelClusterSoA/interface/SiPixelClustersDevice.h

@@ -2,17 +2,20 @@
 #define DataFormats_SiPixelClusterSoA_interface_SiPixelClustersDevice_h
 
 #include <cstdint>
+
 #include <alpaka/alpaka.hpp>
-#include "HeterogeneousCore/AlpakaInterface/interface/config.h"
-#include "DataFormats/SiPixelClusterSoA/interface/SiPixelClustersHost.h"
+
+#include "DataFormats/Common/interface/Uninitialized.h"
 #include "DataFormats/Portable/interface/PortableDeviceCollection.h"
+#include "DataFormats/SiPixelClusterSoA/interface/SiPixelClustersHost.h"
 #include "DataFormats/SiPixelClusterSoA/interface/SiPixelClustersSoA.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/CopyToHost.h"
+#include "HeterogeneousCore/AlpakaInterface/interface/config.h"
 
 template <typename TDev>
 class SiPixelClustersDevice : public PortableDeviceCollection<SiPixelClustersSoA, TDev> {
 public:
-  SiPixelClustersDevice() = default;
+  SiPixelClustersDevice(edm::Uninitialized) : PortableDeviceCollection<SiPixelClustersSoA, TDev>{edm::kUninitialized} {}
 
   template <typename TQueue>
   explicit SiPixelClustersDevice(size_t maxModules, TQueue queue)

DataFormats/SiPixelClusterSoA/interface/SiPixelClustersHost.h

@@ -2,16 +2,18 @@
 #define DataFormats_SiPixelClusterSoA_interface_SiPixelClustersHost_h
 
 #include <alpaka/alpaka.hpp>
-#include "HeterogeneousCore/AlpakaInterface/interface/config.h"
+
+#include "DataFormats/Common/interface/Uninitialized.h"
 #include "DataFormats/Portable/interface/PortableHostCollection.h"
 #include "DataFormats/SiPixelClusterSoA/interface/SiPixelClustersSoA.h"
+#include "HeterogeneousCore/AlpakaInterface/interface/config.h"
 
 // TODO: The class is created via inheritance of the PortableCollection.
 // This is generally discouraged, and should be done via composition.
 // See: https://github.com/cms-sw/cmssw/pull/40465#discussion_r1067364306
 class SiPixelClustersHost : public PortableHostCollection<SiPixelClustersSoA> {
 public:
-  SiPixelClustersHost() = default;
+  SiPixelClustersHost(edm::Uninitialized) : PortableHostCollection<SiPixelClustersSoA>{edm::kUninitialized} {}
 
   template <typename TQueue>
   explicit SiPixelClustersHost(size_t maxModules, TQueue queue)