NanoVDB: share the buffer trait detectors and deduplicate GridHandle lookups

BufferHasDeviceSingle/BufferHasHostSingle move next to the BufferTraits
primary in HostBuffer.h: they are companions to the trait protocol, not
GridHandle-specific, so other handle types can consume them without
including GridHandle.h. The three identical grid-lookup bodies behind
grid() and both deviceGrid() families collapse into one private gridAt()
helper, and the supported-combination guard for GridHandle::copy() now
lives solely in the no-arg overload, so the two spellings cannot drift
apart when cross-space transfers relax it. cuda::Buffer documents the
single-space device-buffer concept on its BufferTraits specialization --
naming exactly the interface a consumer of hasDeviceSingle may rely on --
and gains a rebind alias for generic code that constructs sibling buffers.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: Mark Harris <mharris@nvidia.com>

Author: harrism

nanovdb/nanovdb/GridHandle.h

@@ -17,7 +17,6 @@
 #define NANOVDB_GRID_HANDLE_H_HAS_BEEN_INCLUDED
 
 #include <fstream> // for std::ifstream
-#include <type_traits> // for std::void_t
 #include <iostream> // for std::cerr/cout
 #include <vector>
 #include <initializer_list>
@@ -32,27 +31,6 @@ namespace nanovdb {
 
 struct GridHandleMetaData {uint64_t offset, size; GridType gridType;};
 
-/// @brief Detects whether @c BufferTraits<BufferT> defines @c hasDeviceSingle,
-///        i.e. whether the buffer manages a single device-resident allocation.
-/// @details Defaults to false when the trait member is absent, so pre-existing
-///          BufferTraits specializations (in or out of tree) that only define
-///          hasDeviceDual keep compiling unchanged.
-template<typename BufferT, typename = void>
-struct BufferHasDeviceSingle { static constexpr bool value = false; };
-template<typename BufferT>
-struct BufferHasDeviceSingle<BufferT, std::void_t<decltype(BufferTraits<BufferT>::hasDeviceSingle)>>
-{ static constexpr bool value = BufferTraits<BufferT>::hasDeviceSingle; };
-
-/// @brief Companion detection for BufferTraits<...>::hasHostSingle: a
-///        single-space buffer whose storage is host-accessible (e.g. a
-///        pinned-resource cuda::Buffer). GridHandle does not support these
-///        yet and rejects them with a named error below.
-template<typename BufferT, typename = void>
-struct BufferHasHostSingle { static constexpr bool value = false; };
-template<typename BufferT>
-struct BufferHasHostSingle<BufferT, std::void_t<decltype(BufferTraits<BufferT>::hasHostSingle)>>
-{ static constexpr bool value = BufferTraits<BufferT>::hasHostSingle; };
-
 /// @brief This class serves to manage a buffer containing one or more NanoVDB Grids.
 ///
 /// @note  It is important to note that this class does NOT depend on OpenVDB.
@@ -71,6 +49,16 @@ class GridHandle
     template <typename T>
     static T* no_const(const T* ptr) { return const_cast<T*>(ptr); }
 
+    /// @brief Shared lookup behind grid() and deviceGrid(): the @a n'th grid
+    ///        within @a base, or nullptr when @a base is null, @a n is out of
+    ///        range, or the value type does not match the grid.
+    template<typename ValueT>
+    const NanoGrid<ValueT>* gridAt(const void* base, uint32_t n) const
+    {
+        if (base == nullptr || n >= mMetaData.size() || mMetaData[n].gridType != toGridType<ValueT>()) return nullptr;
+        return util::PtrAdd<NanoGrid<ValueT>>(base, mMetaData[n].offset);
+    }
+
     /// @brief Adopts a buffer whose metadata is already known, so a deep copy
     ///        does not re-parse and a non-default-constructible buffer (e.g.
     ///        over a ResourceRef) never needs default construction.
@@ -241,11 +229,7 @@ class GridHandle
     ///          or if the template parameter does not match the specified grid.
     template<typename ValueT, typename U = BufferT>
     typename util::enable_if<BufferHasDeviceSingle<U>::value, const NanoGrid<ValueT>*>::type
-    deviceGrid(uint32_t n=0) const {
-        const void *data = mBuffer.data();
-        if (data == nullptr || n >= mMetaData.size() || mMetaData[n].gridType != toGridType<ValueT>()) return nullptr;
-        return util::PtrAdd<NanoGrid<ValueT>>(data, mMetaData[n].offset);
-    }
+    deviceGrid(uint32_t n=0) const { return this->template gridAt<ValueT>(mBuffer.data(), n); }
     template<typename ValueT, typename U = BufferT>
     typename util::enable_if<BufferHasDeviceSingle<U>::value, NanoGrid<ValueT>*>::type
     deviceGrid(uint32_t n=0){return const_cast<NanoGrid<ValueT>*>(static_cast<const GridHandle*>(this)->template deviceGrid<ValueT>(n));}
@@ -463,11 +447,8 @@ template <typename OtherBufferT>
 inline GridHandle<OtherBufferT> GridHandle<BufferT>::copy(const OtherBufferT& other) const
 {
     if constexpr (BufferHasDeviceSingle<BufferT>::value || BufferHasDeviceSingle<OtherBufferT>::value) {
-        static_assert(util::is_same<OtherBufferT, BufferT>::value && BufferHasDeviceSingle<BufferT>::value,
-                      "GridHandle::copy to or from a single-space device buffer of a different buffer type "
-                      "is not supported yet: copy device-to-device with the same buffer type instead");
         (void)other;// the single-space copy allocates through the source's resource
-        return this->template copy<OtherBufferT>();
+        return this->template copy<OtherBufferT>();// the no-arg overload holds the supported-combination guard
     } else {
         if (mBuffer.size() == 0) return GridHandle<OtherBufferT>();// return an empty handle
         auto buffer = OtherBufferT::create(mBuffer.size(), &other);
@@ -498,19 +479,15 @@ template<typename BufferT>
 template<typename ValueT, typename U, typename util::disable_if<BufferHasDeviceSingle<U>::value, int>::type>
 inline const NanoGrid<ValueT>* GridHandle<BufferT>::grid(uint32_t n) const
 {
-    const void *data = mBuffer.data();
-    if (data == nullptr || n >= mMetaData.size() || mMetaData[n].gridType != toGridType<ValueT>()) return nullptr;
-    return util::PtrAdd<NanoGrid<ValueT>>(data, mMetaData[n].offset);
+    return this->template gridAt<ValueT>(mBuffer.data(), n);
 }// const NanoGrid<ValueT>* GridHandle<BufferT>::grid(uint32_t n) const
 
 template<typename BufferT>
 template<typename ValueT, typename U>
 inline typename util::enable_if<BufferTraits<U>::hasDeviceDual, const NanoGrid<ValueT>*>::type
 GridHandle<BufferT>::deviceGrid(uint32_t n) const
 {
-    const void *data = mBuffer.deviceData();
-    if (data == nullptr || n >= mMetaData.size() || mMetaData[n].gridType != toGridType<ValueT>()) return nullptr;
-    return util::PtrAdd<NanoGrid<ValueT>>(data, mMetaData[n].offset);
+    return this->template gridAt<ValueT>(mBuffer.deviceData(), n);
 }// GridHandle<BufferT>::deviceGrid(uint32_t n) cons
 
 template<typename BufferT>

nanovdb/nanovdb/HostBuffer.h

@@ -87,6 +87,7 @@
 #include <cassert>//           for assert
 #include <sstream>//           for std::stringstream
 #include <cstring>//           for memcpy
+#include <type_traits>//       for std::void_t
 
 #define checkPtr(ptr, msg) \
     { \
@@ -102,6 +103,26 @@ struct BufferTraits
     static constexpr bool hasDeviceSingle = false;
 };
 
+/// @brief Detects whether @c BufferTraits<BufferT> defines @c hasDeviceSingle,
+///        i.e. whether the buffer manages a single device-resident allocation.
+/// @details Defaults to false when the trait member is absent, so pre-existing
+///          BufferTraits specializations (in or out of tree) that only define
+///          hasDeviceDual keep compiling unchanged.
+template<typename BufferT, typename = void>
+struct BufferHasDeviceSingle { static constexpr bool value = false; };
+template<typename BufferT>
+struct BufferHasDeviceSingle<BufferT, std::void_t<decltype(BufferTraits<BufferT>::hasDeviceSingle)>>
+{ static constexpr bool value = BufferTraits<BufferT>::hasDeviceSingle; };
+
+/// @brief Companion detection for BufferTraits<...>::hasHostSingle: a
+///        single-space buffer whose storage is host-accessible (e.g. a
+///        pinned-resource cuda::Buffer).
+template<typename BufferT, typename = void>
+struct BufferHasHostSingle { static constexpr bool value = false; };
+template<typename BufferT>
+struct BufferHasHostSingle<BufferT, std::void_t<decltype(BufferTraits<BufferT>::hasHostSingle)>>
+{ static constexpr bool value = BufferTraits<BufferT>::hasHostSingle; };
+
 // ----------------------------> HostBuffer <--------------------------------------
 
 /// @brief This is a buffer that contains a shared or private pool

nanovdb/nanovdb/cuda/Buffer.h

@@ -68,6 +68,11 @@ class Buffer : private detail::StreamHolder<is_async_resource<R>::value>
     using ElementType  = T;
     using ResourceType = R;
 
+    /// @brief Alias for a sibling buffer over the same resource with a
+    ///        different element type.
+    template<typename U>
+    using rebind = Buffer<U, R>;
+
 private:
     R      mResource;
     T*     mData = nullptr;
@@ -430,11 +435,15 @@ struct BufferTraits;
 ///        owns exactly one allocation, resident on the device, so the handle
 ///        parses metadata through a device read and exposes only the device
 ///        accessors. Requires byte-addressed storage.
-/// @note A buffer whose trait sets hasDeviceSingle must provide the interface
-///       the single-space GridHandle constructor consumes: ElementType and
-///       ResourceType typedefs, data(), size_bytes(), resource(), stream()
-///       (stream-ordered resources), and the (stream, resource, count, noInit)
-///       constructor shape.
+/// @note This trait doubles as the definition of the single-space
+///       device-buffer concept: a buffer whose BufferTraits specialization
+///       sets hasDeviceSingle guarantees ElementType and ResourceType
+///       typedefs, data(), size() and size_bytes() (byte-addressed elements,
+///       enforced by the consumer), resource(), copy(), clear(), and stream()
+///       when the resource is stream-ordered. Any consumer of hasDeviceSingle
+///       may rely on exactly this interface and nothing more; in particular,
+///       scratch allocates through resource() as a cuda::Buffer, so a
+///       conforming buffer never needs to be constructible by a consumer.
 template<typename T, typename R>
 struct BufferTraits<cuda::Buffer<T, R>>
 {