Merge pull request #6399 from stenzek/videocommon-shader-cache

VideoCommon Shader (Pipeline) Cache

1 files changed, 0 insertions, 325 deletions

diff --git a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
index 664ecec3a2..e09e32d8a2 100644
--- a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
@@ -7,7 +7,6 @@
 #include "Common/Align.h"
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
-#include "Common/LinearDiskCache.h"
 #include "Common/MsgHandler.h"
 #include "Common/StringUtil.h"
 
@@ -27,17 +26,6 @@
 
 namespace DX11
 {
-PixelShaderCache::PSCache PixelShaderCache::PixelShaders;
-PixelShaderCache::UberPSCache PixelShaderCache::UberPixelShaders;
-const PixelShaderCache::PSCacheEntry* PixelShaderCache::last_entry;
-const PixelShaderCache::PSCacheEntry* PixelShaderCache::last_uber_entry;
-PixelShaderUid PixelShaderCache::last_uid;
-UberShader::PixelShaderUid PixelShaderCache::last_uber_uid;
-
-LinearDiskCache<PixelShaderUid, u8> g_ps_disk_cache;
-LinearDiskCache<UberShader::PixelShaderUid, u8> g_uber_ps_disk_cache;
-extern std::unique_ptr<VideoCommon::AsyncShaderCompiler> g_async_compiler;
-
 ID3D11PixelShader* s_ColorCopyProgram[2] = {nullptr};
 ID3D11PixelShader* s_ClearProgram = nullptr;
 ID3D11PixelShader* s_AnaglyphProgram = nullptr;
@@ -309,17 +297,6 @@ ID3D11Buffer* PixelShaderCache::GetConstantBuffer()
   return pscbuf;
 }
 
-// this class will load the precompiled shaders into our cache
-template <typename UidType>
-class PixelShaderCacheInserter : public LinearDiskCacheReader<UidType, u8>
-{
-public:
-  void Read(const UidType& key, const u8* value, u32 value_size)
-  {
-    PixelShaderCache::InsertByteCode(key, value, value_size);
-  }
-};
-
 void PixelShaderCache::Init()
 {
   unsigned int cbsize = Common::AlignUp(static_cast<unsigned int>(sizeof(PixelShaderConstants)),
@@ -344,58 +321,6 @@ void PixelShaderCache::Init()
   s_ColorCopyProgram[0] = D3D::CompileAndCreatePixelShader(color_copy_program_code);
   CHECK(s_ColorCopyProgram[0] != nullptr, "Create color copy pixel shader");
   D3D::SetDebugObjectName(s_ColorCopyProgram[0], "color copy pixel shader");
-
-  Clear();
-
-  SETSTAT(stats.numPixelShadersCreated, 0);
-  SETSTAT(stats.numPixelShadersAlive, 0);
-
-  if (g_ActiveConfig.bShaderCache)
-    LoadShaderCache();
-
-  if (g_ActiveConfig.CanPrecompileUberShaders())
-    QueueUberShaderCompiles();
-}
-
-void PixelShaderCache::LoadShaderCache()
-{
-  PixelShaderCacheInserter<PixelShaderUid> inserter;
-  g_ps_disk_cache.OpenAndRead(GetDiskShaderCacheFileName(APIType::D3D, "PS", true, true), inserter);
-
-  PixelShaderCacheInserter<UberShader::PixelShaderUid> uber_inserter;
-  g_uber_ps_disk_cache.OpenAndRead(GetDiskShaderCacheFileName(APIType::D3D, "UberPS", false, true),
-                                   uber_inserter);
-}
-
-void PixelShaderCache::Reload()
-{
-  g_ps_disk_cache.Sync();
-  g_ps_disk_cache.Close();
-  g_uber_ps_disk_cache.Sync();
-  g_uber_ps_disk_cache.Close();
-  Clear();
-
-  if (g_ActiveConfig.bShaderCache)
-    LoadShaderCache();
-
-  if (g_ActiveConfig.CanPrecompileUberShaders())
-    QueueUberShaderCompiles();
-}
-
-// ONLY to be used during shutdown.
-void PixelShaderCache::Clear()
-{
-  for (auto& iter : PixelShaders)
-    iter.second.Destroy();
-  for (auto& iter : UberPixelShaders)
-    iter.second.Destroy();
-  PixelShaders.clear();
-  UberPixelShaders.clear();
-
-  last_entry = nullptr;
-  last_uber_entry = nullptr;
-  last_uid = {};
-  last_uber_uid = {};
 }
 
 // Used in Swap() when AA mode has changed
@@ -420,255 +345,5 @@ void PixelShaderCache::Shutdown()
     SAFE_RELEASE(s_rgba6_to_rgb8[i]);
     SAFE_RELEASE(s_rgb8_to_rgba6[i]);
   }
-
-  Clear();
-  g_ps_disk_cache.Sync();
-  g_ps_disk_cache.Close();
-  g_uber_ps_disk_cache.Sync();
-  g_uber_ps_disk_cache.Close();
-}
-
-bool PixelShaderCache::SetShader()
-{
-  if (g_ActiveConfig.bDisableSpecializedShaders)
-    return SetUberShader();
-
-  PixelShaderUid uid = GetPixelShaderUid();
-  ClearUnusedPixelShaderUidBits(APIType::D3D, &uid);
-  if (last_entry && uid == last_uid)
-  {
-    if (last_entry->pending)
-      return SetUberShader();
-
-    if (!last_entry->shader)
-      return false;
-
-    D3D::stateman->SetPixelShader(last_entry->shader);
-    return true;
-  }
-
-  // Check if the shader is already in the cache
-  auto iter = PixelShaders.find(uid);
-  if (iter != PixelShaders.end())
-  {
-    const PSCacheEntry& entry = iter->second;
-    if (entry.pending)
-      return SetUberShader();
-
-    last_uid = uid;
-    last_entry = &entry;
-
-    GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-    if (!last_entry->shader)
-      return false;
-
-    D3D::stateman->SetPixelShader(last_entry->shader);
-    return true;
-  }
-
-  // Background compiling?
-  if (g_ActiveConfig.CanBackgroundCompileShaders())
-  {
-    // Create a pending entry
-    PSCacheEntry entry;
-    entry.pending = true;
-    PixelShaders[uid] = entry;
-
-    // Queue normal shader compiling and use ubershader
-    g_async_compiler->QueueWorkItem(
-        g_async_compiler->CreateWorkItem<PixelShaderCompilerWorkItem>(uid));
-    return SetUberShader();
-  }
-
-  // Need to compile a new shader
-  D3DBlob* bytecode = nullptr;
-  ShaderCode code =
-      GeneratePixelShaderCode(APIType::D3D, ShaderHostConfig::GetCurrent(), uid.GetUidData());
-  D3D::CompilePixelShader(code.GetBuffer(), &bytecode);
-  if (!InsertByteCode(uid, bytecode ? bytecode->Data() : nullptr, bytecode ? bytecode->Size() : 0))
-  {
-    SAFE_RELEASE(bytecode);
-    return false;
-  }
-
-  g_ps_disk_cache.Append(uid, bytecode->Data(), bytecode->Size());
-  return SetShader();
-}
-
-bool PixelShaderCache::SetUberShader()
-{
-  UberShader::PixelShaderUid uid = UberShader::GetPixelShaderUid();
-  UberShader::ClearUnusedPixelShaderUidBits(APIType::D3D, &uid);
-
-  if (last_uber_entry && last_uber_uid == uid)
-  {
-    if (!last_uber_entry->shader)
-      return false;
-
-    D3D::stateman->SetPixelShader(last_uber_entry->shader);
-    return true;
-  }
-
-  auto iter = UberPixelShaders.find(uid);
-  if (iter != UberPixelShaders.end())
-  {
-    const PSCacheEntry& entry = iter->second;
-    last_uber_uid = uid;
-    last_uber_entry = &entry;
-
-    GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-    if (!last_uber_entry->shader)
-      return false;
-
-    D3D::stateman->SetPixelShader(last_uber_entry->shader);
-    return true;
-  }
-
-  D3DBlob* bytecode = nullptr;
-  ShaderCode code =
-      UberShader::GenPixelShader(APIType::D3D, ShaderHostConfig::GetCurrent(), uid.GetUidData());
-  D3D::CompilePixelShader(code.GetBuffer(), &bytecode);
-  if (!InsertByteCode(uid, bytecode ? bytecode->Data() : nullptr, bytecode ? bytecode->Size() : 0))
-  {
-    SAFE_RELEASE(bytecode);
-    return false;
-  }
-
-  // Lookup map again.
-  g_uber_ps_disk_cache.Append(uid, bytecode->Data(), bytecode->Size());
-  bytecode->Release();
-  return SetUberShader();
-}
-
-bool PixelShaderCache::InsertByteCode(const PixelShaderUid& uid, const u8* data, size_t len)
-{
-  ID3D11PixelShader* shader = data ? D3D::CreatePixelShaderFromByteCode(data, len) : nullptr;
-  if (!InsertShader(uid, shader))
-  {
-    SAFE_RELEASE(shader);
-    return false;
-  }
-
-  return true;
-}
-
-bool PixelShaderCache::InsertByteCode(const UberShader::PixelShaderUid& uid, const u8* data,
-                                      size_t len)
-{
-  ID3D11PixelShader* shader = data ? D3D::CreatePixelShaderFromByteCode(data, len) : nullptr;
-  if (!InsertShader(uid, shader))
-  {
-    SAFE_RELEASE(shader);
-    return false;
-  }
-
-  return true;
-}
-
-bool PixelShaderCache::InsertShader(const PixelShaderUid& uid, ID3D11PixelShader* shader)
-{
-  auto iter = PixelShaders.find(uid);
-  if (iter != PixelShaders.end() && !iter->second.pending)
-    return false;
-
-  PSCacheEntry& newentry = PixelShaders[uid];
-  newentry.pending = false;
-  newentry.shader = shader;
-
-  INCSTAT(stats.numPixelShadersCreated);
-  SETSTAT(stats.numPixelShadersAlive, PixelShaders.size());
-  return (shader != nullptr);
-}
-
-bool PixelShaderCache::InsertShader(const UberShader::PixelShaderUid& uid,
-                                    ID3D11PixelShader* shader)
-{
-  auto iter = UberPixelShaders.find(uid);
-  if (iter != UberPixelShaders.end() && !iter->second.pending)
-    return false;
-
-  PSCacheEntry& newentry = UberPixelShaders[uid];
-  newentry.pending = false;
-  newentry.shader = shader;
-  return (shader != nullptr);
-}
-
-void PixelShaderCache::QueueUberShaderCompiles()
-{
-  UberShader::EnumeratePixelShaderUids([&](const UberShader::PixelShaderUid& uid) {
-    if (UberPixelShaders.find(uid) != UberPixelShaders.end())
-      return;
-
-    g_async_compiler->QueueWorkItem(
-        g_async_compiler->CreateWorkItem<UberPixelShaderCompilerWorkItem>(uid));
-  });
-
-  g_async_compiler->WaitUntilCompletion([](size_t completed, size_t total) {
-    Host_UpdateProgressDialog(GetStringT("Compiling shaders...").c_str(),
-                              static_cast<int>(completed), static_cast<int>(total));
-  });
-  g_async_compiler->RetrieveWorkItems();
-  Host_UpdateProgressDialog("", -1, -1);
-}
-
-PixelShaderCache::PixelShaderCompilerWorkItem::PixelShaderCompilerWorkItem(
-    const PixelShaderUid& uid)
-{
-  std::memcpy(&m_uid, &uid, sizeof(uid));
 }
-
-PixelShaderCache::PixelShaderCompilerWorkItem::~PixelShaderCompilerWorkItem()
-{
-  SAFE_RELEASE(m_bytecode);
-}
-
-bool PixelShaderCache::PixelShaderCompilerWorkItem::Compile()
-{
-  ShaderCode code =
-      GeneratePixelShaderCode(APIType::D3D, ShaderHostConfig::GetCurrent(), m_uid.GetUidData());
-
-  if (D3D::CompilePixelShader(code.GetBuffer(), &m_bytecode))
-    m_shader = D3D::CreatePixelShaderFromByteCode(m_bytecode);
-
-  return true;
-}
-
-void PixelShaderCache::PixelShaderCompilerWorkItem::Retrieve()
-{
-  if (InsertShader(m_uid, m_shader))
-    g_ps_disk_cache.Append(m_uid, m_bytecode->Data(), m_bytecode->Size());
-  else
-    SAFE_RELEASE(m_shader);
-}
-
-PixelShaderCache::UberPixelShaderCompilerWorkItem::UberPixelShaderCompilerWorkItem(
-    const UberShader::PixelShaderUid& uid)
-{
-  std::memcpy(&m_uid, &uid, sizeof(uid));
-}
-
-PixelShaderCache::UberPixelShaderCompilerWorkItem::~UberPixelShaderCompilerWorkItem()
-{
-  SAFE_RELEASE(m_bytecode);
-}
-
-bool PixelShaderCache::UberPixelShaderCompilerWorkItem::Compile()
-{
-  ShaderCode code =
-      UberShader::GenPixelShader(APIType::D3D, ShaderHostConfig::GetCurrent(), m_uid.GetUidData());
-
-  if (D3D::CompilePixelShader(code.GetBuffer(), &m_bytecode))
-    m_shader = D3D::CreatePixelShaderFromByteCode(m_bytecode);
-
-  return true;
-}
-
-void PixelShaderCache::UberPixelShaderCompilerWorkItem::Retrieve()
-{
-  if (InsertShader(m_uid, m_shader))
-    g_uber_ps_disk_cache.Append(m_uid, m_bytecode->Data(), m_bytecode->Size());
-  else
-    SAFE_RELEASE(m_shader);
-}
-
 }  // DX11