7c53b69c30
The type in the `texOp` in the textureSize instruction doesn't have the exact type on SPIR-V (for example, it is missing the Array flag). This PR gives it the proper type before giving it to the unscaling helper. This fixes the ground textures being broken on Pokemon Scarlet/Violet when scaling. It wasn't finding the texture, so the descriptor index it provided was -1...
838 lines
31 KiB
C#
838 lines
31 KiB
C#
using Ryujinx.Graphics.GAL;
|
|
using Ryujinx.Graphics.Shader;
|
|
using Ryujinx.Graphics.Shader.Translation;
|
|
using System;
|
|
using System.IO;
|
|
using System.Numerics;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
|
|
{
|
|
/// <summary>
|
|
/// On-disk shader cache storage for host code.
|
|
/// </summary>
|
|
class DiskCacheHostStorage
|
|
{
|
|
private const uint TocsMagic = (byte)'T' | ((byte)'O' << 8) | ((byte)'C' << 16) | ((byte)'S' << 24);
|
|
private const uint TochMagic = (byte)'T' | ((byte)'O' << 8) | ((byte)'C' << 16) | ((byte)'H' << 24);
|
|
private const uint ShdiMagic = (byte)'S' | ((byte)'H' << 8) | ((byte)'D' << 16) | ((byte)'I' << 24);
|
|
private const uint BufdMagic = (byte)'B' | ((byte)'U' << 8) | ((byte)'F' << 16) | ((byte)'D' << 24);
|
|
private const uint TexdMagic = (byte)'T' | ((byte)'E' << 8) | ((byte)'X' << 16) | ((byte)'D' << 24);
|
|
|
|
private const ushort FileFormatVersionMajor = 1;
|
|
private const ushort FileFormatVersionMinor = 2;
|
|
private const uint FileFormatVersionPacked = ((uint)FileFormatVersionMajor << 16) | FileFormatVersionMinor;
|
|
private const uint CodeGenVersion = 3863;
|
|
|
|
private const string SharedTocFileName = "shared.toc";
|
|
private const string SharedDataFileName = "shared.data";
|
|
|
|
private readonly string _basePath;
|
|
|
|
public bool CacheEnabled => !string.IsNullOrEmpty(_basePath);
|
|
|
|
/// <summary>
|
|
/// TOC (Table of contents) file header.
|
|
/// </summary>
|
|
private struct TocHeader
|
|
{
|
|
/// <summary>
|
|
/// Magic value, for validation and identification.
|
|
/// </summary>
|
|
public uint Magic;
|
|
|
|
/// <summary>
|
|
/// File format version.
|
|
/// </summary>
|
|
public uint FormatVersion;
|
|
|
|
/// <summary>
|
|
/// Generated shader code version.
|
|
/// </summary>
|
|
public uint CodeGenVersion;
|
|
|
|
/// <summary>
|
|
/// Header padding.
|
|
/// </summary>
|
|
public uint Padding;
|
|
|
|
/// <summary>
|
|
/// Timestamp of when the file was first created.
|
|
/// </summary>
|
|
public ulong Timestamp;
|
|
|
|
/// <summary>
|
|
/// Reserved space, to be used in the future. Write as zero.
|
|
/// </summary>
|
|
public ulong Reserved;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Offset and size pair.
|
|
/// </summary>
|
|
private struct OffsetAndSize
|
|
{
|
|
/// <summary>
|
|
/// Offset.
|
|
/// </summary>
|
|
public ulong Offset;
|
|
|
|
/// <summary>
|
|
/// Size of uncompressed data.
|
|
/// </summary>
|
|
public uint UncompressedSize;
|
|
|
|
/// <summary>
|
|
/// Size of compressed data.
|
|
/// </summary>
|
|
public uint CompressedSize;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Per-stage data entry.
|
|
/// </summary>
|
|
private struct DataEntryPerStage
|
|
{
|
|
/// <summary>
|
|
/// Index of the guest code on the guest code cache TOC file.
|
|
/// </summary>
|
|
public int GuestCodeIndex;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Per-program data entry.
|
|
/// </summary>
|
|
private struct DataEntry
|
|
{
|
|
/// <summary>
|
|
/// Bit mask where each bit set is a used shader stage. Should be zero for compute shaders.
|
|
/// </summary>
|
|
public uint StagesBitMask;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Per-stage shader information, returned by the translator.
|
|
/// </summary>
|
|
private struct DataShaderInfo
|
|
{
|
|
/// <summary>
|
|
/// Total constant buffers used.
|
|
/// </summary>
|
|
public ushort CBuffersCount;
|
|
|
|
/// <summary>
|
|
/// Total storage buffers used.
|
|
/// </summary>
|
|
public ushort SBuffersCount;
|
|
|
|
/// <summary>
|
|
/// Total textures used.
|
|
/// </summary>
|
|
public ushort TexturesCount;
|
|
|
|
/// <summary>
|
|
/// Total images used.
|
|
/// </summary>
|
|
public ushort ImagesCount;
|
|
|
|
/// <summary>
|
|
/// Shader stage.
|
|
/// </summary>
|
|
public ShaderStage Stage;
|
|
|
|
/// <summary>
|
|
/// Indicates if the shader accesses the Instance ID built-in variable.
|
|
/// </summary>
|
|
public bool UsesInstanceId;
|
|
|
|
/// <summary>
|
|
/// Indicates if the shader modifies the Layer built-in variable.
|
|
/// </summary>
|
|
public bool UsesRtLayer;
|
|
|
|
/// <summary>
|
|
/// Bit mask with the clip distances written on the vertex stage.
|
|
/// </summary>
|
|
public byte ClipDistancesWritten;
|
|
|
|
/// <summary>
|
|
/// Bit mask of the render target components written by the fragment stage.
|
|
/// </summary>
|
|
public int FragmentOutputMap;
|
|
|
|
/// <summary>
|
|
/// Indicates if the vertex shader accesses draw parameters.
|
|
/// </summary>
|
|
public bool UsesDrawParameters;
|
|
}
|
|
|
|
private readonly DiskCacheGuestStorage _guestStorage;
|
|
|
|
/// <summary>
|
|
/// Creates a disk cache host storage.
|
|
/// </summary>
|
|
/// <param name="basePath">Base path of the shader cache</param>
|
|
public DiskCacheHostStorage(string basePath)
|
|
{
|
|
_basePath = basePath;
|
|
_guestStorage = new DiskCacheGuestStorage(basePath);
|
|
|
|
if (CacheEnabled)
|
|
{
|
|
Directory.CreateDirectory(basePath);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the total of host programs on the cache.
|
|
/// </summary>
|
|
/// <returns>Host programs count</returns>
|
|
public int GetProgramCount()
|
|
{
|
|
string tocFilePath = Path.Combine(_basePath, SharedTocFileName);
|
|
|
|
if (!File.Exists(tocFilePath))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return Math.Max((int)((new FileInfo(tocFilePath).Length - Unsafe.SizeOf<TocHeader>()) / sizeof(ulong)), 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Guest the name of the host program cache file, with extension.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
/// <returns>Name of the file, without extension</returns>
|
|
private static string GetHostFileName(GpuContext context)
|
|
{
|
|
string apiName = context.Capabilities.Api.ToString().ToLowerInvariant();
|
|
string vendorName = RemoveInvalidCharacters(context.Capabilities.VendorName.ToLowerInvariant());
|
|
return $"{apiName}_{vendorName}";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes invalid path characters and spaces from a file name.
|
|
/// </summary>
|
|
/// <param name="fileName">File name</param>
|
|
/// <returns>Filtered file name</returns>
|
|
private static string RemoveInvalidCharacters(string fileName)
|
|
{
|
|
int indexOfSpace = fileName.IndexOf(' ');
|
|
if (indexOfSpace >= 0)
|
|
{
|
|
fileName = fileName.Substring(0, indexOfSpace);
|
|
}
|
|
|
|
return string.Concat(fileName.Split(Path.GetInvalidFileNameChars(), StringSplitOptions.RemoveEmptyEntries));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the name of the TOC host file.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
/// <returns>File name</returns>
|
|
private static string GetHostTocFileName(GpuContext context)
|
|
{
|
|
return GetHostFileName(context) + ".toc";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the name of the data host file.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
/// <returns>File name</returns>
|
|
private static string GetHostDataFileName(GpuContext context)
|
|
{
|
|
return GetHostFileName(context) + ".data";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if a disk cache exists for the current application.
|
|
/// </summary>
|
|
/// <returns>True if a disk cache exists, false otherwise</returns>
|
|
public bool CacheExists()
|
|
{
|
|
string tocFilePath = Path.Combine(_basePath, SharedTocFileName);
|
|
string dataFilePath = Path.Combine(_basePath, SharedDataFileName);
|
|
|
|
if (!File.Exists(tocFilePath) || !File.Exists(dataFilePath) || !_guestStorage.TocFileExists() || !_guestStorage.DataFileExists())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loads all shaders from the cache.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
/// <param name="loader">Parallel disk cache loader</param>
|
|
public void LoadShaders(GpuContext context, ParallelDiskCacheLoader loader)
|
|
{
|
|
if (!CacheExists())
|
|
{
|
|
return;
|
|
}
|
|
|
|
Stream hostTocFileStream = null;
|
|
Stream hostDataFileStream = null;
|
|
|
|
try
|
|
{
|
|
using var tocFileStream = DiskCacheCommon.OpenFile(_basePath, SharedTocFileName, writable: false);
|
|
using var dataFileStream = DiskCacheCommon.OpenFile(_basePath, SharedDataFileName, writable: false);
|
|
|
|
using var guestTocFileStream = _guestStorage.OpenTocFileStream();
|
|
using var guestDataFileStream = _guestStorage.OpenDataFileStream();
|
|
|
|
BinarySerializer tocReader = new BinarySerializer(tocFileStream);
|
|
BinarySerializer dataReader = new BinarySerializer(dataFileStream);
|
|
|
|
TocHeader header = new TocHeader();
|
|
|
|
if (!tocReader.TryRead(ref header) || header.Magic != TocsMagic)
|
|
{
|
|
throw new DiskCacheLoadException(DiskCacheLoadResult.FileCorruptedGeneric);
|
|
}
|
|
|
|
if (header.FormatVersion != FileFormatVersionPacked)
|
|
{
|
|
throw new DiskCacheLoadException(DiskCacheLoadResult.IncompatibleVersion);
|
|
}
|
|
|
|
bool loadHostCache = header.CodeGenVersion == CodeGenVersion;
|
|
|
|
int programIndex = 0;
|
|
|
|
DataEntry entry = new DataEntry();
|
|
|
|
while (tocFileStream.Position < tocFileStream.Length && loader.Active)
|
|
{
|
|
ulong dataOffset = 0;
|
|
tocReader.Read(ref dataOffset);
|
|
|
|
if ((ulong)dataOffset >= (ulong)dataFileStream.Length)
|
|
{
|
|
throw new DiskCacheLoadException(DiskCacheLoadResult.FileCorruptedGeneric);
|
|
}
|
|
|
|
dataFileStream.Seek((long)dataOffset, SeekOrigin.Begin);
|
|
|
|
dataReader.BeginCompression();
|
|
dataReader.Read(ref entry);
|
|
uint stagesBitMask = entry.StagesBitMask;
|
|
|
|
if ((stagesBitMask & ~0x3fu) != 0)
|
|
{
|
|
throw new DiskCacheLoadException(DiskCacheLoadResult.FileCorruptedGeneric);
|
|
}
|
|
|
|
bool isCompute = stagesBitMask == 0;
|
|
if (isCompute)
|
|
{
|
|
stagesBitMask = 1;
|
|
}
|
|
|
|
GuestCodeAndCbData?[] guestShaders = new GuestCodeAndCbData?[isCompute ? 1 : Constants.ShaderStages + 1];
|
|
|
|
DataEntryPerStage stageEntry = new DataEntryPerStage();
|
|
|
|
while (stagesBitMask != 0)
|
|
{
|
|
int stageIndex = BitOperations.TrailingZeroCount(stagesBitMask);
|
|
|
|
dataReader.Read(ref stageEntry);
|
|
|
|
guestShaders[stageIndex] = _guestStorage.LoadShader(
|
|
guestTocFileStream,
|
|
guestDataFileStream,
|
|
stageEntry.GuestCodeIndex);
|
|
|
|
stagesBitMask &= ~(1u << stageIndex);
|
|
}
|
|
|
|
ShaderSpecializationState specState = ShaderSpecializationState.Read(ref dataReader);
|
|
dataReader.EndCompression();
|
|
|
|
if (loadHostCache)
|
|
{
|
|
(byte[] hostCode, CachedShaderStage[] shaders) = ReadHostCode(
|
|
context,
|
|
ref hostTocFileStream,
|
|
ref hostDataFileStream,
|
|
guestShaders,
|
|
programIndex,
|
|
header.Timestamp);
|
|
|
|
if (hostCode != null)
|
|
{
|
|
bool hasFragmentShader = shaders.Length > 5 && shaders[5] != null;
|
|
int fragmentOutputMap = hasFragmentShader ? shaders[5].Info.FragmentOutputMap : -1;
|
|
|
|
ShaderInfo shaderInfo = specState.PipelineState.HasValue
|
|
? new ShaderInfo(fragmentOutputMap, specState.PipelineState.Value, fromCache: true)
|
|
: new ShaderInfo(fragmentOutputMap, fromCache: true);
|
|
|
|
IProgram hostProgram;
|
|
|
|
if (context.Capabilities.Api == TargetApi.Vulkan)
|
|
{
|
|
ShaderSource[] shaderSources = ShaderBinarySerializer.Unpack(shaders, hostCode, isCompute);
|
|
|
|
hostProgram = context.Renderer.CreateProgram(shaderSources, shaderInfo);
|
|
}
|
|
else
|
|
{
|
|
hostProgram = context.Renderer.LoadProgramBinary(hostCode, hasFragmentShader, shaderInfo);
|
|
}
|
|
|
|
CachedShaderProgram program = new CachedShaderProgram(hostProgram, specState, shaders);
|
|
|
|
loader.QueueHostProgram(program, hostCode, programIndex, isCompute);
|
|
}
|
|
else
|
|
{
|
|
loadHostCache = false;
|
|
}
|
|
}
|
|
|
|
if (!loadHostCache)
|
|
{
|
|
loader.QueueGuestProgram(guestShaders, specState, programIndex, isCompute);
|
|
}
|
|
|
|
loader.CheckCompilation();
|
|
programIndex++;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_guestStorage.ClearMemoryCache();
|
|
|
|
hostTocFileStream?.Dispose();
|
|
hostDataFileStream?.Dispose();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads the host code for a given shader, if existent.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
/// <param name="tocFileStream">Host TOC file stream, intialized if needed</param>
|
|
/// <param name="dataFileStream">Host data file stream, initialized if needed</param>
|
|
/// <param name="guestShaders">Guest shader code for each active stage</param>
|
|
/// <param name="programIndex">Index of the program on the cache</param>
|
|
/// <param name="expectedTimestamp">Timestamp of the shared cache file. The host file must be newer than it</param>
|
|
/// <returns>Host binary code, or null if not found</returns>
|
|
private (byte[], CachedShaderStage[]) ReadHostCode(
|
|
GpuContext context,
|
|
ref Stream tocFileStream,
|
|
ref Stream dataFileStream,
|
|
GuestCodeAndCbData?[] guestShaders,
|
|
int programIndex,
|
|
ulong expectedTimestamp)
|
|
{
|
|
if (tocFileStream == null && dataFileStream == null)
|
|
{
|
|
string tocFilePath = Path.Combine(_basePath, GetHostTocFileName(context));
|
|
string dataFilePath = Path.Combine(_basePath, GetHostDataFileName(context));
|
|
|
|
if (!File.Exists(tocFilePath) || !File.Exists(dataFilePath))
|
|
{
|
|
return (null, null);
|
|
}
|
|
|
|
tocFileStream = DiskCacheCommon.OpenFile(_basePath, GetHostTocFileName(context), writable: false);
|
|
dataFileStream = DiskCacheCommon.OpenFile(_basePath, GetHostDataFileName(context), writable: false);
|
|
|
|
BinarySerializer tempTocReader = new BinarySerializer(tocFileStream);
|
|
|
|
TocHeader header = new TocHeader();
|
|
|
|
tempTocReader.Read(ref header);
|
|
|
|
if (header.Timestamp < expectedTimestamp)
|
|
{
|
|
return (null, null);
|
|
}
|
|
}
|
|
|
|
int offset = Unsafe.SizeOf<TocHeader>() + programIndex * Unsafe.SizeOf<OffsetAndSize>();
|
|
if (offset + Unsafe.SizeOf<OffsetAndSize>() > tocFileStream.Length)
|
|
{
|
|
return (null, null);
|
|
}
|
|
|
|
if ((ulong)offset >= (ulong)dataFileStream.Length)
|
|
{
|
|
throw new DiskCacheLoadException(DiskCacheLoadResult.FileCorruptedGeneric);
|
|
}
|
|
|
|
tocFileStream.Seek(offset, SeekOrigin.Begin);
|
|
|
|
BinarySerializer tocReader = new BinarySerializer(tocFileStream);
|
|
|
|
OffsetAndSize offsetAndSize = new OffsetAndSize();
|
|
tocReader.Read(ref offsetAndSize);
|
|
|
|
if (offsetAndSize.Offset >= (ulong)dataFileStream.Length)
|
|
{
|
|
throw new DiskCacheLoadException(DiskCacheLoadResult.FileCorruptedGeneric);
|
|
}
|
|
|
|
dataFileStream.Seek((long)offsetAndSize.Offset, SeekOrigin.Begin);
|
|
|
|
byte[] hostCode = new byte[offsetAndSize.UncompressedSize];
|
|
|
|
BinarySerializer.ReadCompressed(dataFileStream, hostCode);
|
|
|
|
CachedShaderStage[] shaders = new CachedShaderStage[guestShaders.Length];
|
|
BinarySerializer dataReader = new BinarySerializer(dataFileStream);
|
|
|
|
dataFileStream.Seek((long)(offsetAndSize.Offset + offsetAndSize.CompressedSize), SeekOrigin.Begin);
|
|
|
|
dataReader.BeginCompression();
|
|
|
|
for (int index = 0; index < guestShaders.Length; index++)
|
|
{
|
|
if (!guestShaders[index].HasValue)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
GuestCodeAndCbData guestShader = guestShaders[index].Value;
|
|
ShaderProgramInfo info = index != 0 || guestShaders.Length == 1 ? ReadShaderProgramInfo(ref dataReader) : null;
|
|
|
|
shaders[index] = new CachedShaderStage(info, guestShader.Code, guestShader.Cb1Data);
|
|
}
|
|
|
|
dataReader.EndCompression();
|
|
|
|
return (hostCode, shaders);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets output streams for the disk cache, for faster batch writing.
|
|
/// </summary>
|
|
/// <param name="context">The GPU context, used to determine the host disk cache</param>
|
|
/// <returns>A collection of disk cache output streams</returns>
|
|
public DiskCacheOutputStreams GetOutputStreams(GpuContext context)
|
|
{
|
|
var tocFileStream = DiskCacheCommon.OpenFile(_basePath, SharedTocFileName, writable: true);
|
|
var dataFileStream = DiskCacheCommon.OpenFile(_basePath, SharedDataFileName, writable: true);
|
|
|
|
var hostTocFileStream = DiskCacheCommon.OpenFile(_basePath, GetHostTocFileName(context), writable: true);
|
|
var hostDataFileStream = DiskCacheCommon.OpenFile(_basePath, GetHostDataFileName(context), writable: true);
|
|
|
|
return new DiskCacheOutputStreams(tocFileStream, dataFileStream, hostTocFileStream, hostDataFileStream);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a shader to the cache.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
/// <param name="program">Cached program</param>
|
|
/// <param name="hostCode">Optional host binary code</param>
|
|
/// <param name="streams">Output streams to use</param>
|
|
public void AddShader(GpuContext context, CachedShaderProgram program, ReadOnlySpan<byte> hostCode, DiskCacheOutputStreams streams = null)
|
|
{
|
|
uint stagesBitMask = 0;
|
|
|
|
for (int index = 0; index < program.Shaders.Length; index++)
|
|
{
|
|
var shader = program.Shaders[index];
|
|
if (shader == null || (shader.Info != null && shader.Info.Stage == ShaderStage.Compute))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
stagesBitMask |= 1u << index;
|
|
}
|
|
|
|
var tocFileStream = streams != null ? streams.TocFileStream : DiskCacheCommon.OpenFile(_basePath, SharedTocFileName, writable: true);
|
|
var dataFileStream = streams != null ? streams.DataFileStream : DiskCacheCommon.OpenFile(_basePath, SharedDataFileName, writable: true);
|
|
|
|
ulong timestamp = (ulong)DateTime.UtcNow.Subtract(DateTime.UnixEpoch).TotalSeconds;
|
|
|
|
if (tocFileStream.Length == 0)
|
|
{
|
|
TocHeader header = new TocHeader();
|
|
CreateToc(tocFileStream, ref header, TocsMagic, CodeGenVersion, timestamp);
|
|
}
|
|
|
|
tocFileStream.Seek(0, SeekOrigin.End);
|
|
dataFileStream.Seek(0, SeekOrigin.End);
|
|
|
|
BinarySerializer tocWriter = new BinarySerializer(tocFileStream);
|
|
BinarySerializer dataWriter = new BinarySerializer(dataFileStream);
|
|
|
|
ulong dataOffset = (ulong)dataFileStream.Position;
|
|
tocWriter.Write(ref dataOffset);
|
|
|
|
DataEntry entry = new DataEntry();
|
|
|
|
entry.StagesBitMask = stagesBitMask;
|
|
|
|
dataWriter.BeginCompression(DiskCacheCommon.GetCompressionAlgorithm());
|
|
dataWriter.Write(ref entry);
|
|
|
|
DataEntryPerStage stageEntry = new DataEntryPerStage();
|
|
|
|
for (int index = 0; index < program.Shaders.Length; index++)
|
|
{
|
|
var shader = program.Shaders[index];
|
|
if (shader == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
stageEntry.GuestCodeIndex = _guestStorage.AddShader(shader.Code, shader.Cb1Data);
|
|
|
|
dataWriter.Write(ref stageEntry);
|
|
}
|
|
|
|
program.SpecializationState.Write(ref dataWriter);
|
|
dataWriter.EndCompression();
|
|
|
|
if (streams == null)
|
|
{
|
|
tocFileStream.Dispose();
|
|
dataFileStream.Dispose();
|
|
}
|
|
|
|
if (hostCode.IsEmpty)
|
|
{
|
|
return;
|
|
}
|
|
|
|
WriteHostCode(context, hostCode, program.Shaders, streams, timestamp);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears all content from the guest cache files.
|
|
/// </summary>
|
|
public void ClearGuestCache()
|
|
{
|
|
_guestStorage.ClearCache();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears all content from the shared cache files.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
public void ClearSharedCache()
|
|
{
|
|
using var tocFileStream = DiskCacheCommon.OpenFile(_basePath, SharedTocFileName, writable: true);
|
|
using var dataFileStream = DiskCacheCommon.OpenFile(_basePath, SharedDataFileName, writable: true);
|
|
|
|
tocFileStream.SetLength(0);
|
|
dataFileStream.SetLength(0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes all content from the host cache files.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
public void ClearHostCache(GpuContext context)
|
|
{
|
|
using var tocFileStream = DiskCacheCommon.OpenFile(_basePath, GetHostTocFileName(context), writable: true);
|
|
using var dataFileStream = DiskCacheCommon.OpenFile(_basePath, GetHostDataFileName(context), writable: true);
|
|
|
|
tocFileStream.SetLength(0);
|
|
dataFileStream.SetLength(0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the host binary code on the host cache.
|
|
/// </summary>
|
|
/// <param name="context">GPU context</param>
|
|
/// <param name="hostCode">Host binary code</param>
|
|
/// <param name="shaders">Shader stages to be added to the host cache</param>
|
|
/// <param name="streams">Output streams to use</param>
|
|
/// <param name="timestamp">File creation timestamp</param>
|
|
private void WriteHostCode(
|
|
GpuContext context,
|
|
ReadOnlySpan<byte> hostCode,
|
|
CachedShaderStage[] shaders,
|
|
DiskCacheOutputStreams streams,
|
|
ulong timestamp)
|
|
{
|
|
var tocFileStream = streams != null ? streams.HostTocFileStream : DiskCacheCommon.OpenFile(_basePath, GetHostTocFileName(context), writable: true);
|
|
var dataFileStream = streams != null ? streams.HostDataFileStream : DiskCacheCommon.OpenFile(_basePath, GetHostDataFileName(context), writable: true);
|
|
|
|
if (tocFileStream.Length == 0)
|
|
{
|
|
TocHeader header = new TocHeader();
|
|
CreateToc(tocFileStream, ref header, TochMagic, 0, timestamp);
|
|
}
|
|
|
|
tocFileStream.Seek(0, SeekOrigin.End);
|
|
dataFileStream.Seek(0, SeekOrigin.End);
|
|
|
|
BinarySerializer tocWriter = new BinarySerializer(tocFileStream);
|
|
BinarySerializer dataWriter = new BinarySerializer(dataFileStream);
|
|
|
|
OffsetAndSize offsetAndSize = new OffsetAndSize();
|
|
offsetAndSize.Offset = (ulong)dataFileStream.Position;
|
|
offsetAndSize.UncompressedSize = (uint)hostCode.Length;
|
|
|
|
long dataStartPosition = dataFileStream.Position;
|
|
|
|
BinarySerializer.WriteCompressed(dataFileStream, hostCode, DiskCacheCommon.GetCompressionAlgorithm());
|
|
|
|
offsetAndSize.CompressedSize = (uint)(dataFileStream.Position - dataStartPosition);
|
|
|
|
tocWriter.Write(ref offsetAndSize);
|
|
|
|
dataWriter.BeginCompression(DiskCacheCommon.GetCompressionAlgorithm());
|
|
|
|
for (int index = 0; index < shaders.Length; index++)
|
|
{
|
|
if (shaders[index] != null)
|
|
{
|
|
WriteShaderProgramInfo(ref dataWriter, shaders[index].Info);
|
|
}
|
|
}
|
|
|
|
dataWriter.EndCompression();
|
|
|
|
if (streams == null)
|
|
{
|
|
tocFileStream.Dispose();
|
|
dataFileStream.Dispose();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a TOC file for the host or shared cache.
|
|
/// </summary>
|
|
/// <param name="tocFileStream">TOC file stream</param>
|
|
/// <param name="header">Set to the TOC file header</param>
|
|
/// <param name="magic">Magic value to be written</param>
|
|
/// <param name="codegenVersion">Shader codegen version, only valid for the host file</param>
|
|
/// <param name="timestamp">File creation timestamp</param>
|
|
private void CreateToc(Stream tocFileStream, ref TocHeader header, uint magic, uint codegenVersion, ulong timestamp)
|
|
{
|
|
BinarySerializer writer = new BinarySerializer(tocFileStream);
|
|
|
|
header.Magic = magic;
|
|
header.FormatVersion = FileFormatVersionPacked;
|
|
header.CodeGenVersion = codegenVersion;
|
|
header.Padding = 0;
|
|
header.Reserved = 0;
|
|
header.Timestamp = timestamp;
|
|
|
|
if (tocFileStream.Length > 0)
|
|
{
|
|
tocFileStream.Seek(0, SeekOrigin.Begin);
|
|
tocFileStream.SetLength(0);
|
|
}
|
|
|
|
writer.Write(ref header);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads the shader program info from the cache.
|
|
/// </summary>
|
|
/// <param name="dataReader">Cache data reader</param>
|
|
/// <returns>Shader program info</returns>
|
|
private static ShaderProgramInfo ReadShaderProgramInfo(ref BinarySerializer dataReader)
|
|
{
|
|
DataShaderInfo dataInfo = new DataShaderInfo();
|
|
|
|
dataReader.ReadWithMagicAndSize(ref dataInfo, ShdiMagic);
|
|
|
|
BufferDescriptor[] cBuffers = new BufferDescriptor[dataInfo.CBuffersCount];
|
|
BufferDescriptor[] sBuffers = new BufferDescriptor[dataInfo.SBuffersCount];
|
|
TextureDescriptor[] textures = new TextureDescriptor[dataInfo.TexturesCount];
|
|
TextureDescriptor[] images = new TextureDescriptor[dataInfo.ImagesCount];
|
|
|
|
for (int index = 0; index < dataInfo.CBuffersCount; index++)
|
|
{
|
|
dataReader.ReadWithMagicAndSize(ref cBuffers[index], BufdMagic);
|
|
}
|
|
|
|
for (int index = 0; index < dataInfo.SBuffersCount; index++)
|
|
{
|
|
dataReader.ReadWithMagicAndSize(ref sBuffers[index], BufdMagic);
|
|
}
|
|
|
|
for (int index = 0; index < dataInfo.TexturesCount; index++)
|
|
{
|
|
dataReader.ReadWithMagicAndSize(ref textures[index], TexdMagic);
|
|
}
|
|
|
|
for (int index = 0; index < dataInfo.ImagesCount; index++)
|
|
{
|
|
dataReader.ReadWithMagicAndSize(ref images[index], TexdMagic);
|
|
}
|
|
|
|
return new ShaderProgramInfo(
|
|
cBuffers,
|
|
sBuffers,
|
|
textures,
|
|
images,
|
|
dataInfo.Stage,
|
|
dataInfo.UsesInstanceId,
|
|
dataInfo.UsesDrawParameters,
|
|
dataInfo.UsesRtLayer,
|
|
dataInfo.ClipDistancesWritten,
|
|
dataInfo.FragmentOutputMap);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the shader program info into the cache.
|
|
/// </summary>
|
|
/// <param name="dataWriter">Cache data writer</param>
|
|
/// <param name="info">Program info</param>
|
|
private static void WriteShaderProgramInfo(ref BinarySerializer dataWriter, ShaderProgramInfo info)
|
|
{
|
|
if (info == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
DataShaderInfo dataInfo = new DataShaderInfo();
|
|
|
|
dataInfo.CBuffersCount = (ushort)info.CBuffers.Count;
|
|
dataInfo.SBuffersCount = (ushort)info.SBuffers.Count;
|
|
dataInfo.TexturesCount = (ushort)info.Textures.Count;
|
|
dataInfo.ImagesCount = (ushort)info.Images.Count;
|
|
dataInfo.Stage = info.Stage;
|
|
dataInfo.UsesInstanceId = info.UsesInstanceId;
|
|
dataInfo.UsesDrawParameters = info.UsesDrawParameters;
|
|
dataInfo.UsesRtLayer = info.UsesRtLayer;
|
|
dataInfo.ClipDistancesWritten = info.ClipDistancesWritten;
|
|
dataInfo.FragmentOutputMap = info.FragmentOutputMap;
|
|
|
|
dataWriter.WriteWithMagicAndSize(ref dataInfo, ShdiMagic);
|
|
|
|
for (int index = 0; index < info.CBuffers.Count; index++)
|
|
{
|
|
var entry = info.CBuffers[index];
|
|
dataWriter.WriteWithMagicAndSize(ref entry, BufdMagic);
|
|
}
|
|
|
|
for (int index = 0; index < info.SBuffers.Count; index++)
|
|
{
|
|
var entry = info.SBuffers[index];
|
|
dataWriter.WriteWithMagicAndSize(ref entry, BufdMagic);
|
|
}
|
|
|
|
for (int index = 0; index < info.Textures.Count; index++)
|
|
{
|
|
var entry = info.Textures[index];
|
|
dataWriter.WriteWithMagicAndSize(ref entry, TexdMagic);
|
|
}
|
|
|
|
for (int index = 0; index < info.Images.Count; index++)
|
|
{
|
|
var entry = info.Images[index];
|
|
dataWriter.WriteWithMagicAndSize(ref entry, TexdMagic);
|
|
}
|
|
}
|
|
}
|
|
}
|