[ntuple] DAOS support: drop class template for RDaosObject

As suggested in the code review, we demote the `RDaosObject` class template
in favor of simpler code. Therefore, we will only support `std::uint64_t`
as dkey/akey.

This is a separate commit so that we can recover the old templated version if
need be.

Author: jalopezg-git

core/foundation/inc/ROOT/TypeTraits.hxx

@@ -193,16 +193,6 @@ struct HasBeginAndEnd {
    static constexpr bool const value = Check<T>(0);
 };
 
-template <typename... Ts> struct __HasMembers {};
-template <typename T, typename _ = void>
-struct HasDataAndSize : std::false_type {};
-template <typename T>
-struct HasDataAndSize<T, typename std::conditional<false,
-                                         __HasMembers<typename T::pointer,
-                                                      decltype(std::declval<T>().size()),
-                                                      decltype(std::declval<T>().data())>, void>::type
-                    > : std::true_type {};
-
 } // ns TypeTraits
 } // ns ROOT
 #endif // ROOT_TTypeTraits

tree/ntuple/v7/inc/ROOT/RDaos.hxx

@@ -57,28 +57,12 @@ public:
   \class RDaosObject
   \brief Provides low-level access to DAOS objects in a container.
   */
-template <typename DKeyT, typename AKeyT>
 class RDaosObject {
 private:
    daos_handle_t fObjectHandle;
-
-   // Provide support for UINT64 dkey/akey.
-   template <typename T, typename std::enable_if<!ROOT::TypeTraits::HasDataAndSize<T>::value, int>::type = 0>
-   static size_t key_size(T& x) { return sizeof(x); }
-
-   template <typename T, typename std::enable_if<!ROOT::TypeTraits::HasDataAndSize<T>::value, int>::type = 0>
-   static typename std::add_pointer<T>::type key_data(T& x) { return &x; }
-
-   // Provide support for std::string/std::vector dkey/akey.
-   template <typename T, typename std::enable_if<ROOT::TypeTraits::HasDataAndSize<T>::value, int>::type = 0>
-   static size_t key_size(T& x) { return x.size(); }
-
-   template <typename T, typename std::enable_if<ROOT::TypeTraits::HasDataAndSize<T>::value, int>::type = 0>
-   static typename T::pointer key_data(T& x) { return const_cast<typename T::pointer>(x.data()); }
-
 public:
-   using DistributionKey_t = DKeyT;
-   using AttributeKey_t = AKeyT;
+   using DistributionKey_t = std::uint64_t;
+   using AttributeKey_t = std::uint64_t;
 
    /// \brief Contains required information for a single fetch/update operation.
    struct FetchUpdateArgs {
@@ -115,18 +99,19 @@ public:
   \brief A RDaosContainer provides read/write access to objects in a given container.
   */
 class RDaosContainer {
-   template <typename DKeyT, typename AKeyT>
    friend class RDaosObject;
 public:
+   using DistributionKey_t = std::uint64_t;
+   using AttributeKey_t = std::uint64_t;
+  
    /// \brief Describes a read/write operation on multiple objects; see the `ReadV`/`WriteV` functions.
-   template <typename DKeyT, typename AKeyT>
    struct RWOperation {
       RWOperation() = default;
-      RWOperation(daos_obj_id_t o, DKeyT d, AKeyT a, std::vector<d_iov_t> &v)
+      RWOperation(daos_obj_id_t o, DistributionKey_t d, AttributeKey_t a, std::vector<d_iov_t> &v)
          : fOid(o), fDistributionKey(d), fAttributeKey(a), fIovs(v) {};
       daos_obj_id_t fOid{};
-      DKeyT fDistributionKey{};
-      AKeyT fAttributeKey{};
+      DistributionKey_t fDistributionKey{};
+      AttributeKey_t fAttributeKey{};
       std::vector<d_iov_t> fIovs{};
    };
 
@@ -147,7 +132,7 @@ private:
    daos_handle_t fContainerHandle{};
    uuid_t fContainerUuid{};
    std::shared_ptr<RDaosPool> fPool;
-   /// OID that will be used by the next call to `WriteObject(const void *, std::size_t, DKeyT, AKeyT)`.
+   /// OID that will be used by the next call to `WriteObject(const void *, std::size_t, DistributionKey_t, AttributeKey_t)`.
    daos_obj_id_t fSequentialWrOid{};
 
    /**
@@ -156,17 +141,16 @@ private:
      \param fn Either `std::mem_fn<&RDaosObject::Fetch>` (read) or `std::mem_fn<&RDaosObject::Update>` (write).
      \return Number of requests that did not complete; this should be 0 after a successful call.
      */
-   template <typename Fn, typename DKeyT, typename AKeyT>
-   int VectorReadWrite(std::vector<RWOperation<DKeyT, AKeyT>> &vec, Fn fn) {
-      using _RDaosObject = RDaosObject<DKeyT, AKeyT>;
+   template <typename Fn>
+   int VectorReadWrite(std::vector<RWOperation> &vec, Fn fn) {
       int ret;
       DaosEventQueue eventQueue(vec.size());
       {
-         std::vector<std::tuple<std::unique_ptr<_RDaosObject>, typename _RDaosObject::FetchUpdateArgs>> requests{};
+         std::vector<std::tuple<std::unique_ptr<RDaosObject>, RDaosObject::FetchUpdateArgs>> requests{};
          requests.reserve(vec.size());
          for (size_t i = 0; i < vec.size(); ++i) {
-            requests.push_back(std::make_tuple(std::unique_ptr<_RDaosObject>(new _RDaosObject(*this, vec[i].fOid)),
-                                               typename _RDaosObject::FetchUpdateArgs{
+            requests.push_back(std::make_tuple(std::unique_ptr<RDaosObject>(new RDaosObject(*this, vec[i].fOid)),
+                                               RDaosObject::FetchUpdateArgs{
                                                  vec[i].fDistributionKey, vec[i].fAttributeKey,
                                                  vec[i].fIovs, &eventQueue.fEvs[i]}));
             fn(std::get<0>(requests.back()).get(), std::get<1>(requests.back()));
@@ -189,14 +173,7 @@ public:
      \param akey The attribute key used for this operation.
      \return 0 if the operation succeeded; a negative DAOS error number otherwise.
      */
-   template <typename DKeyT, typename AKeyT>
-   int ReadObject(daos_obj_id_t oid, void *buffer, std::size_t length, DKeyT dkey, AKeyT akey)
-   {
-      std::vector<d_iov_t> iovs(1);
-      d_iov_set(&iovs[0], buffer, length);
-      typename RDaosObject<DKeyT, AKeyT>::FetchUpdateArgs args(dkey, akey, iovs);
-      return RDaosObject<DKeyT, AKeyT>(*this, oid).Fetch(args);
-   }
+   int ReadObject(daos_obj_id_t oid, void *buffer, std::size_t length, DistributionKey_t dkey, AttributeKey_t akey);
 
    /**
      \brief Write the given buffer to an object in this container.
@@ -207,14 +184,7 @@ public:
      \param akey The attribute key used for this operation.
      \return 0 if the operation succeeded; a negative DAOS error number otherwise.
      */
-   template <typename DKeyT, typename AKeyT>
-   int WriteObject(daos_obj_id_t oid, const void *buffer, std::size_t length, DKeyT dkey, AKeyT akey)
-   {
-      std::vector<d_iov_t> iovs(1);
-      d_iov_set(&iovs[0], const_cast<void *>(buffer), length);
-      typename RDaosObject<DKeyT, AKeyT>::FetchUpdateArgs args(dkey, akey, iovs);
-      return RDaosObject<DKeyT, AKeyT>(*this, oid).Update(args);
-   }
+   int WriteObject(daos_obj_id_t oid, const void *buffer, std::size_t length, DistributionKey_t dkey, AttributeKey_t akey);
 
    /**
      \brief Write the given buffer to an object in this container and return a generated OID.
@@ -224,32 +194,24 @@ public:
      \param akey The attribute key used for this operation.
      \return A `std::tuple<>` that contains the generated OID and a DAOS error number (0 if the operation succeeded).
      */
-   template <typename DKeyT, typename AKeyT>
-   std::tuple<daos_obj_id_t, int> WriteObject(const void *buffer, std::size_t length, DKeyT dkey, AKeyT akey)
-   {
-      auto ret = std::make_tuple(fSequentialWrOid,
-                                 WriteObject(fSequentialWrOid, buffer, length, dkey, akey));
-      fSequentialWrOid.lo++;
-      return ret;
-   }
+   std::tuple<daos_obj_id_t, int>
+   WriteObject(const void *buffer, std::size_t length, DistributionKey_t dkey, AttributeKey_t akey);
 
    /**
      \brief Perform a vector read operation on (possibly) multiple objects.
      \param vec A `std::vector<RWOperation>` that describes read operations to perform.
      \return Number of operations that could not complete.
      */
-   template <typename DKeyT, typename AKeyT>
-   int ReadV(std::vector<RWOperation<DKeyT, AKeyT>> &vec)
-   { return VectorReadWrite(vec, std::mem_fn(&RDaosObject<DKeyT, AKeyT>::Fetch)); }
+   int ReadV(std::vector<RWOperation> &vec)
+   { return VectorReadWrite(vec, std::mem_fn(&RDaosObject::Fetch)); }
 
    /**
      \brief Perform a vector write operation on (possibly) multiple objects.
      \param vec A `std::vector<RWOperation>` that describes write operations to perform.
      \return Number of operations that could not complete.
      */
-   template <typename DKeyT, typename AKeyT>
-   int WriteV(std::vector<RWOperation<DKeyT, AKeyT>> &vec)
-   { return VectorReadWrite(vec, std::mem_fn(&RDaosObject<DKeyT, AKeyT>::Update)); }
+   int WriteV(std::vector<RWOperation> &vec)
+   { return VectorReadWrite(vec, std::mem_fn(&RDaosObject::Update)); }
 };
 
 } // namespace Detail

tree/ntuple/v7/src/RDaos.cxx

@@ -40,23 +40,21 @@ ROOT::Experimental::Detail::RDaosPool::~RDaosPool() {
 ////////////////////////////////////////////////////////////////////////////////
 
 
-template <typename DKeyT, typename AKeyT>
-ROOT::Experimental::Detail::RDaosObject<DKeyT, AKeyT>::FetchUpdateArgs::FetchUpdateArgs(FetchUpdateArgs&& fua)
+ROOT::Experimental::Detail::RDaosObject::FetchUpdateArgs::FetchUpdateArgs(FetchUpdateArgs&& fua)
   : fDkey(fua.fDkey), fAkey(fua.fAkey),
     fIods{fua.fIods[0]}, fSgls{fua.fSgls[0]}, fIovs(std::move(fua.fIovs)), fEv(fua.fEv)
 {
-   d_iov_set(&fDistributionKey, key_data(fDkey), key_size(fDkey));
-   d_iov_set(&fIods[0].iod_name, key_data(fAkey), key_size(fAkey));
+   d_iov_set(&fDistributionKey, &fDkey, sizeof(fDkey));
+   d_iov_set(&fIods[0].iod_name, &fAkey, sizeof(fAkey));
 }
 
-template <typename DKeyT, typename AKeyT>
-ROOT::Experimental::Detail::RDaosObject<DKeyT, AKeyT>::FetchUpdateArgs::FetchUpdateArgs
+ROOT::Experimental::Detail::RDaosObject::FetchUpdateArgs::FetchUpdateArgs
 (DistributionKey_t &d, AttributeKey_t &a, std::vector<d_iov_t> &v, daos_event_t *p)
   : fDkey(d), fAkey(a), fIovs(v), fEv(p)
 {
-   d_iov_set(&fDistributionKey, key_data(fDkey), key_size(fDkey));
+   d_iov_set(&fDistributionKey, &fDkey, sizeof(fDkey));
 
-   d_iov_set(&fIods[0].iod_name, key_data(fAkey), key_size(fAkey));
+   d_iov_set(&fIods[0].iod_name, &fAkey, sizeof(fAkey));
    fIods[0].iod_nr = 1;
    fIods[0].iod_size = std::accumulate(v.begin(), v.end(), 0,
                                        [](daos_size_t _a, d_iov_t _b) { return _a + _b.iov_len; });
@@ -68,36 +66,27 @@ ROOT::Experimental::Detail::RDaosObject<DKeyT, AKeyT>::FetchUpdateArgs::FetchUpd
    fSgls[0].sg_iovs = fIovs.data();
 }
 
-template <typename DKeyT, typename AKeyT>
-ROOT::Experimental::Detail::RDaosObject<DKeyT, AKeyT>::RDaosObject(RDaosContainer &container, daos_obj_id_t oid,
-                                                                   daos_oclass_id_t cid)
+ROOT::Experimental::Detail::RDaosObject::RDaosObject(RDaosContainer &container, daos_obj_id_t oid,
+                                                     daos_oclass_id_t cid)
 {
-   daos_ofeat_t ofeats{};
-   if (std::is_same<std::uint64_t, DKeyT>::value)
-      ofeats |= DAOS_OF_DKEY_UINT64;
-   if (std::is_same<std::uint64_t, AKeyT>::value)
-      ofeats |= DAOS_OF_AKEY_UINT64;
-   daos_obj_generate_id(&oid, ofeats /*| DAOS_OF_ARRAY_BYTE*/, cid, 0);
+   daos_obj_generate_id(&oid, DAOS_OF_DKEY_UINT64 | DAOS_OF_AKEY_UINT64 /*| DAOS_OF_ARRAY_BYTE*/, cid, 0);
    if (int err = daos_obj_open(container.fContainerHandle, oid, DAOS_OO_RW, &fObjectHandle, nullptr))
       throw RException(R__FAIL("daos_obj_open: error: " + std::string(d_errstr(err))));
 }
 
-template <typename DKeyT, typename AKeyT>
-ROOT::Experimental::Detail::RDaosObject<DKeyT, AKeyT>::~RDaosObject()
+ROOT::Experimental::Detail::RDaosObject::~RDaosObject()
 {
    daos_obj_close(fObjectHandle, nullptr);
 }
 
-template <typename DKeyT, typename AKeyT>
-int ROOT::Experimental::Detail::RDaosObject<DKeyT, AKeyT>::Fetch(FetchUpdateArgs &args)
+int ROOT::Experimental::Detail::RDaosObject::Fetch(FetchUpdateArgs &args)
 {
    args.fIods[0].iod_size = (daos_size_t)DAOS_REC_ANY;
    return daos_obj_fetch(fObjectHandle, DAOS_TX_NONE, 0, &args.fDistributionKey, 1,
                          args.fIods, args.fSgls, nullptr, args.fEv);
 }
 
-template <typename DKeyT, typename AKeyT>
-int ROOT::Experimental::Detail::RDaosObject<DKeyT, AKeyT>::Update(FetchUpdateArgs &args)
+int ROOT::Experimental::Detail::RDaosObject::Update(FetchUpdateArgs &args)
 {
    return daos_obj_update(fObjectHandle, DAOS_TX_NONE, DAOS_COND_DKEY_INSERT, &args.fDistributionKey, 1,
                           args.fIods, args.fSgls, args.fEv);
@@ -157,6 +146,34 @@ ROOT::Experimental::Detail::RDaosContainer::~RDaosContainer() {
    daos_cont_close(fContainerHandle, nullptr);
 }
 
+int ROOT::Experimental::Detail::RDaosContainer::ReadObject(daos_obj_id_t oid, void *buffer, std::size_t length,
+                                                           DistributionKey_t dkey, AttributeKey_t akey)
+{
+   std::vector<d_iov_t> iovs(1);
+   d_iov_set(&iovs[0], buffer, length);
+   RDaosObject::FetchUpdateArgs args(dkey, akey, iovs);
+   return RDaosObject(*this, oid).Fetch(args);
+}
+
+int ROOT::Experimental::Detail::RDaosContainer::WriteObject(daos_obj_id_t oid, const void *buffer, std::size_t length,
+                                                            DistributionKey_t dkey, AttributeKey_t akey)
+{
+   std::vector<d_iov_t> iovs(1);
+   d_iov_set(&iovs[0], const_cast<void *>(buffer), length);
+   RDaosObject::FetchUpdateArgs args(dkey, akey, iovs);
+   return RDaosObject(*this, oid).Update(args);
+}
+
+std::tuple<daos_obj_id_t, int>
+ROOT::Experimental::Detail::RDaosContainer::WriteObject(const void *buffer, std::size_t length,
+                                                        DistributionKey_t dkey, AttributeKey_t akey)
+{
+   auto ret = std::make_tuple(fSequentialWrOid,
+                              WriteObject(fSequentialWrOid, buffer, length, dkey, akey));
+   fSequentialWrOid.lo++;
+   return ret;
+}
+
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -167,6 +184,3 @@ static struct RDaosRAII {
    ~RDaosRAII() { daos_fini(); }
 } RAII{};
 } // anonymous namespace
-
-// Explicit instantiations of `RDaosObject` for specific dkey/akey types
-template class ROOT::Experimental::Detail::RDaosObject<uint64_t, uint64_t>;

tree/ntuple/v7/src/RPageStorageDaos.cxx

@@ -472,7 +472,7 @@ ROOT::Experimental::Detail::RPageSourceDaos::LoadCluster(DescriptorId_t clusterI
    }
 
    // Prepare the input vector for the RDaosContainer::ReadV() call
-   std::vector<RDaosContainer::RWOperation<std::uint64_t, std::uint64_t>> readRequests;
+   std::vector<RDaosContainer::RWOperation> readRequests;
    auto buffer = new unsigned char[szPayload];
    for (auto &s : onDiskPages) {
       std::vector<d_iov_t> iovs(1);