From 603c861532ed1a89254556ff84bbe121bd700765 Mon Sep 17 00:00:00 2001 From: Fernando Sahmkow Date: Sun, 5 Jan 2020 15:23:24 -0400 Subject: [PATCH] Shader_IR: Implement initial code for tracking indexed samplers. --- src/video_core/shader/node.h | 48 +++++++++++++++++ src/video_core/shader/node_helper.h | 6 +++ src/video_core/shader/shader_ir.h | 3 ++ src/video_core/shader/track.cpp | 82 +++++++++++++++++++++++++++++ 4 files changed, 139 insertions(+) diff --git a/src/video_core/shader/node.h b/src/video_core/shader/node.h index 075c7d07ce..b370df8f94 100644 --- a/src/video_core/shader/node.h +++ b/src/video_core/shader/node.h @@ -230,6 +230,12 @@ using Node = std::shared_ptr; using Node4 = std::array; using NodeBlock = std::vector; +class BindlessSamplerNode; +class ArraySamplerNode; + +using TrackSamplerData = std::variant; +using TrackSampler = std::shared_ptr; + class Sampler { public: /// This constructor is for bound samplers @@ -288,6 +294,48 @@ private: bool is_bindless{}; ///< Whether this sampler belongs to a bindless texture or not. }; +/// Represents a tracked bindless sampler into a direct const buffer +class ArraySamplerNode final { +public: + explicit ArraySamplerNode(u32 index, u32 base_offset, u32 bindless_var) + : index{index}, base_offset{base_offset}, bindless_var{bindless_var} {} + + u32 GetIndex() const { + return index; + } + + u32 GetBaseOffset() const { + return base_offset; + } + + u32 GetIndexVar() const { + return bindless_var; + } + +private: + u32 index; + u32 base_offset; + u32 bindless_var; +}; + +/// Represents a tracked bindless sampler into a direct const buffer +class BindlessSamplerNode final { +public: + explicit BindlessSamplerNode(u32 index, u32 offset) : index{index}, offset{offset} {} + + u32 GetIndex() const { + return index; + } + + u32 GetOffset() const { + return offset; + } + +private: + u32 index; + u32 offset; +}; + class Image final { public: /// This constructor is for bound images diff --git a/src/video_core/shader/node_helper.h b/src/video_core/shader/node_helper.h index 0c2aa749b5..11231bbea8 100644 --- a/src/video_core/shader/node_helper.h +++ b/src/video_core/shader/node_helper.h @@ -45,6 +45,12 @@ Node MakeNode(Args&&... args) { return std::make_shared(T(std::forward(args)...)); } +template +TrackSampler MakeTrackSampler(Args&&... args) { + static_assert(std::is_convertible_v); + return std::make_shared(T(std::forward(args)...)); +} + template Node Operation(OperationCode code, Args&&... args) { if constexpr (sizeof...(args) == 0) { diff --git a/src/video_core/shader/shader_ir.h b/src/video_core/shader/shader_ir.h index 92c24247da..d85f14c97b 100644 --- a/src/video_core/shader/shader_ir.h +++ b/src/video_core/shader/shader_ir.h @@ -388,6 +388,9 @@ private: std::tuple TrackCbuf(Node tracked, const NodeBlock& code, s64 cursor) const; + std::tuple TrackSampler(Node tracked, const NodeBlock& code, + s64 cursor) const; + std::optional TrackImmediate(Node tracked, const NodeBlock& code, s64 cursor) const; std::pair TrackRegister(const GprNode* tracked, const NodeBlock& code, diff --git a/src/video_core/shader/track.cpp b/src/video_core/shader/track.cpp index 165c793308..69a6773948 100644 --- a/src/video_core/shader/track.cpp +++ b/src/video_core/shader/track.cpp @@ -8,6 +8,7 @@ #include "common/common_types.h" #include "video_core/shader/node.h" +#include "video_core/shader/node_helper.h" #include "video_core/shader/shader_ir.h" namespace VideoCommon::Shader { @@ -37,6 +38,87 @@ std::pair FindOperation(const NodeBlock& code, s64 cursor, } } // Anonymous namespace +std::optional> DecoupleIndirectRead(const OperationNode& operation) { + if (operation.GetCode() != OperationCode::UAdd) { + return std::nullopt; + } + Node gpr{}; + Node offset{}; + if (operation.GetOperandsCount() != 2) { + return std::nullopt; + } + for (std::size_t i = 0; i < operation.GetOperandsCount(); i++) { + Node operand = operation[i]; + if (std::holds_alternative(*operand)) { + offset = operation[i]; + } else if (std::holds_alternative(*operand)) { + gpr = operation[i]; + } + } + if (offset && gpr) { + return {std::make_pair(gpr, offset)}; + } + return std::nullopt; +} + +std::tuple ShaderIR::TrackSampler(Node tracked, const NodeBlock& code, + s64 cursor) const { + if (const auto cbuf = std::get_if(&*tracked)) { + // Constant buffer found, test if it's an immediate + const auto offset = cbuf->GetOffset(); + if (const auto immediate = std::get_if(&*offset)) { + auto track = + MakeTrackSampler(cbuf->GetIndex(), immediate->GetValue()); + return {tracked, track}; + } else if (const auto operation = std::get_if(&*offset)) { + auto bound_buffer = locker.ObtainBoundBuffer(); + if (!bound_buffer) { + return {}; + } + if (*bound_buffer != cbuf->GetIndex()) { + return {}; + } + auto pair = DecoupleIndirectRead(*operation); + if (!pair) { + return {}; + } + auto [gpr, base_offset] = *pair; + const auto offset_inm = std::get_if(&*base_offset); + // TODO Implement Bindless Index custom variable + auto track = + MakeTrackSampler(cbuf->GetIndex(), offset_inm->GetValue(), 0); + return {tracked, track}; + } + return {}; + } + if (const auto gpr = std::get_if(&*tracked)) { + if (gpr->GetIndex() == Tegra::Shader::Register::ZeroIndex) { + return {}; + } + // Reduce the cursor in one to avoid infinite loops when the instruction sets the same + // register that it uses as operand + const auto [source, new_cursor] = TrackRegister(gpr, code, cursor - 1); + if (!source) { + return {}; + } + return TrackSampler(source, code, new_cursor); + } + if (const auto operation = std::get_if(&*tracked)) { + for (std::size_t i = operation->GetOperandsCount(); i > 0; --i) { + if (auto found = TrackSampler((*operation)[i - 1], code, cursor); std::get<0>(found)) { + // Cbuf found in operand. + return found; + } + } + return {}; + } + if (const auto conditional = std::get_if(&*tracked)) { + const auto& conditional_code = conditional->GetCode(); + return TrackSampler(tracked, conditional_code, static_cast(conditional_code.size())); + } + return {}; +} + std::tuple ShaderIR::TrackCbuf(Node tracked, const NodeBlock& code, s64 cursor) const { if (const auto cbuf = std::get_if(&*tracked)) {