ernie-renderer 0.2.0.dev76__tar.gz → 0.2.0.dev82__tar.gz

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/CMakeLists.txt

@@ -15,7 +15,7 @@ project(
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev76" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev82" CACHE STRING "Pre-release suffix of Ernie's version")
 set(ERNIE_VERSION "${PROJECT_VERSION}${ERNIE_VERSION_SUFFIX}")
 
 option(ERNIE_BUILD_TESTS "Build Ernie's tests" OFF)

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev76
+Version: 0.2.0.dev82
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
 Author: Alex Maietta
 License-Expression: BSD-3-Clause

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/benchmarks/scene/extents.cpp

@@ -2,7 +2,7 @@
 /// @file extents.cpp
 /// @brief Scene updates at 100,000 prims: the first, one edit's, and one inherited edit's.
 #include "benchmarks/bench.h"
-#include "ernie/scene/schemas/geom.h"
+#include "ernie/scene/schema/geom.h"
 
 #include <memory>
 #include <string>

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/CMakeLists.txt

@@ -7,6 +7,7 @@ add_library(
     buffer.cpp
     column.cpp
     context.cpp
+    profile.cpp
     cuda.cpp
     external.cpp
     image.cpp

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/context.cpp

@@ -5,6 +5,7 @@
 
 #include "ernie/util/algorithm.h"
 #include "ernie/util/on_failure.h"
+#include "ernie/util/profiler.h"
 #include "ernie/util/text.h"
 
 #include <algorithm>
@@ -77,6 +78,7 @@ Families FindFamilies(VkPhysicalDevice device) {
 DeviceContext::DeviceContext(const DeviceContextOptions& options)
     : instance_({.validation = options.validation, .extensions = options.instanceExtensions}),
       physical_(Choose(instance_, options.device)) {
+    ERNIE_ZONE("Create device");
     VkPhysicalDeviceMaintenance4Properties maintenance4{
         .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES};
     VkPhysicalDeviceProperties2 properties{.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
@@ -148,10 +150,12 @@ DeviceContext::DeviceContext(const DeviceContextOptions& options)
     main_ = chosen[0];
     compute_ = chosen[1];
     transfer_ = chosen[2];
+    profiler_ = GpuProfiler::Create(*this);
 }
 
 DeviceContext::~DeviceContext() {
     Quietly([this] { WaitIdle(); });
+    profiler_.reset();
     queues_.clear();
     vmaDestroyAllocator(allocator_);
     vkDestroyDevice(device_, nullptr);
@@ -174,6 +178,10 @@ void DeviceContext::Retire(std::function<void()> release) {
 }
 
 void DeviceContext::Collect() {
+    ERNIE_ZONE("Collect");
+    if (profiler_) {
+        profiler_->Collect();
+    }
     std::vector<Retired> done;
     {
         const std::lock_guard lock(retiredMutex_);

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/context.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include "ernie/device/instance.h"
+#include "ernie/device/profile.h"
 #include "ernie/device/queue.h"
 #include "ernie/device/vulkan.h"
 
@@ -102,6 +103,14 @@ class DeviceContext {
 
     /// @brief Names a Vulkan object for validation messages, captures and crash reports.
     void Name(VkObjectType type, std::uint64_t handle, std::string_view name) const;
+    /// @brief Opens and closes a named region of commands, as a capture or validation message
+    /// shows it.
+    void BeginLabel(VkCommandBuffer commands, std::string_view name) const {
+        instance_.BeginLabel(commands, name);
+    }
+    void EndLabel(VkCommandBuffer commands) const {
+        instance_.EndLabel(commands);
+    }
     /// @return The validation layer's messages since the last call; empty without validation.
     std::vector<std::string> TakeValidationMessages() {
         return instance_.TakeMessages();
@@ -116,6 +125,10 @@ class DeviceContext {
     VkDevice Device() const {
         return device_;
     }
+    /// @return The GPU profiler, or null when GPU zones record nothing.
+    GpuProfiler* Profiler() const {
+        return profiler_.get();
+    }
     VmaAllocator Allocator() const {
         return allocator_;
     }
@@ -132,6 +145,7 @@ class DeviceContext {
     std::uint64_t maxBufferSize_ = 0;
     VkDevice device_ = VK_NULL_HANDLE;
     VmaAllocator allocator_ = VK_NULL_HANDLE;
+    std::unique_ptr<GpuProfiler> profiler_;
     std::vector<std::unique_ptr<Queue>> queues_;
     Queue* main_ = nullptr;
     Queue* compute_ = nullptr;

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/cuda.cpp

@@ -249,6 +249,7 @@ CUdeviceptr CudaInterop::Map(const Buffer& buffer) {
     if (found != mappings_.end()) {
         return found->second.pointer;
     }
+    ERNIE_ZONE("Map memory into CUDA");
     ExternalHandle handle = buffer.Export();
     MemoryHandleDesc memory{.type = kMemoryHandleType,
                             .handle = {},
@@ -359,6 +360,7 @@ Ticket CudaInterop::Assign(const DeviceColumn& column, const Tensor& tensor, CUs
 }
 
 std::unique_ptr<DeviceColumn> CudaInterop::Wrap(const Tensor& tensor, std::string_view name) {
+    ERNIE_ZONE("Wrap a CUDA tensor");
     CheckOnDevice(tensor, "Wrapping " + std::string(name));
     const auto pointer = reinterpret_cast<CUdeviceptr>(tensor.Data());
     const std::uint64_t bytes = tensor.Bytes();

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/device.h

@@ -35,6 +35,8 @@ struct DeviceCapabilities {
     bool memoryBudget = false;
     /// What went wrong on device loss.
     bool deviceFault = false;
+    /// The device's and host's clocks read together, so GPU zones line up with CPU zones.
+    bool calibratedTimestamps = false;
     bool sparseResidency = false;
 };
 

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/image.h

@@ -45,6 +45,7 @@ struct ImageDescription {
     glm::uvec3 extent{1, 1, 1};
     std::uint32_t mips = 1;
     ImageUsage usage = ImageUsage::Sampled;
+    bool operator==(const ImageDescription&) const = default;
 };
 
 /// @brief An image, its memory and a view of it all. Images stay in the general layout, which

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/instance.cpp

@@ -100,6 +100,10 @@ Instance::Instance(const InstanceOptions& options) {
             load("vkDestroyDebugUtilsMessengerEXT"));
         setName_ = reinterpret_cast<PFN_vkSetDebugUtilsObjectNameEXT>(
             load("vkSetDebugUtilsObjectNameEXT"));
+        beginLabel_ = reinterpret_cast<PFN_vkCmdBeginDebugUtilsLabelEXT>(
+            load("vkCmdBeginDebugUtilsLabelEXT"));
+        endLabel_ =
+            reinterpret_cast<PFN_vkCmdEndDebugUtilsLabelEXT>(load("vkCmdEndDebugUtilsLabelEXT"));
         const VkDebugUtilsMessengerCreateInfoEXT messenger{
             .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
             .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
@@ -134,6 +138,22 @@ void Instance::Name(VkDevice device, VkObjectType type, std::uint64_t handle,
     setName_(device, &info);
 }
 
+void Instance::BeginLabel(VkCommandBuffer commands, std::string_view name) const {
+    if (beginLabel_ == nullptr) {
+        return;
+    }
+    const std::string text(name);
+    const VkDebugUtilsLabelEXT label{.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT,
+                                     .pLabelName = text.c_str()};
+    beginLabel_(commands, &label);
+}
+
+void Instance::EndLabel(VkCommandBuffer commands) const {
+    if (endLabel_ != nullptr) {
+        endLabel_(commands);
+    }
+}
+
 std::vector<VkPhysicalDevice> Instance::PhysicalDevices() const {
     std::uint32_t count = 0;
     vkEnumeratePhysicalDevices(instance_, &count, nullptr);

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/instance.h

@@ -41,6 +41,10 @@ class Instance {
     /// @brief Names a device's object, when validating; otherwise does nothing.
     void Name(VkDevice device, VkObjectType type, std::uint64_t handle,
               std::string_view name) const;
+    /// @brief Opens a named region of commands for captures and validation messages, when
+    /// validating; otherwise does nothing.
+    void BeginLabel(VkCommandBuffer commands, std::string_view name) const;
+    void EndLabel(VkCommandBuffer commands) const;
 
   private:
     static VKAPI_ATTR VkBool32 VKAPI_CALL Report(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
@@ -54,6 +58,8 @@ class Instance {
     // with validation have these.
     PFN_vkDestroyDebugUtilsMessengerEXT destroyMessenger_ = nullptr;
     PFN_vkSetDebugUtilsObjectNameEXT setName_ = nullptr;
+    PFN_vkCmdBeginDebugUtilsLabelEXT beginLabel_ = nullptr;
+    PFN_vkCmdEndDebugUtilsLabelEXT endLabel_ = nullptr;
     std::mutex mutex_;
     std::vector<std::string> messages_;
 };

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/kernel.cpp

@@ -14,6 +14,8 @@ ComputeKernel::ComputeKernel(DeviceContext& context, std::span<const std::uint32
                              const BindlessHeap* heap, std::string_view entryPoint)
     : device_(context.Device()), name_(name), parameterBytes_(parameterBytes),
       heap_(heap != nullptr ? heap->Set() : VK_NULL_HANDLE) {
+    ERNIE_ZONE("Create compute pipeline");
+    ERNIE_ZONE_TEXT(name_);
     if (parameterBytes > context.Limits().maxPushConstantsSize) {
         throw DeviceError(DeviceErrorKind::Unsupported,
                           name_ + " passes more bytes per dispatch than the device allows");

ernie_renderer-0.2.0.dev82/ernie/device/profile.cpp

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file profile.cpp
+/// @brief Tracy's host-calibrated Vulkan context, and its zones around commands.
+#include "ernie/device/profile.h"
+
+#include "ernie/device/context.h"
+
+#if ERNIE_TRACY
+#include <tracy/TracyVulkan.hpp>
+
+#include <cstring>
+#endif
+
+namespace ernie {
+
+std::unique_ptr<GpuProfiler> GpuProfiler::Create(const DeviceContext& context) {
+#if ERNIE_TRACY
+    if (!context.Capabilities().calibratedTimestamps) {
+        return nullptr;
+    }
+    tracy::VkCtx* tracy = tracy::CreateVkContext(
+        context.Physical(), context.Device(), vkResetQueryPool,
+        vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, vkGetCalibratedTimestampsEXT);
+    const std::string& name = context.Info().name;
+    tracy->Name(name.c_str(), static_cast<std::uint16_t>(name.size()));
+    return std::unique_ptr<GpuProfiler>(new GpuProfiler(tracy));
+#else
+    static_cast<void>(context);
+    return nullptr;
+#endif
+}
+
+GpuProfiler::~GpuProfiler() {
+#if ERNIE_TRACY
+    tracy::DestroyVkContext(static_cast<tracy::VkCtx*>(tracy_));
+#endif
+}
+
+void GpuProfiler::Collect() {
+#if ERNIE_TRACY
+    static_cast<tracy::VkCtx*>(tracy_)->Collect(VK_NULL_HANDLE);
+#endif
+}
+
+GpuZone::GpuZone(const DeviceContext& context, VkCommandBuffer commands, std::string_view name)
+    : zone_(nullptr, [](void*) {}) {
+#if ERNIE_TRACY
+    GpuProfiler* profiler = context.Profiler();
+    if (profiler == nullptr) {
+        return;
+    }
+    // A transient zone: its name is copied, so it may be built at run time.
+    static constexpr char kFunction[] = "GpuZone";
+    zone_ = {new tracy::VkCtxScope(static_cast<tracy::VkCtx*>(profiler->Tracy()), __LINE__,
+                                   __FILE__, std::strlen(__FILE__), kFunction,
+                                   sizeof(kFunction) - 1, name.data(), name.size(), commands, true),
+             [](void* zone) { delete static_cast<tracy::VkCtxScope*>(zone); }};
+#else
+    static_cast<void>(context);
+    static_cast<void>(commands);
+    static_cast<void>(name);
+#endif
+}
+
+GpuZone::~GpuZone() = default;
+
+}  // namespace ernie

ernie_renderer-0.2.0.dev82/ernie/device/profile.h

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file profile.h
+/// @brief GPU profiling zones: timestamps around commands, shown in Tracy beside the CPU zones
+/// with -DERNIE_TRACY=ON. Nothing is recorded in other builds, or on devices without
+/// `DeviceCapabilities::calibratedTimestamps`.
+///
+///     // The rest of the scope's commands; the name may be built at run time.
+///     ERNIE_GPU_ZONE(context, commands, pass.name);
+///
+/// References:
+/// - B. Taudul, "Tracy Profiler", its Vulkan GPU zones (TracyVulkan.hpp), host calibrated.
+///   https://github.com/wolfpld/tracy
+#pragma once
+
+#include "ernie/device/vulkan.h"
+#include "ernie/util/profiler.h"
+
+#include <memory>
+#include <string_view>
+
+namespace ernie {
+
+class DeviceContext;
+
+/// @brief A device's GPU timeline for Tracy: timestamp queries reset from the host and clocks
+/// read with the host's, collected as the context collects retired work.
+class GpuProfiler {
+  public:
+    /// @return The profiler, or null in builds without Tracy and on devices that cannot
+    /// calibrate their clock.
+    static std::unique_ptr<GpuProfiler> Create(const DeviceContext& context);
+    ~GpuProfiler();
+    GpuProfiler(const GpuProfiler&) = delete;
+    GpuProfiler& operator=(const GpuProfiler&) = delete;
+
+    /// @brief Reads the timestamps of finished zones.
+    void Collect();
+    /// @return Tracy's Vulkan context.
+    void* Tracy() const {
+        return tracy_;
+    }
+
+  private:
+    explicit GpuProfiler(void* tracy) : tracy_(tracy) {}
+    void* tracy_;
+};
+
+/// @brief Timestamps around the rest of the scope's commands, as one GPU zone.
+class GpuZone {
+  public:
+    GpuZone(const DeviceContext& context, VkCommandBuffer commands, std::string_view name);
+    ~GpuZone();
+    GpuZone(const GpuZone&) = delete;
+    GpuZone& operator=(const GpuZone&) = delete;
+
+  private:
+    /// Tracy's zone, when recording.
+    std::unique_ptr<void, void (*)(void*)> zone_;
+};
+
+}  // namespace ernie
+
+#define ERNIE_GPU_ZONE(context, commands, name)                                                    \
+    const ::ernie::GpuZone ERNIE_PROFILE_CONCAT(ernieGpuZone, __LINE__)((context), (commands),     \
+                                                                        (name))

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/queue.cpp

@@ -35,6 +35,7 @@ void Ticket::Wait() const {
     if (timeline == nullptr) {
         return;
     }
+    ERNIE_ZONE("Wait for the GPU");
     const VkSemaphore semaphore = timeline->Handle();
     const VkSemaphoreWaitInfo wait{.sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
                                    .semaphoreCount = 1,

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/shader_compiler.cpp

@@ -3,6 +3,8 @@
 /// @brief Compiling through Slang's API: a session per compile, modules loaded from source.
 #include "ernie/device/shader_compiler.h"
 
+#include "ernie/util/profiler.h"
+
 #include <slang-com-ptr.h>
 #include <slang.h>
 
@@ -93,6 +95,7 @@ ShaderCompiler::~ShaderCompiler() = default;
 
 std::vector<std::uint32_t> ShaderCompiler::Spirv(std::span<const ShaderModule> modules,
                                                  std::string_view entryPoint) const {
+    ERNIE_ZONE("Compile Slang to SPIR-V");
     const Slang::ComPtr<slang::IBlob> code =
         session_->Compile(modules, entryPoint, SLANG_SPIRV, "spirv_1_6");
     std::vector<std::uint32_t> words(code->getBufferSize() / 4);
@@ -102,6 +105,7 @@ std::vector<std::uint32_t> ShaderCompiler::Spirv(std::span<const ShaderModule> m
 
 std::string ShaderCompiler::Wgsl(std::span<const ShaderModule> modules,
                                  std::string_view entryPoint) const {
+    ERNIE_ZONE("Compile Slang to WGSL");
     return Text(session_->Compile(modules, entryPoint, SLANG_WGSL, "wgsl").get());
 }
 

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/staging.cpp

@@ -74,6 +74,8 @@ Ticket Uploader::Flush(std::span<const Ticket> waits) {
     if (copies_.empty()) {
         return {};
     }
+    ERNIE_ZONE("Upload");
+    ERNIE_PLOT("Uploaded bytes", pending_);
     const Ticket ticket = queue_.Submit(
         [&](VkCommandBuffer commands) {
             BeforeCopies(commands);
@@ -132,6 +134,7 @@ Readback::~Readback() {
 }
 
 std::span<const std::byte> Readback::Bytes() {
+    ERNIE_ZONE("Read back");
     ticket_.Wait();
     host_->Invalidate(0, host_->Size());
     return host_->Mapped();

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/vulkan.cpp

@@ -30,6 +30,8 @@ const std::array kExtensions{
     Extension{kExternalSemaphoreExtension, &DeviceCapabilities::externalTimeline},
     Extension{VK_EXT_MEMORY_BUDGET_EXTENSION_NAME, &DeviceCapabilities::memoryBudget},
     Extension{VK_EXT_DEVICE_FAULT_EXTENSION_NAME, &DeviceCapabilities::deviceFault},
+    Extension{VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME,
+              &DeviceCapabilities::calibratedTimestamps},
 };
 
 /// @brief A feature bit Ernie requires: its name, for the error naming it, and where it lives.
@@ -207,13 +209,17 @@ PhysicalDevice Probe(VkPhysicalDevice handle) {
                     .externalMemory = true,
                     .externalTimeline = true,
                     .memoryBudget = true,
-                    .deviceFault = true};
+                    .deviceFault = true,
+                    .calibratedTimestamps = true};
     for (const Extension& extension : kExtensions) {
         capabilities.*extension.capability &= has(extension.name);
     }
     capabilities.rayQuery &= features.accelerationStructure.accelerationStructure == VK_TRUE &&
                              features.rayQuery.rayQuery == VK_TRUE;
     capabilities.deviceFault &= features.fault.deviceFault == VK_TRUE;
+    // Timestamp queries reset from the host, so GPU zones need no command buffers of their own.
+    capabilities.calibratedTimestamps &=
+        features.v12.hostQueryReset == VK_TRUE && p.limits.timestampComputeAndGraphics == VK_TRUE;
     capabilities.externalMemory = capabilities.externalMemory && SharesMemory(handle);
     capabilities.externalTimeline = capabilities.externalTimeline && SharesTimelines(handle);
     capabilities.shaderInt64 = features.core.features.shaderInt64 == VK_TRUE;
@@ -250,6 +256,7 @@ FeatureChain PhysicalDevice::EnabledFeatures() const {
     enabled.accelerationStructure.accelerationStructure = bit(capabilities.rayQuery);
     enabled.rayQuery.rayQuery = bit(capabilities.rayQuery);
     enabled.fault.deviceFault = bit(capabilities.deviceFault);
+    enabled.v12.hostQueryReset = bit(capabilities.calibratedTimestamps);
     enabled.Link(capabilities.rayQuery, capabilities.rayQuery, capabilities.deviceFault);
     return enabled;
 }

{ernie_renderer-0.2.0.dev76 → ernie_renderer-0.2.0.dev82}/ernie/device/vulkan.h

@@ -7,6 +7,7 @@
 
 #include "ernie/device/device.h"
 #include "ernie/util/log.h"
+#include "ernie/util/profiler.h"
 
 #include <vk_mem_alloc.h>
 #include <volk.h>

ernie_renderer-0.2.0.dev82/ernie/graph/CMakeLists.txt

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_library(ernie_graph OBJECT dependencies.cpp graph.cpp pool.cpp)
+target_link_libraries(
+    ernie_graph
+    PUBLIC ernie_device
+    PRIVATE ernie_volk ernie_vma ernie_build_options
+)

ernie_renderer-0.2.0.dev82/ernie/graph/blackboard.h

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file blackboard.h
+/// @brief A per-graph store where passes leave structs of handles for later passes to find by
+/// type, rather than in renderer members.
+///
+///     struct Hits { graph::Image ids, depth; };
+///     graph.Board().Put(Hits{ids, depth});
+///     // Later, in another feature's setup:
+///     const Hits& hits = graph.Board().Get<Hits>();
+///
+/// References:
+/// - Google, Filament's FrameGraph Blackboard. https://github.com/google/filament
+#pragma once
+
+#include <any>
+#include <stdexcept>
+#include <string>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+
+namespace ernie::graph {
+
+/// @brief One value of each type, such as a feature's handles.
+class Blackboard {
+  public:
+    /// @brief Stores a value, replacing one of the same type.
+    /// @return The stored value.
+    template <typename T> T& Put(T value) {
+        std::any& slot = values_[typeid(T)];
+        slot = std::move(value);
+        return std::any_cast<T&>(slot);
+    }
+    /// @return The value of type `T`, or null.
+    template <typename T> T* Find() {
+        const auto found = values_.find(typeid(T));
+        return found == values_.end() ? nullptr : std::any_cast<T>(&found->second);
+    }
+    template <typename T> const T* Find() const {
+        const auto found = values_.find(typeid(T));
+        return found == values_.end() ? nullptr : std::any_cast<T>(&found->second);
+    }
+    /// @return The value of type `T`.
+    /// @throws std::out_of_range if none was put.
+    template <typename T> T& Get() {
+        if (T* value = Find<T>()) {
+            return *value;
+        }
+        throw std::out_of_range(std::string("The blackboard has no ") + typeid(T).name());
+    }
+    template <typename T> bool Has() const {
+        return values_.contains(typeid(T));
+    }
+    void Clear() {
+        values_.clear();
+    }
+
+  private:
+    std::unordered_map<std::type_index, std::any> values_;
+};
+
+}  // namespace ernie::graph