+using Ryujinx.Graphics.Shader.Translation;

+

+ public readonly TargetApi Api;

+ public readonly string VendorName;

+

+ TargetApi api,

+ string vendorName,

+ Api = api;

+ VendorName = vendorName;

+ IProgram CreateProgram(ShaderSource[] shaders, ShaderInfo info);

+namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer

+namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer

+ private ShaderSource[] _shaders;

+ public SourceProgramRequest(ThreadedProgram program, ShaderSource[] shaders, ShaderInfo info)

+ return renderer.CreateProgram(_shaders, _info);

+ public IProgram CreateProgram(ShaderSource[] shaders, ShaderInfo info)

+using Ryujinx.Graphics.Shader;

+using Ryujinx.Graphics.Shader.Translation;

+

+namespace Ryujinx.Graphics.GAL

+{

+ public struct ShaderSource

+ {

+ public string Code { get; }

+ public byte[] BinaryCode { get; }

+ public ShaderStage Stage { get; }

+ public TargetLanguage Language { get; }

+

+ public ShaderSource(string code, byte[] binaryCode, ShaderStage stage, TargetLanguage language)

+ {

+ Code = code;

+ BinaryCode = binaryCode;

+ Stage = stage;

+ Language = language;

+ }

+

+ public ShaderSource(string code, ShaderStage stage, TargetLanguage language) : this(code, null, stage, language)

+ {

+ }

+

+ public ShaderSource(byte[] binaryCode, ShaderStage stage, TargetLanguage language) : this(null, binaryCode, stage, language)

+ {

+ }

+ }

+} \ No newline at end of file

+ GpuChannelPoolState poolState = new GpuChannelPoolState(

+ _state.State.SetBindlessTextureConstantBufferSlotSelect);

+

+ GpuChannelComputeState computeState = new GpuChannelComputeState(

+ CachedShaderProgram cs = memoryManager.Physical.ShaderCache.GetComputeShader(_channel, poolState, computeState, shaderGpuVa);

+

+ private ShaderSpecializationState _shaderSpecState;

+ // If any state that the shader depends on changed,

+ // then we may need to compile/bind a different version

+ // of the shader for the new state.

+ if (_shaderSpecState != null)

+ {

+ if (!_shaderSpecState.MatchesGraphics(_channel, GetPoolState()))

+ {

+ ForceShaderUpdate();

+ }

+ }

+

+ var shaderCache = _channel.MemoryManager.Physical.ShaderCache;

+ _vtgWritesRtLayer = false;

+ ShaderAddresses addresses = new ShaderAddresses();

+ Span<ulong> addressesSpan = addresses.AsSpan();

+ addressesSpan[index] = baseAddress + shader.Offset;

+ GpuChannelPoolState poolState = GetPoolState();

+ GpuChannelGraphicsState graphicsState = GetGraphicsState();

+ CachedShaderProgram gs = shaderCache.GetGraphicsShader(ref _state.State, _channel, poolState, graphicsState, addresses);

+

+ _shaderSpecState = gs.SpecializationState;

+ _drawState.VsUsesInstanceId = gs.Shaders[1]?.Info.UsesInstanceId ?? false;

+ _vsClipDistancesWritten = gs.Shaders[1]?.Info.ClipDistancesWritten ?? 0;

+ for (int stageIndex = 0; stageIndex < Constants.ShaderStages; stageIndex++)

+ UpdateStageBindings(stageIndex, gs.Shaders[stageIndex + 1]?.Info);

+ }

+ _context.Renderer.Pipeline.SetProgram(gs.HostProgram);

+ }

+ private void UpdateStageBindings(int stage, ShaderProgramInfo info)

+ {

+ _currentProgramInfo[stage] = info;

+ if (info == null)

+ {

+ _channel.TextureManager.RentGraphicsTextureBindings(stage, 0);

+ _channel.TextureManager.RentGraphicsImageBindings(stage, 0);

+ _channel.BufferManager.SetGraphicsStorageBufferBindings(stage, null);

+ _channel.BufferManager.SetGraphicsUniformBufferBindings(stage, null);

+ return;

+ }

+ Span<TextureBindingInfo> textureBindings = _channel.TextureManager.RentGraphicsTextureBindings(stage, info.Textures.Count);

+ if (info.UsesRtLayer)

+ {

+ _vtgWritesRtLayer = true;

+ }

+ for (int index = 0; index < info.Textures.Count; index++)

+ {

+ var descriptor = info.Textures[index];

+ Target target = ShaderTexture.GetTarget(descriptor.Type);

+ textureBindings[index] = new TextureBindingInfo(

+ target,

+ descriptor.Binding,

+ descriptor.CbufSlot,

+ descriptor.HandleIndex,

+ descriptor.Flags);

+ }

+ TextureBindingInfo[] imageBindings = _channel.TextureManager.RentGraphicsImageBindings(stage, info.Images.Count);

+ for (int index = 0; index < info.Images.Count; index++)

+ {

+ var descriptor = info.Images[index];

+

+ Target target = ShaderTexture.GetTarget(descriptor.Type);

+ Format format = ShaderTexture.GetFormat(descriptor.Format);

+

+ imageBindings[index] = new TextureBindingInfo(

+ target,

+ format,

+ descriptor.Binding,

+ descriptor.CbufSlot,

+ descriptor.HandleIndex,

+ descriptor.Flags);

+ _channel.BufferManager.SetGraphicsStorageBufferBindings(stage, info.SBuffers);

+ _channel.BufferManager.SetGraphicsUniformBufferBindings(stage, info.CBuffers);

+ }

+

+ private GpuChannelPoolState GetPoolState()

+ {

+ return new GpuChannelPoolState(

+ _state.State.TexturePoolState.Address.Pack(),

+ _state.State.TexturePoolState.MaximumId,

+ (int)_state.State.TextureBufferIndex);

+ }

+

+ /// <summary>

+ /// Gets the current GPU channel state for shader creation or compatibility verification.

+ /// </summary>

+ /// <returns>Current GPU channel state</returns>

+ private GpuChannelGraphicsState GetGraphicsState()

+ {

+ return new GpuChannelGraphicsState(

+ _state.State.EarlyZForce,

+ _drawState.Topology,

+ _state.State.TessMode);

+ public void InitializeShaderCache(CancellationToken cancellationToken)

+ physicalMemory.ShaderCache.Initialize(cancellationToken);

+ /// Gets a read-only span of data from GPU mapped memory, up to the entire range specified,

+ /// or the last mapped page if the range is not fully mapped.

+ /// </summary>

+ /// <param name="va">GPU virtual address where the data is located</param>

+ /// <param name="size">Size of the data</param>

+ /// <param name="tracked">True if read tracking is triggered on the span</param>

+ /// <returns>The span of the data at the specified memory location</returns>

+ public ReadOnlySpan<byte> GetSpanMapped(ulong va, int size, bool tracked = false)

+ {

+ bool isContiguous = true;

+ int mappedSize;

+

+ if (ValidateAddress(va) && GetPte(va) != PteUnmapped && Physical.IsMapped(Translate(va)))

+ {

+ ulong endVa = va + (ulong)size;

+ ulong endVaAligned = (endVa + PageMask) & ~PageMask;

+ ulong currentVa = va & ~PageMask;

+

+ int pages = (int)((endVaAligned - currentVa) / PageSize);

+

+ for (int page = 0; page < pages - 1; page++)

+ {

+ ulong nextVa = currentVa + PageSize;

+ ulong nextPa = Translate(nextVa);

+

+ if (!ValidateAddress(nextVa) || GetPte(nextVa) == PteUnmapped || !Physical.IsMapped(nextPa))

+ {

+ break;

+ }

+

+ if (Translate(currentVa) + PageSize != nextPa)

+ {

+ isContiguous = false;

+ }

+

+ currentVa += PageSize;

+ }

+

+ currentVa += PageSize;

+

+ if (currentVa > endVa)

+ {

+ currentVa = endVa;

+ }

+

+ mappedSize = (int)(currentVa - va);

+ }

+ else

+ {

+ return ReadOnlySpan<byte>.Empty;

+ }

+

+ if (isContiguous)

+ {

+ return Physical.GetSpan(Translate(va), mappedSize, tracked);

+ }

+ else

+ {

+ Span<byte> data = new byte[mappedSize];

+

+ ReadImpl(va, data, tracked);

+

+ return data;

+ }

+ }

+

+ /// <summary>

+ /// Checks if a given memory page is mapped.

+ /// <param name="address">CPU virtual address of the page</param>

+ public static TransformFeedbackDescriptorOld[] ReadTransformFeedbackInformation(ref ReadOnlySpan<byte> data, GuestShaderCacheHeader header)

+ TransformFeedbackDescriptorOld[] result = new TransformFeedbackDescriptorOld[header.TransformFeedbackCount];

+ result[i] = new TransformFeedbackDescriptorOld(feedbackHeader.BufferIndex, feedbackHeader.Stride, data.Slice(Unsafe.SizeOf<GuestShaderCacheTransformFeedbackHeader>(), feedbackHeader.VaryingLocationsLength).ToArray());

+ default,

+ internal static byte[] Create(ReadOnlySpan<byte> programCode, CachedShaderStage[] codeHolders)

+using Ryujinx.Common;

+using Ryujinx.Common.Logging;

+using Ryujinx.Common.Memory;

+using Ryujinx.Graphics.GAL;

+using Ryujinx.Graphics.Gpu.Engine.Threed;

+using Ryujinx.Graphics.Gpu.Shader.Cache.Definition;

+using Ryujinx.Graphics.Gpu.Shader.DiskCache;

+using Ryujinx.Graphics.Shader;

+using System;

+using System.Collections.Generic;

+using System.Diagnostics;

+using System.IO;

+using System.Runtime.InteropServices;

+

+namespace Ryujinx.Graphics.Gpu.Shader.Cache

+{

+ /// <summary>

+ /// Class handling shader cache migrations.

+ /// </summary>

+ static class Migration

+ {

+ // Last codegen version before the migration to the new cache.

+ private const ulong ShaderCodeGenVersion = 3054;

+

+ /// <summary>

+ /// Migrates from the old cache format to the new one.

+ /// </summary>

+ /// <param name="context">GPU context</param>

+ /// <param name="hostStorage">Disk cache host storage (used to create the new shader files)</param>

+ /// <returns>Number of migrated shaders</returns>

+ public static int MigrateFromLegacyCache(GpuContext context, DiskCacheHostStorage hostStorage)

+ {

+ string baseCacheDirectory = CacheHelper.GetBaseCacheDirectory(GraphicsConfig.TitleId);

+ string cacheDirectory = CacheHelper.GenerateCachePath(baseCacheDirectory, CacheGraphicsApi.Guest, "", "program");

+

+ // If the directory does not exist, we have no old cache.

+ // Exist early as the CacheManager constructor will create the directories.

+ if (!Directory.Exists(cacheDirectory))

+ {

+ return 0;

+ }

+

+ if (GraphicsConfig.EnableShaderCache && GraphicsConfig.TitleId != null)

+ {

+ CacheManager cacheManager = new CacheManager(CacheGraphicsApi.OpenGL, CacheHashType.XxHash128, "glsl", GraphicsConfig.TitleId, ShaderCodeGenVersion);

+

+ bool isReadOnly = cacheManager.IsReadOnly;

+

+ HashSet<Hash128> invalidEntries = null;

+

+ if (isReadOnly)

+ {

+ Logger.Warning?.Print(LogClass.Gpu, "Loading shader cache in read-only mode (cache in use by another program!)");

+ }

+ else

+ {

+ invalidEntries = new HashSet<Hash128>();

+ }

+

+ ReadOnlySpan<Hash128> guestProgramList = cacheManager.GetGuestProgramList();

+

+ for (int programIndex = 0; programIndex < guestProgramList.Length; programIndex++)

+ {

+ Hash128 key = guestProgramList[programIndex];

+

+ byte[] guestProgram = cacheManager.GetGuestProgramByHash(ref key);

+

+ if (guestProgram == null)

+ {

+ Logger.Error?.Print(LogClass.Gpu, $"Ignoring orphan shader hash {key} in cache (is the cache incomplete?)");

+

+ continue;

+ }

+

+ ReadOnlySpan<byte> guestProgramReadOnlySpan = guestProgram;

+

+ ReadOnlySpan<GuestShaderCacheEntry> cachedShaderEntries = GuestShaderCacheEntry.Parse(ref guestProgramReadOnlySpan, out GuestShaderCacheHeader fileHeader);

+

+ if (cachedShaderEntries[0].Header.Stage == ShaderStage.Compute)

+ {

+ Debug.Assert(cachedShaderEntries.Length == 1);

+

+ GuestShaderCacheEntry entry = cachedShaderEntries[0];

+

+ byte[] code = entry.Code.AsSpan(0, entry.Header.Size - entry.Header.Cb1DataSize).ToArray();

+

+ Span<byte> codeSpan = entry.Code;

+ byte[] cb1Data = codeSpan.Slice(codeSpan.Length - entry.Header.Cb1DataSize).ToArray();

+

+ ShaderProgramInfo info = new ShaderProgramInfo(

+ Array.Empty<BufferDescriptor>(),

+ Array.Empty<BufferDescriptor>(),

+ Array.Empty<TextureDescriptor>(),

+ Array.Empty<TextureDescriptor>(),

+ ShaderStage.Compute,

+ false,

+ false,

+ 0,

+ 0);

+

+ GpuChannelComputeState computeState = new GpuChannelComputeState(

+ entry.Header.GpuAccessorHeader.ComputeLocalSizeX,

+ entry.Header.GpuAccessorHeader.ComputeLocalSizeY,

+ entry.Header.GpuAccessorHeader.ComputeLocalSizeZ,

+ entry.Header.GpuAccessorHeader.ComputeLocalMemorySize,

+ entry.Header.GpuAccessorHeader.ComputeSharedMemorySize);

+

+ ShaderSpecializationState specState = new ShaderSpecializationState(computeState);

+

+ foreach (var td in entry.TextureDescriptors)

+ {

+ var handle = td.Key;

+ var data = td.Value;

+

+ specState.RegisterTexture(

+ 0,

+ handle,

+ -1,

+ data.UnpackFormat(),

+ data.UnpackSrgb(),

+ data.UnpackTextureTarget(),

+ data.UnpackTextureCoordNormalized());

+ }

+

+ CachedShaderStage shader = new CachedShaderStage(info, code, cb1Data);

+ CachedShaderProgram program = new CachedShaderProgram(null, specState, shader);

+

+ hostStorage.AddShader(context, program, ReadOnlySpan<byte>.Empty);

+ }

+ else

+ {

+ Debug.Assert(cachedShaderEntries.Length == Constants.ShaderStages);

+

+ CachedShaderStage[] shaders = new CachedShaderStage[Constants.ShaderStages + 1];

+ List<ShaderProgram> shaderPrograms = new List<ShaderProgram>();

+

+ TransformFeedbackDescriptorOld[] tfd = CacheHelper.ReadTransformFeedbackInformation(ref guestProgramReadOnlySpan, fileHeader);

+

+ GuestShaderCacheEntry[] entries = cachedShaderEntries.ToArray();

+

+ GuestGpuAccessorHeader accessorHeader = entries[0].Header.GpuAccessorHeader;

+

+ TessMode tessMode = new TessMode();

+

+ int tessPatchType = accessorHeader.TessellationModePacked & 3;

+ int tessSpacing = (accessorHeader.TessellationModePacked >> 2) & 3;

+ bool tessCw = (accessorHeader.TessellationModePacked & 0x10) != 0;

+

+ tessMode.Packed = (uint)tessPatchType;

+ tessMode.Packed |= (uint)(tessSpacing << 4);

+

+ if (tessCw)

+ {

+ tessMode.Packed |= 0x100;

+ }

+

+ PrimitiveTopology topology = accessorHeader.PrimitiveTopology switch

+ {

+ InputTopology.Lines => PrimitiveTopology.Lines,

+ InputTopology.LinesAdjacency => PrimitiveTopology.LinesAdjacency,

+ InputTopology.Triangles => PrimitiveTopology.Triangles,

+ InputTopology.TrianglesAdjacency => PrimitiveTopology.TrianglesAdjacency,

+ _ => PrimitiveTopology.Points

+ };

+

+ GpuChannelGraphicsState graphicsState = new GpuChannelGraphicsState(

+ accessorHeader.StateFlags.HasFlag(GuestGpuStateFlags.EarlyZForce),

+ topology,

+ tessMode);

+

+ TransformFeedbackDescriptor[] tfdNew = null;

+

+ if (tfd != null)

+ {

+ tfdNew = new TransformFeedbackDescriptor[tfd.Length];

+

+ for (int tfIndex = 0; tfIndex < tfd.Length; tfIndex++)

+ {

+ Array32<uint> varyingLocations = new Array32<uint>();

+ Span<byte> varyingLocationsSpan = MemoryMarshal.Cast<uint, byte>(varyingLocations.ToSpan());

+ tfd[tfIndex].VaryingLocations.CopyTo(varyingLocationsSpan.Slice(0, tfd[tfIndex].VaryingLocations.Length));

+

+ tfdNew[tfIndex] = new TransformFeedbackDescriptor(

+ tfd[tfIndex].BufferIndex,

+ tfd[tfIndex].Stride,

+ tfd[tfIndex].VaryingLocations.Length,

+ ref varyingLocations);

+ }

+ }

+

+ ShaderSpecializationState specState = new ShaderSpecializationState(graphicsState, tfdNew);

+

+ for (int i = 0; i < entries.Length; i++)

+ {

+ GuestShaderCacheEntry entry = entries[i];

+

+ if (entry == null)

+ {

+ continue;

+ }

+

+ ShaderProgramInfo info = new ShaderProgramInfo(

+ Array.Empty<BufferDescriptor>(),

+ Array.Empty<BufferDescriptor>(),

+ Array.Empty<TextureDescriptor>(),

+ Array.Empty<TextureDescriptor>(),

+ (ShaderStage)(i + 1),

+ false,

+ false,

+ 0,

+ 0);

+

+ // NOTE: Vertex B comes first in the shader cache.

+ byte[] code = entry.Code.AsSpan(0, entry.Header.Size - entry.Header.Cb1DataSize).ToArray();

+ byte[] code2 = entry.Header.SizeA != 0 ? entry.Code.AsSpan(entry.Header.Size, entry.Header.SizeA).ToArray() : null;

+

+ Span<byte> codeSpan = entry.Code;

+ byte[] cb1Data = codeSpan.Slice(codeSpan.Length - entry.Header.Cb1DataSize).ToArray();

+

+ shaders[i + 1] = new CachedShaderStage(info, code, cb1Data);

+

+ if (code2 != null)

+ {

+ shaders[0] = new CachedShaderStage(null, code2, cb1Data);

+ }

+

+ foreach (var td in entry.TextureDescriptors)

+ {

+ var handle = td.Key;

+ var data = td.Value;

+

+ specState.RegisterTexture(

+ i,

+ handle,

+ -1,

+ data.UnpackFormat(),

+ data.UnpackSrgb(),

+ data.UnpackTextureTarget(),

+ data.UnpackTextureCoordNormalized());

+ }

+ }

+

+ CachedShaderProgram program = new CachedShaderProgram(null, specState, shaders);

+

+ hostStorage.AddShader(context, program, ReadOnlySpan<byte>.Empty);

+ }

+ }

+

+ return guestProgramList.Length;

+ }

+

+ return 0;

+ }

+ }

+} \ No newline at end of file

+using System;

+

+namespace Ryujinx.Graphics.Gpu.Shader.Cache

+{

+ struct TransformFeedbackDescriptorOld

+ {

+ public int BufferIndex { get; }

+ public int Stride { get; }

+

+ public byte[] VaryingLocations { get; }

+

+ public TransformFeedbackDescriptorOld(int bufferIndex, int stride, byte[] varyingLocations)

+ {

+ BufferIndex = bufferIndex;

+ Stride = stride;

+ VaryingLocations = varyingLocations ?? throw new ArgumentNullException(nameof(varyingLocations));

+ }

+ }

+}

+ class CachedShaderProgram : IDisposable

+ /// GPU state used to create this version of the shader.

+ /// </summary>

+ public ShaderSpecializationState SpecializationState { get; }

+

+ /// <summary>

+ public CachedShaderStage[] Shaders { get; }

+ /// <param name="specializationState">GPU state used to create this version of the shader</param>

+ public CachedShaderProgram(IProgram hostProgram, ShaderSpecializationState specializationState, params CachedShaderStage[] shaders)

+ SpecializationState = specializationState;

+using Ryujinx.Graphics.Shader;

+

+namespace Ryujinx.Graphics.Gpu.Shader

+{

+ /// <summary>

+ /// Cached shader code for a single shader stage.

+ /// </summary>

+ class CachedShaderStage

+ {

+ /// <summary>

+ /// Shader program information.

+ /// </summary>

+ public ShaderProgramInfo Info { get; }

+

+ /// <summary>

+ /// Maxwell binary shader code.

+ /// </summary>

+ public byte[] Code { get; }

+

+ /// <summary>

+ /// Constant buffer 1 data accessed by the shader.

+ /// </summary>

+ public byte[] Cb1Data { get; }

+

+ /// <summary>

+ /// Creates a new instance of the shader code holder.

+ /// </summary>

+ /// <param name="info">Shader program information</param>

+ /// <param name="code">Maxwell binary shader code</param>

+ /// <param name="cb1Data">Constant buffer 1 data accessed by the shader</param>

+ public CachedShaderStage(ShaderProgramInfo info, byte[] code, byte[] cb1Data)

+ {

+ Info = info;

+ Code = code;

+ Cb1Data = cb1Data;

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Graphics.Gpu.Shader.HashTable;

+using System.Collections.Generic;

+

+namespace Ryujinx.Graphics.Gpu.Shader

+{

+ /// <summary>

+ /// Compute shader cache hash table.

+ /// </summary>

+ class ComputeShaderCacheHashTable

+ {

+ private readonly PartitionedHashTable<ShaderSpecializationList> _cache;

+ private readonly List<CachedShaderProgram> _shaderPrograms;

+

+ /// <summary>

+ /// Creates a new compute shader cache hash table.

+ /// </summary>

+ public ComputeShaderCacheHashTable()

+ {

+ _cache = new PartitionedHashTable<ShaderSpecializationList>();

+ _shaderPrograms = new List<CachedShaderProgram>();

+ }

+

+ /// <summary>

+ /// Adds a program to the cache.

+ /// </summary>

+ /// <param name="program">Program to be added</param>

+ public void Add(CachedShaderProgram program)

+ {

+ var specList = _cache.GetOrAdd(program.Shaders[0].Code, new ShaderSpecializationList());

+ specList.Add(program);

+ _shaderPrograms.Add(program);

+ }

+

+ /// <summary>

+ /// Tries to find a cached program.

+ /// </summary>

+ /// <param name="channel">GPU channel</param>

+ /// <param name="poolState">Texture pool state</param>

+ /// <param name="gpuVa">GPU virtual address of the compute shader</param>

+ /// <param name="program">Cached host program for the given state, if found</param>

+ /// <param name="cachedGuestCode">Cached guest code, if any found</param>

+ /// <returns>True if a cached host program was found, false otherwise</returns>

+ public bool TryFind(

+ GpuChannel channel,

+ GpuChannelPoolState poolState,

+ ulong gpuVa,

+ out CachedShaderProgram program,

+ out byte[] cachedGuestCode)

+ {

+ program = null;

+ ShaderCodeAccessor codeAccessor = new ShaderCodeAccessor(channel.MemoryManager, gpuVa);

+ bool hasSpecList = _cache.TryFindItem(codeAccessor, out var specList, out cachedGuestCode);

+ return hasSpecList && specList.TryFindForCompute(channel, poolState, out program);

+ }

+

+ /// <summary>

+ /// Gets all programs that have been added to the table.

+ /// </summary>

+ /// <returns>Programs added to the table</returns>

+ public IEnumerable<CachedShaderProgram> GetPrograms()

+ {

+ foreach (var program in _shaderPrograms)

+ {

+ yield return program;

+ }

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Common;

+using Ryujinx.Common.Logging;

+using System;

+using System.IO;

+

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ /// <summary>

+ /// Represents a background disk cache writer.

+ /// </summary>

+ class BackgroundDiskCacheWriter : IDisposable

+ {

+ /// <summary>

+ /// Possible operation to do on the <see cref="_fileWriterWorkerQueue"/>.

+ /// </summary>

+ private enum CacheFileOperation

+ {

+ /// <summary>

+ /// Operation to add a shader to the cache.

+ /// </summary>

+ AddShader

+ }

+

+ /// <summary>

+ /// Represents an operation to perform on the <see cref="_fileWriterWorkerQueue"/>.

+ /// </summary>

+ private struct CacheFileOperationTask

+ {

+ /// <summary>

+ /// The type of operation to perform.

+ /// </summary>

+ public readonly CacheFileOperation Type;

+

+ /// <summary>

+ /// The data associated to this operation or null.

+ /// </summary>

+ public readonly object Data;

+

+ public CacheFileOperationTask(CacheFileOperation type, object data)

+ {

+ Type = type;

+ Data = data;

+ }

+ }

+

+ /// <summary>

+ /// Background shader cache write information.

+ /// </summary>

+ private struct AddShaderData

+ {

+ /// <summary>

+ /// Cached shader program.

+ /// </summary>

+ public readonly CachedShaderProgram Program;

+

+ /// <summary>

+ /// Binary host code.

+ /// </summary>

+ public readonly byte[] HostCode;

+

+ /// <summary>

+ /// Creates a new background shader cache write information.

+ /// </summary>

+ /// <param name="program">Cached shader program</param>

+ /// <param name="hostCode">Binary host code</param>

+ public AddShaderData(CachedShaderProgram program, byte[] hostCode)

+ {

+ Program = program;

+ HostCode = hostCode;

+ }

+ }

+

+ private readonly GpuContext _context;

+ private readonly DiskCacheHostStorage _hostStorage;

+ private readonly AsyncWorkQueue<CacheFileOperationTask> _fileWriterWorkerQueue;

+

+ /// <summary>

+ /// Creates a new background disk cache writer.

+ /// </summary>

+ /// <param name="context">GPU context</param>

+ /// <param name="hostStorage">Disk cache host storage</param>

+ public BackgroundDiskCacheWriter(GpuContext context, DiskCacheHostStorage hostStorage)

+ {

+ _context = context;

+ _hostStorage = hostStorage;

+ _fileWriterWorkerQueue = new AsyncWorkQueue<CacheFileOperationTask>(ProcessTask, "Gpu.BackgroundDiskCacheWriter");

+ }

+

+ /// <summary>

+ /// Processes a shader cache background operation.

+ /// </summary>

+ /// <param name="task">Task to process</param>

+ private void ProcessTask(CacheFileOperationTask task)

+ {

+ switch (task.Type)

+ {

+ case CacheFileOperation.AddShader:

+ AddShaderData data = (AddShaderData)task.Data;

+ try

+ {

+ _hostStorage.AddShader(_context, data.Program, data.HostCode);

+ }

+ catch (DiskCacheLoadException diskCacheLoadException)

+ {

+ Logger.Error?.Print(LogClass.Gpu, $"Error writing shader to disk cache. {diskCacheLoadException.Message}");

+ }

+ catch (IOException ioException)

+ {

+ Logger.Error?.Print(LogClass.Gpu, $"Error writing shader to disk cache. {ioException.Message}");

+ }

+ break;

+ }

+ }

+

+ /// <summary>

+ /// Adds a shader program to be cached in the background.

+ /// </summary>

+ /// <param name="program">Shader program to cache</param>

+ /// <param name="hostCode">Host binary code of the program</param>

+ public void AddShader(CachedShaderProgram program, byte[] hostCode)

+ {

+ _fileWriterWorkerQueue.Add(new CacheFileOperationTask(CacheFileOperation.AddShader, new AddShaderData(program, hostCode)));

+ }

+

+ public void Dispose()

+ {

+ Dispose(true);

+ }

+

+ protected virtual void Dispose(bool disposing)

+ {

+ if (disposing)

+ {

+ _fileWriterWorkerQueue.Dispose();

+ }

+ }

+ }

+}

+using System;

+using System.IO;

+using System.IO.Compression;

+using System.Runtime.CompilerServices;

+using System.Runtime.InteropServices;

+

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ /// <summary>

+ /// Binary data serializer.

+ /// </summary>

+ struct BinarySerializer

+ {

+ private readonly Stream _stream;

+ private Stream _activeStream;

+

+ /// <summary>

+ /// Creates a new binary serializer.

+ /// </summary>

+ /// <param name="stream">Stream to read from or write into</param>

+ public BinarySerializer(Stream stream)

+ {

+ _stream = stream;

+ _activeStream = stream;

+ }

+

+ /// <summary>

+ /// Reads data from the stream.

+ /// </summary>

+ /// <typeparam name="T">Type of the data</typeparam>

+ /// <param name="data">Data read</param>

+ public void Read<T>(ref T data) where T : unmanaged

+ {

+ Span<byte> buffer = MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref data, 1));

+ for (int offset = 0; offset < buffer.Length;)

+ {

+ offset += _activeStream.Read(buffer.Slice(offset));

+ }

+ }

+

+ /// <summary>

+ /// Tries to read data from the stream.

+ /// </summary>

+ /// <typeparam name="T">Type of the data</typeparam>

+ /// <param name="data">Data read</param>

+ /// <returns>True if the read was successful, false otherwise</returns>

+ public bool TryRead<T>(ref T data) where T : unmanaged

+ {

+ // Length is unknown on compressed streams.

+ if (_activeStream == _stream)

+ {

+ int size = Unsafe.SizeOf<T>();

+ if (_activeStream.Length - _activeStream.Position < size)

+ {

+ return false;

+ }

+ }

+

+ Read(ref data);

+ return true;

+ }

+

+ /// <summary>

+ /// Reads data prefixed with a magic and size from the stream.

+ /// </summary>

+ /// <typeparam name="T">Type of the data</typeparam>

+ /// <param name="data">Data read</param>

+ /// <param name="magic">Expected magic value, for validation</param>

+ public void ReadWithMagicAndSize<T>(ref T data, uint magic) where T : unmanaged

+ {

+ uint actualMagic = 0;

+ int size = 0;

+ Read(ref actualMagic);

+ Read(ref size);

+

+ if (actualMagic != magic)

+ {

+ throw new DiskCacheLoadException(DiskCacheLoadResult.FileCorruptedInvalidMagic);

+ }

+

+ // Structs are expected to expand but not shrink between versions.

+ if (size > Unsafe.SizeOf<T>())

+ {

+ throw new DiskCacheLoadException(DiskCacheLoadResult.FileCorruptedInvalidLength);

+ }

+

+ Span<byte> buffer = MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref data, 1)).Slice(0, size);

+ for (int offset = 0; offset < buffer.Length;)

+ {

+ offset += _activeStream.Read(buffer.Slice(offset));

+ }

+ }

+

+ /// <summary>

+ /// Writes data into the stream.

+ /// </summary>

+ /// <typeparam name="T">Type of the data</typeparam>

+ /// <param name="data">Data to be written</param>

+ public void Write<T>(ref T data) where T : unmanaged

+ {

+ Span<byte> buffer = MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref data, 1));

+ _activeStream.Write(buffer);

+ }

+

+ /// <summary>

+ /// Writes data prefixed with a magic and size into the stream.

+ /// </summary>

+ /// <typeparam name="T">Type of the data</typeparam>

+ /// <param name="data">Data to write</param>

+ /// <param name="magic">Magic value to write</param>

+ public void WriteWithMagicAndSize<T>(ref T data, uint magic) where T : unmanaged

+ {

+ int size = Unsafe.SizeOf<T>();

+ Write(ref magic);

+ Write(ref size);

+ Span<byte> buffer = MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref data, 1));

+ _activeStream.Write(buffer);

+ }

+

+ /// <summary>

+ /// Indicates that all data that will be read from the stream has been compressed.

+ /// </summary>

+ public void BeginCompression()

+ {

+ CompressionAlgorithm algorithm = CompressionAlgorithm.None;

+ Read(ref algorithm);

+

+ if (algorithm == CompressionAlgorithm.Deflate)

+ {

+ _activeStream = new DeflateStream(_stream, CompressionMode.Decompress, true);

+ }

+ }

+

+ /// <summary>

+ /// Indicates that all data that will be written into the stream should be compressed.

+ /// </summary>

+ /// <param name="algorithm">Compression algorithm that should be used</param>

+ public void BeginCompression(CompressionAlgorithm algorithm)

+ {

+ Write(ref algorithm);

+

+ if (algorithm == CompressionAlgorithm.Deflate)

+ {

+ _activeStream = new DeflateStream(_stream, CompressionLevel.SmallestSize, true);

+ }

+ }

+

+ /// <summary>

+ /// Indicates the end of a compressed chunck.

+ /// </summary>

+ /// <remarks>

+ /// Any data written after this will not be compressed unless <see cref="BeginCompression(CompressionAlgorithm)"/> is called again.

+ /// Any data read after this will be assumed to be uncompressed unless <see cref="BeginCompression"/> is called again.

+ /// </remarks>

+ public void EndCompression()

+ {

+ if (_activeStream != _stream)

+ {

+ _activeStream.Dispose();

+ _activeStream = _stream;

+ }

+ }

+

+ /// <summary>

+ /// Reads compressed data from the stream.

+ /// </summary>

+ /// <remarks>

+ /// <paramref name="data"/> must have the exact length of the uncompressed data,

+ /// otherwise decompression will fail.

+ /// </remarks>

+ /// <param name="stream">Stream to read from</param>

+ /// <param name="data">Buffer to write the uncompressed data into</param>

+ public static void ReadCompressed(Stream stream, Span<byte> data)

+ {

+ CompressionAlgorithm algorithm = (CompressionAlgorithm)stream.ReadByte();

+

+ switch (algorithm)

+ {

+ case CompressionAlgorithm.None:

+ stream.Read(data);

+ break;

+ case CompressionAlgorithm.Deflate:

+ stream = new DeflateStream(stream, CompressionMode.Decompress, true);

+ for (int offset = 0; offset < data.Length;)

+ {

+ offset += stream.Read(data.Slice(offset));

+ }

+ stream.Dispose();

+ break;

+ }

+ }

+

+ /// <summary>

+ /// Compresses and writes the compressed data into the stream.

+ /// </summary>

+ /// <param name="stream">Stream to write into</param>

+ /// <param name="data">Data to compress</param>

+ /// <param name="algorithm">Compression algorithm to be used</param>

+ public static void WriteCompressed(Stream stream, ReadOnlySpan<byte> data, CompressionAlgorithm algorithm)

+ {

+ stream.WriteByte((byte)algorithm);

+

+ switch (algorithm)

+ {

+ case CompressionAlgorithm.None:

+ stream.Write(data);

+ break;

+ case CompressionAlgorithm.Deflate:

+ stream = new DeflateStream(stream, CompressionLevel.SmallestSize, true);

+ stream.Write(data);

+ stream.Dispose();

+ break;

+ }

+ }

+ }

+} \ No newline at end of file

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ /// <summary>

+ /// Algorithm used to compress the cache.

+ /// </summary>

+ enum CompressionAlgorithm : byte

+ {

+ /// <summary>

+ /// No compression, the data is stored as-is.

+ /// </summary>

+ None,

+

+ /// <summary>

+ /// Deflate compression (RFC 1951).

+ /// </summary>

+ Deflate

+ }

+} \ No newline at end of file

+using Ryujinx.Common.Logging;

+using System.IO;

+

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ /// <summary>

+ /// Common disk cache utility methods.

+ /// </summary>

+ static class DiskCacheCommon

+ {

+ /// <summary>

+ /// Opens a file for read or write.

+ /// </summary>

+ /// <param name="basePath">Base path of the file (should not include the file name)</param>

+ /// <param name="fileName">Name of the file</param>

+ /// <param name="writable">Indicates if the file will be read or written</param>

+ /// <returns>File stream</returns>

+ public static FileStream OpenFile(string basePath, string fileName, bool writable)

+ {

+ string fullPath = Path.Combine(basePath, fileName);

+

+ FileMode mode;

+ FileAccess access;

+

+ if (writable)

+ {

+ mode = FileMode.OpenOrCreate;

+ access = FileAccess.ReadWrite;

+ }

+ else

+ {

+ mode = FileMode.Open;

+ access = FileAccess.Read;

+ }

+

+ try

+ {

+ return new FileStream(fullPath, mode, access, FileShare.Read);

+ }

+ catch (IOException ioException)

+ {

+ Logger.Error?.Print(LogClass.Gpu, $"Could not access file \"{fullPath}\". {ioException.Message}");

+

+ throw new DiskCacheLoadException(DiskCacheLoadResult.NoAccess);

+ }

+ }

+

+ /// <summary>

+ /// Gets the compression algorithm that should be used when writing the disk cache.

+ /// </summary>

+ /// <returns>Compression algorithm</returns>

+ public static CompressionAlgorithm GetCompressionAlgorithm()

+ {

+ return CompressionAlgorithm.Deflate;

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Common.Logging;

+using Ryujinx.Graphics.Gpu.Image;

+using Ryujinx.Graphics.Shader;

+using System;

+using System.Runtime.InteropServices;

+

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ /// <summary>

+ /// Represents a GPU state and memory accessor.

+ /// </summary>

+ class DiskCacheGpuAccessor : GpuAccessorBase, IGpuAccessor

+ {

+ private readonly ReadOnlyMemory<byte> _data;

+ private readonly ReadOnlyMemory<byte> _cb1Data;

+ private readonly ShaderSpecializationState _oldSpecState;

+ private readonly ShaderSpecializationState _newSpecState;

+ private readonly int _stageIndex;

+ private ResourceCounts _resourceCounts;

+

+ /// <summary>

+ /// Creates a new instance of the cached GPU state accessor for shader translation.

+ /// </summary>

+ /// <param name="context">GPU context</param>

+ /// <param name="data">The data of the shader</param>

+ /// <param name="cb1Data">The constant buffer 1 data of the shader</param>

+ /// <param name="oldSpecState">Shader specialization state of the cached shader</param>

+ /// <param name="newSpecState">Shader specialization state of the recompiled shader</param>

+ /// <param name="stageIndex">Shader stage index</param>

+ public DiskCacheGpuAccessor(

+ GpuContext context,

+ ReadOnlyMemory<byte> data,

+ ReadOnlyMemory<byte> cb1Data,

+ ShaderSpecializationState oldSpecState,

+ ShaderSpecializationState newSpecState,

+ ResourceCounts counts,

+ int stageIndex) : base(context)

+ {

+ _data = data;

+ _cb1Data = cb1Data;

+ _oldSpecState = oldSpecState;

+ _newSpecState = newSpecState;

+ _stageIndex = stageIndex;

+ _resourceCounts = counts;

+ }

+

+ /// <inheritdoc/>

+ public uint ConstantBuffer1Read(int offset)

+ {

+ if (offset + sizeof(uint) > _cb1Data.Length)

+ {

+ throw new DiskCacheLoadException(DiskCacheLoadResult.InvalidCb1DataLength);

+ }

+

+ return MemoryMarshal.Cast<byte, uint>(_cb1Data.Span.Slice(offset))[0];

+ }

+

+ /// <inheritdoc/>

+ public void Log(string message)

+ {

+ Logger.Warning?.Print(LogClass.Gpu, $"Shader translator: {message}");

+ }

+

+ /// <inheritdoc/>

+ public ReadOnlySpan<ulong> GetCode(ulong address, int minimumSize)

+ {

+ return MemoryMarshal.Cast<byte, ulong>(_data.Span.Slice((int)address));

+ }

+

+ /// <inheritdoc/>

+ public int QueryBindingConstantBuffer(int index)

+ {

+ return _resourceCounts.UniformBuffersCount++;

+ }

+

+ /// <inheritdoc/>

+ public int QueryBindingStorageBuffer(int index)

+ {

+ return _resourceCounts.StorageBuffersCount++;

+ }

+

+ /// <inheritdoc/>

+ public int QueryBindingTexture(int index)

+ {

+ return _resourceCounts.TexturesCount++;

+ }

+

+ /// <inheritdoc/>

+ public int QueryBindingImage(int index)

+ {

+ return _resourceCounts.ImagesCount++;

+ }

+

+ /// <inheritdoc/>

+ public int QueryComputeLocalSizeX() => _oldSpecState.ComputeState.LocalSizeX;

+

+ /// <inheritdoc/>

+ public int QueryComputeLocalSizeY() => _oldSpecState.ComputeState.LocalSizeY;

+

+ /// <inheritdoc/>

+ public int QueryComputeLocalSizeZ() => _oldSpecState.ComputeState.LocalSizeZ;

+

+ /// <inheritdoc/>

+ public int QueryComputeLocalMemorySize() => _oldSpecState.ComputeState.LocalMemorySize;

+

+ /// <inheritdoc/>

+ public int QueryComputeSharedMemorySize() => _oldSpecState.ComputeState.SharedMemorySize;

+

+ /// <inheritdoc/>

+ public uint QueryConstantBufferUse()

+ {

+ _newSpecState.RecordConstantBufferUse(_stageIndex, _oldSpecState.ConstantBufferUse[_stageIndex]);

+ return _oldSpecState.ConstantBufferUse[_stageIndex];

+ }

+

+ /// <inheritdoc/>

+ public InputTopology QueryPrimitiveTopology()

+ {

+ _newSpecState.RecordPrimitiveTopology();

+ return ConvertToInputTopology(_oldSpecState.GraphicsState.Topology, _oldSpecState.GraphicsState.TessellationMode);

+ }

+

+ /// <inheritdoc/>

+ public bool QueryTessCw()

+ {

+ return _oldSpecState.GraphicsState.TessellationMode.UnpackCw();

+ }

+

+ /// <inheritdoc/>

+ public TessPatchType QueryTessPatchType()

+ {

+ return _oldSpecState.GraphicsState.TessellationMode.UnpackPatchType();

+ }

+

+ /// <inheritdoc/>

+ public TessSpacing QueryTessSpacing()

+ {

+ return _oldSpecState.GraphicsState.TessellationMode.UnpackSpacing();

+ }

+

+ /// <inheritdoc/>

+ public TextureFormat QueryTextureFormat(int handle, int cbufSlot)

+ {

+ _newSpecState.RecordTextureFormat(_stageIndex, handle, cbufSlot);

+ (uint format, bool formatSrgb) = _oldSpecState.GetFormat(_stageIndex, handle, cbufSlot);

+ return ConvertToTextureFormat(format, formatSrgb);

+ }

+

+ /// <inheritdoc/>

+ public SamplerType QuerySamplerType(int handle, int cbufSlot)

+ {

+ _newSpecState.RecordTextureSamplerType(_stageIndex, handle, cbufSlot);

+ return _oldSpecState.GetTextureTarget(_stageIndex, handle, cbufSlot).ConvertSamplerType();

+ }

+

+ /// <inheritdoc/>

+ public bool QueryTextureCoordNormalized(int handle, int cbufSlot)

+ {

+ _newSpecState.RecordTextureCoordNormalized(_stageIndex, handle, cbufSlot);

+ return _oldSpecState.GetCoordNormalized(_stageIndex, handle, cbufSlot);

+ }

+

+ /// <inheritdoc/>

+ public bool QueryTransformFeedbackEnabled()

+ {

+ return _oldSpecState.TransformFeedbackDescriptors != null;

+ }

+

+ /// <inheritdoc/>

+ public ReadOnlySpan<byte> QueryTransformFeedbackVaryingLocations(int bufferIndex)

+ {

+ return _oldSpecState.TransformFeedbackDescriptors[bufferIndex].AsSpan();

+ }

+

+ /// <inheritdoc/>

+ public int QueryTransformFeedbackStride(int bufferIndex)

+ {

+ return _oldSpecState.TransformFeedbackDescriptors[bufferIndex].Stride;

+ }

+

+ /// <inheritdoc/>

+ public bool QueryEarlyZForce()

+ {

+ _newSpecState.RecordEarlyZForce();

+ return _oldSpecState.GraphicsState.EarlyZForce;

+ }

+

+ /// <inheritdoc/>

+ public void RegisterTexture(int handle, int cbufSlot)

+ {

+ if (!_oldSpecState.TextureRegistered(_stageIndex, handle, cbufSlot))

+ {

+ throw new DiskCacheLoadException(DiskCacheLoadResult.MissingTextureDescriptor);

+ }

+

+ (uint format, bool formatSrgb) = _oldSpecState.GetFormat(_stageIndex, handle, cbufSlot);

+ TextureTarget target = _oldSpecState.GetTextureTarget(_stageIndex, handle, cbufSlot);

+ bool coordNormalized = _oldSpecState.GetCoordNormalized(_stageIndex, handle, cbufSlot);

+ _newSpecState.RegisterTexture(_stageIndex, handle, cbufSlot, format, formatSrgb, target, coordNormalized);

+ }

+ }

+}

+using Ryujinx.Common;

+using System;

+using System.Collections.Generic;

+using System.IO;

+using System.Runtime.CompilerServices;

+

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ /// <summary>

+ /// On-disk shader cache storage for guest code.

+ /// </summary>

+ class DiskCacheGuestStorage

+ {

+ private const uint TocMagic = (byte)'T' | ((byte)'O' << 8) | ((byte)'C' << 16) | ((byte)'G' << 24);

+

+ private const ushort VersionMajor = 1;

+ private const ushort VersionMinor = 0;

+ private const uint VersionPacked = ((uint)VersionMajor << 16) | VersionMinor;

+

+ private const string TocFileName = "guest.toc";

+ private const string DataFileName = "guest.data";

+

+ private readonly string _basePath;

+

+ /// <summary>

+ /// TOC (Table of contents) file header.

+ /// </summary>

+ private struct TocHeader

+ {

+ /// <summary>

+ /// Magic value, for validation and identification purposes.

+ /// </summary>

+ public uint Magic;

+

+ /// <summary>

+ /// File format version.

+ /// </summary>

+ public uint Version;

+

+ /// <summary>

+ /// Header padding.

+ /// </summary>

+ public uint Padding;

+

+ /// <summary>

+ /// Number of modifications to the file, also the shaders count.

+ /// </summary>

+ public uint ModificationsCount;

+

+ /// <summary>

+ /// Reserved space, to be used in the future. Write as zero.

+ /// </summary>

+ public ulong Reserved;

+

+ /// <summary>

+ /// Reserved space, to be used in the future. Write as zero.

+ /// </summary>

+ public ulong Reserved2;

+ }

+

+ /// <summary>

+ /// TOC (Table of contents) file entry.

+ /// </summary>

+ private struct TocEntry

+ {

+ /// <summary>

+ /// Offset of the data on the data file.

+ /// </summary>

+ public uint Offset;

+

+ /// <summary>

+ /// Code size.

+ /// </summary>

+ public uint CodeSize;

+

+ /// <summary>

+ /// Constant buffer 1 data size.

+ /// </summary>

+ public uint Cb1DataSize;

+

+ /// <summary>

+ /// Hash of the code and constant buffer data.

+ /// </summary>

+ public uint Hash;

+ }

+

+ /// <summary>

+ /// TOC (Table of contents) memory cache entry.

+ /// </summary>

+ private struct TocMemoryEntry

+ {

+ /// <summary>

+ /// Offset of the data on the data file.

+ /// </summary>

+ public uint Offset;

+

+ /// <summary>

+ /// Code size.

+ /// </summary>

+ public uint CodeSize;

+

+ /// <summary>

+ /// Constant buffer 1 data size.

+ /// </summary>

+ public uint Cb1DataSize;

+

+ /// <summary>

+ /// Index of the shader on the cache.

+ /// </summary>

+ public readonly int Index;

+

+ /// <summary>

+ /// Creates a new TOC memory entry.

+ /// </summary>

+ /// <param name="offset">Offset of the data on the data file</param>

+ /// <param name="codeSize">Code size</param>

+ /// <param name="cb1DataSize">Constant buffer 1 data size</param>

+ /// <param name="index">Index of the shader on the cache</param>

+ public TocMemoryEntry(uint offset, uint codeSize, uint cb1DataSize, int index)

+ {

+ Offset = offset;

+ CodeSize = codeSize;

+ Cb1DataSize = cb1DataSize;

+ Index = index;

+ }

+ }

+

+ private Dictionary<uint, List<TocMemoryEntry>> _toc;

+ private uint _tocModificationsCount;

+

+ private (byte[], byte[])[] _cache;

+

+ /// <summary>

+ /// Creates a new disk cache guest storage.

+ /// </summary>

+ /// <param name="basePath">Base path of the disk shader cache</param>

+ public DiskCacheGuestStorage(string basePath)

+ {

+ _basePath = basePath;

+ }

+

+ /// <summary>

+ /// Checks if the TOC (table of contents) file for the guest cache exists.

+ /// </summary>

+ /// <returns>True if the file exists, false otherwise</returns>

+ public bool TocFileExists()

+ {

+ return File.Exists(Path.Combine(_basePath, TocFileName));

+ }

+

+ /// <summary>

+ /// Checks if the data file for the guest cache exists.

+ /// </summary>

+ /// <returns>True if the file exists, false otherwise</returns>

+ public bool DataFileExists()

+ {

+ return File.Exists(Path.Combine(_basePath, DataFileName));

+ }

+

+ /// <summary>

+ /// Opens the guest cache TOC (table of contents) file.

+ /// </summary>

+ /// <returns>File stream</returns>

+ public Stream OpenTocFileStream()

+ {

+ return DiskCacheCommon.OpenFile(_basePath, TocFileName, writable: false);

+ }

+

+ /// <summary>

+ /// Opens the guest cache data file.

+ /// </summary>

+ /// <returns>File stream</returns>

+ public Stream OpenDataFileStream()

+ {

+ return DiskCacheCommon.OpenFile(_basePath, DataFileName, writable: false);

+ }

+

+ /// <summary>

+ /// Clear all content from the guest cache files.

+ /// </summary>

+ public void ClearCache()

+ {

+ using var tocFileStream = DiskCacheCommon.OpenFile(_basePath, TocFileName, writable: true);

+ using var dataFileStream = DiskCacheCommon.OpenFile(_basePath, DataFileName, writable: true);

+

+ tocFileStream.SetLength(0);

+ dataFileStream.SetLength(0);

+ }

+

+ /// <summary>

+ /// Loads the guest cache from file or memory cache.

+ /// </summary>

+ /// <param name="tocFileStream">Guest TOC file stream</param>

+ /// <param name="dataFileStream">Guest data file stream</param>

+ /// <param name="index">Guest shader index</param>

+ /// <returns>Tuple with the guest code and constant buffer 1 data, respectively</returns>

+ public (byte[], byte[]) LoadShader(Stream tocFileStream, Stream dataFileStream, int index)

+ {

+ if (_cache == null || index >= _cache.Length)

+ {

+ _cache = new (byte[], byte[])[Math.Max(index + 1, GetShadersCountFromLength(tocFileStream.Length))];

+ }

+

+ (byte[] guestCode, byte[] cb1Data) = _cache[index];

+

+ if (guestCode == null || cb1Data == null)

+ {

+ BinarySerializer tocReader = new BinarySerializer(tocFileStream);

+ tocFileStream.Seek(Unsafe.SizeOf<TocHeader>() + index * Unsafe.SizeOf<TocEntry>(), SeekOrigin.Begin);

+

+ TocEntry entry = new TocEntry();

+ tocReader.Read(ref entry);

+

+ guestCode = new byte[entry.CodeSize];

+ cb1Data = new byte[entry.Cb1DataSize];

+

+ if (entry.Offset >= (ulong)dataFileStream.Length)

+ {

+ throw new DiskCacheLoadException(DiskCacheLoadResult.FileCorruptedGeneric);

+ }

+

+ dataFileStream.Seek((long)entry.Offset, SeekOrigin.Begin);

+ dataFileStream.Read(cb1Data);

+ BinarySerializer.ReadCompressed(dataFileStream, guestCode);

+

+ _cache[index] = (guestCode, cb1Data);

+ }

+

+ return (guestCode, cb1Data);

+ }

+

+ /// <summary>

+ /// Clears guest code memory cache, forcing future loads to be from file.

+ /// </summary>

+ public void ClearMemoryCache()

+ {

+ _cache = null;

+ }

+

+ /// <summary>

+ /// Calculates the guest shaders count from the TOC file length.

+ /// </summary>

+ /// <param name="length">TOC file length</param>

+ /// <returns>Shaders count</returns>

+ private static int GetShadersCountFromLength(long length)

+ {

+ return (int)((length - Unsafe.SizeOf<TocHeader>()) / Unsafe.SizeOf<TocEntry>());

+ }

+

+ /// <summary>

+ /// Adds a guest shader to the cache.

+ /// </summary>

+ /// <remarks>

+ /// If the shader is already on the cache, the existing index will be returned and nothing will be written.

+ /// </remarks>

+ /// <param name="data">Guest code</param>

+ /// <param name="cb1Data">Constant buffer 1 data accessed by the code</param>

+ /// <returns>Index of the shader on the cache</returns>

+ public int AddShader(ReadOnlySpan<byte> data, ReadOnlySpan<byte> cb1Data)

+ {

+ using var tocFileStream = DiskCacheCommon.OpenFile(_basePath, TocFileName, writable: true);

+ using var dataFileStream = DiskCacheCommon.OpenFile(_basePath, DataFileName, writable: true);

+

+ TocHeader header = new TocHeader();

+

+ LoadOrCreateToc(tocFileStream, ref header);

+

+ uint hash = CalcHash(data, cb1Data);

+

+ if (_toc.TryGetValue(hash, out var list))

+ {

+ foreach (var entry in list)

+ {

+ if (data.Length != entry.CodeSize || cb1Data.Length != entry.Cb1DataSize)

+ {

+ continue;

+ }

+

+ dataFileStream.Seek((long)entry.Offset, SeekOrigin.Begin);

+ byte[] cachedCode = new byte[entry.CodeSize];

+ byte[] cachedCb1Data = new byte[entry.Cb1DataSize];

+ dataFileStream.Read(cachedCb1Data);

+ BinarySerializer.ReadCompressed(dataFileStream, cachedCode);

+

+ if (data.SequenceEqual(cachedCode) && cb1Data.SequenceEqual(cachedCb1Data))

+ {

+ return entry.Index;

+ }

+ }

+ }

+

+ return WriteNewEntry(tocFileStream, dataFileStream, ref header, data, cb1Data, hash);

+ }

+

+ /// <summary>

+ /// Loads the guest cache TOC file, or create a new one if not present.

+ /// </summary>

+ /// <param name="tocFileStream">Guest TOC file stream</param>

+ /// <param name="header">Set to the TOC file header</param>

+ private void LoadOrCreateToc(Stream tocFileStream, ref TocHeader header)

+ {

+ BinarySerializer reader = new BinarySerializer(tocFileStream);

+

+ if (!reader.TryRead(ref header) || header.Magic != TocMagic || header.Version != VersionPacked)

+ {

+ CreateToc(tocFileStream, ref header);

+ }

+

+ if (_toc == null || header.ModificationsCount != _tocModificationsCount)

+ {

+ if (!LoadTocEntries(tocFileStream, ref reader))

+ {

+ CreateToc(tocFileStream, ref header);

+ }

+

+ _tocModificationsCount = header.ModificationsCount;

+ }

+ }

+

+ /// <summary>

+ /// Creates a new guest cache TOC file.

+ /// </summary>

+ /// <param name="tocFileStream">Guest TOC file stream</param>

+ /// <param name="header">Set to the TOC header</param>

+ private void CreateToc(Stream tocFileStream, ref TocHeader header)

+ {

+ BinarySerializer writer = new BinarySerializer(tocFileStream);

+

+ header.Magic = TocMagic;

+ header.Version = VersionPacked;

+ header.Padding = 0;

+ header.ModificationsCount = 0;

+ header.Reserved = 0;

+ header.Reserved2 = 0;

+

+ if (tocFileStream.Length > 0)

+ {

+ tocFileStream.Seek(0, SeekOrigin.Begin);

+ tocFileStream.SetLength(0);

+ }

+

+ writer.Write(ref header);

+ }

+

+ /// <summary>

+ /// Reads all the entries on the guest TOC file.

+ /// </summary>

+ /// <param name="tocFileStream">Guest TOC file stream</param>

+ /// <param name="reader">TOC file reader</param>

+ /// <returns>True if the operation was successful, false otherwise</returns>

+ private bool LoadTocEntries(Stream tocFileStream, ref BinarySerializer reader)

+ {

+ _toc = new Dictionary<uint, List<TocMemoryEntry>>();

+

+ TocEntry entry = new TocEntry();

+ int index = 0;

+

+ while (tocFileStream.Position < tocFileStream.Length)

+ {

+ if (!reader.TryRead(ref entry))

+ {

+ return false;

+ }

+

+ AddTocMemoryEntry(entry.Offset, entry.CodeSize, entry.Cb1DataSize, entry.Hash, index++);

+ }

+

+ return true;

+ }

+

+ /// <summary>

+ /// Writes a new guest code entry into the file.

+ /// </summary>

+ /// <param name="tocFileStream">TOC file stream</param>

+ /// <param name="dataFileStream">Data file stream</param>

+ /// <param name="header">TOC header, to be updated with the new count</param>

+ /// <param name="data">Guest code</param>

+ /// <param name="cb1Data">Constant buffer 1 data accessed by the guest code</param>

+ /// <param name="hash">Code and constant buffer data hash</param>

+ /// <returns>Entry index</returns>

+ private int WriteNewEntry(

+ Stream tocFileStream,

+ Stream dataFileStream,

+ ref TocHeader header,

+ ReadOnlySpan<byte> data,

+ ReadOnlySpan<byte> cb1Data,

+ uint hash)

+ {

+ BinarySerializer tocWriter = new BinarySerializer(tocFileStream);

+

+ dataFileStream.Seek(0, SeekOrigin.End);

+ uint dataOffset = checked((uint)dataFileStream.Position);

+ uint codeSize = (uint)data.Length;

+ uint cb1DataSize = (uint)cb1Data.Length;

+ dataFileStream.Write(cb1Data);

+ BinarySerializer.WriteCompressed(dataFileStream, data, DiskCacheCommon.GetCompressionAlgorithm());

+

+ _tocModificationsCount = ++header.ModificationsCount;

+ tocFileStream.Seek(0, SeekOrigin.Begin);

+ tocWriter.Write(ref header);

+

+ TocEntry entry = new TocEntry()

+ {

+ Offset = dataOffset,

+ CodeSize = codeSize,

+ Cb1DataSize = cb1DataSize,

+ Hash = hash

+ };

+

+ tocFileStream.Seek(0, SeekOrigin.End);

+ int index = (int)((tocFileStream.Position - Unsafe.SizeOf<TocHeader>()) / Unsafe.SizeOf<TocEntry>());

+

+ tocWriter.Write(ref entry);

+

+ AddTocMemoryEntry(dataOffset, codeSize, cb1DataSize, hash, index);

+

+ return index;

+ }

+

+ /// <summary>

+ /// Adds an entry to the memory TOC cache. This can be used to avoid reading the TOC file all the time.

+ /// </summary>

+ /// <param name="dataOffset">Offset of the code and constant buffer data in the data file</param>

+ /// <param name="codeSize">Code size</param>

+ /// <param name="cb1DataSize">Constant buffer 1 data size</param>

+ /// <param name="hash">Code and constant buffer data hash</param>

+ /// <param name="index">Index of the data on the cache</param>

+ private void AddTocMemoryEntry(uint dataOffset, uint codeSize, uint cb1DataSize, uint hash, int index)

+ {

+ if (!_toc.TryGetValue(hash, out var list))

+ {

+ _toc.Add(hash, list = new List<TocMemoryEntry>());

+ }

+

+ list.Add(new TocMemoryEntry(dataOffset, codeSize, cb1DataSize, index));

+ }

+

+ /// <summary>

+ /// Calculates the hash for a data pair.

+ /// </summary>

+ /// <param name="data">Data 1</param>

+ /// <param name="data2">Data 2</param>

+ /// <returns>Hash of both data</returns>

+ private static uint CalcHash(ReadOnlySpan<byte> data, ReadOnlySpan<byte> data2)

+ {

+ return CalcHash(data2) * 23 ^ CalcHash(data);

+ }

+

+ /// <summary>

+ /// Calculates the hash for data.

+ /// </summary>

+ /// <param name="data">Data to be hashed</param>

+ /// <returns>Hash of the data</returns>

+ private static uint CalcHash(ReadOnlySpan<byte> data)

+ {

+ return (uint)XXHash128.ComputeHash(data).Low;

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Graphics.GAL;

+using Ryujinx.Graphics.Shader;

+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 = 1;

+ private const uint FileFormatVersionPacked = ((uint)FileFormatVersionMajor << 16) | FileFormatVersionMinor;

+ private const uint CodeGenVersion = 0;

+

+ 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>

+ /// Reserved space, to be used in the future. Write as zero.

+ /// </summary>

+ public ulong Reserved;

+

+ /// <summary>

+ /// Reserved space, to be used in the future. Write as zero.

+ /// </summary>

+ public ulong Reserved2;

+ }

+

+ /// <summary>

+ /// Offset and size pair.

+ /// </summary>

+ private struct OffsetAndSize

+ {

+ /// <summary>

+ /// Offset.

+ /// </summary>

+ public ulong Offset;

+

+ /// <summary>

+ /// Size.

+ /// </summary>

+ public uint Size;

+ }

+

+ /// <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;

+ }

+

+ 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 (int)((new FileInfo(tocFilePath).Length - Unsafe.SizeOf<TocHeader>()) / sizeof(ulong));

+ }

+

+ /// <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;

+ }

+

+ CachedShaderStage[] shaders = new CachedShaderStage[isCompute ? 1 : Constants.ShaderStages + 1];

+

+ DataEntryPerStage stageEntry = new DataEntryPerStage();

+

+ while (stagesBitMask != 0)

+ {

+ int stageIndex = BitOperations.TrailingZeroCount(stagesBitMask);

+

+ dataReader.Read(ref stageEntry);

+

+ ShaderProgramInfo info = stageIndex != 0 || isCompute ? ReadShaderProgramInfo(ref dataReader) : null;

+

+ (byte[] guestCode, byte[] cb1Data) = _guestStorage.LoadShader(

+ guestTocFileStream,

+ guestDataFileStream,

+ stageEntry.GuestCodeIndex);

+

+ shaders[stageIndex] = new CachedShaderStage(info, guestCode, cb1Data);

+

+ stagesBitMask &= ~(1u << stageIndex);

+ }

+

+ ShaderSpecializationState specState = ShaderSpecializationState.Read(ref dataReader);

+ dataReader.EndCompression();

+

+ if (loadHostCache)

+ {

+ byte[] hostCode = ReadHostCode(context, ref hostTocFileStream, ref hostDataFileStream, programIndex);

+

+ if (hostCode != null)

+ {

+ bool hasFragmentShader = shaders.Length > 5 && shaders[5] != null;

+ int fragmentOutputMap = hasFragmentShader ? shaders[5].Info.FragmentOutputMap : -1;

+ IProgram hostProgram = context.Renderer.LoadProgramBinary(hostCode, hasFragmentShader, new ShaderInfo(fragmentOutputMap));

+

+ CachedShaderProgram program = new CachedShaderProgram(hostProgram, specState, shaders);

+

+ loader.QueueHostProgram(program, hostProgram, programIndex, isCompute);

+ }

+ else

+ {

+ loadHostCache = false;

+ }

+ }

+

+ if (!loadHostCache)

+ {

+ loader.QueueGuestProgram(shaders, 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="programIndex">Index of the program on the cache</param>

+ /// <returns>Host binary code, or null if not found</returns>

+ private byte[] ReadHostCode(GpuContext context, ref Stream tocFileStream, ref Stream dataFileStream, int programIndex)

+ {

+ 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;

+ }

+

+ tocFileStream = DiskCacheCommon.OpenFile(_basePath, GetHostTocFileName(context), writable: false);

+ dataFileStream = DiskCacheCommon.OpenFile(_basePath, GetHostDataFileName(context), writable: false);

+ }

+

+ int offset = Unsafe.SizeOf<TocHeader>() + programIndex * Unsafe.SizeOf<OffsetAndSize>();

+ if (offset + Unsafe.SizeOf<OffsetAndSize>() > tocFileStream.Length)

+ {

+ return 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.Size];

+

+ BinarySerializer.ReadCompressed(dataFileStream, hostCode);

+

+ return hostCode;

+ }

+

+ /// <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);

+

+ if (tocFileStream.Length == 0)

+ {

+ TocHeader header = new TocHeader();

+ CreateToc(tocFileStream, ref header, TocsMagic, CodeGenVersion);

+ }

+

+ 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);

+

+ WriteShaderProgramInfo(ref dataWriter, shader.Info);

+ }

+

+ program.SpecializationState.Write(ref dataWriter);

+ dataWriter.EndCompression();

+

+ if (streams == null)

+ {

+ tocFileStream.Dispose();

+ dataFileStream.Dispose();

+ }

+

+ if (hostCode.IsEmpty)

+ {

+ return;

+ }

+

+ WriteHostCode(context, hostCode, -1, streams);

+ }

+

+ /// <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>

+ /// Adds a host binary shader to the host cache.

+ /// </summary>

+ /// <remarks>

+ /// This only modifies the host cache. The shader must already exist in the other caches.

+ /// This method should only be used for rebuilding the host cache after a clear.

+ /// </remarks>

+ /// <param name="context">GPU context</param>

+ /// <param name="hostCode">Host binary code</param>

+ /// <param name="programIndex">Index of the program in the cache</param>

+ public void AddHostShader(GpuContext context, ReadOnlySpan<byte> hostCode, int programIndex)

+ {

+ WriteHostCode(context, hostCode, programIndex);

+ }

+

+ /// <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="programIndex">Index of the program in the cache</param>

+ /// <param name="streams">Output streams to use</param>

+ private void WriteHostCode(GpuContext context, ReadOnlySpan<byte> hostCode, int programIndex, DiskCacheOutputStreams streams = null)

+ {

+ 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);

+ }

+

+ if (programIndex == -1)

+ {

+ tocFileStream.Seek(0, SeekOrigin.End);

+ }

+ else

+ {

+ tocFileStream.Seek(Unsafe.SizeOf<TocHeader>() + (programIndex * Unsafe.SizeOf<OffsetAndSize>()), SeekOrigin.Begin);

+ }

+

+ dataFileStream.Seek(0, SeekOrigin.End);

+

+ BinarySerializer tocWriter = new BinarySerializer(tocFileStream);

+

+ OffsetAndSize offsetAndSize = new OffsetAndSize();

+ offsetAndSize.Offset = (ulong)dataFileStream.Position;

+ offsetAndSize.Size = (uint)hostCode.Length;

+ tocWriter.Write(ref offsetAndSize);

+

+ BinarySerializer.WriteCompressed(dataFileStream, hostCode, DiskCacheCommon.GetCompressionAlgorithm());

+

+ 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>

+ private void CreateToc(Stream tocFileStream, ref TocHeader header, uint magic, uint codegenVersion)

+ {

+ BinarySerializer writer = new BinarySerializer(tocFileStream);

+

+ header.Magic = magic;

+ header.FormatVersion = FileFormatVersionPacked;

+ header.CodeGenVersion = codegenVersion;

+ header.Padding = 0;

+ header.Reserved = 0;

+ header.Reserved2 = 0;

+

+ 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.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.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);

+ }

+ }

+ }

+} \ No newline at end of file

+using System;

+

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ /// <summary>

+ /// Disk cache load exception.

+ /// </summary>

+ class DiskCacheLoadException : Exception

+ {

+ /// <summary>

+ /// Result of the cache load operation.

+ /// </summary>

+ public DiskCacheLoadResult Result { get; }

+

+ /// <summary>

+ /// Creates a new instance of the disk cache load exception.

+ /// </summary>

+ public DiskCacheLoadException()

+ {

+ }

+

+ /// <summary>

+ /// Creates a new instance of the disk cache load exception.

+ /// </summary>

+ /// <param name="message">Exception message</param>

+ public DiskCacheLoadException(string message) : base(message)

+ {

+ }

+

+ /// <summary>

+ /// Creates a new instance of the disk cache load exception.

+ /// </summary>

+ /// <param name="message">Exception message</param>

+ /// <param name="inner">Inner exception</param>

+ public DiskCacheLoadException(string message, Exception inner) : base(message, inner)

+ {

+ }

+

+ /// <summary>

+ /// Creates a new instance of the disk cache load exception.

+ /// </summary>

+ /// <param name="result">Result code</param>

+ public DiskCacheLoadException(DiskCacheLoadResult result) : base(result.GetMessage())

+ {

+ Result = result;

+ }

+ }

+} \ No newline at end of file

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ /// <summary>

+ /// Result of a shader cache load operation.

+ /// </summary>

+ enum DiskCacheLoadResult

+ {

+ /// <summary>

+ /// No error.

+ /// </summary>

+ Success,

+

+ /// <summary>

+ /// File can't be accessed.

+ /// </summary>

+ NoAccess,

+

+ /// <summary>

+ /// The constant buffer 1 data length is too low for the translation of the guest shader.

+ /// </summary>

+ InvalidCb1DataLength,

+

+ /// <summary>

+ /// The cache is missing the descriptor of a texture used by the shader.

+ /// </summary>

+ MissingTextureDescriptor,

+

+ /// <summary>

+ /// File is corrupted.

+ /// </summary>

+ FileCorruptedGeneric,

+

+ /// <summary>

+ /// File is corrupted, detected by magic value check.

+ /// </summary>

+ FileCorruptedInvalidMagic,

+

+ /// <summary>

+ /// File is corrupted, detected by length check.

+ /// </summary>

+ FileCorruptedInvalidLength,

+

+ /// <summary>

+ /// File might be valid, but is incompatible with the current emulator version.

+ /// </summary>

+ IncompatibleVersion

+ }

+

+ static class DiskCacheLoadResultExtensions

+ {

+ /// <summary>

+ /// Gets an error message from a result code.

+ /// </summary>

+ /// <param name="result">Result code</param>

+ /// <returns>Error message</returns>

+ public static string GetMessage(this DiskCacheLoadResult result)

+ {

+ return result switch

+ {

+ DiskCacheLoadResult.Success => "No error.",

+ DiskCacheLoadResult.NoAccess => "Could not access the cache file.",

+ DiskCacheLoadResult.InvalidCb1DataLength => "Constant buffer 1 data length is too low.",

+ DiskCacheLoadResult.MissingTextureDescriptor => "Texture descriptor missing from the cache file.",

+ DiskCacheLoadResult.FileCorruptedGeneric => "The cache file is corrupted.",

+ DiskCacheLoadResult.FileCorruptedInvalidMagic => "Magic check failed, the cache file is corrupted.",

+ DiskCacheLoadResult.FileCorruptedInvalidLength => "Length check failed, the cache file is corrupted.",

+ DiskCacheLoadResult.IncompatibleVersion => "The version of the disk cache is not compatible with this version of the emulator.",

+ _ => "Unknown error."

+ };

+ }

+ }

+} \ No newline at end of file

+using System;

+using System.IO;

+

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ /// <summary>

+ /// Output streams for the disk shader cache.

+ /// </summary>

+ class DiskCacheOutputStreams : IDisposable

+ {

+ /// <summary>

+ /// Shared table of contents (TOC) file stream.

+ /// </summary>

+ public readonly FileStream TocFileStream;

+

+ /// <summary>

+ /// Shared data file stream.

+ /// </summary>

+ public readonly FileStream DataFileStream;

+

+ /// <summary>

+ /// Host table of contents (TOC) file stream.

+ /// </summary>

+ public readonly FileStream HostTocFileStream;

+

+ /// <summary>

+ /// Host data file stream.

+ /// </summary>

+ public readonly FileStream HostDataFileStream;

+

+ /// <summary>

+ /// Creates a new instance of a disk cache output stream container.

+ /// </summary>

+ /// <param name="tocFileStream">Stream for the shared table of contents file</param>

+ /// <param name="dataFileStream">Stream for the shared data file</param>

+ /// <param name="hostTocFileStream">Stream for the host table of contents file</param>

+ /// <param name="hostDataFileStream">Stream for the host data file</param>

+ public DiskCacheOutputStreams(FileStream tocFileStream, FileStream dataFileStream, FileStream hostTocFileStream, FileStream hostDataFileStream)

+ {

+ TocFileStream = tocFileStream;

+ DataFileStream = dataFileStream;

+ HostTocFileStream = hostTocFileStream;

+ HostDataFileStream = hostDataFileStream;

+ }

+

+ /// <summary>

+ /// Disposes the output file streams.

+ /// </summary>

+ public void Dispose()

+ {

+ TocFileStream.Dispose();

+ DataFileStream.Dispose();

+ HostTocFileStream.Dispose();

+ HostDataFileStream.Dispose();

+ }

+ }

+}

+using Ryujinx.Common.Logging;

+using Ryujinx.Graphics.GAL;

+using Ryujinx.Graphics.Shader;

+using Ryujinx.Graphics.Shader.Translation;

+using System;

+using System.Collections.Concurrent;

+using System.Collections.Generic;

+using System.IO;

+using System.Threading;

+using static Ryujinx.Graphics.Gpu.Shader.ShaderCache;

+

+namespace Ryujinx.Graphics.Gpu.Shader.DiskCache

+{

+ class ParallelDiskCacheLoader

+ {

+ private const int ThreadCount = 8;

+

+ private readonly GpuContext _context;

+ private readonly ShaderCacheHashTable _graphicsCache;

+ private readonly ComputeShaderCacheHashTable _computeCache;

+ private readonly DiskCacheHostStorage _hostStorage;

+ private readonly CancellationToken _cancellationToken;

+ private readonly Action<ShaderCacheState, int, int> _stateChangeCallback;

+

+ /// <summary>

+ /// Indicates if the cache should be loaded.

+ /// </summary>

+ public bool Active => !_cancellationToken.IsCancellationRequested;

+

+ private bool _needsHostRegen;

+

+ /// <summary>

+ /// Number of shaders that failed to compile from the cache.

+ /// </summary>

+ public int ErrorCount { get; private set; }

+

+ /// <summary>

+ /// Program validation entry.

+ /// </summary>

+ private struct ProgramEntry

+ {

+ /// <summary>

+ /// Cached shader program.

+ /// </summary>

+ public readonly CachedShaderProgram CachedProgram;

+

+ /// <summary>

+ /// Host program.

+ /// </summary>

+ public readonly IProgram HostProgram;

+

+ /// <summary>

+ /// Program index.

+ /// </summary>

+ public readonly int ProgramIndex;

+

+ /// <summary>

+ /// Indicates if the program is a compute shader.

+ /// </summary>

+ public readonly bool IsCompute;

+

+ /// <summary>

+ /// Indicates if the program is a host binary shader.

+ /// </summary>

+ public readonly bool IsBinary;

+

+ /// <summary>

+ /// Creates a new program validation entry.

+ /// </summary>

+ /// <param name="cachedProgram">Cached shader program</param>

+ /// <param name="hostProgram">Host program</param>

+ /// <param name="programIndex">Program index</param>

+ /// <param name="isCompute">Indicates if the program is a compute shader</param>

+ /// <param name="isBinary">Indicates if the program is a host binary shader</param>

+ public ProgramEntry(

+ CachedShaderProgram cachedProgram,

+ IProgram hostProgram,

+ int programIndex,

+ bool isCompute,

+ bool isBinary)

+ {

+ CachedProgram = cachedProgram;

+ HostProgram = hostProgram;

+ ProgramIndex = programIndex;

+ IsCompute = isCompute;

+ IsBinary = isBinary;

+ }

+ }

+

+ /// <summary>

+ /// Translated shader compilation entry.

+ /// </summary>

+ private struct ProgramCompilation

+ {

+ /// <summary>

+ /// Translated shader stages.

+ /// </summary>

+ public readonly ShaderProgram[] TranslatedStages;

+

+ /// <summary>

+ /// Cached shaders.

+ /// </summary>

+ public readonly CachedShaderStage[] Shaders;

+

+ /// <summary>

+ /// Specialization state.

+ /// </summary>

+ public readonly ShaderSpecializationState SpecializationState;

+

+ /// <summary>

+ /// Program index.

+ /// </summary>

+ public readonly int ProgramIndex;

+

+ /// <summary>

+ /// Indicates if the program is a compute shader.

+ /// </summary>

+ public readonly bool IsCompute;

+

+ /// <summary>

+ /// Creates a new translated shader compilation entry.

+ /// </summary>

+ /// <param name="translatedStages">Translated shader stages</param>

+ /// <param name="shaders">Cached shaders</param>

+ /// <param name="specState">Specialization state</param>

+ /// <param name="programIndex">Program index</param>

+ /// <param name="isCompute">Indicates if the program is a compute shader</param>

+ public ProgramCompilation(

+ ShaderProgram[] translatedStages,

+ CachedShaderStage[] shaders,

+ ShaderSpecializationState specState,

+ int programIndex,

+ bool isCompute)

+ {

+ TranslatedStages = translatedStages;

+ Shaders = shaders;

+ SpecializationState = specState;

+ ProgramIndex = programIndex;

+ IsCompute = isCompute;

+ }

+ }

+

+ /// <summary>

+ /// Program translation entry.

+ /// </summary>

+ private struct AsyncProgramTranslation

+ {

+ /// <summary>

+ /// Cached shader stages.

+ /// </summary>

+ public readonly CachedShaderStage[] Shaders;

+

+ /// <summary>

+ /// Specialization state.

+ /// </summary>

+ public readonly ShaderSpecializationState SpecializationState;

+

+ /// <summary>

+ /// Program index.

+ /// </summary>

+ public readonly int ProgramIndex;

+

+ /// <summary>

+ /// Indicates if the program is a compute shader.

+ /// </summary>

+ public readonly bool IsCompute;

+

+ /// <summary>

+ /// Creates a new program translation entry.

+ /// </summary>

+ /// <param name="shaders">Cached shader stages</param>

+ /// <param name="specState">Specialization state</param>

+ /// <param name="programIndex">Program index</param>

+ /// <param name="isCompute">Indicates if the program is a compute shader</param>

+ public AsyncProgramTranslation(

+ CachedShaderStage[] shaders,

+ ShaderSpecializationState specState,

+ int programIndex,

+ bool isCompute)

+ {

+ Shaders = shaders;

+ SpecializationState = specState;

+ ProgramIndex = programIndex;

+ IsCompute = isCompute;

+ }

+ }

+

+ private readonly Queue<ProgramEntry> _validationQueue;

+ private readonly ConcurrentQueue<ProgramCompilation> _compilationQueue;

+ private readonly BlockingCollection<AsyncProgramTranslation> _asyncTranslationQueue;

+ private readonly SortedList<int, CachedShaderProgram> _programList;

+

+ private int _backendParallelCompileThreads;

+ private int _compiledCount;

+ private int _totalCount;

+

+ /// <summary>

+ /// Creates a new parallel disk cache loader.

+ /// </summary>

+ /// <param name="context">GPU context</param>

+ /// <param name="graphicsCache">Graphics shader cache</param>

+ /// <param name="computeCache">Compute shader cache</param>

+ /// <param name="hostStorage">Disk cache host storage</param>

+ /// <param name="cancellationToken">Cancellation token</param>

+ /// <param name="stateChangeCallback">Function to be called when there is a state change, reporting state, compiled and total shaders count</param>

+ public ParallelDiskCacheLoader(

+ GpuContext context,

+ ShaderCacheHashTable graphicsCache,

+ ComputeShaderCacheHashTable computeCache,

+ DiskCacheHostStorage hostStorage,

+ CancellationToken cancellationToken,

+ Action<ShaderCacheState, int, int> stateChangeCallback)

+ {

+ _context = context;

+ _graphicsCache = graphicsCache;

+ _computeCache = computeCache;

+ _hostStorage = hostStorage;

+ _cancellationToken = cancellationToken;

+ _stateChangeCallback = stateChangeCallback;

+ _validationQueue = new Queue<ProgramEntry>();

+ _compilationQueue = new ConcurrentQueue<ProgramCompilation>();

+ _asyncTranslationQueue = new BlockingCollection<AsyncProgramTranslation>(ThreadCount);

+ _programList = new SortedList<int, CachedShaderProgram>();

+ _backendParallelCompileThreads = Math.Min(Environment.ProcessorCount, 8); // Must be kept in sync with the backend code.

+ }

+

+ /// <summary>

+ /// Loads all shaders from the cache.

+ /// </summary>

+ public void LoadShaders()

+ {

+ Thread[] workThreads = new Thread[ThreadCount];

+

+ for (int index = 0; index < ThreadCount; index++)

+ {

+ workThreads[index] = new Thread(ProcessAsyncQueue)

+ {

+ Name = $"Gpu.AsyncTranslationThread.{index}"

+ };

+ }

+

+ int programCount = _hostStorage.GetProgramCount();

+

+ _compiledCount = 0;

+ _totalCount = programCount;

+

+ _stateChangeCallback(ShaderCacheState.Start, 0, programCount);

+

+ Logger.Info?.Print(LogClass.Gpu, $"Loading {programCount} shaders from the cache...");

+

+ for (int index = 0; index < ThreadCount; index++)

+ {

+ workThreads[index].Start(_cancellationToken);

+ }

+

+ try

+ {

+ _hostStorage.LoadShaders(_context, this);

+ }

+ catch (DiskCacheLoadException diskCacheLoadException)

+ {

+ Logger.Warning?.Print(LogClass.Gpu, $"Error loading the shader cache. {diskCacheLoadException.Message}");

+

+ // If we can't even access the file, then we also can't rebuild.

+ if (diskCacheLoadException.Result != DiskCacheLoadResult.NoAccess)

+ {

+ _needsHostRegen = true;

+ }

+ }

+ catch (InvalidDataException invalidDataException)

+ {

+ Logger.Warning?.Print(LogClass.Gpu, $"Error decompressing the shader cache file. {invalidDataException.Message}");

+ _needsHostRegen = true;

+ }

+ catch (IOException ioException)

+ {

+ Logger.Warning?.Print(LogClass.Gpu, $"Error reading the shader cache file. {ioException.Message}");

+ _needsHostRegen = true;

+ }

+

+ _asyncTranslationQueue.CompleteAdding();

+

+ for (int index = 0; index < ThreadCount; index++)

+ {

+ workThreads[index].Join();

+ }

+

+ CheckCompilationBlocking();

+

+ if (_needsHostRegen)

+ {

+ // Rebuild both shared and host cache files.

+ // Rebuilding shared is required because the shader information returned by the translator

+ // might have changed, and so we have to reconstruct the file with the new information.

+ try

+ {

+ _hostStorage.ClearSharedCache();

+ _hostStorage.ClearHostCache(_context);

+

+ if (_programList.Count != 0)

+ {

+ Logger.Info?.Print(LogClass.Gpu, $"Rebuilding {_programList.Count} shaders...");

+

+ using var streams = _hostStorage.GetOutputStreams(_context);

+

+ foreach (var kv in _programList)

+ {

+ if (!Active)

+ {

+ break;

+ }

+

+ CachedShaderProgram program = kv.Value;

+ _hostStorage.AddShader(_context, program, program.HostProgram.GetBinary(), streams);

+ }

+

+ Logger.Info?.Print(LogClass.Gpu, $"Rebuilt {_programList.Count} shaders successfully.");

+ }

+ else

+ {

+ _hostStorage.ClearGuestCache();

+

+ Logger.Info?.Print(LogClass.Gpu, "Shader cache deleted due to corruption.");

+ }

+ }

+ catch (DiskCacheLoadException diskCacheLoadException)

+ {

+ Logger.Warning?.Print(LogClass.Gpu, $"Error deleting the shader cache. {diskCacheLoadException.Message}");

+ }

+ catch (IOException ioException)

+ {

+ Logger.Warning?.Print(LogClass.Gpu, $"Error deleting the shader cache file. {ioException.Message}");

+ }

+ }

+

+ Logger.Info?.Print(LogClass.Gpu, "Shader cache loaded.");

+

+ _stateChangeCallback(ShaderCacheState.Loaded, programCount, programCount);

+ }

+

+ /// <summary>

+ /// Enqueues a host program for compilation.

+ /// </summary>

+ /// <param name="cachedProgram">Cached program</param>

+ /// <param name="hostProgram">Host program to be compiled</param>

+ /// <param name="programIndex">Program index</param>

+ /// <param name="isCompute">Indicates if the program is a compute shader</param>

+ public void QueueHostProgram(CachedShaderProgram cachedProgram, IProgram hostProgram, int programIndex, bool isCompute)

+ {

+ EnqueueForValidation(new ProgramEntry(cachedProgram, hostProgram, programIndex, isCompute, isBinary: true));

+ }

+

+ /// <summary>

+ /// Enqueues a guest program for compilation.

+ /// </summary>

+ /// <param name="shaders">Cached shader stages</param>

+ /// <param name="specState">Specialization state</param>

+ /// <param name="programIndex">Program index</param>

+ /// <param name="isCompute">Indicates if the program is a compute shader</param>

+ public void QueueGuestProgram(CachedShaderStage[] shaders, ShaderSpecializationState specState, int programIndex, bool isCompute)

+ {

+ _asyncTranslationQueue.Add(new AsyncProgramTranslation(shaders, specState, programIndex, isCompute));

+ }

+

+ /// <summary>

+ /// Check the state of programs that have already been compiled,

+ /// and add to the cache if the compilation was successful.

+ /// </summary>

+ public void CheckCompilation()

+ {

+ ProcessCompilationQueue();

+

+ // Process programs that already finished compiling.

+ // If not yet compiled, do nothing. This avoids blocking to wait for shader compilation.

+ while (_validationQueue.TryPeek(out ProgramEntry entry))

+ {

+ ProgramLinkStatus result = entry.HostProgram.CheckProgramLink(false);

+

+ if (result != ProgramLinkStatus.Incomplete)

+ {

+ ProcessCompiledProgram(ref entry, result);

+ _validationQueue.Dequeue();

+ }

+ else

+ {

+ break;

+ }

+ }

+ }

+

+ /// <summary>

+ /// Waits until all programs finishes compiling, then adds the ones

+ /// with successful compilation to the cache.

+ /// </summary>

+ private void CheckCompilationBlocking()

+ {

+ ProcessCompilationQueue();

+

+ while (_validationQueue.TryDequeue(out ProgramEntry entry) && Active)

+ {

+ ProcessCompiledProgram(ref entry, entry.HostProgram.CheckProgramLink(true), asyncCompile: false);

+ }

+ }

+

+ /// <summary>

+ /// Process a compiled program result.

+ /// </summary>

+ /// <param name="entry">Compiled program entry</param>

+ /// <param name="result">Compilation result</param>

+ /// <param name="asyncCompile">For failed host compilations, indicates if a guest compilation should be done asynchronously</param>

+ private void ProcessCompiledProgram(ref ProgramEntry entry, ProgramLinkStatus result, bool asyncCompile = true)

+ {

+ if (result == ProgramLinkStatus.Success)

+ {

+ // Compilation successful, add to memory cache.

+ if (entry.IsCompute)

+ {

+ _computeCache.Add(entry.CachedProgram);

+ }

+ else

+ {

+ _graphicsCache.Add(entry.CachedProgram);

+ }

+

+ if (!entry.IsBinary)

+ {

+ _needsHostRegen = true;

+ }

+

+ _programList.Add(entry.ProgramIndex, entry.CachedProgram);

+ SignalCompiled();

+ }

+ else if (entry.IsBinary)

+ {

+ // If this is a host binary and compilation failed,

+ // we still have a chance to recompile from the guest binary.

+ CachedShaderProgram program = entry.CachedProgram;

+

+ if (asyncCompile)

+ {

+ QueueGuestProgram(program.Shaders, program.SpecializationState, entry.ProgramIndex, entry.IsCompute);

+ }

+ else

+ {

+ RecompileFromGuestCode(program.Shaders, program.SpecializationState, entry.ProgramIndex, entry.IsCompute);

+ ProcessCompilationQueue();

+ }

+ }

+ else

+ {

+ // Failed to compile from both host and guest binary.

+ ErrorCount++;

+ SignalCompiled();

+ }

+ }

+

+ /// <summary>

+ /// Processes the queue of translated guest programs that should be compiled on the host.

+ /// </summary>

+ private void ProcessCompilationQueue()

+ {

+ while (_compilationQueue.TryDequeue(out ProgramCompilation compilation) && Active)

+ {

+ ShaderSource[] shaderSources = new ShaderSource[compilation.TranslatedStages.Length];

+

+ int fragmentOutputMap = -1;

+

+ for (int index = 0; index < compilation.TranslatedStages.Length; index++)

+ {

+ ShaderProgram shader = compilation.TranslatedStages[index];

+ shaderSources[index] = CreateShaderSource(shader);

+

+ if (shader.Info.Stage == ShaderStage.Fragment)

+ {

+ fragmentOutputMap = shader.Info.FragmentOutputMap;

+ }

+ }

+

+ IProgram hostProgram = _context.Renderer.CreateProgram(shaderSources, new ShaderInfo(fragmentOutputMap));

+ CachedShaderProgram program = new CachedShaderProgram(hostProgram, compilation.SpecializationState, compilation.Shaders);

+

+ EnqueueForValidation(new ProgramEntry(program, hostProgram, compilation.ProgramIndex, compilation.IsCompute, isBinary: false));

+ }

+ }

+

+ /// <summary>

+ /// Enqueues a program for validation, which will check if the program was compiled successfully.

+ /// </summary>

+ /// <param name="newEntry">Program entry to be validated</param>

+ private void EnqueueForValidation(ProgramEntry newEntry)

+ {

+ _validationQueue.Enqueue(newEntry);

+

+ // Do not allow more than N shader compilation in-flight, where N is the maximum number of threads

+ // the driver will be using for parallel compilation.

+ // Submitting more seems to cause NVIDIA OpenGL driver to crash.

+ if (_validationQueue.Count >= _backendParallelCompileThreads && _validationQueue.TryDequeue(out ProgramEntry entry))

+ {

+ ProcessCompiledProgram(ref entry, entry.HostProgram.CheckProgramLink(true), asyncCompile: false);

+ }

+ }

+

+ /// <summary>

+ /// Processses the queue of programs that should be translated from guest code.

+ /// </summary>

+ /// <param name="state">Cancellation token</param>

+ private void ProcessAsyncQueue(object state)

+ {

+ CancellationToken ct = (CancellationToken)state;

+

+ try

+ {

+ foreach (AsyncProgramTranslation asyncCompilation in _asyncTranslationQueue.GetConsumingEnumerable(ct))

+ {

+ RecompileFromGuestCode(

+ asyncCompilation.Shaders,

+ asyncCompilation.SpecializationState,

+ asyncCompilation.ProgramIndex,

+ asyncCompilation.IsCompute);

+ }

+ }

+ catch (OperationCanceledException)

+ {

+ }

+ }

+

+ /// <summary>

+ /// Recompiles a program from guest code.

+ /// </summary>

+ /// <param name="shaders">Shader stages</param>

+ /// <param name="specState">Specialization state</param>

+ /// <param name="programIndex">Program index</param>

+ /// <param name="isCompute">Indicates if the program is a compute shader</param>

+ private void RecompileFromGuestCode(CachedShaderStage[] shaders, ShaderSpecializationState specState, int programIndex, bool isCompute)

+ {

+ try

+ {

+ if (isCompute)

+ {

+ RecompileComputeFromGuestCode(shaders, specState, programIndex);

+ }

+ else

+ {

+ RecompileGraphicsFromGuestCode(shaders, specState, programIndex);

+ }

+ }

+ catch (DiskCacheLoadException diskCacheLoadException)

+ {

+ Logger.Error?.Print(LogClass.Gpu, $"Error translating guest shader. {diskCacheLoadException.Message}");

+

+ ErrorCount++;

+ SignalCompiled();

+ }

+ }

+

+ /// <summary>

+ /// Recompiles a graphics program from guest code.

+ /// </summary>

+ /// <param name="shaders">Shader stages</param>

+ /// <param name="specState">Specialization state</param>

+ /// <param name="programIndex">Program index</param>

+ private void RecompileGraphicsFromGuestCode(CachedShaderStage[] shaders, ShaderSpecializationState specState, int programIndex)

+ {

+ ShaderSpecializationState newSpecState = new ShaderSpecializationState(specState.GraphicsState, specState.TransformFeedbackDescriptors);

+ ResourceCounts counts = new ResourceCounts();

+

+ TranslatorContext[] translatorContexts = new TranslatorContext[Constants.ShaderStages + 1];

+ TranslatorContext nextStage = null;

+

+ for (int stageIndex = Constants.ShaderStages - 1; stageIndex >= 0; stageIndex--)

+ {

+ CachedShaderStage shader = shaders[stageIndex + 1];

+

+ if (shader != null)

+ {

+ byte[] guestCode = shader.Code;

+ byte[] cb1Data = shader.Cb1Data;

+

+ DiskCacheGpuAccessor gpuAccessor = new DiskCacheGpuAccessor(_context, guestCode, cb1Data, specState, newSpecState, counts, stageIndex);

+ TranslatorContext currentStage = DecodeGraphicsShader(gpuAccessor, DefaultFlags, 0);

+

+ if (nextStage != null)

+ {

+ currentStage.SetNextStage(nextStage);

+ }

+

+ if (stageIndex == 0 && shaders[0] != null)

+ {

+ byte[] guestCodeA = shaders[0].Code;

+ byte[] cb1DataA = shaders[0].Cb1Data;

+

+ DiskCacheGpuAccessor gpuAccessorA = new DiskCacheGpuAccessor(_context, guestCodeA, cb1DataA, specState, newSpecState, counts, 0);

+ translatorContexts[0] = DecodeGraphicsShader(gpuAccessorA, DefaultFlags | TranslationFlags.VertexA, 0);

+ }

+

+ translatorContexts[stageIndex + 1] = currentStage;

+ nextStage = currentStage;

+ }

+ }

+

+ List<ShaderProgram> translatedStages = new List<ShaderProgram>();

+

+ for (int stageIndex = 0; stageIndex < Constants.ShaderStages; stageIndex++)

+ {

+ TranslatorContext currentStage = translatorContexts[stageIndex + 1];

+

+ if (currentStage != null)

+ {

+ ShaderProgram program;

+

+ byte[] guestCode = shaders[stageIndex + 1].Code;

+ byte[] cb1Data = shaders[stageIndex + 1].Cb1Data;

+

+ if (stageIndex == 0 && shaders[0] != null)

+ {

+ program = currentStage.Translate(translatorContexts[0]);

+

+ byte[] guestCodeA = shaders[0].Code;

+ byte[] cb1DataA = shaders[0].Cb1Data;

+

+ shaders[0] = new CachedShaderStage(null, guestCodeA, cb1DataA);

+ shaders[1] = new CachedShaderStage(program.Info, guestCode, cb1Data);

+ }

+ else

+ {

+ program = currentStage.Translate();

+

+ shaders[stageIndex + 1] = new CachedShaderStage(program.Info, guestCode, cb1Data);

+ }

+

+ if (program != null)

+ {

+ translatedStages.Add(program);

+ }

+ }

+ }

+

+ _compilationQueue.Enqueue(new ProgramCompilation(translatedStages.ToArray(), shaders, newSpecState, programIndex, isCompute: false));

+ }

+

+ /// <summary>

+ /// Recompiles a compute program from guest code.

+ /// </summary>

+ /// <param name="shaders">Shader stages</param>

+ /// <param name="specState">Specialization state</param>

+ /// <param name="programIndex">Program index</param>

+ private void RecompileComputeFromGuestCode(CachedShaderStage[] shaders, ShaderSpecializationState specState, int programIndex)

+ {

+ CachedShaderStage shader = shaders[0];

+ ResourceCounts counts = new ResourceCounts();

+ ShaderSpecializationState newSpecState = new ShaderSpecializationState(specState.ComputeState);

+ DiskCacheGpuAccessor gpuAccessor = new DiskCacheGpuAccessor(_context, shader.Code, shader.Cb1Data, specState, newSpecState, counts, 0);

+

+ TranslatorContext translatorContext = DecodeComputeShader(gpuAccessor, 0);

+

+ ShaderProgram program = translatorContext.Translate();

+

+ shaders[0] = new CachedShaderStage(program.Info, shader.Code, shader.Cb1Data);

+

+ _compilationQueue.Enqueue(new ProgramCompilation(new[] { program }, shaders, newSpecState, programIndex, isCompute: true));

+ }

+

+ /// <summary>

+ /// Signals that compilation of a program has been finished successfully,

+ /// or that it failed and guest recompilation has also been attempted.

+ /// </summary>

+ private void SignalCompiled()

+ {

+ _stateChangeCallback(ShaderCacheState.Loading, ++_compiledCount, _totalCount);

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Graphics.Gpu.Image;

+ class GpuAccessor : GpuAccessorBase, IGpuAccessor

+ public GpuAccessor(GpuContext context, GpuChannel channel, GpuAccessorState state) : base(context)

+ /// <inheritdoc/>

+ /// <inheritdoc/>

+ /// <inheritdoc/>

+ public ReadOnlySpan<ulong> GetCode(ulong address, int minimumSize)

+ /// <inheritdoc/>

+ public int QueryBindingConstantBuffer(int index)

+ {

+ return _state.ResourceCounts.UniformBuffersCount++;

+ }

+ /// <inheritdoc/>

+ public int QueryBindingStorageBuffer(int index)

+ {

+ return _state.ResourceCounts.StorageBuffersCount++;

+ }

+ /// <inheritdoc/>

+ public int QueryBindingTexture(int index)

+ {

+ return _state.ResourceCounts.TexturesCount++;

+ }

+ /// <inheritdoc/>

+ public int QueryBindingImage(int index)

+ {

+ return _state.ResourceCounts.ImagesCount++;

+ }

+ /// <inheritdoc/>

+ public int QueryComputeLocalSizeX() => _state.ComputeState.LocalSizeX;

+ /// <inheritdoc/>

+ public int QueryComputeLocalSizeY() => _state.ComputeState.LocalSizeY;

+

+ /// <inheritdoc/>

+ public int QueryComputeLocalSizeZ() => _state.ComputeState.LocalSizeZ;

+

+ /// <inheritdoc/>

+ public int QueryComputeLocalMemorySize() => _state.ComputeState.LocalMemorySize;

+

+ /// <inheritdoc/>

+ public int QueryComputeSharedMemorySize() => _state.ComputeState.SharedMemorySize;

+

+ /// <inheritdoc/>

+ uint useMask = _compute

+

+ _state.SpecializationState?.RecordConstantBufferUse(_stageIndex, useMask);

+ return useMask;

+ /// <inheritdoc/>

+ _state.SpecializationState?.RecordPrimitiveTopology();

+ return ConvertToInputTopology(_state.GraphicsState.Topology, _state.GraphicsState.TessellationMode);

+ /// <inheritdoc/>

+ public bool QueryTessCw()

+ {

+ return _state.GraphicsState.TessellationMode.UnpackCw();

+ }

+ /// <inheritdoc/>

+ public TessPatchType QueryTessPatchType()

+ {

+ return _state.GraphicsState.TessellationMode.UnpackPatchType();

+ }

+ /// <inheritdoc/>

+ public TessSpacing QueryTessSpacing()

+ {

+ return _state.GraphicsState.TessellationMode.UnpackSpacing();

+ }

+

+ //// <inheritdoc/>

+ public TextureFormat QueryTextureFormat(int handle, int cbufSlot)

+ {

+ _state.SpecializationState?.RecordTextureFormat(_stageIndex, handle, cbufSlot);

+ var descriptor = GetTextureDescriptor(handle, cbufSlot);

+ return ConvertToTextureFormat(descriptor.UnpackFormat(), descriptor.UnpackSrgb());

+ }

+

+ /// <inheritdoc/>

+ public SamplerType QuerySamplerType(int handle, int cbufSlot)

+ {

+ _state.SpecializationState?.RecordTextureSamplerType(_stageIndex, handle, cbufSlot);

+ return GetTextureDescriptor(handle, cbufSlot).UnpackTextureTarget().ConvertSamplerType();

+ }

+

+ /// <inheritdoc/>

+ public bool QueryTextureCoordNormalized(int handle, int cbufSlot)

+ {

+ _state.SpecializationState?.RecordTextureCoordNormalized(_stageIndex, handle, cbufSlot);

+ return GetTextureDescriptor(handle, cbufSlot).UnpackTextureCoordNormalized();

+ }

+ private Image.TextureDescriptor GetTextureDescriptor(int handle, int cbufSlot)

+ _state.PoolState.TexturePoolGpuVa,

+ _state.PoolState.TextureBufferIndex,

+ _state.PoolState.TexturePoolMaximumId,

+ _state.PoolState.TexturePoolGpuVa,

+ _state.PoolState.TextureBufferIndex,

+ _state.PoolState.TexturePoolMaximumId,

+ /// <inheritdoc/>

+ /// <inheritdoc/>

+ return _state.TransformFeedbackDescriptors[bufferIndex].AsSpan();

+ /// <inheritdoc/>

+ /// <inheritdoc/>

+ _state.SpecializationState?.RecordEarlyZForce();

+ return _state.GraphicsState.EarlyZForce;

+ }

+

+ /// <inheritdoc/>

+ public void RegisterTexture(int handle, int cbufSlot)

+ {

+ _state.SpecializationState?.RegisterTexture(_stageIndex, handle, cbufSlot, GetTextureDescriptor(handle, cbufSlot));

+using Ryujinx.Graphics.GAL;

+using Ryujinx.Graphics.Gpu.Engine.Threed;

+ /// <summary>

+ /// GPU accessor.

+ /// </summary>

+ class GpuAccessorBase

+ /// <summary>

+ /// Creates a new GPU accessor.

+ /// </summary>

+ /// <param name="context">GPU context</param>

+ public GpuAccessorBase(GpuContext context)

+ /// Converts a packed Maxwell texture format to the shader translator texture format.

+ /// <param name="format">Packed maxwell format</param>

+ /// <param name="formatSrgb">Indicates if the format is sRGB</param>

+ /// <returns>Shader translator texture format</returns>

+ protected static TextureFormat ConvertToTextureFormat(uint format, bool formatSrgb)

+ if (!FormatTable.TryGetTextureFormat(format, formatSrgb, out FormatInfo formatInfo))

+ /// Converts the Maxwell primitive topology to the shader translator topology.

+ /// <param name="topology">Maxwell primitive topology</param>

+ /// <param name="tessellationMode">Maxwell tessellation mode</param>

+ /// <returns>Shader translator topology</returns>

+ protected static InputTopology ConvertToInputTopology(PrimitiveTopology topology, TessMode tessellationMode)

+ return topology switch

+ {

+ PrimitiveTopology.Points => InputTopology.Points,

+ PrimitiveTopology.Lines or

+ PrimitiveTopology.LineLoop or

+ PrimitiveTopology.LineStrip => InputTopology.Lines,

+ PrimitiveTopology.LinesAdjacency or

+ PrimitiveTopology.LineStripAdjacency => InputTopology.LinesAdjacency,

+ PrimitiveTopology.Triangles or

+ PrimitiveTopology.TriangleStrip or

+ PrimitiveTopology.TriangleFan => InputTopology.Triangles,

+ PrimitiveTopology.TrianglesAdjacency or

+ PrimitiveTopology.TriangleStripAdjacency => InputTopology.TrianglesAdjacency,

+ PrimitiveTopology.Patches => tessellationMode.UnpackPatchType() == TessPatchType.Isolines

+ ? InputTopology.Lines

+ : InputTopology.Triangles,

+ _ => InputTopology.Points

+ };

+ class GpuAccessorState

+ /// GPU texture pool state.

+ public readonly GpuChannelPoolState PoolState;

+ /// GPU compute state, for compute shaders.

+ public readonly GpuChannelComputeState ComputeState;

+ /// GPU graphics state, for vertex, tessellation, geometry and fragment shaders.

+ public readonly GpuChannelGraphicsState GraphicsState;

+ /// Shader specialization state (shared by all stages).

+ public readonly ShaderSpecializationState SpecializationState;

+ /// Transform feedback information, if the shader uses transform feedback. Otherwise, should be null.

+ public readonly TransformFeedbackDescriptor[] TransformFeedbackDescriptors;

+ /// Shader resource counts (shared by all stages).

+ public readonly ResourceCounts ResourceCounts;

+ /// Creates a new GPU accessor state.

+ /// <param name="poolState">GPU texture pool state</param>

+ /// <param name="computeState">GPU compute state, for compute shaders</param>

+ /// <param name="graphicsState">GPU graphics state, for vertex, tessellation, geometry and fragment shaders</param>

+ /// <param name="specializationState">Shader specialization state (shared by all stages)</param>

+ /// <param name="transformFeedbackDescriptors">Transform feedback information, if the shader uses transform feedback. Otherwise, should be null</param>

+ GpuChannelPoolState poolState,

+ GpuChannelComputeState computeState,

+ GpuChannelGraphicsState graphicsState,

+ ShaderSpecializationState specializationState,

+ TransformFeedbackDescriptor[] transformFeedbackDescriptors = null)

+ PoolState = poolState;

+ GraphicsState = graphicsState;

+ ComputeState = computeState;

+ SpecializationState = specializationState;

+ TransformFeedbackDescriptors = transformFeedbackDescriptors;

+ ResourceCounts = new ResourceCounts();

+namespace Ryujinx.Graphics.Gpu.Shader

+{

+ /// <summary>

+ /// State used by the <see cref="GpuAccessor"/>.

+ /// </summary>

+ struct GpuChannelComputeState

+ {

+ // New fields should be added to the end of the struct to keep disk shader cache compatibility.

+

+ /// <summary>

+ /// Local group size X of the compute shader.

+ /// </summary>

+ public readonly int LocalSizeX;

+

+ /// <summary>

+ /// Local group size Y of the compute shader.

+ /// </summary>

+ public readonly int LocalSizeY;

+

+ /// <summary>

+ /// Local group size Z of the compute shader.

+ /// </summary>

+ public readonly int LocalSizeZ;

+

+ /// <summary>

+ /// Local memory size of the compute shader.

+ /// </summary>

+ public readonly int LocalMemorySize;

+

+ /// <summary>

+ /// Shared memory size of the compute shader.

+ /// </summary>

+ public readonly int SharedMemorySize;

+

+ /// <summary>

+ /// Creates a new GPU compute state.

+ /// </summary>

+ /// <param name="localSizeX">Local group size X of the compute shader</param>

+ /// <param name="localSizeY">Local group size Y of the compute shader</param>

+ /// <param name="localSizeZ">Local group size Z of the compute shader</param>

+ /// <param name="localMemorySize">Local memory size of the compute shader</param>

+ /// <param name="sharedMemorySize">Shared memory size of the compute shader</param>

+ public GpuChannelComputeState(

+ int localSizeX,

+ int localSizeY,

+ int localSizeZ,

+ int localMemorySize,

+ int sharedMemorySize)

+ {

+ LocalSizeX = localSizeX;

+ LocalSizeY = localSizeY;

+ LocalSizeZ = localSizeZ;

+ LocalMemorySize = localMemorySize;

+ SharedMemorySize = sharedMemorySize;

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Graphics.GAL;

+using Ryujinx.Graphics.Gpu.Engine.Threed;

+

+namespace Ryujinx.Graphics.Gpu.Shader

+{

+ /// <summary>

+ /// State used by the <see cref="GpuAccessor"/>.

+ /// </summary>

+ struct GpuChannelGraphicsState

+ {

+ // New fields should be added to the end of the struct to keep disk shader cache compatibility.

+

+ /// <summary>

+ /// Early Z force enable.

+ /// </summary>

+ public readonly bool EarlyZForce;

+

+ /// <summary>

+ /// Primitive topology of current draw.

+ /// </summary>

+ public readonly PrimitiveTopology Topology;

+

+ /// <summary>

+ /// Tessellation mode.

+ /// </summary>

+ public readonly TessMode TessellationMode;

+

+ /// <summary>

+ /// Creates a new GPU graphics state.

+ /// </summary>

+ /// <param name="earlyZForce">Early Z force enable</param>

+ /// <param name="topology">Primitive topology</param>

+ /// <param name="tessellationMode">Tessellation mode</param>

+ public GpuChannelGraphicsState(bool earlyZForce, PrimitiveTopology topology, TessMode tessellationMode)

+ {

+ EarlyZForce = earlyZForce;

+ Topology = topology;

+ TessellationMode = tessellationMode;

+ }

+ }

+} \ No newline at end of file

+namespace Ryujinx.Graphics.Gpu.Shader

+{

+ /// <summary>

+ /// State used by the <see cref="GpuAccessor"/>.

+ /// </summary>

+ struct GpuChannelPoolState

+ {

+ /// <summary>

+ /// GPU virtual address of the texture pool.

+ /// </summary>

+ public readonly ulong TexturePoolGpuVa;

+

+ /// <summary>

+ /// Maximum ID of the texture pool.

+ /// </summary>

+ public readonly int TexturePoolMaximumId;

+

+ /// <summary>

+ /// Constant buffer slot where the texture handles are located.

+ /// </summary>

+ public readonly int TextureBufferIndex;

+

+ /// <summary>

+ /// Creates a new GPU texture pool state.

+ /// </summary>

+ /// <param name="texturePoolGpuVa">GPU virtual address of the texture pool</param>

+ /// <param name="texturePoolMaximumId">Maximum ID of the texture pool</param>

+ /// <param name="textureBufferIndex">Constant buffer slot where the texture handles are located</param>

+ public GpuChannelPoolState(ulong texturePoolGpuVa, int texturePoolMaximumId, int textureBufferIndex)

+ {

+ TexturePoolGpuVa = texturePoolGpuVa;

+ TexturePoolMaximumId = texturePoolMaximumId;

+ TextureBufferIndex = textureBufferIndex;

+ }

+ }

+} \ No newline at end of file

+using System;

+using System.Runtime.InteropServices;

+

+namespace Ryujinx.Graphics.Gpu.Shader.HashTable

+{

+ /// <summary>

+ /// State of a hash calculation.

+ /// </summary>

+ struct HashState

+ {

+ // This is using a slightly modified implementation of FastHash64.

+ // Reference: https://github.com/ztanml/fast-hash/blob/master/fasthash.c

+ private const ulong M = 0x880355f21e6d1965UL;

+ private ulong _hash;

+ private int _start;

+

+ /// <summary>

+ /// One shot hash calculation for a given data.

+ /// </summary>

+ /// <param name="data">Data to be hashed</param>

+ /// <returns>Hash of the given data</returns>

+ public static uint CalcHash(ReadOnlySpan<byte> data)

+ {

+ HashState state = new HashState();

+

+ state.Initialize();

+ state.Continue(data);

+ return state.Finalize(data);

+ }

+

+ /// <summary>

+ /// Initializes the hash state.

+ /// </summary>

+ public void Initialize()

+ {

+ _hash = 23;

+ }

+

+ /// <summary>

+ /// Calculates the hash of the given data.

+ /// </summary>

+ /// <remarks>

+ /// The full data must be passed on <paramref name="data"/>.

+ /// If this is not the first time the method is called, then <paramref name="data"/> must start with the data passed on the last call.

+ /// If a smaller slice of the data was already hashed before, only the additional data will be hashed.

+ /// This can be used for additive hashing of data in chuncks.

+ /// </remarks>

+ /// <param name="data">Data to be hashed</param>

+ public void Continue(ReadOnlySpan<byte> data)

+ {

+ ulong h = _hash;

+

+ ReadOnlySpan<ulong> dataAsUlong = MemoryMarshal.Cast<byte, ulong>(data.Slice(_start));

+

+ for (int i = 0; i < dataAsUlong.Length; i++)

+ {

+ ulong value = dataAsUlong[i];

+

+ h ^= Mix(value);

+ h *= M;

+ }

+

+ _hash = h;

+ _start = data.Length & ~7;

+ }

+

+ /// <summary>

+ /// Performs the hash finalization step, and returns the calculated hash.

+ /// </summary>

+ /// <remarks>

+ /// The full data must be passed on <paramref name="data"/>.

+ /// <paramref name="data"/> must start with the data passed on the last call to <see cref="Continue"/>.

+ /// No internal state is changed, so one can still continue hashing data with <see cref="Continue"/>

+ /// after calling this method.

+ /// </remarks>

+ /// <param name="data">Data to be hashed</param>

+ /// <returns>Hash of all the data hashed with this <see cref="HashState"/></returns>

+ public uint Finalize(ReadOnlySpan<byte> data)

+ {

+ ulong h = _hash;

+

+ int remainder = data.Length & 7;

+ if (remainder != 0)

+ {

+ ulong v = 0;

+

+ for (int i = data.Length - remainder; i < data.Length; i++)

+ {

+ v |= (ulong)data[i] << ((i - remainder) * 8);

+ }

+

+ h ^= Mix(v);

+ h *= M;

+ }

+

+ h = Mix(h);

+ return (uint)(h - (h >> 32));

+ }

+

+ /// <summary>

+ /// Hash mix function.

+ /// </summary>

+ /// <param name="h">Hash to mix</param>

+ /// <returns>Mixed hash</returns>

+ private static ulong Mix(ulong h)

+ {

+ h ^= h >> 23;

+ h *= 0x2127599bf4325c37UL;

+ h ^= h >> 47;

+ return h;

+ }

+ }

+}

+using System;

+

+namespace Ryujinx.Graphics.Gpu.Shader.HashTable

+{

+ /// <summary>

+ /// Data accessor, used by <see cref="PartitionedHashTable{T}"/> to access data of unknown length.

+ /// </summary>

+ /// <remarks>

+ /// This will be used to access chuncks of data and try finding a match on the table.

+ /// This is necessary because the data size is assumed to be unknown, and so the

+ /// hash table must try to "guess" the size of the data based on the entries on the table.

+ /// </remarks>

+ public interface IDataAccessor

+ {

+ /// <summary>

+ /// Gets a span of shader code at the specified offset, with at most the specified size.

+ /// </summary>

+ /// <remarks>

+ /// This might return a span smaller than the requested <paramref name="length"/> if there's

+ /// no more code available.

+ /// </remarks>

+ /// <param name="offset">Offset in shader code</param>

+ /// <param name="length">Size in bytes</param>

+ /// <returns>Shader code span</returns>

+ ReadOnlySpan<byte> GetSpan(int offset, int length);

+ }

+}

+using System;

+using System.Collections.Generic;

+using System.Linq;

+using System.Numerics;

+

+namespace Ryujinx.Graphics.Gpu.Shader.HashTable

+{

+ /// <summary>

+ /// Partitioned hash table.

+ /// </summary>

+ /// <typeparam name="T">Hash table entry type</typeparam>

+ class PartitionHashTable<T>

+ {

+ /// <summary>

+ /// Hash table entry.

+ /// </summary>

+ private struct Entry

+ {

+ /// <summary>

+ /// Hash <see cref="OwnSize"/> bytes of <see cref="Data"/>.

+ /// </summary>

+ public readonly uint Hash;

+

+ /// <summary>

+ /// If this entry is only a sub-region of <see cref="Data"/>, this indicates the size in bytes

+ /// of that region. Otherwise, it should be zero.

+ /// </summary>

+ public readonly int OwnSize;

+

+ /// <summary>

+ /// Data used to compute the hash for this entry.

+ /// </summary>

+ /// <remarks>

+ /// To avoid additional allocations, this might be a instance of the full entry data,

+ /// and only a sub-region of it might be actually used by this entry. Such sub-region

+ /// has its size indicated by <see cref="OwnSize"/> in this case.

+ /// </remarks>

+ public readonly byte[] Data;

+

+ /// <summary>

+ /// Item associated with this entry.

+ /// </summary>

+ public T Item;

+

+ /// <summary>

+ /// Indicates if the entry is partial, which means that this entry is only for a sub-region of the data.

+ /// </summary>

+ /// <remarks>

+ /// Partial entries have no items associated with them. They just indicates that the data might be present on

+ /// the table, and one must keep looking for the full entry on other tables of larger data size.

+ /// </remarks>

+ public bool IsPartial => OwnSize != 0;

+

+ /// <summary>

+ /// Creates a new partial hash table entry.

+ /// </summary>

+ /// <param name="hash">Hash of the data</param>

+ /// <param name="ownerData">Full data</param>

+ /// <param name="ownSize">Size of the sub-region of data that belongs to this entry</param>

+ public Entry(uint hash, byte[] ownerData, int ownSize)

+ {

+ Hash = hash;

+ OwnSize = ownSize;

+ Data = ownerData;

+ Item = default;

+ }

+

+ /// <summary>

+ /// Creates a new full hash table entry.

+ /// </summary>

+ /// <param name="hash">Hash of the data</param>

+ /// <param name="data">Data</param>

+ /// <param name="item">Item associated with this entry</param>

+ public Entry(uint hash, byte[] data, T item)

+ {

+ Hash = hash;

+ OwnSize = 0;

+ Data = data;

+ Item = item;

+ }

+

+ /// <summary>

+ /// Gets the data for this entry, either full or partial.

+ /// </summary>

+ /// <returns>Data sub-region</returns>

+ public ReadOnlySpan<byte> GetData()

+ {

+ if (OwnSize != 0)

+ {

+ return new ReadOnlySpan<byte>(Data).Slice(0, OwnSize);

+ }

+

+ return Data;

+ }

+ }

+

+ /// <summary>

+ /// Hash table bucket.

+ /// </summary>

+ private struct Bucket

+ {

+ /// <summary>

+ /// Inline entry, to avoid allocations for the common single entry case.

+ /// </summary>

+ public Entry InlineEntry;

+

+ /// <summary>

+ /// List of additional entries for the not-so-common multiple entries case.

+ /// </summary>

+ public List<Entry> MoreEntries;

+ }

+

+ private Bucket[] _buckets;

+ private int _count;

+

+ /// <summary>

+ /// Total amount of entries on the hash table.

+ /// </summary>

+ public int Count => _count;

+

+ /// <summary>

+ /// Creates a new instance of the partitioned hash table.

+ /// </summary>

+ public PartitionHashTable()

+ {

+ _buckets = Array.Empty<Bucket>();

+ }

+

+ /// <summary>

+ /// Gets an item on the table, or adds a new one if not present.

+ /// </summary>

+ /// <param name="data">Data</param>

+ /// <param name="dataHash">Hash of the data</param>

+ /// <param name="item">Item to be added if not found</param>

+ /// <returns>Existing item if found, or <paramref name="item"/> if not found</returns>

+ public T GetOrAdd(byte[] data, uint dataHash, T item)

+ {

+ if (TryFindItem(dataHash, data, out T existingItem))

+ {

+ return existingItem;

+ }

+

+ Entry entry = new Entry(dataHash, data, item);

+

+ AddToBucket(dataHash, ref entry);

+

+ return item;

+ }

+

+ /// <summary>

+ /// Adds an item to the hash table.

+ /// </summary>

+ /// <param name="data">Data</param>

+ /// <param name="dataHash">Hash of the data</param>

+ /// <param name="item">Item to be added</param>

+ /// <returns>True if the item was added, false due to an item associated with the data already being on the table</returns>

+ public bool Add(byte[] data, uint dataHash, T item)

+ {

+ if (TryFindItem(dataHash, data, out _))

+ {

+ return false;

+ }

+

+ Entry entry = new Entry(dataHash, data, item);

+

+ AddToBucket(dataHash, ref entry);

+

+ return true;

+ }

+

+ /// <summary>

+ /// Adds a partial entry to the hash table.

+ /// </summary>

+ /// <param name="ownerData">Full data</param>

+ /// <param name="ownSize">Size of the sub-region of <paramref name="ownerData"/> used by the partial entry</param>

+ /// <returns>True if added, false otherwise</returns>

+ public bool AddPartial(byte[] ownerData, int ownSize)

+ {

+ ReadOnlySpan<byte> data = new ReadOnlySpan<byte>(ownerData).Slice(0, ownSize);

+

+ return AddPartial(ownerData, HashState.CalcHash(data), ownSize);

+ }

+

+ /// <summary>

+ /// Adds a partial entry to the hash table.

+ /// </summary>

+ /// <param name="ownerData">Full data</param>

+ /// <param name="dataHash">Hash of the data sub-region</param>

+ /// <param name="ownSize">Size of the sub-region of <paramref name="ownerData"/> used by the partial entry</param>

+ /// <returns>True if added, false otherwise</returns>

+ public bool AddPartial(byte[] ownerData, uint dataHash, int ownSize)

+ {

+ ReadOnlySpan<byte> data = new ReadOnlySpan<byte>(ownerData).Slice(0, ownSize);

+

+ if (TryFindItem(dataHash, data, out _))

+ {

+ return false;

+ }

+

+ Entry entry = new Entry(dataHash, ownerData, ownSize);

+

+ AddToBucket(dataHash, ref entry);

+

+ return true;

+ }

+

+ /// <summary>

+ /// Adds entry with a given hash to the table.

+ /// </summary>

+ /// <param name="dataHash">Hash of the entry</param>

+ /// <param name="entry">Entry</param>

+ private void AddToBucket(uint dataHash, ref Entry entry)

+ {

+ int pow2Count = GetPow2Count(++_count);

+ if (pow2Count != _buckets.Length)

+ {

+ Rebuild(pow2Count);

+ }

+

+ ref Bucket bucket = ref GetBucketForHash(dataHash);

+

+ AddToBucket(ref bucket, ref entry);

+ }

+

+ /// <summary>

+ /// Adds an entry to a bucket.

+ /// </summary>

+ /// <param name="bucket">Bucket to add the entry into</param>

+ /// <param name="entry">Entry to be added</param>

+ private void AddToBucket(ref Bucket bucket, ref Entry entry)

+ {

+ if (bucket.InlineEntry.Data == null)

+ {

+ bucket.InlineEntry = entry;

+ }

+ else

+ {

+ (bucket.MoreEntries ??= new List<Entry>()).Add(entry);

+ }

+ }

+

+ /// <summary>

+ /// Creates partial entries on a new hash table for all existing full entries.

+ /// </summary>

+ /// <remarks>

+ /// This should be called every time a new hash table is created, and there are hash

+ /// tables with data sizes that are higher than that of the new table.

+ /// This will then fill the new hash table with "partial" entries of full entries

+ /// on the hash tables with higher size.

+ /// </remarks>

+ /// <param name="newTable">New hash table</param>

+ /// <param name="newEntrySize">Size of the data on the new hash table</param>

+ public void FillPartials(PartitionHashTable<T> newTable, int newEntrySize)

+ {

+ for (int i = 0; i < _buckets.Length; i++)

+ {

+ ref Bucket bucket = ref _buckets[i];

+ ref Entry inlineEntry = ref bucket.InlineEntry;

+

+ if (inlineEntry.Data != null)

+ {

+ if (!inlineEntry.IsPartial)

+ {

+ newTable.AddPartial(inlineEntry.Data, newEntrySize);

+ }

+

+ if (bucket.MoreEntries != null)

+ {

+ foreach (Entry entry in bucket.MoreEntries)

+ {

+ if (entry.IsPartial)

+ {

+ continue;

+ }

+

+ newTable.AddPartial(entry.Data, newEntrySize);

+ }

+ }

+ }

+ }

+ }

+

+ /// <summary>

+ /// Tries to find an item on the table.

+ /// </summary>

+ /// <param name="dataHash">Hash of <paramref name="data"/></param>

+ /// <param name="data">Data to find</param>

+ /// <param name="item">Item associated with the data</param>

+ /// <returns>True if an item was found, false otherwise</returns>

+ private bool TryFindItem(uint dataHash, ReadOnlySpan<byte> data, out T item)

+ {

+ if (_count == 0)

+ {

+ item = default;

+ return false;

+ }

+

+ ref Bucket bucket = ref GetBucketForHash(dataHash);

+

+ if (bucket.InlineEntry.Data != null)

+ {

+ if (bucket.InlineEntry.Hash == dataHash && bucket.InlineEntry.GetData().SequenceEqual(data))

+ {

+ item = bucket.InlineEntry.Item;

+ return true;

+ }

+

+ if (bucket.MoreEntries != null)

+ {

+ foreach (Entry entry in bucket.MoreEntries)

+ {

+ if (entry.Hash == dataHash && entry.GetData().SequenceEqual(data))

+ {

+ item = entry.Item;

+ return true;

+ }

+ }

+ }

+ }

+

+ item = default;

+ return false;

+ }

+

+ /// <summary>

+ /// Indicates the result of a hash table lookup.

+ /// </summary>

+ public enum SearchResult

+ {

+ /// <summary>

+ /// No entry was found, the search must continue on hash tables of lower size.

+ /// </summary>

+ NotFound,

+

+ /// <summary>

+ /// A partial entry was found, the search must continue on hash tables of higher size.

+ /// </summary>

+ FoundPartial,

+

+ /// <summary>

+ /// A full entry was found, the search was concluded and the item can be retrieved.

+ /// </summary>

+ FoundFull

+ }

+

+ /// <summary>

+ /// Tries to find an item on the table.

+ /// </summary>

+ /// <param name="dataAccessor">Data accessor</param>

+ /// <param name="size">Size of the hash table data</param>

+ /// <param name="item">The item on the table, if found, otherwise unmodified</param>

+ /// <param name="data">The data on the table, if found, otherwise unmodified</param>

+ /// <returns>Table lookup result</returns>

+ public SearchResult TryFindItem(ref SmartDataAccessor dataAccessor, int size, ref T item, ref byte[] data)

+ {

+ if (_count == 0)

+ {

+ return SearchResult.NotFound;

+ }

+

+ ReadOnlySpan<byte> dataSpan = dataAccessor.GetSpanAndHash(size, out uint dataHash);

+

+ if (dataSpan.Length != size)

+ {

+ return SearchResult.NotFound;

+ }

+

+ ref Bucket bucket = ref GetBucketForHash(dataHash);

+

+ if (bucket.InlineEntry.Data != null)

+ {

+ if (bucket.InlineEntry.Hash == dataHash && bucket.InlineEntry.GetData().SequenceEqual(dataSpan))

+ {

+ item = bucket.InlineEntry.Item;

+ data = bucket.InlineEntry.Data;

+ return bucket.InlineEntry.IsPartial ? SearchResult.FoundPartial : SearchResult.FoundFull;

+ }

+

+ if (bucket.MoreEntries != null)

+ {

+ foreach (Entry entry in bucket.MoreEntries)

+ {

+ if (entry.Hash == dataHash && entry.GetData().SequenceEqual(dataSpan))

+ {

+ item = entry.Item;

+ data = entry.Data;

+ return entry.IsPartial ? SearchResult.FoundPartial : SearchResult.FoundFull;

+ }

+ }

+ }

+ }

+

+ return SearchResult.NotFound;

+ }

+

+ /// <summary>

+ /// Rebuilds the table for a new count.

+ /// </summary>

+ /// <param name="newPow2Count">New power of two count of the table</param>

+ private void Rebuild(int newPow2Count)

+ {

+ Bucket[] newBuckets = new Bucket[newPow2Count];

+

+ uint mask = (uint)newPow2Count - 1;

+

+ for (int i = 0; i < _buckets.Length; i++)

+ {

+ ref Bucket bucket = ref _buckets[i];

+

+ if (bucket.InlineEntry.Data != null)

+ {

+ AddToBucket(ref newBuckets[(int)(bucket.InlineEntry.Hash & mask)], ref bucket.InlineEntry);

+

+ if (bucket.MoreEntries != null)

+ {

+ foreach (Entry entry in bucket.MoreEntries)

+ {

+ Entry entryCopy = entry;

+ AddToBucket(ref newBuckets[(int)(entry.Hash & mask)], ref entryCopy);

+ }

+ }

+ }

+ }

+

+ _buckets = newBuckets;

+ }

+

+ /// <summary>

+ /// Gets the bucket for a given hash.

+ /// </summary>

+ /// <param name="hash">Data hash</param>

+ /// <returns>Bucket for the hash</returns>

+ private ref Bucket GetBucketForHash(uint hash)

+ {

+ int index = (int)(hash & (_buckets.Length - 1));

+

+ return ref _buckets[index];

+ }

+

+ /// <summary>

+ /// Gets a power of two count from a regular count.

+ /// </summary>

+ /// <param name="count">Count</param>

+ /// <returns>Power of two count</returns>

+ private static int GetPow2Count(int count)

+ {

+ // This returns the nearest power of two that is lower than count.

+ // This was done to optimize memory usage rather than performance.

+ return 1 << BitOperations.Log2((uint)count);

+ }

+ }

+}

+using System;

+using System.Collections.Generic;

+using System.Diagnostics;

+

+namespace Ryujinx.Graphics.Gpu.Shader.HashTable

+{

+ /// <summary>

+ /// Partitioned hash table.

+ /// </summary>

+ /// <typeparam name="T"></typeparam>

+ public class PartitionedHashTable<T>

+ {

+ /// <summary>

+ /// Entry for a given data size.

+ /// </summary>

+ private struct SizeEntry

+ {

+ /// <summary>

+ /// Size for the data that will be stored on the hash table on this entry.

+ /// </summary>

+ public int Size { get; }

+

+ /// <summary>

+ /// Number of entries on the hash table.

+ /// </summary>

+ public int TableCount => _table.Count;

+

+ private readonly PartitionHashTable<T> _table;

+

+ /// <summary>

+ /// Creates an entry for a given size.

+ /// </summary>

+ /// <param name="size">Size of the data to be stored on this entry</param>

+ public SizeEntry(int size)

+ {

+ Size = size;

+ _table = new PartitionHashTable<T>();

+ }

+

+ /// <summary>

+ /// Gets an item for existing data, or adds a new one.

+ /// </summary>

+ /// <param name="data">Data associated with the item</param>

+ /// <param name="dataHash">Hash of <paramref name="data"/></param>

+ /// <param name="item">Item to be added</param>

+ /// <returns>Existing item, or <paramref name="item"/> if not present</returns>

+ public T GetOrAdd(byte[] data, uint dataHash, T item)

+ {

+ Debug.Assert(data.Length == Size);

+ return _table.GetOrAdd(data, dataHash, item);

+ }

+

+ /// <summary>

+ /// Adds a new item.

+ /// </summary>

+ /// <param name="data">Data associated with the item</param>

+ /// <param name="dataHash">Hash of <paramref name="data"/></param>

+ /// <param name="item">Item to be added</param>

+ /// <returns>True if added, false otherwise</returns>

+ public bool Add(byte[] data, uint dataHash, T item)

+ {

+ Debug.Assert(data.Length == Size);

+ return _table.Add(data, dataHash, item);

+ }

+

+ /// <summary>

+ /// Adds a partial entry.

+ /// </summary>

+ /// <param name="ownerData">Full entry data</param>

+ /// <param name="dataHash">Hash of the sub-region of the data that belongs to this entry</param>

+ /// <returns>True if added, false otherwise</returns>

+ public bool AddPartial(byte[] ownerData, uint dataHash)

+ {

+ return _table.AddPartial(ownerData, dataHash, Size);

+ }

+

+ /// <summary>

+ /// Fills a new hash table with "partials" of existing full entries of higher size.

+ /// </summary>

+ /// <param name="newEntry">Entry with the new hash table</param>

+ public void FillPartials(SizeEntry newEntry)

+ {

+ Debug.Assert(newEntry.Size < Size);

+ _table.FillPartials(newEntry._table, newEntry.Size);

+ }

+

+ /// <summary>

+ /// Tries to find an item on the hash table.

+ /// </summary>

+ /// <param name="dataAccessor">Data accessor</param>

+ /// <param name="item">The item on the table, if found, otherwise unmodified</param>

+ /// <param name="data">The data on the table, if found, otherwise unmodified</param>

+ /// <returns>Table lookup result</returns>

+ public PartitionHashTable<T>.SearchResult TryFindItem(ref SmartDataAccessor dataAccessor, ref T item, ref byte[] data)

+ {

+ return _table.TryFindItem(ref dataAccessor, Size, ref item, ref data);

+ }

+ }

+

+ private readonly List<SizeEntry> _sizeTable;

+

+ /// <summary>

+ /// Creates a new partitioned hash table.

+ /// </summary>

+ public PartitionedHashTable()

+ {

+ _sizeTable = new List<SizeEntry>();

+ }

+

+ /// <summary>

+ /// Adds a new item to the table.

+ /// </summary>

+ /// <param name="data">Data</param>

+ /// <param name="item">Item associated with the data</param>

+ public void Add(byte[] data, T item)

+ {

+ GetOrAdd(data, item);

+ }

+

+ /// <summary>

+ /// Gets an existing item from the table, or adds a new one if not present.

+ /// </summary>

+ /// <param name="data">Data</param>

+ /// <param name="item">Item associated with the data</param>

+ /// <returns>Existing item, or <paramref name="item"/> if not present</returns>

+ public T GetOrAdd(byte[] data, T item)

+ {

+ SizeEntry sizeEntry;

+

+ int index = BinarySearch(_sizeTable, data.Length);

+ if (index < _sizeTable.Count && _sizeTable[index].Size == data.Length)

+ {

+ sizeEntry = _sizeTable[index];

+ }

+ else

+ {

+ if (index < _sizeTable.Count && _sizeTable[index].Size < data.Length)

+ {

+ index++;

+ }

+

+ sizeEntry = new SizeEntry(data.Length);

+

+ _sizeTable.Insert(index, sizeEntry);

+

+ for (int i = index + 1; i < _sizeTable.Count; i++)

+ {

+ _sizeTable[i].FillPartials(sizeEntry);

+ }

+ }

+

+ HashState hashState = new HashState();

+ hashState.Initialize();

+

+ for (int i = 0; i < index; i++)

+ {

+ ReadOnlySpan<byte> dataSlice = new ReadOnlySpan<byte>(data).Slice(0, _sizeTable[i].Size);

+ hashState.Continue(dataSlice);

+ _sizeTable[i].AddPartial(data, hashState.Finalize(dataSlice));

+ }

+

+ hashState.Continue(data);

+ return sizeEntry.GetOrAdd(data, hashState.Finalize(data), item);

+ }

+

+ /// <summary>

+ /// Performs binary search on a list of hash tables, each one with a fixed data size.

+ /// </summary>

+ /// <param name="entries">List of hash tables</param>

+ /// <param name="size">Size to search for</param>

+ /// <returns>Index of the hash table with the given size, or nearest one otherwise</returns>

+ private static int BinarySearch(List<SizeEntry> entries, int size)

+ {

+ int left = 0;

+ int middle = 0;

+ int right = entries.Count - 1;

+

+ while (left <= right)

+ {

+ middle = left + ((right - left) >> 1);

+

+ SizeEntry entry = entries[middle];

+

+ if (size == entry.Size)

+ {

+ break;

+ }

+

+ if (size < entry.Size)

+ {

+ right = middle - 1;

+ }

+ else

+ {

+ left = middle + 1;

+ }

+ }

+

+ return middle;

+ }

+

+ /// <summary>

+ /// Tries to find an item on the table.

+ /// </summary>

+ /// <param name="dataAccessor">Data accessor</param>

+ /// <param name="item">Item, if found</param>

+ /// <param name="data">Data, if found</param>

+ /// <returns>True if the item was found on the table, false otherwise</returns>

+ public bool TryFindItem(IDataAccessor dataAccessor, out T item, out byte[] data)

+ {

+ SmartDataAccessor sda = new SmartDataAccessor(dataAccessor);

+

+ item = default;

+ data = null;

+

+ int left = 0;

+ int right = _sizeTable.Count;

+

+ while (left != right)

+ {

+ int index = left + ((right - left) >> 1);

+

+ PartitionHashTable<T>.SearchResult result = _sizeTable[index].TryFindItem(ref sda, ref item, ref data);

+

+ if (result == PartitionHashTable<T>.SearchResult.FoundFull)

+ {

+ return true;

+ }

+

+ if (result == PartitionHashTable<T>.SearchResult.NotFound)

+ {

+ right = index;

+ }

+ else /* if (result == PartitionHashTable<T>.SearchResult.FoundPartial) */

+ {

+ left = index + 1;

+ }

+ }

+

+ data = null;

+ return false;

+ }

+ }

+}

+using System;

+using System.Collections.Generic;

+

+namespace Ryujinx.Graphics.Gpu.Shader.HashTable

+{

+ /// <summary>

+ /// Smart data accessor that can cache data and hashes to avoid reading and re-hashing the same memory regions.

+ /// </summary>

+ ref struct SmartDataAccessor

+ {

+ private readonly IDataAccessor _dataAccessor;

+ private ReadOnlySpan<byte> _data;

+ private readonly SortedList<int, HashState> _cachedHashes;

+

+ /// <summary>

+ /// Creates a new smart data accessor.

+ /// </summary>

+ /// <param name="dataAccessor">Data accessor</param>

+ public SmartDataAccessor(IDataAccessor dataAccessor)

+ {

+ _dataAccessor = dataAccessor;

+ _data = ReadOnlySpan<byte>.Empty;

+ _cachedHashes = new SortedList<int, HashState>();

+ }

+

+ /// <summary>

+ /// Get a spans of a given size.

+ /// </summary>

+ /// <remarks>

+ /// The actual length of the span returned depends on the <see cref="IDataAccessor"/>

+ /// and might be less than requested.

+ /// </remarks>

+ /// <param name="length">Size in bytes</param>

+ /// <returns>Span with the requested size</returns>

+ public ReadOnlySpan<byte> GetSpan(int length)

+ {

+ if (_data.Length < length)

+ {

+ _data = _dataAccessor.GetSpan(0, length);

+ }

+ else if (_data.Length > length)

+ {

+ return _data.Slice(0, length);

+ }

+

+ return _data;

+ }

+

+ /// <summary>

+ /// Gets a span of the requested size, and a hash of its data.

+ /// </summary>

+ /// <param name="length">Length of the span</param>

+ /// <param name="hash">Hash of the span data</param>

+ /// <returns>Span of data</returns>

+ public ReadOnlySpan<byte> GetSpanAndHash(int length, out uint hash)

+ {

+ ReadOnlySpan<byte> data = GetSpan(length);

+ hash = data.Length == length ? CalcHashCached(data) : 0;

+ return data;

+ }

+

+ /// <summary>

+ /// Calculates the hash for a requested span.

+ /// This will try to use a cached hash if the data was already accessed before, to avoid re-hashing.

+ /// </summary>

+ /// <param name="data">Data to be hashed</param>

+ /// <returns>Hash of the data</returns>

+ private uint CalcHashCached(ReadOnlySpan<byte> data)

+ {

+ HashState state = default;

+ bool found = false;

+

+ for (int i = _cachedHashes.Count - 1; i >= 0; i--)

+ {

+ int cachedHashSize = _cachedHashes.Keys[i];

+

+ if (cachedHashSize < data.Length)

+ {

+ state = _cachedHashes.Values[i];

+ found = true;

+ break;

+ }

+ }

+

+ if (!found)

+ {

+ state = new HashState();

+ state.Initialize();

+ }

+

+ state.Continue(data);

+ _cachedHashes[data.Length & ~7] = state;

+ return state.Finalize(data);

+ }

+ }

+}

+namespace Ryujinx.Graphics.Gpu.Shader

+{

+ /// <summary>

+ /// Holds counts for the resources used by a shader.

+ /// </summary>

+ class ResourceCounts

+ {

+ /// <summary>

+ /// Total of uniform buffers used by the shaders.

+ /// </summary>

+ public int UniformBuffersCount;

+

+ /// <summary>

+ /// Total of storage buffers used by the shaders.

+ /// </summary>

+ public int StorageBuffersCount;

+

+ /// <summary>

+ /// Total of textures used by the shaders.

+ /// </summary>

+ public int TexturesCount;

+

+ /// <summary>

+ /// Total of images used by the shaders.

+ /// </summary>

+ public int ImagesCount;

+

+ /// <summary>

+ /// Creates a new instance of the shader resource counts class.

+ /// </summary>

+ public ResourceCounts()

+ {

+ UniformBuffersCount = 1; // The first binding is reserved for the support buffer.

+ }

+ }

+} \ No newline at end of file

+using System.Runtime.CompilerServices;

+using System.Runtime.InteropServices;

+ public ulong VertexB;

+ VertexB == other.VertexB &&

+ return HashCode.Combine(VertexA, VertexB, TessControl, TessEvaluation, Geometry, Fragment);

+ }

+

+ /// <summary>

+ /// Gets a view of the structure as a span of addresses.

+ /// </summary>

+ /// <returns>Span of addresses</returns>

+ public Span<ulong> AsSpan()

+ {

+ return MemoryMarshal.CreateSpan(ref VertexA, Unsafe.SizeOf<ShaderAddresses>() / sizeof(ulong));

+using Ryujinx.Graphics.Gpu.Shader.DiskCache;

+ /// <summary>

+ /// Default flags used on the shader translation process.

+ /// </summary>

+ public const TranslationFlags DefaultFlags = TranslationFlags.DebugMode;

+

+ private struct TranslatedShader

+ {

+ public readonly CachedShaderStage Shader;

+ public readonly ShaderProgram Program;

+

+ public TranslatedShader(CachedShaderStage shader, ShaderProgram program)

+ {

+ Shader = shader;

+ Program = program;

+ }

+ }

+

+ private struct TranslatedShaderVertexPair

+ {

+ public readonly CachedShaderStage VertexA;

+ public readonly CachedShaderStage VertexB;

+ public readonly ShaderProgram Program;

+

+ public TranslatedShaderVertexPair(CachedShaderStage vertexA, CachedShaderStage vertexB, ShaderProgram program)

+ {

+ VertexA = vertexA;

+ VertexB = vertexB;

+ Program = program;

+ }

+ }

+ private readonly Dictionary<ulong, CachedShaderProgram> _cpPrograms;

+ private readonly Dictionary<ShaderAddresses, CachedShaderProgram> _gpPrograms;

+ private struct ProgramToSave

+ {

+ public readonly CachedShaderProgram CachedProgram;

+ public readonly IProgram HostProgram;

+

+ public ProgramToSave(CachedShaderProgram cachedProgram, IProgram hostProgram)

+ {

+ CachedProgram = cachedProgram;

+ HostProgram = hostProgram;

+ }

+ }

+ private Queue<ProgramToSave> _programsToSaveQueue;

+ private readonly ComputeShaderCacheHashTable _computeShaderCache;

+ private readonly ShaderCacheHashTable _graphicsShaderCache;

+ private readonly DiskCacheHostStorage _diskCacheHostStorage;

+ private readonly BackgroundDiskCacheWriter _cacheWriter;

+ /// Event for signalling shader cache loading progress.

+ _cpPrograms = new Dictionary<ulong, CachedShaderProgram>();

+ _gpPrograms = new Dictionary<ShaderAddresses, CachedShaderProgram>();

+

+ _programsToSaveQueue = new Queue<ProgramToSave>();

+

+ string diskCacheTitleId = GraphicsConfig.EnableShaderCache && GraphicsConfig.TitleId != null

+ ? CacheHelper.GetBaseCacheDirectory(GraphicsConfig.TitleId)

+ : null;

+

+ _computeShaderCache = new ComputeShaderCacheHashTable();

+ _graphicsShaderCache = new ShaderCacheHashTable();

+ _diskCacheHostStorage = new DiskCacheHostStorage(diskCacheTitleId);

+ if (_diskCacheHostStorage.CacheEnabled)

+ {

+ _cacheWriter = new BackgroundDiskCacheWriter(context, _diskCacheHostStorage);

+ }

+ while (_programsToSaveQueue.TryPeek(out ProgramToSave programToSave))

+ ProgramLinkStatus result = programToSave.HostProgram.CheckProgramLink(false);

+ if (result != ProgramLinkStatus.Incomplete)

+ if (result == ProgramLinkStatus.Success)

+ {

+ _cacheWriter.AddShader(programToSave.CachedProgram, programToSave.HostProgram.GetBinary());

+ }

+

+ /// <param name="cancellationToken">Cancellation token to cancel the shader cache initialization process</param>

+ internal void Initialize(CancellationToken cancellationToken)

+ if (_diskCacheHostStorage.CacheEnabled)

+ if (!_diskCacheHostStorage.CacheExists())

+ // If we don't have a shader cache on the new format, try to perform migration from the old shader cache.

+ Logger.Info?.Print(LogClass.Gpu, "No shader cache found, trying to migrate from legacy shader cache...");

+ int migrationCount = Migration.MigrateFromLegacyCache(_context, _diskCacheHostStorage);

+ Logger.Info?.Print(LogClass.Gpu, $"Migrated {migrationCount} shaders.");