summaryrefslogtreecommitdiffstats
path: root/src/video_core
diff options
context:
space:
mode:
Diffstat (limited to 'src/video_core')
-rw-r--r--src/video_core/renderer_opengl/gl_shader_disk_cache.cpp525
-rw-r--r--src/video_core/renderer_opengl/gl_shader_disk_cache.h30
2 files changed, 339 insertions, 216 deletions
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 5157e319a..f8bdb7779 100644
--- a/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
@@ -24,6 +24,8 @@
namespace OpenGL {
+using ShaderCacheVersionHash = std::array<u8, 64>;
+
enum class TransferableEntryKind : u32 {
Raw,
Usage,
@@ -35,7 +37,6 @@ enum class PrecompiledEntryKind : u32 {
};
constexpr u32 NativeVersion = 1;
-constexpr u32 ShaderHashSize = 64;
// Making sure sizes doesn't change by accident
static_assert(sizeof(BaseBindings) == 12);
@@ -46,10 +47,11 @@ std::string GetTitleID() {
return fmt::format("{:016X}", Core::CurrentProcess()->GetTitleID());
}
-std::string GetShaderHash() {
- std::array<char, ShaderHashSize> hash{};
- std::strncpy(hash.data(), Common::g_shader_cache_version, ShaderHashSize);
- return std::string(hash.data(), hash.size());
+ShaderCacheVersionHash GetShaderCacheVersionHash() {
+ ShaderCacheVersionHash hash{};
+ const std::size_t length = std::min(std::strlen(Common::g_shader_cache_version), hash.size());
+ std::memcpy(hash.data(), Common::g_shader_cache_version, length);
+ return hash;
}
template <typename T>
@@ -82,50 +84,64 @@ std::vector<u8> DecompressData(const std::vector<u8>& compressed, std::size_t un
}
} // namespace
-ShaderDiskCacheRaw::ShaderDiskCacheRaw(FileUtil::IOFile& file) {
- file.ReadBytes(&unique_identifier, sizeof(u64));
- file.ReadBytes(&program_type, sizeof(u32));
+ShaderDiskCacheRaw::ShaderDiskCacheRaw(u64 unique_identifier, Maxwell::ShaderProgram program_type,
+ u32 program_code_size, u32 program_code_size_b,
+ ProgramCode program_code, ProgramCode program_code_b)
+ : unique_identifier{unique_identifier}, program_type{program_type},
+ program_code_size{program_code_size}, program_code_size_b{program_code_size_b},
+ program_code{std::move(program_code)}, program_code_b{std::move(program_code_b)} {}
+
+ShaderDiskCacheRaw::ShaderDiskCacheRaw() = default;
+ShaderDiskCacheRaw::~ShaderDiskCacheRaw() = default;
+
+bool ShaderDiskCacheRaw::Load(FileUtil::IOFile& file) {
+ if (file.ReadBytes(&unique_identifier, sizeof(u64)) != sizeof(u64) ||
+ file.ReadBytes(&program_type, sizeof(u32)) != sizeof(u32)) {
+ return false;
+ }
u32 program_code_size{};
u32 program_code_size_b{};
- file.ReadBytes(&program_code_size, sizeof(u32));
- file.ReadBytes(&program_code_size_b, sizeof(u32));
+ if (file.ReadBytes(&program_code_size, sizeof(u32)) != sizeof(u32) ||
+ file.ReadBytes(&program_code_size_b, sizeof(u32)) != sizeof(u32)) {
+ return false;
+ }
program_code.resize(program_code_size);
program_code_b.resize(program_code_size_b);
- file.ReadArray(program_code.data(), program_code_size);
- if (HasProgramA()) {
- file.ReadArray(program_code_b.data(), program_code_size_b);
+ if (file.ReadArray(program_code.data(), program_code_size) != program_code_size)
+ return false;
+
+ if (HasProgramA() &&
+ file.ReadArray(program_code_b.data(), program_code_size_b) != program_code_size_b) {
+ return false;
}
+ return true;
}
-ShaderDiskCacheRaw::ShaderDiskCacheRaw(u64 unique_identifier, Maxwell::ShaderProgram program_type,
- u32 program_code_size, u32 program_code_size_b,
- ProgramCode program_code, ProgramCode program_code_b)
- : unique_identifier{unique_identifier}, program_type{program_type},
- program_code_size{program_code_size}, program_code_size_b{program_code_size_b},
- program_code{std::move(program_code)}, program_code_b{std::move(program_code_b)} {}
-
-ShaderDiskCacheRaw::~ShaderDiskCacheRaw() = default;
+bool ShaderDiskCacheRaw::Save(FileUtil::IOFile& file) const {
+ if (file.WriteObject(unique_identifier) != 1 ||
+ file.WriteObject(static_cast<u32>(program_type)) != 1 ||
+ file.WriteObject(program_code_size) != 1 || file.WriteObject(program_code_size_b) != 1) {
+ return false;
+ }
-void ShaderDiskCacheRaw::Save(FileUtil::IOFile& file) const {
- file.WriteObject(unique_identifier);
- file.WriteObject(static_cast<u32>(program_type));
- file.WriteObject(program_code_size);
- file.WriteObject(program_code_size_b);
+ if (file.WriteArray(program_code.data(), program_code_size) != program_code_size)
+ return false;
- file.WriteArray(program_code.data(), program_code_size);
- if (HasProgramA()) {
- file.WriteArray(program_code_b.data(), program_code_size_b);
+ if (HasProgramA() &&
+ file.WriteArray(program_code_b.data(), program_code_size_b) != program_code_size_b) {
+ return false;
}
+ return true;
}
std::optional<std::pair<std::vector<ShaderDiskCacheRaw>, std::vector<ShaderDiskCacheUsage>>>
ShaderDiskCacheOpenGL::LoadTransferable() {
- if (!Settings::values.use_disk_shader_cache) {
+ if (!Settings::values.use_disk_shader_cache)
return {};
- }
+ tried_to_load = true;
FileUtil::IOFile file(GetTransferablePath(), "rb");
if (!file.IsOpen()) {
@@ -133,15 +149,19 @@ ShaderDiskCacheOpenGL::LoadTransferable() {
GetTitleID());
return {};
}
- const u64 file_size = file.GetSize();
u32 version{};
- file.ReadBytes(&version, sizeof(version));
+ if (file.ReadBytes(&version, sizeof(version)) != sizeof(version)) {
+ LOG_ERROR(Render_OpenGL,
+ "Failed to get transferable cache version for title id={} - skipping",
+ GetTitleID());
+ return {};
+ }
if (version < NativeVersion) {
LOG_INFO(Render_OpenGL, "Transferable shader cache is old - removing");
file.Close();
- FileUtil::Delete(GetTransferablePath());
+ InvalidateTransferable();
return {};
}
if (version > NativeVersion) {
@@ -153,25 +173,35 @@ ShaderDiskCacheOpenGL::LoadTransferable() {
// Version is valid, load the shaders
std::vector<ShaderDiskCacheRaw> raws;
std::vector<ShaderDiskCacheUsage> usages;
- while (file.Tell() < file_size) {
+ while (file.Tell() < file.GetSize()) {
TransferableEntryKind kind{};
- file.ReadBytes(&kind, sizeof(u32));
+ if (file.ReadBytes(&kind, sizeof(u32)) != sizeof(u32)) {
+ LOG_ERROR(Render_OpenGL, "Failed to read transferable file - skipping");
+ return {};
+ }
switch (kind) {
case TransferableEntryKind::Raw: {
- ShaderDiskCacheRaw entry{file};
+ ShaderDiskCacheRaw entry;
+ if (!entry.Load(file)) {
+ LOG_ERROR(Render_OpenGL, "Failed to load transferable raw entry - skipping");
+ return {};
+ }
transferable.insert({entry.GetUniqueIdentifier(), {}});
raws.push_back(std::move(entry));
break;
}
case TransferableEntryKind::Usage: {
ShaderDiskCacheUsage usage{};
- file.ReadBytes(&usage, sizeof(usage));
+ if (file.ReadBytes(&usage, sizeof(usage)) != sizeof(usage)) {
+ LOG_ERROR(Render_OpenGL, "Failed to load transferable usage entry - skipping");
+ return {};
+ }
usages.push_back(std::move(usage));
break;
}
default:
- LOG_ERROR(Render_OpenGL, "Unknown transferable shader cache entry kind={} - aborting",
+ LOG_ERROR(Render_OpenGL, "Unknown transferable shader cache entry kind={} - skipping",
static_cast<u32>(kind));
return {};
}
@@ -182,9 +212,8 @@ ShaderDiskCacheOpenGL::LoadTransferable() {
std::pair<std::map<u64, ShaderDiskCacheDecompiled>,
std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>
ShaderDiskCacheOpenGL::LoadPrecompiled() {
- if (!Settings::values.use_disk_shader_cache) {
+ if (!IsUsable())
return {};
- }
FileUtil::IOFile file(GetPrecompiledPath(), "rb");
if (!file.IsOpen()) {
@@ -192,119 +221,75 @@ ShaderDiskCacheOpenGL::LoadPrecompiled() {
GetTitleID());
return {};
}
- const u64 file_size = file.GetSize();
- char precompiled_hash[ShaderHashSize];
- file.ReadBytes(&precompiled_hash, ShaderHashSize);
- if (precompiled_hash != GetShaderHash()) {
- LOG_INFO(Render_OpenGL, "Precompiled cache is from another version of yuzu - removing");
+ const auto result = LoadPrecompiledFile(file);
+ if (!result) {
+ LOG_INFO(Render_OpenGL,
+ "Failed to load precompiled cache for game with title id={} - removing",
+ GetTitleID());
file.Close();
InvalidatePrecompiled();
return {};
}
+ return *result;
+}
+
+std::optional<std::pair<std::map<u64, ShaderDiskCacheDecompiled>,
+ std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
+ShaderDiskCacheOpenGL::LoadPrecompiledFile(FileUtil::IOFile& file) {
+ ShaderCacheVersionHash file_hash{};
+ if (file.ReadArray(file_hash.data(), file_hash.size()) != file_hash.size()) {
+ return {};
+ }
+ if (GetShaderCacheVersionHash() != file_hash) {
+ LOG_INFO(Render_OpenGL, "Precompiled cache is from another version of the emulator");
+ return {};
+ }
std::map<u64, ShaderDiskCacheDecompiled> decompiled;
std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump> dumps;
- while (file.Tell() < file_size) {
+ while (file.Tell() < file.GetSize()) {
PrecompiledEntryKind kind{};
- file.ReadBytes(&kind, sizeof(u32));
+ if (file.ReadBytes(&kind, sizeof(u32)) != sizeof(u32)) {
+ return {};
+ }
switch (kind) {
case PrecompiledEntryKind::Decompiled: {
- ShaderDiskCacheDecompiled entry;
-
u64 unique_identifier{};
- file.ReadBytes(&unique_identifier, sizeof(u64));
-
- u32 code_size{};
- u32 compressed_code_size{};
- file.ReadBytes(&code_size, sizeof(u32));
- file.ReadBytes(&compressed_code_size, sizeof(u32));
-
- std::vector<u8> compressed_code(compressed_code_size);
- file.ReadArray(compressed_code.data(), compressed_code.size());
-
- const std::vector<u8> code = DecompressData(compressed_code, code_size);
- if (code.empty()) {
- LOG_ERROR(Render_OpenGL,
- "Failed to decompress GLSL code in precompiled shader={:016x} - removing",
- unique_identifier);
- InvalidatePrecompiled();
+ if (file.ReadBytes(&unique_identifier, sizeof(u64)) != sizeof(u64))
return {};
- }
- entry.code = std::string(reinterpret_cast<const char*>(code.data()), code_size);
-
- u32 const_buffers_count{};
- file.ReadBytes(&const_buffers_count, sizeof(u32));
- for (u32 i = 0; i < const_buffers_count; ++i) {
- u32 max_offset{}, index{};
- u8 is_indirect{};
- file.ReadBytes(&max_offset, sizeof(u32));
- file.ReadBytes(&index, sizeof(u32));
- file.ReadBytes(&is_indirect, sizeof(u8));
-
- entry.entries.const_buffers.emplace_back(max_offset, is_indirect != 0, index);
- }
-
- u32 samplers_count{};
- file.ReadBytes(&samplers_count, sizeof(u32));
- for (u32 i = 0; i < samplers_count; ++i) {
- u64 offset{}, index{};
- u32 type{};
- u8 is_array{}, is_shadow{};
- file.ReadBytes(&offset, sizeof(u64));
- file.ReadBytes(&index, sizeof(u64));
- file.ReadBytes(&type, sizeof(u32));
- file.ReadBytes(&is_array, sizeof(u8));
- file.ReadBytes(&is_shadow, sizeof(u8));
-
- entry.entries.samplers.emplace_back(
- static_cast<std::size_t>(offset), static_cast<std::size_t>(index),
- static_cast<Tegra::Shader::TextureType>(type), is_array != 0, is_shadow != 0);
- }
- u32 global_memory_count{};
- file.ReadBytes(&global_memory_count, sizeof(u32));
- for (u32 i = 0; i < global_memory_count; ++i) {
- u32 cbuf_index{}, cbuf_offset{};
- file.ReadBytes(&cbuf_index, sizeof(u32));
- file.ReadBytes(&cbuf_offset, sizeof(u32));
- entry.entries.global_memory_entries.emplace_back(cbuf_index, cbuf_offset);
- }
-
- for (auto& clip_distance : entry.entries.clip_distances) {
- u8 clip_distance_raw{};
- file.ReadBytes(&clip_distance_raw, sizeof(u8));
- clip_distance = clip_distance_raw != 0;
- }
-
- u64 shader_length{};
- file.ReadBytes(&shader_length, sizeof(u64));
- entry.entries.shader_length = static_cast<std::size_t>(shader_length);
-
- decompiled.insert({unique_identifier, std::move(entry)});
+ const auto entry = LoadDecompiledEntry(file);
+ if (!entry)
+ return {};
+ decompiled.insert({unique_identifier, std::move(*entry)});
break;
}
case PrecompiledEntryKind::Dump: {
ShaderDiskCacheUsage usage;
- file.ReadBytes(&usage, sizeof(usage));
+ if (file.ReadBytes(&usage, sizeof(usage)) != sizeof(usage))
+ return {};
ShaderDiskCacheDump dump;
- file.ReadBytes(&dump.binary_format, sizeof(u32));
+ if (file.ReadBytes(&dump.binary_format, sizeof(u32)) != sizeof(u32))
+ return {};
u32 binary_length{};
u32 compressed_size{};
- file.ReadBytes(&binary_length, sizeof(u32));
- file.ReadBytes(&compressed_size, sizeof(u32));
+ if (file.ReadBytes(&binary_length, sizeof(u32)) != sizeof(u32) ||
+ file.ReadBytes(&compressed_size, sizeof(u32)) != sizeof(u32)) {
+ return {};
+ }
std::vector<u8> compressed_binary(compressed_size);
- file.ReadArray(compressed_binary.data(), compressed_binary.size());
+ if (file.ReadArray(compressed_binary.data(), compressed_binary.size()) !=
+ compressed_binary.size()) {
+ return {};
+ }
dump.binary = DecompressData(compressed_binary, binary_length);
if (dump.binary.empty()) {
- LOG_ERROR(Render_OpenGL,
- "Failed to decompress precompiled binary program - removing");
- InvalidatePrecompiled();
return {};
}
@@ -312,28 +297,165 @@ ShaderDiskCacheOpenGL::LoadPrecompiled() {
break;
}
default:
- LOG_ERROR(Render_OpenGL, "Unknown precompiled shader cache entry kind={} - removing",
- static_cast<u32>(kind));
- InvalidatePrecompiled();
return {};
}
}
- return {decompiled, dumps};
+ return {{decompiled, dumps}};
+}
+
+std::optional<ShaderDiskCacheDecompiled> ShaderDiskCacheOpenGL::LoadDecompiledEntry(
+ FileUtil::IOFile& file) {
+ u32 code_size{};
+ u32 compressed_code_size{};
+ if (file.ReadBytes(&code_size, sizeof(u32)) != sizeof(u32) ||
+ file.ReadBytes(&compressed_code_size, sizeof(u32)) != sizeof(u32)) {
+ return {};
+ }
+
+ std::vector<u8> compressed_code(compressed_code_size);
+ if (file.ReadArray(compressed_code.data(), compressed_code.size()) != compressed_code.size()) {
+ return {};
+ }
+
+ const std::vector<u8> code = DecompressData(compressed_code, code_size);
+ if (code.empty()) {
+ return {};
+ }
+ ShaderDiskCacheDecompiled entry;
+ entry.code = std::string(reinterpret_cast<const char*>(code.data()), code_size);
+
+ u32 const_buffers_count{};
+ if (file.ReadBytes(&const_buffers_count, sizeof(u32)) != sizeof(u32))
+ return {};
+ for (u32 i = 0; i < const_buffers_count; ++i) {
+ u32 max_offset{};
+ u32 index{};
+ u8 is_indirect{};
+ if (file.ReadBytes(&max_offset, sizeof(u32)) != sizeof(u32) ||
+ file.ReadBytes(&index, sizeof(u32)) != sizeof(u32) ||
+ file.ReadBytes(&is_indirect, sizeof(u8)) != sizeof(u8)) {
+ return {};
+ }
+ entry.entries.const_buffers.emplace_back(max_offset, is_indirect != 0, index);
+ }
+
+ u32 samplers_count{};
+ if (file.ReadBytes(&samplers_count, sizeof(u32)) != sizeof(u32))
+ return {};
+ for (u32 i = 0; i < samplers_count; ++i) {
+ u64 offset{};
+ u64 index{};
+ u32 type{};
+ u8 is_array{};
+ u8 is_shadow{};
+ if (file.ReadBytes(&offset, sizeof(u64)) != sizeof(u64) ||
+ file.ReadBytes(&index, sizeof(u64)) != sizeof(u64) ||
+ file.ReadBytes(&type, sizeof(u32)) != sizeof(u32) ||
+ file.ReadBytes(&is_array, sizeof(u8)) != sizeof(u8) ||
+ file.ReadBytes(&is_shadow, sizeof(u8)) != sizeof(u8)) {
+ return {};
+ }
+ entry.entries.samplers.emplace_back(
+ static_cast<std::size_t>(offset), static_cast<std::size_t>(index),
+ static_cast<Tegra::Shader::TextureType>(type), is_array != 0, is_shadow != 0);
+ }
+
+ u32 global_memory_count{};
+ if (file.ReadBytes(&global_memory_count, sizeof(u32)) != sizeof(u32))
+ return {};
+ for (u32 i = 0; i < global_memory_count; ++i) {
+ u32 cbuf_index{};
+ u32 cbuf_offset{};
+ if (file.ReadBytes(&cbuf_index, sizeof(u32)) != sizeof(u32) ||
+ file.ReadBytes(&cbuf_offset, sizeof(u32)) != sizeof(u32)) {
+ return {};
+ }
+ entry.entries.global_memory_entries.emplace_back(cbuf_index, cbuf_offset);
+ }
+
+ for (auto& clip_distance : entry.entries.clip_distances) {
+ u8 clip_distance_raw{};
+ if (file.ReadBytes(&clip_distance_raw, sizeof(u8)) != sizeof(u8))
+ return {};
+ clip_distance = clip_distance_raw != 0;
+ }
+
+ u64 shader_length{};
+ if (file.ReadBytes(&shader_length, sizeof(u64)) != sizeof(u64))
+ return {};
+ entry.entries.shader_length = static_cast<std::size_t>(shader_length);
+
+ return entry;
+}
+
+bool ShaderDiskCacheOpenGL::SaveDecompiledFile(FileUtil::IOFile& file, u64 unique_identifier,
+ const std::string& code,
+ const std::vector<u8>& compressed_code,
+ const GLShader::ShaderEntries& entries) {
+ if (file.WriteObject(static_cast<u32>(PrecompiledEntryKind::Decompiled)) != 1 ||
+ file.WriteObject(unique_identifier) != 1 ||
+ file.WriteObject(static_cast<u32>(code.size())) != 1 ||
+ file.WriteObject(static_cast<u32>(compressed_code.size())) != 1 ||
+ file.WriteArray(compressed_code.data(), compressed_code.size()) != compressed_code.size()) {
+ return false;
+ }
+
+ if (file.WriteObject(static_cast<u32>(entries.const_buffers.size())) != 1)
+ return false;
+ for (const auto& cbuf : entries.const_buffers) {
+ if (file.WriteObject(static_cast<u32>(cbuf.GetMaxOffset())) != 1 ||
+ file.WriteObject(static_cast<u32>(cbuf.GetIndex())) != 1 ||
+ file.WriteObject(static_cast<u8>(cbuf.IsIndirect() ? 1 : 0)) != 1) {
+ return false;
+ }
+ }
+
+ if (file.WriteObject(static_cast<u32>(entries.samplers.size())) != 1)
+ return false;
+ for (const auto& sampler : entries.samplers) {
+ if (file.WriteObject(static_cast<u64>(sampler.GetOffset())) != 1 ||
+ file.WriteObject(static_cast<u64>(sampler.GetIndex())) != 1 ||
+ file.WriteObject(static_cast<u32>(sampler.GetType())) != 1 ||
+ file.WriteObject(static_cast<u8>(sampler.IsArray() ? 1 : 0)) != 1 ||
+ file.WriteObject(static_cast<u8>(sampler.IsShadow() ? 1 : 0)) != 1) {
+ return false;
+ }
+ }
+
+ if (file.WriteObject(static_cast<u32>(entries.global_memory_entries.size())) != 1)
+ return false;
+ for (const auto& gmem : entries.global_memory_entries) {
+ if (file.WriteObject(static_cast<u32>(gmem.GetCbufIndex())) != 1 ||
+ file.WriteObject(static_cast<u32>(gmem.GetCbufOffset())) != 1) {
+ return false;
+ }
+ }
+
+ for (const bool clip_distance : entries.clip_distances) {
+ if (file.WriteObject(static_cast<u8>(clip_distance ? 1 : 0)) != 1)
+ return false;
+ }
+
+ return file.WriteObject(static_cast<u64>(entries.shader_length)) == 1;
}
-bool ShaderDiskCacheOpenGL::InvalidateTransferable() const {
- const bool success = FileUtil::Delete(GetTransferablePath());
- return InvalidatePrecompiled() && success;
+void ShaderDiskCacheOpenGL::InvalidateTransferable() const {
+ if (!FileUtil::Delete(GetTransferablePath())) {
+ LOG_ERROR(Render_OpenGL, "Failed to invalidate transferable file={}",
+ GetTransferablePath());
+ }
+ InvalidatePrecompiled();
}
-bool ShaderDiskCacheOpenGL::InvalidatePrecompiled() const {
- return FileUtil::Delete(GetPrecompiledPath());
+void ShaderDiskCacheOpenGL::InvalidatePrecompiled() const {
+ if (!FileUtil::Delete(GetPrecompiledPath())) {
+ LOG_ERROR(Render_OpenGL, "Failed to invalidate precompiled file={}", GetPrecompiledPath());
+ }
}
void ShaderDiskCacheOpenGL::SaveRaw(const ShaderDiskCacheRaw& entry) {
- if (!Settings::values.use_disk_shader_cache) {
+ if (!IsUsable())
return;
- }
const u64 id = entry.GetUniqueIdentifier();
if (transferable.find(id) != transferable.end()) {
@@ -342,47 +464,44 @@ void ShaderDiskCacheOpenGL::SaveRaw(const ShaderDiskCacheRaw& entry) {
}
FileUtil::IOFile file = AppendTransferableFile();
- if (!file.IsOpen()) {
+ if (!file.IsOpen())
+ return;
+ if (file.WriteObject(TransferableEntryKind::Raw) != 1 || !entry.Save(file)) {
+ LOG_ERROR(Render_OpenGL, "Failed to save raw transferable cache entry - removing");
+ file.Close();
+ InvalidateTransferable();
return;
}
- file.WriteObject(TransferableEntryKind::Raw);
- entry.Save(file);
-
transferable.insert({id, {}});
}
void ShaderDiskCacheOpenGL::SaveUsage(const ShaderDiskCacheUsage& usage) {
- if (!Settings::values.use_disk_shader_cache) {
+ if (!IsUsable())
return;
- }
const auto it = transferable.find(usage.unique_identifier);
- if (it == transferable.end()) {
- LOG_CRITICAL(Render_OpenGL, "Saving shader usage without storing raw previously");
- UNREACHABLE();
- }
+ ASSERT_MSG(it != transferable.end(), "Saving shader usage without storing raw previously");
+
auto& usages{it->second};
ASSERT(usages.find(usage) == usages.end());
usages.insert(usage);
FileUtil::IOFile file = AppendTransferableFile();
- if (!file.IsOpen()) {
+ if (!file.IsOpen())
+ return;
+
+ if (file.WriteObject(TransferableEntryKind::Usage) != 1 || file.WriteObject(usage) != 1) {
+ LOG_ERROR(Render_OpenGL, "Failed to save usage transferable cache entry - removing");
+ file.Close();
+ InvalidateTransferable();
return;
}
- file.WriteObject(TransferableEntryKind::Usage);
- file.WriteObject(usage);
}
void ShaderDiskCacheOpenGL::SaveDecompiled(u64 unique_identifier, const std::string& code,
const GLShader::ShaderEntries& entries) {
- if (!Settings::values.use_disk_shader_cache) {
+ if (!IsUsable())
return;
- }
-
- FileUtil::IOFile file = AppendPrecompiledFile();
- if (!file.IsOpen()) {
- return;
- }
const std::vector<u8> compressed_code{CompressData(code.data(), code.size())};
if (compressed_code.empty()) {
@@ -391,52 +510,21 @@ void ShaderDiskCacheOpenGL::SaveDecompiled(u64 unique_identifier, const std::str
return;
}
- file.WriteObject(static_cast<u32>(PrecompiledEntryKind::Decompiled));
-
- file.WriteObject(unique_identifier);
-
- file.WriteObject(static_cast<u32>(code.size()));
- file.WriteObject(static_cast<u32>(compressed_code.size()));
- file.WriteArray(compressed_code.data(), compressed_code.size());
-
- file.WriteObject(static_cast<u32>(entries.const_buffers.size()));
- for (const auto& cbuf : entries.const_buffers) {
- file.WriteObject(static_cast<u32>(cbuf.GetMaxOffset()));
- file.WriteObject(static_cast<u32>(cbuf.GetIndex()));
- file.WriteObject(static_cast<u8>(cbuf.IsIndirect() ? 1 : 0));
- }
-
- file.WriteObject(static_cast<u32>(entries.samplers.size()));
- for (const auto& sampler : entries.samplers) {
- file.WriteObject(static_cast<u64>(sampler.GetOffset()));
- file.WriteObject(static_cast<u64>(sampler.GetIndex()));
- file.WriteObject(static_cast<u32>(sampler.GetType()));
- file.WriteObject(static_cast<u8>(sampler.IsArray() ? 1 : 0));
- file.WriteObject(static_cast<u8>(sampler.IsShadow() ? 1 : 0));
- }
-
- file.WriteObject(static_cast<u32>(entries.global_memory_entries.size()));
- for (const auto& gmem : entries.global_memory_entries) {
- file.WriteObject(static_cast<u32>(gmem.GetCbufIndex()));
- file.WriteObject(static_cast<u32>(gmem.GetCbufOffset()));
- }
+ FileUtil::IOFile file = AppendPrecompiledFile();
+ if (!file.IsOpen())
+ return;
- for (const bool clip_distance : entries.clip_distances) {
- file.WriteObject(static_cast<u8>(clip_distance ? 1 : 0));
+ if (!SaveDecompiledFile(file, unique_identifier, code, compressed_code, entries)) {
+ LOG_ERROR(Render_OpenGL,
+ "Failed to save decompiled entry to the precompiled file - removing");
+ file.Close();
+ InvalidatePrecompiled();
}
-
- file.WriteObject(static_cast<u64>(entries.shader_length));
}
void ShaderDiskCacheOpenGL::SaveDump(const ShaderDiskCacheUsage& usage, GLuint program) {
- if (!Settings::values.use_disk_shader_cache) {
+ if (!IsUsable())
return;
- }
-
- FileUtil::IOFile file = AppendPrecompiledFile();
- if (!file.IsOpen()) {
- return;
- }
GLint binary_length{};
glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binary_length);
@@ -452,20 +540,31 @@ void ShaderDiskCacheOpenGL::SaveDump(const ShaderDiskCacheUsage& usage, GLuint p
return;
}
- file.WriteObject(static_cast<u32>(PrecompiledEntryKind::Dump));
+ FileUtil::IOFile file = AppendPrecompiledFile();
+ if (!file.IsOpen())
+ return;
- file.WriteObject(usage);
+ if (file.WriteObject(static_cast<u32>(PrecompiledEntryKind::Dump)) != 1 ||
+ file.WriteObject(usage) != 1 || file.WriteObject(static_cast<u32>(binary_format)) != 1 ||
+ file.WriteObject(static_cast<u32>(binary_length)) != 1 ||
+ file.WriteObject(static_cast<u32>(compressed_binary.size())) != 1 ||
+ file.WriteArray(compressed_binary.data(), compressed_binary.size()) !=
+ compressed_binary.size()) {
+ LOG_ERROR(Render_OpenGL, "Failed to save binary program file in shader={:016x} - removing",
+ usage.unique_identifier);
+ file.Close();
+ InvalidatePrecompiled();
+ return;
+ }
+}
- file.WriteObject(static_cast<u32>(binary_format));
- file.WriteObject(static_cast<u32>(binary_length));
- file.WriteObject(static_cast<u32>(compressed_binary.size()));
- file.WriteArray(compressed_binary.data(), compressed_binary.size());
+bool ShaderDiskCacheOpenGL::IsUsable() const {
+ return tried_to_load && Settings::values.use_disk_shader_cache;
}
FileUtil::IOFile ShaderDiskCacheOpenGL::AppendTransferableFile() const {
- if (!EnsureDirectories()) {
+ if (!EnsureDirectories())
return {};
- }
const auto transferable_path{GetTransferablePath()};
const bool existed = FileUtil::Exists(transferable_path);
@@ -477,15 +576,18 @@ FileUtil::IOFile ShaderDiskCacheOpenGL::AppendTransferableFile() const {
}
if (!existed || file.GetSize() == 0) {
// If the file didn't exist, write its version
- file.WriteObject(NativeVersion);
+ if (file.WriteObject(NativeVersion) != 1) {
+ LOG_ERROR(Render_OpenGL, "Failed to write transferable cache version in path={}",
+ transferable_path);
+ return {};
+ }
}
return file;
}
FileUtil::IOFile ShaderDiskCacheOpenGL::AppendPrecompiledFile() const {
- if (!EnsureDirectories()) {
+ if (!EnsureDirectories())
return {};
- }
const auto precompiled_path{GetPrecompiledPath()};
const bool existed = FileUtil::Exists(precompiled_path);
@@ -497,9 +599,12 @@ FileUtil::IOFile ShaderDiskCacheOpenGL::AppendPrecompiledFile() const {
}
if (!existed || file.GetSize() == 0) {
- std::array<char, ShaderHashSize> hash{};
- std::strcpy(hash.data(), GetShaderHash().c_str());
- file.WriteArray(hash.data(), hash.size());
+ const auto hash{GetShaderCacheVersionHash()};
+ if (file.WriteArray(hash.data(), hash.size()) != hash.size()) {
+ LOG_ERROR(Render_OpenGL, "Failed to write precompiled cache version hash in path={}",
+ precompiled_path);
+ return {};
+ }
}
return file;
}
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 4bffe4307..ddcd4cf51 100644
--- a/src/video_core/renderer_opengl/gl_shader_disk_cache.h
+++ b/src/video_core/renderer_opengl/gl_shader_disk_cache.h
@@ -53,15 +53,15 @@ struct BaseBindings {
/// Describes a shader how it's used by the guest GPU
class ShaderDiskCacheRaw {
public:
- explicit ShaderDiskCacheRaw(FileUtil::IOFile& file);
-
explicit ShaderDiskCacheRaw(u64 unique_identifier, Maxwell::ShaderProgram program_type,
u32 program_code_size, u32 program_code_size_b,
ProgramCode program_code, ProgramCode program_code_b);
-
+ ShaderDiskCacheRaw();
~ShaderDiskCacheRaw();
- void Save(FileUtil::IOFile& file) const;
+ bool Load(FileUtil::IOFile& file);
+
+ bool Save(FileUtil::IOFile& file) const;
u64 GetUniqueIdentifier() const {
return unique_identifier;
@@ -158,10 +158,10 @@ public:
LoadPrecompiled();
/// Removes the transferable (and precompiled) cache file.
- bool InvalidateTransferable() const;
+ void InvalidateTransferable() const;
/// Removes the precompiled cache file.
- bool InvalidatePrecompiled() const;
+ void InvalidatePrecompiled() const;
/// Saves a raw dump to the transferable file. Checks for collisions.
void SaveRaw(const ShaderDiskCacheRaw& entry);
@@ -177,6 +177,22 @@ public:
void SaveDump(const ShaderDiskCacheUsage& usage, GLuint program);
private:
+ /// Loads the transferable cache. Returns empty on failure.
+ std::optional<std::pair<std::map<u64, ShaderDiskCacheDecompiled>,
+ std::map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
+ LoadPrecompiledFile(FileUtil::IOFile& file);
+
+ /// Loads a decompiled cache entry from the passed file. Returns empty on failure.
+ std::optional<ShaderDiskCacheDecompiled> LoadDecompiledEntry(FileUtil::IOFile& file);
+
+ /// Saves a decompiled entry to the passed file. Returns true on success.
+ bool SaveDecompiledFile(FileUtil::IOFile& file, u64 unique_identifier, const std::string& code,
+ const std::vector<u8>& compressed_code,
+ const GLShader::ShaderEntries& entries);
+
+ /// Returns if the cache can be used
+ bool IsUsable() const;
+
/// Opens current game's transferable file and write it's header if it doesn't exist
FileUtil::IOFile AppendTransferableFile() const;
@@ -203,6 +219,8 @@ private:
// Stored transferable shaders
std::map<u64, std::set<ShaderDiskCacheUsage>> transferable;
+ // The cache has been loaded at boot
+ bool tried_to_load{};
};
} // namespace OpenGL \ No newline at end of file