shader/registry: Store graphics and compute metadata

Store information GLSL forces us to provide but it's dynamic state in
hardware (workgroup sizes, primitive topology, shared memory size).

src/video_core/shader/registry.cpp

@@ -6,21 +6,55 @@
 #include <tuple>
 
 #include "common/common_types.h"
+#include "video_core/engines/kepler_compute.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/shader_type.h"
 #include "video_core/shader/registry.h"
 
 namespace VideoCommon::Shader {
 
+using Tegra::Engines::ConstBufferEngineInterface;
 using Tegra::Engines::SamplerDescriptor;
+using Tegra::Engines::ShaderType;
 
-Registry::Registry(Tegra::Engines::ShaderType shader_stage,
-                   VideoCore::GuestDriverProfile stored_guest_driver_profile)
-    : stage{shader_stage}, stored_guest_driver_profile{stored_guest_driver_profile} {}
+namespace {
+
+GraphicsInfo MakeGraphicsInfo(ShaderType shader_stage, ConstBufferEngineInterface& engine) {
+    if (shader_stage == ShaderType::Compute) {
+        return {};
+    }
+    auto& graphics = static_cast<Tegra::Engines::Maxwell3D&>(engine);
+
+    GraphicsInfo info;
+    info.primitive_topology = graphics.regs.draw.topology;
+    return info;
+}
+
+ComputeInfo MakeComputeInfo(ShaderType shader_stage, ConstBufferEngineInterface& engine) {
+    if (shader_stage != ShaderType::Compute) {
+        return {};
+    }
+    auto& compute = static_cast<Tegra::Engines::KeplerCompute&>(engine);
+    const auto& launch = compute.launch_description;
+
+    ComputeInfo info;
+    info.workgroup_size = {launch.block_dim_x, launch.block_dim_y, launch.block_dim_z};
+    info.local_memory_size_in_words = launch.local_pos_alloc;
+    info.shared_memory_size_in_words = launch.shared_alloc;
+    return info;
+}
+
+} // Anonymous namespace
+
+Registry::Registry(Tegra::Engines::ShaderType shader_stage, const SerializedRegistryInfo& info)
+    : stage{shader_stage}, stored_guest_driver_profile{info.guest_driver_profile},
+      bound_buffer{info.bound_buffer}, graphics_info{info.graphics}, compute_info{info.compute} {}
 
 Registry::Registry(Tegra::Engines::ShaderType shader_stage,
                    Tegra::Engines::ConstBufferEngineInterface& engine)
-    : stage{shader_stage}, engine{&engine} {}
+    : stage{shader_stage}, engine{&engine}, bound_buffer{engine.GetBoundBuffer()},
+      graphics_info{MakeGraphicsInfo(shader_stage, engine)}, compute_info{MakeComputeInfo(
+                                                                 shader_stage, engine)} {}
 
 Registry::~Registry() = default;
 
@@ -67,18 +101,6 @@ std::optional<Tegra::Engines::SamplerDescriptor> Registry::ObtainBindlessSampler
     return value;
 }
 
-std::optional<u32> Registry::ObtainBoundBuffer() {
-    if (bound_buffer_saved) {
-        return bound_buffer;
-    }
-    if (!engine) {
-        return std::nullopt;
-    }
-    bound_buffer_saved = true;
-    bound_buffer = engine->GetBoundBuffer();
-    return bound_buffer;
-}
-
 void Registry::InsertKey(u32 buffer, u32 offset, u32 value) {
     keys.insert_or_assign({buffer, offset}, value);
 }
@@ -91,11 +113,6 @@ void Registry::InsertBindlessSampler(u32 buffer, u32 offset, SamplerDescriptor s
     bindless_samplers.insert_or_assign({buffer, offset}, sampler);
 }
 
-void Registry::SetBoundBuffer(u32 buffer) {
-    bound_buffer_saved = true;
-    bound_buffer = buffer;
-}
-
 bool Registry::IsConsistent() const {
     if (!engine) {
         return true;

src/video_core/shader/registry.h

@@ -4,11 +4,16 @@
 
 #pragma once
 
+#include <array>
 #include <optional>
+#include <type_traits>
 #include <unordered_map>
+#include <utility>
+
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "video_core/engines/const_buffer_engine_interface.h"
+#include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/shader_type.h"
 #include "video_core/guest_driver.h"
 
@@ -19,6 +24,25 @@ using BoundSamplerMap = std::unordered_map<u32, Tegra::Engines::SamplerDescripto
 using BindlessSamplerMap =
     std::unordered_map<std::pair<u32, u32>, Tegra::Engines::SamplerDescriptor, Common::PairHash>;
 
+struct GraphicsInfo {
+    Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology primitive_topology{};
+};
+static_assert(std::is_trivially_copyable_v<GraphicsInfo>);
+
+struct ComputeInfo {
+    std::array<u32, 3> workgroup_size{};
+    u32 shared_memory_size_in_words = 0;
+    u32 local_memory_size_in_words = 0;
+};
+static_assert(std::is_trivially_copyable_v<ComputeInfo>);
+
+struct SerializedRegistryInfo {
+    VideoCore::GuestDriverProfile guest_driver_profile;
+    u32 bound_buffer = 0;
+    GraphicsInfo graphics;
+    ComputeInfo compute;
+};
+
 /**
  * The Registry is a class use to interface the 3D and compute engines with the shader compiler.
  * With it, the shader can obtain required data from GPU state and store it for disk shader
@@ -26,8 +50,7 @@ using BindlessSamplerMap =
  */
 class Registry {
 public:
-    explicit Registry(Tegra::Engines::ShaderType shader_stage,
-                      VideoCore::GuestDriverProfile stored_guest_driver_profile);
+    explicit Registry(Tegra::Engines::ShaderType shader_stage, const SerializedRegistryInfo& info);
 
     explicit Registry(Tegra::Engines::ShaderType shader_stage,
                       Tegra::Engines::ConstBufferEngineInterface& engine);
@@ -42,8 +65,6 @@ public:
 
     std::optional<Tegra::Engines::SamplerDescriptor> ObtainBindlessSampler(u32 buffer, u32 offset);
 
-    std::optional<u32> ObtainBoundBuffer();
-
     /// Inserts a key.
     void InsertKey(u32 buffer, u32 offset, u32 value);
 
@@ -53,9 +74,6 @@ public:
     /// Inserts a bindless sampler key.
     void InsertBindlessSampler(u32 buffer, u32 offset, Tegra::Engines::SamplerDescriptor sampler);
 
-    /// Set the bound buffer for this registry.
-    void SetBoundBuffer(u32 buffer);
-
     /// Checks keys and samplers against engine's current const buffers.
     /// Returns true if they are the same value, false otherwise.
     bool IsConsistent() const;
@@ -83,6 +101,18 @@ public:
         return bound_buffer;
     }
 
+    /// Returns compute information from this shader
+    const GraphicsInfo& GetGraphicsInfo() const {
+        ASSERT(stage != Tegra::Engines::ShaderType::Compute);
+        return graphics_info;
+    }
+
+    /// Returns compute information from this shader
+    const ComputeInfo& GetComputeInfo() const {
+        ASSERT(stage == Tegra::Engines::ShaderType::Compute);
+        return compute_info;
+    }
+
     /// Obtains access to the guest driver's profile.
     VideoCore::GuestDriverProfile& AccessGuestDriverProfile() {
         return engine ? engine->AccessGuestDriverProfile() : stored_guest_driver_profile;
@@ -95,8 +125,9 @@ private:
     KeyMap keys;
     BoundSamplerMap bound_samplers;
     BindlessSamplerMap bindless_samplers;
-    bool bound_buffer_saved{};
-    u32 bound_buffer{};
+    u32 bound_buffer;
+    GraphicsInfo graphics_info;
+    ComputeInfo compute_info;
 };
 
 } // namespace VideoCommon::Shader

src/video_core/shader/track.cpp

@@ -81,14 +81,11 @@ std::tuple<Node, TrackSampler> ShaderIR::TrackBindlessSampler(Node tracked, cons
                 MakeTrackSampler<BindlessSamplerNode>(cbuf->GetIndex(), immediate->GetValue());
             return {tracked, track};
         } else if (const auto operation = std::get_if<OperationNode>(&*offset)) {
-            const auto bound_buffer = registry.ObtainBoundBuffer();
-            if (!bound_buffer) {
+            const u32 bound_buffer = registry.GetBoundBuffer();
+            if (bound_buffer != cbuf->GetIndex()) {
                 return {};
             }
-            if (*bound_buffer != cbuf->GetIndex()) {
-                return {};
-            }
-            auto pair = DecoupleIndirectRead(*operation);
+            const auto pair = DecoupleIndirectRead(*operation);
             if (!pair) {
                 return {};
             }