D3D: Uber shader support

2025-07-22 22:00:39 -06:00 · 2017-07-20 15:25:31 +10:00
parent cd502990fa
commit 4bf5625895
15 changed files with 720 additions and 193 deletions
--- a/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
@ -8,23 +8,32 @@
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
 #include "Common/LinearDiskCache.h"
+#include "Common/MsgHandler.h"
 #include "Common/StringUtil.h"

 #include "Core/ConfigManager.h"
+#include "Core/Host.h"

 #include "VideoBackends/D3D/D3DShader.h"
+#include "VideoBackends/D3D/D3DState.h"
+#include "VideoBackends/D3D/VertexManager.h"
 #include "VideoBackends/D3D/VertexShaderCache.h"

 #include "VideoCommon/Debugger.h"
 #include "VideoCommon/Statistics.h"
+#include "VideoCommon/UberShaderVertex.h"
+#include "VideoCommon/VertexLoaderManager.h"
 #include "VideoCommon/VertexShaderGen.h"
 #include "VideoCommon/VertexShaderManager.h"

 namespace DX11
 {
 VertexShaderCache::VSCache VertexShaderCache::vshaders;
+VertexShaderCache::UberVSCache VertexShaderCache::ubervshaders;
 const VertexShaderCache::VSCacheEntry* VertexShaderCache::last_entry;
+const VertexShaderCache::VSCacheEntry* VertexShaderCache::last_uber_entry;
 VertexShaderUid VertexShaderCache::last_uid;
+UberShader::VertexShaderUid VertexShaderCache::last_uber_uid;

 static ID3D11VertexShader* SimpleVertexShader = nullptr;
 static ID3D11VertexShader* ClearVertexShader = nullptr;
@ -32,6 +41,8 @@ static ID3D11InputLayout* SimpleLayout = nullptr;
 static ID3D11InputLayout* ClearLayout = nullptr;

 LinearDiskCache<VertexShaderUid, u8> g_vs_disk_cache;
+LinearDiskCache<UberShader::VertexShaderUid, u8> g_uber_vs_disk_cache;
+std::unique_ptr<VideoCommon::AsyncShaderCompiler> g_async_compiler;

 ID3D11VertexShader* VertexShaderCache::GetSimpleVertexShader()
 {
@ -70,10 +81,11 @@ ID3D11Buffer*& VertexShaderCache::GetConstantBuffer()
 }

 // this class will load the precompiled shaders into our cache
-class VertexShaderCacheInserter : public LinearDiskCacheReader<VertexShaderUid, u8>
+template <typename UidType>
+class VertexShaderCacheInserter : public LinearDiskCacheReader<UidType, u8>
 {
 public:
-  void Read(const VertexShaderUid& key, const u8* value, u32 value_size)
+  void Read(const UidType& key, const u8* value, u32 value_size)
  {
    D3DBlob* blob = new D3DBlob(value_size, value);
    VertexShaderCache::InsertByteCode(key, blob);
@ -160,36 +172,65 @@ void VertexShaderCache::Init()

  if (g_ActiveConfig.bShaderCache)
    LoadShaderCache();
+
+  g_async_compiler = std::make_unique<VideoCommon::AsyncShaderCompiler>();
+  if (g_ActiveConfig.GetShaderCompilerThreads() > 0)
+    g_async_compiler->StartWorkerThreads(g_ActiveConfig.GetShaderCompilerThreads());
+
+  if (g_ActiveConfig.CanPrecompileUberShaders())
+    PrecompileUberShaders();
 }

 void VertexShaderCache::LoadShaderCache()
 {
-  VertexShaderCacheInserter inserter;
+  VertexShaderCacheInserter<VertexShaderUid> inserter;
  g_vs_disk_cache.OpenAndRead(GetDiskShaderCacheFileName(APIType::D3D, "VS", true, true), inserter);
+
+  VertexShaderCacheInserter<UberShader::VertexShaderUid> uber_inserter;
+  g_uber_vs_disk_cache.OpenAndRead(GetDiskShaderCacheFileName(APIType::D3D, "UberVS", false, true),
+                                   uber_inserter);
 }

 void VertexShaderCache::Reload()
 {
+  g_async_compiler->WaitUntilCompletion();
+  g_async_compiler->RetrieveWorkItems();
+
  g_vs_disk_cache.Sync();
  g_vs_disk_cache.Close();
+  g_uber_vs_disk_cache.Sync();
+  g_uber_vs_disk_cache.Close();
  Clear();

  if (g_ActiveConfig.bShaderCache)
    LoadShaderCache();
+
+  if (g_ActiveConfig.CanPrecompileUberShaders())
+    PrecompileUberShaders();
 }

 void VertexShaderCache::Clear()
 {
  for (auto& iter : vshaders)
    iter.second.Destroy();
+  for (auto& iter : ubervshaders)
+    iter.second.Destroy();
  vshaders.clear();
+  ubervshaders.clear();

-  last_entry = nullptr;
  last_uid = {};
+  last_uber_uid = {};
+  last_entry = nullptr;
+  last_uber_entry = nullptr;
+  last_uid = {};
+  last_uber_uid = {};
 }

 void VertexShaderCache::Shutdown()
 {
+  g_async_compiler->StopWorkerThreads();
+  g_async_compiler->RetrieveWorkItems();
+
  SAFE_RELEASE(vscbuf);

  SAFE_RELEASE(SimpleVertexShader);
@ -201,74 +242,264 @@ void VertexShaderCache::Shutdown()
  Clear();
  g_vs_disk_cache.Sync();
  g_vs_disk_cache.Close();
+  g_uber_vs_disk_cache.Sync();
+  g_uber_vs_disk_cache.Close();
 }

-bool VertexShaderCache::SetShader()
+bool VertexShaderCache::SetShader(D3DVertexFormat* vertex_format)
 {
-  VertexShaderUid uid = GetVertexShaderUid();
-
-  if (last_entry)
+  if (g_ActiveConfig.CanUseUberShaders() &&
+      (g_ActiveConfig.bDisableSpecializedShaders || g_ActiveConfig.bForceVertexUberShaders))
  {
-    if (uid == last_uid)
-    {
-      GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-      return (last_entry->shader != nullptr);
-    }
+    return SetUberShader(vertex_format);
  }

-  last_uid = uid;
+  VertexShaderUid uid = GetVertexShaderUid();
+  if (last_entry && uid == last_uid)
+  {
+    if (last_entry->pending)
+      return SetUberShader(vertex_format);

-  VSCache::iterator iter = vshaders.find(uid);
+    if (!last_entry->shader)
+      return false;
+
+    vertex_format->SetInputLayout(last_entry->bytecode);
+    D3D::stateman->SetVertexShader(last_entry->shader);
+    return true;
+  }
+
+  auto iter = vshaders.find(uid);
  if (iter != vshaders.end())
  {
    const VSCacheEntry& entry = iter->second;
+    if (entry.pending)
+      return SetUberShader(vertex_format);
+
+    last_uid = uid;
    last_entry = &entry;

    GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-    return (entry.shader != nullptr);
+    if (!last_entry->shader)
+      return false;
+
+    vertex_format->SetInputLayout(last_entry->bytecode);
+    D3D::stateman->SetVertexShader(last_entry->shader);
+    return true;
  }

+  // Background compiling?
+  if (g_ActiveConfig.CanBackgroundCompileShaders())
+  {
+    // Create a pending entry
+    VSCacheEntry entry;
+    entry.pending = true;
+    vshaders[uid] = entry;
+
+    // Queue normal shader compiling and use ubershader
+    g_async_compiler->QueueWorkItem(
+        g_async_compiler->CreateWorkItem<VertexShaderCompilerWorkItem>(uid));
+    return SetUberShader(vertex_format);
+  }
+
+  // Need to compile a new shader
+  D3DBlob* bytecode = nullptr;
  ShaderCode code =
      GenerateVertexShaderCode(APIType::D3D, ShaderHostConfig::GetCurrent(), uid.GetUidData());
-
-  D3DBlob* pbytecode = nullptr;
-  D3D::CompileVertexShader(code.GetBuffer(), &pbytecode);
-
-  if (pbytecode == nullptr)
+  D3D::CompileVertexShader(code.GetBuffer(), &bytecode);
+  if (!InsertByteCode(uid, bytecode))
  {
-    GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true);
+    SAFE_RELEASE(bytecode);
    return false;
  }
-  g_vs_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size());

-  bool success = InsertByteCode(uid, pbytecode);
-  pbytecode->Release();
-
-  GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
-  return success;
+  g_vs_disk_cache.Append(uid, bytecode->Data(), bytecode->Size());
+  bytecode->Release();
+  return SetShader(vertex_format);
 }

-bool VertexShaderCache::InsertByteCode(const VertexShaderUid& uid, D3DBlob* bcodeblob)
+bool VertexShaderCache::SetUberShader(D3DVertexFormat* vertex_format)
 {
-  ID3D11VertexShader* shader = D3D::CreateVertexShaderFromByteCode(bcodeblob);
-  if (shader == nullptr)
+  D3DVertexFormat* uber_vertex_format = static_cast<D3DVertexFormat*>(
+      VertexLoaderManager::GetUberVertexFormat(vertex_format->GetVertexDeclaration()));
+  UberShader::VertexShaderUid uid = UberShader::GetVertexShaderUid();
+  if (last_uber_entry && last_uber_uid == uid)
+  {
+    if (!last_uber_entry->shader)
+      return false;
+
+    uber_vertex_format->SetInputLayout(last_uber_entry->bytecode);
+    D3D::stateman->SetVertexShader(last_uber_entry->shader);
+    return true;
+  }
+
+  auto iter = ubervshaders.find(uid);
+  if (iter != ubervshaders.end())
+  {
+    const VSCacheEntry& entry = iter->second;
+    last_uber_uid = uid;
+    last_uber_entry = &entry;
+
+    GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
+    if (!last_uber_entry->shader)
+      return false;
+
+    uber_vertex_format->SetInputLayout(last_uber_entry->bytecode);
+    D3D::stateman->SetVertexShader(last_uber_entry->shader);
+    return true;
+  }
+
+  // Need to compile a new shader
+  D3DBlob* bytecode = nullptr;
+  ShaderCode code =
+      UberShader::GenVertexShader(APIType::D3D, ShaderHostConfig::GetCurrent(), uid.GetUidData());
+  D3D::CompileVertexShader(code.GetBuffer(), &bytecode);
+  if (!InsertByteCode(uid, bytecode))
+  {
+    SAFE_RELEASE(bytecode);
+    return false;
+  }
+
+  g_uber_vs_disk_cache.Append(uid, bytecode->Data(), bytecode->Size());
+  bytecode->Release();
+  return SetUberShader(vertex_format);
+}
+
+bool VertexShaderCache::InsertByteCode(const VertexShaderUid& uid, D3DBlob* blob)
+{
+  ID3D11VertexShader* shader =
+      blob ? D3D::CreateVertexShaderFromByteCode(blob->Data(), blob->Size()) : nullptr;
+  bool result = InsertShader(uid, shader, blob);
+  SAFE_RELEASE(shader);
+  return result;
+}
+
+bool VertexShaderCache::InsertByteCode(const UberShader::VertexShaderUid& uid, D3DBlob* blob)
+{
+  ID3D11VertexShader* shader =
+      blob ? D3D::CreateVertexShaderFromByteCode(blob->Data(), blob->Size()) : nullptr;
+  bool result = InsertShader(uid, shader, blob);
+  SAFE_RELEASE(shader);
+  return result;
+}
+
+bool VertexShaderCache::InsertShader(const VertexShaderUid& uid, ID3D11VertexShader* shader,
+                                     D3DBlob* blob)
+{
+  auto iter = vshaders.find(uid);
+  if (iter != vshaders.end() && !iter->second.pending)
    return false;

-  // TODO: Somehow make the debug name a bit more specific
-  D3D::SetDebugObjectName((ID3D11DeviceChild*)shader, "a vertex shader of VertexShaderCache");
+  VSCacheEntry& newentry = vshaders[uid];
+  newentry.pending = false;
+  if (!shader || !blob)
+    return false;

-  // Make an entry in the table
-  VSCacheEntry entry;
-  entry.shader = shader;
-  entry.SetByteCode(bcodeblob);
+  shader->AddRef();
+  newentry.SetByteCode(blob);
+  newentry.shader = shader;

-  vshaders[uid] = entry;
-  last_entry = &vshaders[uid];
+  INCSTAT(stats.numPixelShadersCreated);
+  SETSTAT(stats.numPixelShadersAlive, static_cast<int>(vshaders.size()));
+  return true;
+}

-  INCSTAT(stats.numVertexShadersCreated);
-  SETSTAT(stats.numVertexShadersAlive, (int)vshaders.size());
+bool VertexShaderCache::InsertShader(const UberShader::VertexShaderUid& uid,
+                                     ID3D11VertexShader* shader, D3DBlob* blob)
+{
+  auto iter = ubervshaders.find(uid);
+  if (iter != ubervshaders.end() && !iter->second.pending)
+    return false;
+
+  VSCacheEntry& newentry = ubervshaders[uid];
+  newentry.pending = false;
+  if (!shader || !blob)
+    return false;
+
+  shader->AddRef();
+  newentry.SetByteCode(blob);
+  newentry.shader = shader;
+  return true;
+}
+
+void VertexShaderCache::RetreiveAsyncShaders()
+{
+  g_async_compiler->RetrieveWorkItems();
+}
+
+void VertexShaderCache::PrecompileUberShaders()
+{
+  UberShader::EnumerateVertexShaderUids([&](const UberShader::VertexShaderUid& uid) {
+    if (ubervshaders.find(uid) != ubervshaders.end())
+      return;
+
+    g_async_compiler->QueueWorkItem(
+        g_async_compiler->CreateWorkItem<UberVertexShaderCompilerWorkItem>(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);
+}
+
+VertexShaderCache::VertexShaderCompilerWorkItem::VertexShaderCompilerWorkItem(
+    const VertexShaderUid& uid)
+{
+  std::memcpy(&m_uid, &uid, sizeof(uid));
+}
+
+VertexShaderCache::VertexShaderCompilerWorkItem::~VertexShaderCompilerWorkItem()
+{
+  SAFE_RELEASE(m_bytecode);
+  SAFE_RELEASE(m_vs);
+}
+
+bool VertexShaderCache::VertexShaderCompilerWorkItem::Compile()
+{
+  ShaderCode code =
+      GenerateVertexShaderCode(APIType::D3D, ShaderHostConfig::GetCurrent(), m_uid.GetUidData());
+
+  if (D3D::CompileVertexShader(code.GetBuffer(), &m_bytecode))
+    m_vs = D3D::CreateVertexShaderFromByteCode(m_bytecode);

  return true;
 }

+void VertexShaderCache::VertexShaderCompilerWorkItem::Retrieve()
+{
+  if (InsertShader(m_uid, m_vs, m_bytecode))
+    g_vs_disk_cache.Append(m_uid, m_bytecode->Data(), m_bytecode->Size());
+}
+
+VertexShaderCache::UberVertexShaderCompilerWorkItem::UberVertexShaderCompilerWorkItem(
+    const UberShader::VertexShaderUid& uid)
+{
+  std::memcpy(&m_uid, &uid, sizeof(uid));
+}
+
+VertexShaderCache::UberVertexShaderCompilerWorkItem::~UberVertexShaderCompilerWorkItem()
+{
+  SAFE_RELEASE(m_bytecode);
+  SAFE_RELEASE(m_vs);
+}
+
+bool VertexShaderCache::UberVertexShaderCompilerWorkItem::Compile()
+{
+  ShaderCode code =
+      UberShader::GenVertexShader(APIType::D3D, ShaderHostConfig::GetCurrent(), m_uid.GetUidData());
+
+  if (D3D::CompileVertexShader(code.GetBuffer(), &m_bytecode))
+    m_vs = D3D::CreateVertexShaderFromByteCode(m_bytecode);
+
+  return true;
+}
+
+void VertexShaderCache::UberVertexShaderCompilerWorkItem::Retrieve()
+{
+  if (InsertShader(m_uid, m_vs, m_bytecode))
+    g_uber_vs_disk_cache.Append(m_uid, m_bytecode->Data(), m_bytecode->Size());
+}
+
 }  // namespace DX11