Merge remote-tracking branch 'upstream/next' into zitai/next-dev

* upstream/next: (40 commits) trying to fix windows build trying to fix windows build Update ext minor minor update to nvtt flags use tmpfile to make cuda backend safer Update ext better unreachable code removal in dce merge edges in CFG visualization better CFG visualization refactored ray query inst better dce unreachable code elimination in dce pass fix dom tree tweak cfg visualizer add dom tree compute pass wip: dominance Fix windows mysterious, uncharted bug Fix build fix llvm link ...
Learning-Ray-Tracing-From-Zero · Jan 9, 2025 · 4d14601 · 4d14601
2 parents f3da0b2 + 6d32dd0
commit 4d14601
Show file tree

Hide file tree

Showing 79 changed files with 48,076 additions and 46,096 deletions.
diff --git a/include/luisa/backends/ext/dx_hdr_ext.hpp b/include/luisa/backends/ext/dx_hdr_ext.hpp
@@ -6,4 +6,23 @@ namespace luisa::compute {
 Swapchain DXHDRExt::create_swapchain(const Stream &stream, const DXSwapchainOption &option) noexcept {
     return Swapchain{stream.device(), create_swapchain(option, stream.handle())};
 }
+void DXHDRExt::set_color_space(
+    Swapchain const &swapchain,
+    ColorSpace const &color_space) const noexcept {
+    set_color_space(swapchain.handle(), color_space);
+}
+auto DXHDRExt::set_hdr_meta_data(
+    Swapchain const &swapchain,
+    float max_output_nits,
+    float min_output_nits,
+    float max_cll,
+    float max_fall,
+    const DisplayChromaticities *custom_chroma) noexcept -> Meta {
+    return set_hdr_meta_data(
+        swapchain.handle(),
+        max_output_nits,
+        min_output_nits,
+        max_cll,
+        max_fall);
+}
 }// namespace luisa::compute
diff --git a/include/luisa/backends/ext/dx_hdr_ext_interface.h b/include/luisa/backends/ext/dx_hdr_ext_interface.h
@@ -64,7 +64,6 @@ class DXHDRExt : public DeviceExtension {
     };
 
     struct Meta {
-        ColorSpace color_space;
         DisplayChromaticities chromaticities;
     };
 
@@ -80,8 +79,20 @@ class DXHDRExt : public DeviceExtension {
         const DisplayChromaticities *custom_chroma = nullptr) noexcept = 0;
     static constexpr luisa::string_view name = "DXHDRExt";
     [[nodiscard]] Swapchain create_swapchain(const Stream &stream, const DXSwapchainOption &option) noexcept;
-    [[nodiscard]] virtual bool device_support_hdr() const = 0;
-
+    [[nodiscard]] virtual bool device_support_hdr() const noexcept = 0;
+    virtual void set_color_space(
+        uint64_t handle,
+        ColorSpace const &color_space) const noexcept = 0;
+    void set_color_space(
+        Swapchain const& swapchain,
+        ColorSpace const &color_space) const noexcept;
+    Meta set_hdr_meta_data(
+        Swapchain const& swapchain,
+        float max_output_nits = 1000.0f,
+        float min_output_nits = 0.001f,
+        float max_cll = 2000.0f,
+        float max_fall = 500.0f,
+        const DisplayChromaticities *custom_chroma = nullptr) noexcept;
 protected:
     ~DXHDRExt() = default;
 };

diff --git a/include/luisa/backends/ext/tex_compress_ext.h b/include/luisa/backends/ext/tex_compress_ext.h
@@ -2,10 +2,14 @@
 
 #include <luisa/runtime/rhi/device_interface.h>
 #include <luisa/runtime/image.h>
+
 namespace luisa::compute {
+
 template<typename T>
 class BufferView;
+
 class Stream;
+
 template<typename T>
 class Image;
 
@@ -16,11 +20,22 @@ class TexCompressExt : public DeviceExtension {
 
 public:
     static constexpr luisa::string_view name = "TexCompressExt";
+
+// avoid macro pollution from X11
+#ifdef Success
+#undef Success
+#endif
+
+#ifdef Failed
+#undef Failed
+#endif
+
     enum class Result : int8_t {
         NotImplemented = -1,
         Success = 0,
         Failed = 1
     };
+
     // TODO: astc
     virtual Result compress_bc6h(Stream &stream,
                                  const ImageView<float> &src,

diff --git a/include/luisa/core/logging.h b/include/luisa/core/logging.h
@@ -24,13 +24,22 @@ using spdlog::logger;
 using log_level = spdlog::level::level_enum;
 
 namespace detail {
+
 [[nodiscard]] LC_CORE_API luisa::logger &default_logger() noexcept;
+
+[[deprecated("Please use `luisa::default_logger_set_sink`")]]
 LC_CORE_API void set_sink(spdlog::sink_ptr sink) noexcept;
+
+LC_CORE_API void default_logger_set_sink(spdlog::sink_ptr sink) noexcept;
+LC_CORE_API void default_logger_add_sink(spdlog::sink_ptr sink) noexcept;
+
 LC_CORE_API spdlog::sink_ptr create_sink_with_callback(void (*callback)(LCLoggerMessage)) noexcept;
+
 LC_CORE_API spdlog::sink_ptr create_sink_with_callback(
     luisa::function<void(const char *level,
                          const char *message)>
         callback) noexcept;
+
 }// namespace detail
 
 template<typename... Args>

diff --git a/include/luisa/luisa-compute.h b/include/luisa/luisa-compute.h
@@ -206,12 +206,15 @@
 #include <luisa/xir/ilist.h>
 #include <luisa/xir/instruction.h>
 #include <luisa/xir/instructions/alloca.h>
+#include <luisa/xir/instructions/arithmetic.h>
 #include <luisa/xir/instructions/assert.h>
 #include <luisa/xir/instructions/assume.h>
+#include <luisa/xir/instructions/atomic.h>
 #include <luisa/xir/instructions/branch.h>
 #include <luisa/xir/instructions/break.h>
 #include <luisa/xir/instructions/call.h>
 #include <luisa/xir/instructions/cast.h>
+#include <luisa/xir/instructions/clock.h>
 #include <luisa/xir/instructions/continue.h>
 #include <luisa/xir/instructions/gep.h>
 #include <luisa/xir/instructions/if.h>
@@ -221,20 +224,26 @@
 #include <luisa/xir/instructions/outline.h>
 #include <luisa/xir/instructions/phi.h>
 #include <luisa/xir/instructions/print.h>
+#include <luisa/xir/instructions/raster_discard.h>
 #include <luisa/xir/instructions/ray_query.h>
+#include <luisa/xir/instructions/resource.h>
 #include <luisa/xir/instructions/return.h>
 #include <luisa/xir/instructions/store.h>
 #include <luisa/xir/instructions/switch.h>
+#include <luisa/xir/instructions/thread_group.h>
 #include <luisa/xir/instructions/unreachable.h>
 #include <luisa/xir/metadata.h>
 #include <luisa/xir/metadata/comment.h>
 #include <luisa/xir/metadata/location.h>
 #include <luisa/xir/metadata/name.h>
 #include <luisa/xir/module.h>
-#include <luisa/xir/passes/extract_cfg.h>
+#include <luisa/xir/passes/dce.h>
+#include <luisa/xir/passes/dom_tree.h>
 #include <luisa/xir/passes/outline.h>
 #include <luisa/xir/passes/sink_alloca.h>
+#include <luisa/xir/passes/trace_gep.h>
 #include <luisa/xir/pool.h>
+#include <luisa/xir/special_register.h>
 #include <luisa/xir/translators/ast2xir.h>
 #include <luisa/xir/translators/json2xir.h>
 #include <luisa/xir/translators/xir2json.h>

diff --git a/include/luisa/xir/basic_block.h b/include/luisa/xir/basic_block.h
@@ -13,10 +13,65 @@ class LC_XIR_API BasicBlock : public DerivedValue<DerivedValueTag::BASIC_BLOCK>
 private:
     InstructionList _instructions;
 
+private:
+    void _do_traverse_predecessors(bool exclude_self, void *ctx, void (*visit)(void *, BasicBlock *)) noexcept;
+    void _do_traverse_successors(bool exclude_self, void *ctx, void (*visit)(void *, BasicBlock *)) noexcept;
+
 public:
     BasicBlock() noexcept;
     [[nodiscard]] auto &instructions() noexcept { return _instructions; }
     [[nodiscard]] auto &instructions() const noexcept { return _instructions; }
+
+    [[nodiscard]] bool is_terminated() const noexcept;
+    [[nodiscard]] TerminatorInstruction *terminator() noexcept;
+    [[nodiscard]] const TerminatorInstruction *terminator() const noexcept;
+
+    template<typename Visit>
+    void traverse_predecessors(bool exclude_self, Visit &&visit) noexcept {
+        _do_traverse_predecessors(
+            exclude_self, &visit, [](void *ctx, BasicBlock *bb) noexcept {
+                (*static_cast<Visit *>(ctx))(bb);
+            });
+    }
+
+    template<typename Visit>
+    void traverse_predecessors(bool exclude_self, Visit &&visit) const noexcept {
+        const_cast<BasicBlock *>(this)->traverse_predecessors(
+            exclude_self, [&visit](const BasicBlock *bb) noexcept {
+                visit(bb);
+            });
+    }
+
+    template<typename Visit>
+    void traverse_successors(bool exclude_self, Visit &&visit) noexcept {
+        _do_traverse_successors(
+            exclude_self, &visit, [](void *ctx, BasicBlock *bb) noexcept {
+                (*static_cast<Visit *>(ctx))(bb);
+            });
+    }
+
+    template<typename Visit>
+    void traverse_successors(bool exclude_self, Visit &&visit) const noexcept {
+        const_cast<BasicBlock *>(this)->traverse_successors(
+            exclude_self, [&visit](const BasicBlock *bb) noexcept {
+                visit(bb);
+            });
+    }
+
+    template<typename Visit>
+    void traverse_instructions(Visit &&visit) noexcept {
+        for (auto &inst : _instructions) {
+            visit(&inst);
+        }
+    }
+
+    template<typename Visit>
+    void traverse_instructions(Visit &&visit) const noexcept {
+        const_cast<BasicBlock *>(this)->traverse_instructions(
+            [&visit](const Instruction *inst) noexcept {
+                visit(inst);
+            });
+    }
 };
 
 }// namespace luisa::compute::xir
diff --git a/include/luisa/xir/builder.h b/include/luisa/xir/builder.h
@@ -3,12 +3,15 @@
 #include <luisa/ast/type_registry.h>
 #include <luisa/xir/constant.h>
 #include <luisa/xir/instructions/alloca.h>
+#include <luisa/xir/instructions/arithmetic.h>
 #include <luisa/xir/instructions/assert.h>
 #include <luisa/xir/instructions/assume.h>
+#include <luisa/xir/instructions/atomic.h>
 #include <luisa/xir/instructions/branch.h>
 #include <luisa/xir/instructions/break.h>
 #include <luisa/xir/instructions/call.h>
 #include <luisa/xir/instructions/cast.h>
+#include <luisa/xir/instructions/clock.h>
 #include <luisa/xir/instructions/continue.h>
 #include <luisa/xir/instructions/gep.h>
 #include <luisa/xir/instructions/if.h>
@@ -19,11 +22,17 @@
 #include <luisa/xir/instructions/phi.h>
 #include <luisa/xir/instructions/print.h>
 #include <luisa/xir/instructions/ray_query.h>
+#include <luisa/xir/instructions/raster_discard.h>
 #include <luisa/xir/instructions/return.h>
+#include <luisa/xir/instructions/resource.h>
 #include <luisa/xir/instructions/store.h>
 #include <luisa/xir/instructions/switch.h>
+#include <luisa/xir/instructions/thread_group.h>
 #include <luisa/xir/instructions/unreachable.h>
 
+namespace luisa::compute::xir {
+class ClockInst;
+}// namespace luisa::compute::xir
 namespace luisa::compute::xir {
 
 class LC_XIR_API Builder {
@@ -68,6 +77,7 @@ class LC_XIR_API Builder {
     UnreachableInst *unreachable_(luisa::string_view message = {}) noexcept;
     ReturnInst *return_(Value *value) noexcept;
     ReturnInst *return_void() noexcept;
+    RasterDiscardInst *raster_discard() noexcept;
 
     AssertInst *assert_(Value *condition, luisa::string_view message = {}) noexcept;
     AssumeInst *assume_(Value *condition, luisa::string_view message = {}) noexcept;
@@ -78,6 +88,24 @@ class LC_XIR_API Builder {
     IntrinsicInst *call(const Type *type, IntrinsicOp op, luisa::span<Value *const> arguments) noexcept;
     IntrinsicInst *call(const Type *type, IntrinsicOp op, std::initializer_list<Value *> arguments) noexcept;
 
+    AtomicInst *call(const Type *type, AtomicOp op, Value *base, luisa::span<Value *const> indices, luisa::span<Value *const> values) noexcept;
+    AtomicInst *call(const Type *type, AtomicOp op, Value *base, luisa::span<Value *const> indices, std::initializer_list<Value *> values) noexcept;
+
+    ThreadGroupInst *call(const Type *type, ThreadGroupOp op, luisa::span<Value *const> operands) noexcept;
+    ThreadGroupInst *call(const Type *type, ThreadGroupOp op, std::initializer_list<Value *> operands) noexcept;
+
+    ArithmeticInst *call(const Type *type, ArithmeticOp op, luisa::span<Value *const> operands) noexcept;
+    ArithmeticInst *call(const Type *type, ArithmeticOp op, std::initializer_list<Value *> operands) noexcept;
+
+    ResourceQueryInst *call(const Type *type, ResourceQueryOp op, luisa::span<Value *const> operands) noexcept;
+    ResourceQueryInst *call(const Type *type, ResourceQueryOp op, std::initializer_list<Value *> operands) noexcept;
+
+    ResourceReadInst *call(const Type *type, ResourceReadOp op, luisa::span<Value *const> operands) noexcept;
+    ResourceReadInst *call(const Type *type, ResourceReadOp op, std::initializer_list<Value *> operands) noexcept;
+
+    ResourceWriteInst *call(ResourceWriteOp op, luisa::span<Value *const> operands) noexcept;
+    ResourceWriteInst *call(ResourceWriteOp op, std::initializer_list<Value *> operands) noexcept;
+
     Instruction *static_cast_(const Type *type, Value *value) noexcept;
     CastInst *bit_cast_(const Type *type, Value *value) noexcept;
 
@@ -100,8 +128,32 @@ class LC_XIR_API Builder {
     LoadInst *load(const Type *type, Value *variable) noexcept;
     StoreInst *store(Value *variable, Value *value) noexcept;
 
+    ClockInst *clock() noexcept;
+
     OutlineInst *outline() noexcept;
-    RayQueryInst *ray_query(Value *query_object) noexcept;
+
+    RayQueryLoopInst *ray_query_loop() noexcept;
+    RayQueryDispatchInst *ray_query_dispatch(Value *query_object) noexcept;
+    RayQueryObjectReadInst *call(const Type *type, RayQueryObjectReadOp op, luisa::span<Value *const> operands) noexcept;
+    RayQueryObjectReadInst *call(const Type *type, RayQueryObjectReadOp op, std::initializer_list<Value *> operands) noexcept;
+    RayQueryObjectWriteInst *call(RayQueryObjectWriteOp op, luisa::span<Value *const> operands) noexcept;
+    RayQueryObjectWriteInst *call(RayQueryObjectWriteOp op, std::initializer_list<Value *> operands) noexcept;
+
+    AtomicInst *atomic_fetch_add(const Type *type, Value *base, luisa::span<Value *const> indices, Value *value) noexcept;
+    AtomicInst *atomic_fetch_sub(const Type *type, Value *base, luisa::span<Value *const> indices, Value *value) noexcept;
+    AtomicInst *atomic_fetch_and(const Type *type, Value *base, luisa::span<Value *const> indices, Value *value) noexcept;
+    AtomicInst *atomic_fetch_or(const Type *type, Value *base, luisa::span<Value *const> indices, Value *value) noexcept;
+    AtomicInst *atomic_fetch_xor(const Type *type, Value *base, luisa::span<Value *const> indices, Value *value) noexcept;
+    AtomicInst *atomic_fetch_min(const Type *type, Value *base, luisa::span<Value *const> indices, Value *value) noexcept;
+    AtomicInst *atomic_fetch_max(const Type *type, Value *base, luisa::span<Value *const> indices, Value *value) noexcept;
+    AtomicInst *atomic_exchange(const Type *type, Value *base, luisa::span<Value *const> indices, Value *value) noexcept;
+    AtomicInst *atomic_compare_exchange(const Type *type, Value *base, luisa::span<Value *const> indices, Value *expected, Value *desired) noexcept;
+
+    ThreadGroupInst *shader_execution_reorder() noexcept;
+    ThreadGroupInst *shader_execution_reorder(Value *hint, Value *hint_bits) noexcept;
+    ThreadGroupInst *synchronize_block() noexcept;
+    ThreadGroupInst *raster_quad_ddx(const Type *type, Value *value) noexcept;
+    ThreadGroupInst *raster_quad_ddy(const Type *type, Value *value) noexcept;
 };
 
 }// namespace luisa::compute::xir