summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/video_core/renderer_opengl/gl_shader_cache.cpp6
-rw-r--r--src/video_core/renderer_opengl/gl_shader_cache.h20
-rw-r--r--src/video_core/renderer_opengl/gl_shader_disk_cache.cpp12
-rw-r--r--src/video_core/renderer_opengl/gl_shader_disk_cache.h82
4 files changed, 64 insertions, 56 deletions
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index bbcd15867..4883e4f62 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -431,11 +431,11 @@ CachedProgram ShaderCacheOpenGL::GeneratePrecompiledProgram(
return shader;
}
-std::map<u64, UnspecializedShader> ShaderCacheOpenGL::GenerateUnspecializedShaders(
+std::unordered_map<u64, UnspecializedShader> ShaderCacheOpenGL::GenerateUnspecializedShaders(
const std::atomic_bool& stop_loading, const VideoCore::DiskResourceLoadCallback& callback,
const std::vector<ShaderDiskCacheRaw>& raws,
- const std::map<u64, ShaderDiskCacheDecompiled>& decompiled) {
- std::map<u64, UnspecializedShader> unspecialized;
+ const std::unordered_map<u64, ShaderDiskCacheDecompiled>& decompiled) {
+ std::unordered_map<u64, UnspecializedShader> unspecialized;
if (callback)
callback(VideoCore::LoadCallbackStage::Decompile, 0, raws.size());
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.h b/src/video_core/renderer_opengl/gl_shader_cache.h
index 9c6b19fc3..97eed192f 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.h
+++ b/src/video_core/renderer_opengl/gl_shader_cache.h
@@ -5,10 +5,10 @@
#pragma once
#include <array>
-#include <map>
#include <memory>
#include <set>
#include <tuple>
+#include <unordered_map>
#include <glad/glad.h>
@@ -34,8 +34,8 @@ struct UnspecializedShader;
using Shader = std::shared_ptr<CachedShader>;
using CachedProgram = std::shared_ptr<OGLProgram>;
using Maxwell = Tegra::Engines::Maxwell3D::Regs;
-using PrecompiledPrograms = std::map<ShaderDiskCacheUsage, CachedProgram>;
-using PrecompiledShaders = std::map<u64, GLShader::ProgramResult>;
+using PrecompiledPrograms = std::unordered_map<ShaderDiskCacheUsage, CachedProgram>;
+using PrecompiledShaders = std::unordered_map<u64, GLShader::ProgramResult>;
class CachedShader final : public RasterizerCacheObject {
public:
@@ -102,12 +102,12 @@ private:
std::string code;
- std::map<BaseBindings, CachedProgram> programs;
- std::map<BaseBindings, GeometryPrograms> geometry_programs;
+ std::unordered_map<BaseBindings, CachedProgram> programs;
+ std::unordered_map<BaseBindings, GeometryPrograms> geometry_programs;
- std::map<u32, GLuint> cbuf_resource_cache;
- std::map<u32, GLuint> gmem_resource_cache;
- std::map<u32, GLint> uniform_cache;
+ std::unordered_map<u32, GLuint> cbuf_resource_cache;
+ std::unordered_map<u32, GLuint> gmem_resource_cache;
+ std::unordered_map<u32, GLint> uniform_cache;
};
class ShaderCacheOpenGL final : public RasterizerCache<Shader> {
@@ -122,10 +122,10 @@ public:
Shader GetStageProgram(Maxwell::ShaderProgram program);
private:
- std::map<u64, UnspecializedShader> GenerateUnspecializedShaders(
+ std::unordered_map<u64, UnspecializedShader> GenerateUnspecializedShaders(
const std::atomic_bool& stop_loading, const VideoCore::DiskResourceLoadCallback& callback,
const std::vector<ShaderDiskCacheRaw>& raws,
- const std::map<u64, ShaderDiskCacheDecompiled>& decompiled);
+ const std::unordered_map<u64, ShaderDiskCacheDecompiled>& decompiled);
CachedProgram GeneratePrecompiledProgram(const ShaderDiskCacheDump& dump,
const std::set<GLenum>& supported_formats);
diff --git a/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp b/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
index d88fff388..554d0dfb9 100644
--- a/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
@@ -211,8 +211,8 @@ ShaderDiskCacheOpenGL::LoadTransferable() {
return {{raws, usages}};
}
-std::pair<std::map<u64, ShaderDiskCacheDecompiled>,
- std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>
+std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
+ std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>
ShaderDiskCacheOpenGL::LoadPrecompiled() {
if (!IsUsable())
return {};
@@ -236,8 +236,8 @@ ShaderDiskCacheOpenGL::LoadPrecompiled() {
return *result;
}
-std::optional<std::pair<std::map<u64, ShaderDiskCacheDecompiled>,
- std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
+std::optional<std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
+ std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
ShaderDiskCacheOpenGL::LoadPrecompiledFile(FileUtil::IOFile& file) {
ShaderCacheVersionHash file_hash{};
if (file.ReadArray(file_hash.data(), file_hash.size()) != file_hash.size()) {
@@ -248,8 +248,8 @@ ShaderDiskCacheOpenGL::LoadPrecompiledFile(FileUtil::IOFile& file) {
return {};
}
- std::map<u64, ShaderDiskCacheDecompiled> decompiled;
- std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump> dumps;
+ std::unordered_map<u64, ShaderDiskCacheDecompiled> decompiled;
+ std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump> dumps;
while (file.Tell() < file.GetSize()) {
PrecompiledEntryKind kind{};
if (file.ReadBytes(&kind, sizeof(u32)) != sizeof(u32)) {
diff --git a/src/video_core/renderer_opengl/gl_shader_disk_cache.h b/src/video_core/renderer_opengl/gl_shader_disk_cache.h
index 061c4f204..6be0c0547 100644
--- a/src/video_core/renderer_opengl/gl_shader_disk_cache.h
+++ b/src/video_core/renderer_opengl/gl_shader_disk_cache.h
@@ -5,9 +5,10 @@
#pragma once
#include <optional>
-#include <set>
#include <string>
#include <tuple>
+#include <unordered_map>
+#include <unordered_set>
#include <utility>
#include <vector>
@@ -37,23 +38,54 @@ struct BaseBindings {
u32 gmem{};
u32 sampler{};
- bool operator<(const BaseBindings& rhs) const {
- return Tie() < rhs.Tie();
- }
-
bool operator==(const BaseBindings& rhs) const {
- return Tie() == rhs.Tie();
+ return std::tie(cbuf, gmem, sampler) == std::tie(rhs.cbuf, rhs.gmem, rhs.sampler);
}
bool operator!=(const BaseBindings& rhs) const {
return !operator==(rhs);
}
+};
+
+/// Describes how a shader is used
+struct ShaderDiskCacheUsage {
+ u64 unique_identifier{};
+ BaseBindings bindings;
+ GLenum primitive{};
+
+ bool operator==(const ShaderDiskCacheUsage& rhs) const {
+ return std::tie(unique_identifier, bindings, primitive) ==
+ std::tie(rhs.unique_identifier, rhs.bindings, rhs.primitive);
+ }
+
+ bool operator!=(const ShaderDiskCacheUsage& rhs) const {
+ return !operator==(rhs);
+ }
+};
+
+} // namespace OpenGL
+
+namespace std {
+
+template <>
+struct hash<OpenGL::BaseBindings> {
+ std::size_t operator()(const OpenGL::BaseBindings& bindings) const {
+ return bindings.cbuf | bindings.gmem << 8 | bindings.sampler << 16;
+ }
+};
- std::tuple<u32, u32, u32> Tie() const {
- return std::tie(cbuf, gmem, sampler);
+template <>
+struct hash<OpenGL::ShaderDiskCacheUsage> {
+ std::size_t operator()(const OpenGL::ShaderDiskCacheUsage& usage) const {
+ return static_cast<std::size_t>(usage.unique_identifier) ^
+ std::hash<OpenGL::BaseBindings>()(usage.bindings) ^ usage.primitive << 16;
}
};
+} // namespace std
+
+namespace OpenGL {
+
/// Describes a shader how it's used by the guest GPU
class ShaderDiskCacheRaw {
public:
@@ -114,30 +146,6 @@ private:
ProgramCode program_code_b;
};
-/// Describes how a shader is used
-struct ShaderDiskCacheUsage {
- bool operator<(const ShaderDiskCacheUsage& rhs) const {
- return Tie() < rhs.Tie();
- }
-
- bool operator==(const ShaderDiskCacheUsage& rhs) const {
- return Tie() == rhs.Tie();
- }
-
- bool operator!=(const ShaderDiskCacheUsage& rhs) const {
- return !operator==(rhs);
- }
-
- u64 unique_identifier{};
- BaseBindings bindings;
- GLenum primitive{};
-
-private:
- std::tuple<u64, BaseBindings, GLenum> Tie() const {
- return std::tie(unique_identifier, bindings, primitive);
- }
-};
-
/// Contains decompiled data from a shader
struct ShaderDiskCacheDecompiled {
std::string code;
@@ -159,8 +167,8 @@ public:
LoadTransferable();
/// Loads current game's precompiled cache. Invalidates on failure.
- std::pair<std::map<u64, ShaderDiskCacheDecompiled>,
- std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>
+ std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
+ std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>
LoadPrecompiled();
/// Removes the transferable (and precompiled) cache file.
@@ -184,8 +192,8 @@ public:
private:
/// Loads the transferable cache. Returns empty on failure.
- std::optional<std::pair<std::map<u64, ShaderDiskCacheDecompiled>,
- std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
+ std::optional<std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
+ std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
LoadPrecompiledFile(FileUtil::IOFile& file);
/// Loads a decompiled cache entry from the passed file. Returns empty on failure.
@@ -229,7 +237,7 @@ private:
// Copre system
Core::System& system;
// Stored transferable shaders
- std::map<u64, std::set<ShaderDiskCacheUsage>> transferable;
+ std::map<u64, std::unordered_set<ShaderDiskCacheUsage>> transferable;
// The cache has been loaded at boot
bool tried_to_load{};
};
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 08:28:21 +0100