VideoCommon: add custom shader cache

2025-06-13 00:58:29 +02:00 · 2022-08-17 01:26:06 -05:00
parent dbaf24ef09
commit bedbf2b8c6
4 changed files with 524 additions and 0 deletions
--- a/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp
+++ b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp
@ -0,0 +1,376 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.h"
+#include "VideoCommon/AbstractGfx.h"
+#include "VideoCommon/VideoConfig.h"
+
+CustomShaderCache::CustomShaderCache()
+{
+  m_api_type = g_ActiveConfig.backend_info.api_type;
+  m_host_config.bits = ShaderHostConfig::GetCurrent().bits;
+
+  m_async_shader_compiler = g_gfx->CreateAsyncShaderCompiler();
+  m_async_shader_compiler->StartWorkerThreads(1);  // TODO
+
+  m_async_uber_shader_compiler = g_gfx->CreateAsyncShaderCompiler();
+  m_async_uber_shader_compiler->StartWorkerThreads(1);  // TODO
+
+  m_frame_end_handler =
+      AfterFrameEvent::Register([this] { RetrieveAsyncShaders(); }, "RetreiveAsyncShaders");
+}
+
+CustomShaderCache::~CustomShaderCache()
+{
+  if (m_async_shader_compiler)
+    m_async_shader_compiler->StopWorkerThreads();
+
+  if (m_async_uber_shader_compiler)
+    m_async_uber_shader_compiler->StopWorkerThreads();
+}
+
+void CustomShaderCache::RetrieveAsyncShaders()
+{
+  m_async_shader_compiler->RetrieveWorkItems();
+  m_async_uber_shader_compiler->RetrieveWorkItems();
+}
+
+void CustomShaderCache::Reload()
+{
+  while (m_async_shader_compiler->HasPendingWork() || m_async_shader_compiler->HasCompletedWork())
+  {
+    m_async_shader_compiler->RetrieveWorkItems();
+  }
+
+  while (m_async_uber_shader_compiler->HasPendingWork() ||
+         m_async_uber_shader_compiler->HasCompletedWork())
+  {
+    m_async_uber_shader_compiler->RetrieveWorkItems();
+  }
+
+  m_ps_cache = {};
+  m_uber_ps_cache = {};
+  m_pipeline_cache = {};
+  m_uber_pipeline_cache = {};
+}
+
+std::optional<const AbstractPipeline*>
+CustomShaderCache::GetPipelineAsync(const VideoCommon::GXPipelineUid& uid,
+                                    const CustomShaderInstance& custom_shaders,
+                                    const AbstractPipelineConfig& pipeline_config)
+{
+  if (auto holder = m_pipeline_cache.GetHolder(uid, custom_shaders))
+  {
+    if (holder->pending)
+      return std::nullopt;
+    return holder->value.get();
+  }
+  AsyncCreatePipeline(uid, custom_shaders, pipeline_config);
+  return std::nullopt;
+}
+
+std::optional<const AbstractPipeline*>
+CustomShaderCache::GetPipelineAsync(const VideoCommon::GXUberPipelineUid& uid,
+                                    const CustomShaderInstance& custom_shaders,
+                                    const AbstractPipelineConfig& pipeline_config)
+{
+  if (auto holder = m_uber_pipeline_cache.GetHolder(uid, custom_shaders))
+  {
+    if (holder->pending)
+      return std::nullopt;
+    return holder->value.get();
+  }
+  AsyncCreatePipeline(uid, custom_shaders, pipeline_config);
+  return std::nullopt;
+}
+
+void CustomShaderCache::AsyncCreatePipeline(const VideoCommon::GXPipelineUid& uid,
+
+                                            const CustomShaderInstance& custom_shaders,
+                                            const AbstractPipelineConfig& pipeline_config)
+{
+  class PipelineWorkItem final : public VideoCommon::AsyncShaderCompiler::WorkItem
+  {
+  public:
+    PipelineWorkItem(CustomShaderCache* shader_cache, const VideoCommon::GXPipelineUid& uid,
+                     const CustomShaderInstance& custom_shaders, PipelineIterator iterator,
+                     const AbstractPipelineConfig& pipeline_config)
+        : m_shader_cache(shader_cache), m_uid(uid), m_iterator(iterator),
+          m_custom_shaders(custom_shaders), m_config(pipeline_config)
+    {
+      SetStagesReady();
+    }
+
+    void SetStagesReady()
+    {
+      m_stages_ready = true;
+
+      PixelShaderUid ps_uid = m_uid.ps_uid;
+      ClearUnusedPixelShaderUidBits(m_shader_cache->m_api_type, m_shader_cache->m_host_config,
+                                    &ps_uid);
+
+      if (auto holder = m_shader_cache->m_ps_cache.GetHolder(ps_uid, m_custom_shaders))
+      {
+        // If the pixel shader is no longer pending compilation
+        // and the shader compilation succeeded, set
+        // the pipeline to use the new pixel shader.
+        // Otherwise, use the existing shader.
+        if (!holder->pending && holder->value.get())
+        {
+          m_config.pixel_shader = holder->value.get();
+        }
+        m_stages_ready &= !holder->pending;
+      }
+      else
+      {
+        m_stages_ready &= false;
+        m_shader_cache->QueuePixelShaderCompile(ps_uid, m_custom_shaders);
+      }
+    }
+
+    bool Compile() override
+    {
+      if (m_stages_ready)
+      {
+        m_pipeline = g_gfx->CreatePipeline(m_config);
+      }
+      return true;
+    }
+
+    void Retrieve() override
+    {
+      if (m_stages_ready)
+      {
+        m_shader_cache->NotifyPipelineFinished(m_iterator, std::move(m_pipeline));
+      }
+      else
+      {
+        // Re-queue for next frame.
+        auto wi = m_shader_cache->m_async_shader_compiler->CreateWorkItem<PipelineWorkItem>(
+            m_shader_cache, m_uid, m_custom_shaders, m_iterator, m_config);
+        m_shader_cache->m_async_shader_compiler->QueueWorkItem(std::move(wi), 0);
+      }
+    }
+
+  private:
+    CustomShaderCache* m_shader_cache;
+    std::unique_ptr<AbstractPipeline> m_pipeline;
+    VideoCommon::GXPipelineUid m_uid;
+    PipelineIterator m_iterator;
+    AbstractPipelineConfig m_config;
+    CustomShaderInstance m_custom_shaders;
+    bool m_stages_ready;
+  };
+
+  auto list_iter = m_pipeline_cache.InsertElement(uid, custom_shaders);
+  auto work_item = m_async_shader_compiler->CreateWorkItem<PipelineWorkItem>(
+      this, uid, custom_shaders, list_iter, pipeline_config);
+  m_async_shader_compiler->QueueWorkItem(std::move(work_item), 0);
+}
+
+void CustomShaderCache::AsyncCreatePipeline(const VideoCommon::GXUberPipelineUid& uid,
+
+                                            const CustomShaderInstance& custom_shaders,
+                                            const AbstractPipelineConfig& pipeline_config)
+{
+  class PipelineWorkItem final : public VideoCommon::AsyncShaderCompiler::WorkItem
+  {
+  public:
+    PipelineWorkItem(CustomShaderCache* shader_cache, const VideoCommon::GXUberPipelineUid& uid,
+                     const CustomShaderInstance& custom_shaders, UberPipelineIterator iterator,
+                     const AbstractPipelineConfig& pipeline_config)
+        : m_shader_cache(shader_cache), m_uid(uid), m_iterator(iterator),
+          m_custom_shaders(custom_shaders), m_config(pipeline_config)
+    {
+      SetStagesReady();
+    }
+
+    void SetStagesReady()
+    {
+      m_stages_ready = true;
+
+      UberShader::PixelShaderUid ps_uid = m_uid.ps_uid;
+      ClearUnusedPixelShaderUidBits(m_shader_cache->m_api_type, m_shader_cache->m_host_config,
+                                    &ps_uid);
+
+      if (auto holder = m_shader_cache->m_uber_ps_cache.GetHolder(ps_uid, m_custom_shaders))
+      {
+        if (!holder->pending && holder->value.get())
+        {
+          m_config.pixel_shader = holder->value.get();
+        }
+        m_stages_ready &= !holder->pending;
+      }
+      else
+      {
+        m_stages_ready &= false;
+        m_shader_cache->QueuePixelShaderCompile(ps_uid, m_custom_shaders);
+      }
+    }
+
+    bool Compile() override
+    {
+      if (m_stages_ready)
+      {
+        if (m_config.pixel_shader == nullptr || m_config.vertex_shader == nullptr)
+          return false;
+
+        m_pipeline = g_gfx->CreatePipeline(m_config);
+      }
+      return true;
+    }
+
+    void Retrieve() override
+    {
+      if (m_stages_ready)
+      {
+        m_shader_cache->NotifyPipelineFinished(m_iterator, std::move(m_pipeline));
+      }
+      else
+      {
+        // Re-queue for next frame.
+        auto wi = m_shader_cache->m_async_uber_shader_compiler->CreateWorkItem<PipelineWorkItem>(
+            m_shader_cache, m_uid, m_custom_shaders, m_iterator, m_config);
+        m_shader_cache->m_async_uber_shader_compiler->QueueWorkItem(std::move(wi), 0);
+      }
+    }
+
+  private:
+    CustomShaderCache* m_shader_cache;
+    std::unique_ptr<AbstractPipeline> m_pipeline;
+    VideoCommon::GXUberPipelineUid m_uid;
+    UberPipelineIterator m_iterator;
+    AbstractPipelineConfig m_config;
+    CustomShaderInstance m_custom_shaders;
+    bool m_stages_ready;
+  };
+
+  auto list_iter = m_uber_pipeline_cache.InsertElement(uid, custom_shaders);
+  auto work_item = m_async_uber_shader_compiler->CreateWorkItem<PipelineWorkItem>(
+      this, uid, custom_shaders, list_iter, pipeline_config);
+  m_async_uber_shader_compiler->QueueWorkItem(std::move(work_item), 0);
+}
+
+void CustomShaderCache::NotifyPipelineFinished(PipelineIterator iterator,
+                                               std::unique_ptr<AbstractPipeline> pipeline)
+{
+  iterator->second.pending = false;
+  iterator->second.value = std::move(pipeline);
+}
+
+void CustomShaderCache::NotifyPipelineFinished(UberPipelineIterator iterator,
+                                               std::unique_ptr<AbstractPipeline> pipeline)
+{
+  iterator->second.pending = false;
+  iterator->second.value = std::move(pipeline);
+}
+
+void CustomShaderCache::QueuePixelShaderCompile(const PixelShaderUid& uid,
+
+                                                const CustomShaderInstance& custom_shaders)
+{
+  class PixelShaderWorkItem final : public VideoCommon::AsyncShaderCompiler::WorkItem
+  {
+  public:
+    PixelShaderWorkItem(CustomShaderCache* shader_cache, const PixelShaderUid& uid,
+                        const CustomShaderInstance& custom_shaders, PixelShaderIterator iter)
+        : m_shader_cache(shader_cache), m_uid(uid), m_custom_shaders(custom_shaders), m_iter(iter)
+    {
+    }
+
+    bool Compile() override
+    {
+      m_shader = m_shader_cache->CompilePixelShader(m_uid, m_custom_shaders);
+      return true;
+    }
+
+    void Retrieve() override
+    {
+      m_shader_cache->NotifyPixelShaderFinished(m_iter, std::move(m_shader));
+    }
+
+  private:
+    CustomShaderCache* m_shader_cache;
+    std::unique_ptr<AbstractShader> m_shader;
+    PixelShaderUid m_uid;
+    CustomShaderInstance m_custom_shaders;
+    PixelShaderIterator m_iter;
+  };
+
+  auto list_iter = m_ps_cache.InsertElement(uid, custom_shaders);
+  auto work_item = m_async_shader_compiler->CreateWorkItem<PixelShaderWorkItem>(
+      this, uid, custom_shaders, list_iter);
+  m_async_shader_compiler->QueueWorkItem(std::move(work_item), 0);
+}
+
+void CustomShaderCache::QueuePixelShaderCompile(const UberShader::PixelShaderUid& uid,
+
+                                                const CustomShaderInstance& custom_shaders)
+{
+  class PixelShaderWorkItem final : public VideoCommon::AsyncShaderCompiler::WorkItem
+  {
+  public:
+    PixelShaderWorkItem(CustomShaderCache* shader_cache, const UberShader::PixelShaderUid& uid,
+                        const CustomShaderInstance& custom_shaders, UberPixelShaderIterator iter)
+        : m_shader_cache(shader_cache), m_uid(uid), m_custom_shaders(custom_shaders), m_iter(iter)
+    {
+    }
+
+    bool Compile() override
+    {
+      m_shader = m_shader_cache->CompilePixelShader(m_uid, m_custom_shaders);
+      return true;
+    }
+
+    void Retrieve() override
+    {
+      m_shader_cache->NotifyPixelShaderFinished(m_iter, std::move(m_shader));
+    }
+
+  private:
+    CustomShaderCache* m_shader_cache;
+    std::unique_ptr<AbstractShader> m_shader;
+    UberShader::PixelShaderUid m_uid;
+    CustomShaderInstance m_custom_shaders;
+    UberPixelShaderIterator m_iter;
+  };
+
+  auto list_iter = m_uber_ps_cache.InsertElement(uid, custom_shaders);
+  auto work_item = m_async_uber_shader_compiler->CreateWorkItem<PixelShaderWorkItem>(
+      this, uid, custom_shaders, list_iter);
+  m_async_uber_shader_compiler->QueueWorkItem(std::move(work_item), 0);
+}
+
+std::unique_ptr<AbstractShader>
+CustomShaderCache::CompilePixelShader(const PixelShaderUid& uid,
+                                      const CustomShaderInstance& custom_shaders) const
+{
+  const ShaderCode source_code = GeneratePixelShaderCode(
+      m_api_type, m_host_config, uid.GetUidData(), custom_shaders.pixel_contents);
+  return g_gfx->CreateShaderFromSource(ShaderStage::Pixel, source_code.GetBuffer(),
+                                       "Custom Pixel Shader");
+}
+
+std::unique_ptr<AbstractShader>
+CustomShaderCache::CompilePixelShader(const UberShader::PixelShaderUid& uid,
+                                      const CustomShaderInstance& custom_shaders) const
+{
+  const ShaderCode source_code =
+      GenPixelShader(m_api_type, m_host_config, uid.GetUidData(), custom_shaders.pixel_contents);
+  return g_gfx->CreateShaderFromSource(ShaderStage::Pixel, source_code.GetBuffer(),
+                                       "Custom Uber Pixel Shader");
+}
+
+void CustomShaderCache::NotifyPixelShaderFinished(PixelShaderIterator iterator,
+                                                  std::unique_ptr<AbstractShader> shader)
+{
+  iterator->second.pending = false;
+  iterator->second.value = std::move(shader);
+}
+
+void CustomShaderCache::NotifyPixelShaderFinished(UberPixelShaderIterator iterator,
+                                                  std::unique_ptr<AbstractShader> shader)
+{
+  iterator->second.pending = false;
+  iterator->second.value = std::move(shader);
+}