nv-sgl 0.6.0__cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

sgl/include/sgl/device/hot_reload.h

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/types.h"
+#include "sgl/device/reflection.h"
+#include "sgl/device/device_resource.h"
+
+#include "sgl/core/fwd.h"
+#include "sgl/core/object.h"
+#include "sgl/core/enum.h"
+
+#include <slang.h>
+
+#include <exception>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace sgl {
+
+/// Shader hot reload management, detects when relevant slang files
+/// have been editor and triggers session recreates as necessary.
+class SGL_API HotReload : public Object {
+    SGL_OBJECT(HotReload)
+public:
+    HotReload(ref<Device> device);
+
+    /// Force immediate recreation of all registered sessions and
+    /// any modules/programs they've loaded/linked.
+    void recreate_all_sessions();
+
+    /// Updates internal file system monitor for change detection.
+    void update();
+
+    // Enable/disable auto rebuild in response to file system events.
+    bool auto_detect_changes() const { return m_auto_detect_changes; }
+    void set_auto_detect_changes(bool val) { m_auto_detect_changes = val; }
+
+    // Adjust delay used by internal fs monitor before reponding to file system events.
+    uint32_t auto_detect_delay() const;
+    void set_auto_detect_delay(uint32_t delay_ms);
+
+    /// Return true if last attempt to recreate sessions failed with exception.
+    bool last_build_failed() const { return m_last_build_failed; }
+
+    // Internal functions called from session constructor/destructor
+    // to register sessions with hot reload system.
+    void _register_slang_session(SlangSession* session);
+    void _unregister_slang_session(SlangSession* session);
+
+    // Called from session when modules have updated, meaning dependencies may have changed
+    void _on_session_modules_changed(SlangSession* session);
+
+    /// Exclusively for testing, erase all existing file watches
+    void _clear_file_watches();
+    void _reset_reloaded() { m_has_reloaded = false; }
+    bool _has_reloaded() const { return m_has_reloaded; }
+
+private:
+    void on_file_system_event(std::span<FileSystemWatchEvent> events);
+    void update_watched_paths_for_session(SlangSession* session);
+
+    Device* m_device;
+    bool m_auto_detect_changes{true};
+    ref<FileSystemWatcher> m_file_system_watcher;
+    std::set<SlangSession*> m_all_slang_sessions;
+    bool m_last_build_failed{false};
+    std::set<std::filesystem::path> m_watched_paths;
+    bool m_has_reloaded;
+};
+
+} // namespace sgl

sgl/include/sgl/device/input_layout.h

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/enum.h"
+
+#include "sgl/device/device_resource.h"
+#include "sgl/device/formats.h"
+
+#include <slang-gfx.h>
+
+#include <string>
+
+namespace sgl {
+
+enum class InputSlotClass : uint8_t {
+    per_vertex = static_cast<uint8_t>(gfx::InputSlotClass::PerVertex),
+    per_instance = static_cast<uint8_t>(gfx::InputSlotClass::PerInstance),
+};
+
+SGL_ENUM_INFO(
+    InputSlotClass,
+    {
+        {InputSlotClass::per_vertex, "per_vertex"},
+        {InputSlotClass::per_instance, "per_instance"},
+    }
+);
+SGL_ENUM_REGISTER(InputSlotClass);
+
+struct InputElementDesc {
+    /// The name of the corresponding parameter in shader code.
+    std::string semantic_name;
+    /// The index of the corresponding parameter in shader code.
+    /// Only needed if multiple parameters share a semantic name.
+    uint32_t semantic_index{0};
+    /// The format of the data being fetched for this element.
+    Format format{Format::unknown};
+    /// The offset in bytes of this element from the start of the corresponding chunk of vertex stream data.
+    size_t offset{0};
+    /// The index of the vertex stream to fetch this element's data from.
+    uint32_t buffer_slot_index{0};
+};
+
+struct VertexStreamDesc {
+    /// The stride in bytes for this vertex stream.
+    size_t stride{0};
+    /// Whether the stream contains per-vertex or per-instance data.
+    InputSlotClass slot_class{InputSlotClass::per_vertex};
+    /// How many instances to draw per chunk of data.
+    uint32_t instance_data_step_rate{0};
+};
+
+struct InputLayoutDesc {
+    std::vector<InputElementDesc> input_elements;
+    std::vector<VertexStreamDesc> vertex_streams;
+};
+
+class SGL_API InputLayout : public DeviceResource {
+    SGL_OBJECT(InputLayout)
+public:
+    InputLayout(ref<Device> device, InputLayoutDesc desc);
+
+    const InputLayoutDesc& desc() const { return m_desc; }
+
+    gfx::IInputLayout* gfx_input_layout() const { return m_gfx_input_layout.get(); }
+
+    std::string to_string() const override;
+
+private:
+    InputLayoutDesc m_desc;
+    Slang::ComPtr<gfx::IInputLayout> m_gfx_input_layout;
+};
+
+} // namespace sgl

sgl/include/sgl/device/kernel.h

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/device_resource.h"
+#include "sgl/device/shader_cursor.h"
+
+#include "sgl/core/macros.h"
+#include "sgl/core/object.h"
+
+#include <functional>
+
+namespace sgl {
+
+class SGL_API Kernel : public DeviceResource {
+    SGL_OBJECT(Kernel)
+public:
+    using BindVarsCallback = std::function<void(ShaderCursor)>;
+
+    virtual ~Kernel() = default;
+
+    ShaderProgram* program() const { return m_program; }
+    ReflectionCursor reflection() const { return ReflectionCursor(program()); }
+
+protected:
+    Kernel(ref<Device> device, ref<ShaderProgram> program);
+
+    ref<ShaderProgram> m_program;
+};
+
+struct ComputeKernelDesc {
+    ref<ShaderProgram> program;
+};
+
+class SGL_API ComputeKernel : public Kernel {
+    SGL_OBJECT(ComputeKernel)
+public:
+    ComputeKernel(ref<Device> device, ComputeKernelDesc desc);
+    ~ComputeKernel() = default;
+
+    ComputePipeline* pipeline() const;
+
+    void dispatch(uint3 thread_count, BindVarsCallback bind_vars, ComputeCommandEncoder& encoder);
+
+    void dispatch(uint3 thread_count, BindVarsCallback bind_vars, CommandBuffer* command_buffer = nullptr);
+
+private:
+    uint3 m_thread_group_size;
+    mutable ref<ComputePipeline> m_pipeline;
+};
+
+class SGL_API RayTracingKernel : public Kernel {
+    SGL_OBJECT(RayTracingKernel)
+public:
+    RayTracingKernel(ref<Device> device, ref<ShaderProgram> program);
+    ~RayTracingKernel() = default;
+
+    RayTracingPipeline* pipeline() const;
+
+    void dispatch(uint3 thread_count, BindVarsCallback bind_vars, RayTracingCommandEncoder& encoder);
+
+    void dispatch(uint3 thread_count, BindVarsCallback bind_vars, CommandBuffer* command_buffer = nullptr);
+
+private:
+    mutable ref<RayTracingPipeline> m_pipeline;
+};
+
+} // namespace sgl

sgl/include/sgl/device/memory_heap.h

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/device/fwd.h"
+#include "sgl/device/device_resource.h"
+#include "sgl/device/resource.h"
+
+#include <memory>
+#include <vector>
+#include <deque>
+
+namespace sgl {
+
+struct MemoryHeapDesc {
+    /// The memory type of the heap.
+    MemoryType memory_type{MemoryType::upload};
+    /// The resource usage of the heap.
+    ResourceUsage usage{ResourceUsage::none};
+    /// The size of a page in bytes.
+    DeviceSize page_size{4 * 1024 * 1024};
+    /// True to retain large pages, false to release them after use.
+    bool retain_large_pages{false};
+    /// The debug name of the heap.
+    std::string debug_name;
+};
+
+/**
+ * \brief A memory heap is used to allocate temporary host-visible memory.
+ *
+ * A memory heap is a collection of memory pages. Each page has a buffer of size \c page_size.
+ * When allocating memory, the heap tries to add the allocation to the current page.
+ * If the allocation does not fit, a new page is allocated.
+ * For allocations larger than the configured page size, a new large page is allocated.
+ *
+ * The memory heap is tied to a fence. Each allocation records the currently signaled fence
+ * value when it is created. On release, the allocation is put on a deferred release queue.
+ * Only if the fence value of the memory heap is greater than the fence value of the allocation,
+ * the allocation is actually freed. This ensures that memory is not freed while still in use
+ * by the device.
+ *
+ * Allocations are returned as unique pointers. When the pointer is destroyed, the allocation
+ * is released. This ensures that the memory is freed when it is no longer used.
+ */
+class SGL_API MemoryHeap : public DeviceResource {
+    SGL_OBJECT(MemoryHeap)
+public:
+    SGL_NON_COPYABLE_AND_MOVABLE(MemoryHeap);
+
+    using PageID = uint64_t;
+
+    struct AllocationData {
+        /// The heap this allocation belongs to.
+        const ref<MemoryHeap> heap;
+        /// The buffer this allocation belongs to.
+        const ref<Buffer> buffer;
+        /// The size of the allocation.
+        const DeviceSize size;
+        /// The offset of the allocation within the buffer.
+        const DeviceOffset offset;
+        /// Pointer to the host-visible memory.
+        uint8_t* const data;
+
+        /// The page where the allocation is stored.
+        PageID page_id;
+        /// The signaled fence value at the time when the allocation was created.
+        const uint64_t fence_value;
+
+        ~AllocationData() { heap->release(this); }
+
+        /// The device address of the allocation.
+        DeviceAddress device_address() const { return buffer->device_address() + offset; }
+    };
+
+    using Allocation = std::unique_ptr<AllocationData>;
+
+    struct Stats {
+        /// The total size of the heap.
+        DeviceSize total_size{0};
+        /// The used size of the heap.
+        DeviceSize used_size{0};
+        /// The number of pages in the heap.
+        uint32_t page_count{0};
+        /// The number of large pages in the heap.
+        uint32_t large_page_count{0};
+    };
+
+    MemoryHeap(ref<Device> device, ref<Fence> fence, MemoryHeapDesc desc);
+    ~MemoryHeap();
+
+    /// Description of the heap.
+    const MemoryHeapDesc& desc() const { return m_desc; }
+    /// Statistics of the heap.
+    const Stats& stats() const { return m_stats; }
+
+    /**
+     * \brief Allocate memory from this heap.
+     *
+     * \param size The number of bytes to allocate.
+     * \param alignment The alignment of the allocation.
+     * \return Returns a unique pointer to the allocation.
+     */
+    Allocation allocate(DeviceSize size, DeviceSize alignment = 16);
+
+    /**
+     * \brief Execute deferred releases.
+     *
+     * This function should be called regularly to execute deferred releases.
+     */
+    void execute_deferred_releases();
+
+    std::string to_string() const override;
+
+private:
+    void release(AllocationData* allocation);
+
+    PageID allocate_page(DeviceSize size);
+    void free_page(PageID page_id);
+
+    PageID reclaim_or_allocate_page();
+
+    struct Page {
+        ref<Buffer> buffer;
+        uint8_t* data{nullptr};
+        uint32_t allocation_count{0};
+        DeviceOffset current_offset{0};
+
+        void reset()
+        {
+            allocation_count = 0;
+            current_offset = 0;
+        }
+    };
+
+    struct DeferredRelease {
+        uint64_t fence_value;
+        PageID page_id;
+        DeviceSize size;
+    };
+
+    static constexpr PageID INVALID_PAGE = PageID(-1);
+
+    ref<Fence> m_fence;
+    MemoryHeapDesc m_desc;
+    Stats m_stats;
+
+    std::vector<Page> m_pages;
+    std::vector<PageID> m_free_pages;
+    std::vector<PageID> m_available_pages;
+    PageID m_current_page{INVALID_PAGE};
+
+    std::deque<DeferredRelease> m_deferred_releases;
+};
+
+} // namespace sgl