eden-emu
/
eden
mirror of https://git.eden-emu.dev/eden-emu/eden.git
1
0
Fork 0
Code Releases Wiki Activity
Browse Source

gl_shader_disk_cache: Guard reads and writes against failure

nce_cpp
ReinUsesLisp 7 years ago
parent
720c2456f4
commit
f9bcb4e842
2 changed files with 339 additions and 216 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 525
      src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
  2. 30
      src/video_core/renderer_opengl/gl_shader_disk_cache.h

525
src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
View File

@ -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;
}

30
src/video_core/renderer_opengl/gl_shader_disk_cache.h
View File

@ -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
Write Preview
Loading…
Cancel
Save