nv-sgl 0.6.0__cp313-cp313-win_amd64.whl

sgl/include/sgl/device/cuda_interop.h

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/object.h"
+
+#include "sgl/device/fwd.h"
+
+namespace sgl::cuda {
+
+struct TensorView {
+    void* data;
+    size_t size;
+    size_t stride;
+};
+
+class InteropBuffer : public Object {
+public:
+    InteropBuffer(sgl::Device* device, const TensorView tensor_view, bool is_uav);
+    ~InteropBuffer();
+
+    Buffer* buffer() const { return m_buffer; }
+    bool is_uav() const { return m_is_uav; }
+    ref<ResourceView> get_resource_view() const;
+
+    void copy_from_cuda(void* cuda_stream = 0);
+    void copy_to_cuda(void* cuda_stream = 0);
+
+private:
+    sgl::Device* m_device;
+    TensorView m_tensor_view;
+    bool m_is_uav;
+    ref<sgl::Buffer> m_buffer;
+    ref<cuda::ExternalMemory> m_external_memory;
+    ref<sgl::ResourceView> m_srv;
+    ref<sgl::ResourceView> m_uav;
+};
+
+} // namespace sgl::cuda

sgl/include/sgl/device/cuda_utils.h

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/macros.h"
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/fence.h"
+#include "sgl/device/cuda_api.h"
+
+#define SGL_CU_CHECK(call)                                                                                             \
+    do {                                                                                                               \
+        CUresult result = call;                                                                                        \
+        if (result != CUDA_SUCCESS) {                                                                                  \
+            const char* errorName;                                                                                     \
+            cuGetErrorName(result, &errorName);                                                                        \
+            const char* errorString;                                                                                   \
+            cuGetErrorString(result, &errorString);                                                                    \
+            SGL_THROW("CUDA call {} failed with error {} ({}).", #call, errorName, errorString);                       \
+        }                                                                                                              \
+    } while (0)
+
+#define SGL_CU_SCOPE(device) sgl::cuda::ContextScope _context_scope(device)
+
+
+namespace sgl::cuda {
+
+SGL_API void* malloc_device(size_t size);
+SGL_API void free_device(void* ptr);
+
+SGL_API void memcpy_device_to_device(void* dst, const void* src, size_t count);
+SGL_API void memcpy_host_to_device(void* dst, const void* src, size_t count);
+SGL_API void memcpy_device_to_host(void* dst, const void* src, size_t count);
+
+SGL_API void memset_device(void* dst, uint8_t value, size_t count);
+
+SGL_API CUexternalMemory import_external_memory(const Buffer* buffer);
+SGL_API void destroy_external_memory(CUexternalMemory ext_mem);
+SGL_API void* external_memory_get_mapped_buffer(CUexternalMemory ext_mem, size_t offset, size_t size);
+
+SGL_API CUexternalSemaphore import_external_semaphore(const Fence* fence);
+SGL_API void destroy_external_semaphore(CUexternalSemaphore ext_sem);
+SGL_API void signal_external_semaphore(CUexternalSemaphore ext_sem, uint64_t value, CUstream stream = 0);
+SGL_API void wait_external_semaphore(CUexternalSemaphore ext_sem, uint64_t value, CUstream stream = 0);
+
+/// Wraps a CUDA device, context and stream.
+class SGL_API Device : public Object {
+    SGL_OBJECT(cuda::Device)
+public:
+    /// Constructor.
+    /// Creates a CUDA device on the same adapter as the sgl device.
+    explicit Device(const sgl::Device* device);
+    ~Device();
+
+    CUdevice device() const { return m_device; }
+    CUcontext context() const { return m_context; }
+    CUstream stream() const { return m_stream; }
+
+private:
+    CUdevice m_device;
+    CUcontext m_context;
+    CUstream m_stream;
+};
+
+/// Wraps an external memory resource.
+class SGL_API ExternalMemory : public Object {
+    SGL_OBJECT(cuda::ExternalMemory)
+public:
+    explicit ExternalMemory(const Buffer* buffer);
+    ~ExternalMemory();
+
+    size_t size() const { return m_size; }
+
+    void* mapped_data() const;
+
+private:
+    /// Non-owning pointer to the resource.
+    const Resource* m_resource;
+    CUexternalMemory m_external_memory;
+    size_t m_size;
+    mutable void* m_mapped_data{nullptr};
+};
+
+/// Wraps an external semaphore.
+class SGL_API ExternalSemaphore : public Object {
+    SGL_OBJECT(cuda::ExternalSemaphore)
+public:
+    explicit ExternalSemaphore(Fence* fence);
+    ~ExternalSemaphore();
+
+    void signal(uint64_t value, CUstream stream = 0);
+    void wait(uint64_t value, CUstream stream = 0);
+
+private:
+    /// Non-owning pointer to the fence.
+    Fence* m_fence;
+    CUexternalSemaphore m_external_semaphore;
+};
+
+class SGL_API ContextScope {
+public:
+    explicit ContextScope(const Device* device);
+    explicit ContextScope(const sgl::Device* device);
+    ~ContextScope();
+};
+
+} // namespace sgl::cuda

sgl/include/sgl/device/cursor_utils.h

@@ -0,0 +1,129 @@
+#pragma once
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/reflection.h"
+
+namespace sgl {
+
+namespace cursor_utils {
+    bool allow_scalar_conversion(TypeReflection::ScalarType from, TypeReflection::ScalarType to);
+
+    size_t get_scalar_type_size(TypeReflection::ScalarType type);
+
+    void check_array(
+        const TypeLayoutReflection* type_layout,
+        size_t size,
+        TypeReflection::ScalarType scalar_type,
+        size_t element_count
+    );
+
+    void check_scalar(const TypeLayoutReflection* type_layout, size_t size, TypeReflection::ScalarType scalar_type);
+
+    void check_vector(
+        const TypeLayoutReflection* type_layout,
+        size_t size,
+        TypeReflection::ScalarType scalar_type,
+        int dimension
+    );
+
+    void check_matrix(
+        const TypeLayoutReflection* type_layout,
+        size_t size,
+        TypeReflection::ScalarType scalar_type,
+        int rows,
+        int cols
+    );
+} // namespace cursor_utils
+
+/// Dummy type to represent traits of an arbitrary value type usable by cursors
+struct _AnyCursorValue { };
+
+/// Concept that defines the requirements for a cursor that can be traversed using
+/// field names and element indices. Each traversal function should return a new
+/// cursor object that represents the field or element.
+template<typename T>
+concept TraversableCursor = requires(T obj, std::string_view name_idx, uint32_t el_index) {
+    {
+        obj[name_idx]
+    } -> std::same_as<T>;
+    {
+        obj[el_index]
+    } -> std::same_as<T>;
+    {
+        obj.find_field(name_idx)
+    } -> std::same_as<T>;
+    {
+        obj.find_element(el_index)
+    } -> std::same_as<T>;
+    {
+        obj.has_field(name_idx)
+    } -> std::convertible_to<bool>;
+    {
+        obj.has_element(el_index)
+    } -> std::convertible_to<bool>;
+    {
+        obj.type_layout()
+    } -> std::convertible_to<ref<const TypeLayoutReflection>>;
+    {
+        obj.type()
+    } -> std::convertible_to<ref<const TypeReflection>>;
+    {
+        obj.is_valid()
+    } -> std::convertible_to<bool>;
+};
+
+/// Concept that defines the requirements for a cursor that can be read from.
+template<typename T>
+concept ReadableCursor = requires(
+    T obj,
+    void* data,
+    size_t size,
+    TypeReflection::ScalarType scalar_type,
+    size_t element_count,
+    _AnyCursorValue& val
+) {
+    {
+        obj.template get<_AnyCursorValue>(val)
+    } -> std::same_as<void>; // Ensure set() method exists
+    {
+        obj.template as<_AnyCursorValue>()
+    } -> std::same_as<_AnyCursorValue>;
+    {
+        obj._get_array(data, size, scalar_type, element_count)
+    } -> std::same_as<void>;
+    {
+        obj._get_scalar(data, size, scalar_type)
+    } -> std::same_as<void>;
+    {
+        obj._get_vector(data, size, scalar_type, 0)
+    } -> std::same_as<void>;
+    {
+        obj._get_matrix(data, size, scalar_type, 0, 0)
+    } -> std::same_as<void>;
+};
+
+/// Concept that defines the requirements for a cursor that can be written to.
+template<typename T>
+concept WritableCursor
+    = requires(T obj, void* data, size_t size, TypeReflection::ScalarType scalar_type, size_t element_count) {
+          {
+              obj.template set<_AnyCursorValue>({})
+          } -> std::same_as<void>;
+          {
+              obj.template operator=<_AnyCursorValue>({})
+          } -> std::same_as<void>;
+          {
+              obj._set_array(data, size, scalar_type, element_count)
+          } -> std::same_as<void>;
+          {
+              obj._set_scalar(data, size, scalar_type)
+          } -> std::same_as<void>;
+          {
+              obj._set_vector(data, size, scalar_type, 0)
+          } -> std::same_as<void>;
+          {
+              obj._set_matrix(data, size, scalar_type, 0, 0)
+          } -> std::same_as<void>;
+      };
+
+} // namespace sgl