using Ryujinx.Cpu.Tracking; using Ryujinx.Graphics.Gpu.Memory; using System; namespace Ryujinx.Graphics.Gpu.Image { /// /// Represents a pool of GPU resources, such as samplers or textures. /// /// Type of the GPU resource /// Type of the descriptor abstract class Pool : IDisposable where T2 : unmanaged { protected const int DescriptorSize = 0x20; protected GpuContext Context; protected PhysicalMemory PhysicalMemory; protected int SequenceNumber; protected T1[] Items; protected T2[] DescriptorCache; /// /// The maximum ID value of resources on the pool (inclusive). /// /// /// The maximum amount of resources on the pool is equal to this value plus one. /// public int MaximumId { get; } /// /// The address of the pool in guest memory. /// public ulong Address { get; } /// /// The size of the pool in bytes. /// public ulong Size { get; } private readonly CpuMultiRegionHandle _memoryTracking; private readonly Action _modifiedDelegate; /// /// Creates a new instance of the GPU resource pool. /// /// GPU context that the pool belongs to /// Physical memory where the resource descriptors are mapped /// Address of the pool in physical memory /// Maximum index of an item on the pool (inclusive) public Pool(GpuContext context, PhysicalMemory physicalMemory, ulong address, int maximumId) { Context = context; PhysicalMemory = physicalMemory; MaximumId = maximumId; int count = maximumId + 1; ulong size = (ulong)(uint)count * DescriptorSize; Items = new T1[count]; DescriptorCache = new T2[count]; Address = address; Size = size; _memoryTracking = physicalMemory.BeginGranularTracking(address, size); _memoryTracking.RegisterPreciseAction(address, size, PreciseAction); _modifiedDelegate = RegionModified; } /// /// Gets the descriptor for a given ID. /// /// ID of the descriptor. This is effectively a zero-based index /// The descriptor public T2 GetDescriptor(int id) { return PhysicalMemory.Read(Address + (ulong)id * DescriptorSize); } /// /// Gets the GPU resource with the given ID. /// /// ID of the resource. This is effectively a zero-based index /// The GPU resource with the given ID public abstract T1 Get(int id); /// /// Synchronizes host memory with guest memory. /// This causes invalidation of pool entries, /// if a modification of entries by the CPU is detected. /// public void SynchronizeMemory() { _memoryTracking.QueryModified(_modifiedDelegate); } /// /// Indicate that a region of the pool was modified, and must be loaded from memory. /// /// Start address of the modified region /// Size of the modified region private void RegionModified(ulong mAddress, ulong mSize) { if (mAddress < Address) { mAddress = Address; } ulong maxSize = Address + Size - mAddress; if (mSize > maxSize) { mSize = maxSize; } InvalidateRangeImpl(mAddress, mSize); } /// /// An action to be performed when a precise memory access occurs to this resource. /// Makes sure that the dirty flags are checked. /// /// Address of the memory action /// Size in bytes /// True if the access was a write, false otherwise private bool PreciseAction(ulong address, ulong size, bool write) { if (write && Context.SequenceNumber == SequenceNumber) { SequenceNumber--; } return false; } protected abstract void InvalidateRangeImpl(ulong address, ulong size); protected abstract void Delete(T1 item); /// /// Performs the disposal of all resources stored on the pool. /// It's an error to try using the pool after disposal. /// public virtual void Dispose() { if (Items != null) { for (int index = 0; index < Items.Length; index++) { Delete(Items[index]); } Items = null; } _memoryTracking.Dispose(); } } }