diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/video_core/renderer_opengl/gl_shader_disk_cache.cpp | 525 | ||||
| -rw-r--r-- | src/video_core/renderer_opengl/gl_shader_disk_cache.h | 30 |
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 |