GPU: Don't create tracking handles for buffer textures (#5727)

* GPU: Don't create tracking handles for buffer textures

Buffer texture memory is handled by the buffer cache - the texture shouldn't create any tracking handles as they aren't used. This change simply makes them create and iterate 0 tracking handles, while keeping the rest of the texture group around.

This prevents a possible issue where many buffer textures are created as views of overlapping buffer ranges, and virtual regions have many dependant textures that don't actually contribute anything to handle state.

Should improve performance in Mortal Kombat 1, possibly certain UE4 games when FIFO raises to 100%.

* Fix interval tree bug

* Don't check view compatibility for buffer textures

src/ARMeilleure/Translation/IntervalTree.cs

@@ -189,7 +189,7 @@ namespace ARMeilleure.Translation
             {
                 if (start.CompareTo(node.End) < 0)
                 {
-                    if (overlaps.Length >= overlapCount)
+                    if (overlaps.Length <= overlapCount)
                     {
                         Array.Resize(ref overlaps, overlapCount + ArrayGrowthSize);
                     }

src/Ryujinx.Ava/UI/Windows/MainWindow.axaml.cs

@@ -265,33 +265,47 @@ namespace Ryujinx.Ava.UI.Windows
 
         private void CheckLaunchState()
         {
-            if (ShowKeyErrorOnLoad)
-            {
-                ShowKeyErrorOnLoad = false;
-
-                UserErrorDialog.ShowUserErrorDialog(UserError.NoKeys).Wait();
-            }
-
             if (OperatingSystem.IsLinux() && LinuxHelper.VmMaxMapCount < LinuxHelper.RecommendedVmMaxMapCount)
             {
                 Logger.Warning?.Print(LogClass.Application, $"The value of vm.max_map_count is lower than {LinuxHelper.RecommendedVmMaxMapCount}. ({LinuxHelper.VmMaxMapCount})");
 
                 if (LinuxHelper.PkExecPath is not null)
                 {
-                    ShowVmMaxMapCountDialog().Wait();
+                    Dispatcher.UIThread.Post(async () =>
+                    {
+                        if (OperatingSystem.IsLinux())
+                        {
+                            await ShowVmMaxMapCountDialog();
+                        }
+                    });
                 }
                 else
                 {
-                    ShowVmMaxMapCountWarning().Wait();
+                    Dispatcher.UIThread.Post(async () =>
+                    {
+                        if (OperatingSystem.IsLinux())
+                        {
+                            await ShowVmMaxMapCountWarning();
+                        }
+                    });
                 }
             }
 
+            if (!ShowKeyErrorOnLoad)
+            {
                 if (_deferLoad)
                 {
                     _deferLoad = false;
 
                     ViewModel.LoadApplication(_launchPath, _startFullscreen).Wait();
                 }
+            }
+            else
+            {
+                ShowKeyErrorOnLoad = false;
+
+                Dispatcher.UIThread.Post(async () => await UserErrorDialog.ShowUserErrorDialog(UserError.NoKeys));
+            }
 
             if (ConfigurationState.Instance.CheckUpdatesOnStart.Value && Updater.CanUpdate(false))
             {

src/Ryujinx.Common/Collections/IntervalTree.cs

@@ -192,7 +192,7 @@ namespace Ryujinx.Common.Collections
                     {
                         if (start.CompareTo(overlap.End) < 0)
                         {
-                            if (overlaps.Length >= overlapCount)
+                            if (overlaps.Length <= overlapCount)
                             {
                                 Array.Resize(ref overlaps, overlapCount + ArrayGrowthSize);
                             }

src/Ryujinx.Graphics.Gpu/Image/TextureCache.cs

@@ -696,12 +696,15 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
 
             // Find view compatible matches.
-            int overlapsCount;
+            int overlapsCount = 0;
 
+            if (info.Target != Target.TextureBuffer)
+            {
                 lock (_textures)
                 {
                     overlapsCount = _textures.FindOverlaps(range.Value, ref _textureOverlaps);
                 }
+            }
 
             if (_overlapInfo.Length != _textureOverlaps.Length)
             {

src/Ryujinx.Graphics.Gpu/Image/TextureGroup.cs

@@ -79,6 +79,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         private int[] _allOffsets;
         private int[] _sliceSizes;
         private readonly bool _is3D;
+        private readonly bool _isBuffer;
         private bool _hasMipViews;
         private bool _hasLayerViews;
         private readonly int _layers;
@@ -118,6 +119,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             _physicalMemory = physicalMemory;
 
             _is3D = storage.Info.Target == Target.Texture3D;
+            _isBuffer = storage.Info.Target == Target.TextureBuffer;
             _layers = storage.Info.GetSlices();
             _levels = storage.Info.Levels;
 
@@ -794,7 +796,11 @@ namespace Ryujinx.Graphics.Gpu.Image
             int targetLayerHandles = _hasLayerViews ? slices : 1;
             int targetLevelHandles = _hasMipViews ? levels : 1;
 
-            if (_is3D)
+            if (_isBuffer)
+            {
+                return;
+            }
+            else if (_is3D)
             {
                 // Future mip levels come after all layers of the last mip level. Each mipmap has less layers (depth) than the last.
 
@@ -1327,7 +1333,11 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             TextureGroupHandle[] handles;
 
-            if (!(_hasMipViews || _hasLayerViews))
+            if (_isBuffer)
+            {
+                handles = Array.Empty<TextureGroupHandle>();
+            }
+            else if (!(_hasMipViews || _hasLayerViews))
             {
                 // Single dirty region.
                 var cpuRegionHandles = new RegionHandle[TextureRange.Count];

src/Ryujinx.Graphics.Vulkan/CommandBufferPool.cs

@@ -27,6 +27,7 @@ namespace Ryujinx.Graphics.Vulkan
         {
             public bool InUse;
             public bool InConsumption;
+            public int SubmissionCount;
             public CommandBuffer CommandBuffer;
             public FenceHolder Fence;
             public SemaphoreHolder Semaphore;
@@ -193,6 +194,11 @@ namespace Ryujinx.Graphics.Vulkan
             return _commandBuffers[cbIndex].Fence;
         }
 
+        public int GetSubmissionCount(int cbIndex)
+        {
+            return _commandBuffers[cbIndex].SubmissionCount;
+        }
+
         private int FreeConsumed(bool wait)
         {
             int freeEntry = 0;
@@ -282,6 +288,7 @@ namespace Ryujinx.Graphics.Vulkan
                 Debug.Assert(entry.CommandBuffer.Handle == cbs.CommandBuffer.Handle);
                 entry.InUse = false;
                 entry.InConsumption = true;
+                entry.SubmissionCount++;
                 _inUseCount--;
 
                 var commandBuffer = entry.CommandBuffer;

src/Ryujinx.Graphics.Vulkan/DescriptorSetManager.cs

@@ -6,7 +6,7 @@ namespace Ryujinx.Graphics.Vulkan
 {
     class DescriptorSetManager : IDisposable
     {
-        private const uint DescriptorPoolMultiplier = 16;
+        public const uint MaxSets = 16;
 
         public class DescriptorPoolHolder : IDisposable
         {
@@ -14,36 +14,28 @@ namespace Ryujinx.Graphics.Vulkan
             public Device Device { get; }
 
             private readonly DescriptorPool _pool;
-            private readonly uint _capacity;
+            private int _freeDescriptors;
             private int _totalSets;
             private int _setsInUse;
             private bool _done;
 
-            public unsafe DescriptorPoolHolder(Vk api, Device device)
+            public unsafe DescriptorPoolHolder(Vk api, Device device, ReadOnlySpan<DescriptorPoolSize> poolSizes, bool updateAfterBind)
             {
                 Api = api;
                 Device = device;
 
-                var poolSizes = new[]
+                foreach (var poolSize in poolSizes)
                 {
-                    new DescriptorPoolSize(DescriptorType.UniformBuffer, (1 + Constants.MaxUniformBufferBindings) * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.StorageBuffer, Constants.MaxStorageBufferBindings * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.CombinedImageSampler, Constants.MaxTextureBindings * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.StorageImage, Constants.MaxImageBindings * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.UniformTexelBuffer, Constants.MaxTextureBindings * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.StorageTexelBuffer, Constants.MaxImageBindings * DescriptorPoolMultiplier),
-                };
-
-                uint maxSets = (uint)poolSizes.Length * DescriptorPoolMultiplier;
-
-                _capacity = maxSets;
+                    _freeDescriptors += (int)poolSize.DescriptorCount;
+                }
 
                 fixed (DescriptorPoolSize* pPoolsSize = poolSizes)
                 {
                     var descriptorPoolCreateInfo = new DescriptorPoolCreateInfo
                     {
                         SType = StructureType.DescriptorPoolCreateInfo,
-                        MaxSets = maxSets,
+                        Flags = updateAfterBind ? DescriptorPoolCreateFlags.UpdateAfterBindBit : DescriptorPoolCreateFlags.None,
+                        MaxSets = MaxSets,
                         PoolSizeCount = (uint)poolSizes.Length,
                         PPoolSizes = pPoolsSize,
                     };
@@ -52,18 +44,22 @@ namespace Ryujinx.Graphics.Vulkan
                 }
             }
 
-            public DescriptorSetCollection AllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts)
+            public unsafe DescriptorSetCollection AllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts, int consumedDescriptors)
             {
-                TryAllocateDescriptorSets(layouts, isTry: false, out var dsc);
+                TryAllocateDescriptorSets(layouts, consumedDescriptors, isTry: false, out var dsc);
                 return dsc;
             }
 
-            public bool TryAllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts, out DescriptorSetCollection dsc)
+            public bool TryAllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts, int consumedDescriptors, out DescriptorSetCollection dsc)
             {
-                return TryAllocateDescriptorSets(layouts, isTry: true, out dsc);
+                return TryAllocateDescriptorSets(layouts, consumedDescriptors, isTry: true, out dsc);
             }
 
-            private unsafe bool TryAllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts, bool isTry, out DescriptorSetCollection dsc)
+            private unsafe bool TryAllocateDescriptorSets(
+                ReadOnlySpan<DescriptorSetLayout> layouts,
+                int consumedDescriptors,
+                bool isTry,
+                out DescriptorSetCollection dsc)
             {
                 Debug.Assert(!_done);
 
@@ -84,7 +80,7 @@ namespace Ryujinx.Graphics.Vulkan
                         var result = Api.AllocateDescriptorSets(Device, &descriptorSetAllocateInfo, pDescriptorSets);
                         if (isTry && result == Result.ErrorOutOfPoolMemory)
                         {
-                            _totalSets = (int)_capacity;
+                            _totalSets = (int)MaxSets;
                             _done = true;
                             DestroyIfDone();
                             dsc = default;
@@ -95,6 +91,7 @@ namespace Ryujinx.Graphics.Vulkan
                     }
                 }
 
+                _freeDescriptors -= consumedDescriptors;
                 _totalSets += layouts.Length;
                 _setsInUse += layouts.Length;
 
@@ -109,9 +106,15 @@ namespace Ryujinx.Graphics.Vulkan
                 DestroyIfDone();
             }
 
-            public bool CanFit(int count)
+            public bool CanFit(int setsCount, int descriptorsCount)
             {
-                if (_totalSets + count <= _capacity)
+                // Try to determine if an allocation with the given parameters will succeed.
+                // An allocation may fail if the sets count or descriptors count exceeds the available counts
+                // of the pool.
+                // Not getting that right is not fatal, it will just create a new pool and try again,
+                // but it is less efficient.
+
+                if (_totalSets + setsCount <= MaxSets && _freeDescriptors >= descriptorsCount)
                 {
                     return true;
                 }
@@ -148,46 +151,74 @@ namespace Ryujinx.Graphics.Vulkan
         }
 
         private readonly Device _device;
-        private DescriptorPoolHolder _currentPool;
+        private readonly DescriptorPoolHolder[] _currentPools;
 
-        public DescriptorSetManager(Device device)
+        public DescriptorSetManager(Device device, int poolCount)
         {
             _device = device;
+            _currentPools = new DescriptorPoolHolder[poolCount];
         }
 
-        public Auto<DescriptorSetCollection> AllocateDescriptorSet(Vk api, DescriptorSetLayout layout)
+        public Auto<DescriptorSetCollection> AllocateDescriptorSet(
+            Vk api,
+            DescriptorSetLayout layout,
+            ReadOnlySpan<DescriptorPoolSize> poolSizes,
+            int poolIndex,
+            int consumedDescriptors,
+            bool updateAfterBind)
         {
             Span<DescriptorSetLayout> layouts = stackalloc DescriptorSetLayout[1];
             layouts[0] = layout;
-            return AllocateDescriptorSets(api, layouts);
+            return AllocateDescriptorSets(api, layouts, poolSizes, poolIndex, consumedDescriptors, updateAfterBind);
         }
 
-        public Auto<DescriptorSetCollection> AllocateDescriptorSets(Vk api, ReadOnlySpan<DescriptorSetLayout> layouts)
+        public Auto<DescriptorSetCollection> AllocateDescriptorSets(
+            Vk api,
+            ReadOnlySpan<DescriptorSetLayout> layouts,
+            ReadOnlySpan<DescriptorPoolSize> poolSizes,
+            int poolIndex,
+            int consumedDescriptors,
+            bool updateAfterBind)
         {
             // If we fail the first time, just create a new pool and try again.
-            if (!GetPool(api, layouts.Length).TryAllocateDescriptorSets(layouts, out var dsc))
+
+            var pool = GetPool(api, poolSizes, poolIndex, layouts.Length, consumedDescriptors, updateAfterBind);
+            if (!pool.TryAllocateDescriptorSets(layouts, consumedDescriptors, out var dsc))
             {
-                dsc = GetPool(api, layouts.Length).AllocateDescriptorSets(layouts);
+                pool = GetPool(api, poolSizes, poolIndex, layouts.Length, consumedDescriptors, updateAfterBind);
+                dsc = pool.AllocateDescriptorSets(layouts, consumedDescriptors);
             }
 
             return new Auto<DescriptorSetCollection>(dsc);
         }
 
-        private DescriptorPoolHolder GetPool(Vk api, int requiredCount)
+        private DescriptorPoolHolder GetPool(
+            Vk api,
+            ReadOnlySpan<DescriptorPoolSize> poolSizes,
+            int poolIndex,
+            int setsCount,
+            int descriptorsCount,
+            bool updateAfterBind)
         {
-            if (_currentPool == null || !_currentPool.CanFit(requiredCount))
+            ref DescriptorPoolHolder currentPool = ref _currentPools[poolIndex];
+
+            if (currentPool == null || !currentPool.CanFit(setsCount, descriptorsCount))
             {
-                _currentPool = new DescriptorPoolHolder(api, _device);
+                currentPool = new DescriptorPoolHolder(api, _device, poolSizes, updateAfterBind);
             }
 
-            return _currentPool;
+            return currentPool;
         }
 
         protected virtual void Dispose(bool disposing)
         {
             if (disposing)
             {
-                _currentPool?.Dispose();
+                for (int index = 0; index < _currentPools.Length; index++)
+                {
+                    _currentPools[index]?.Dispose();
+                    _currentPools[index] = null;
+                }
             }
         }
 

src/Ryujinx.Graphics.Vulkan/DescriptorSetUpdater.cs

@@ -59,6 +59,8 @@ namespace Ryujinx.Graphics.Vulkan
         private BitMapStruct<Array2<long>> _uniformMirrored;
         private BitMapStruct<Array2<long>> _storageMirrored;
 
+        private bool _updateDescriptorCacheCbIndex;
+
         [Flags]
         private enum DirtyFlags
         {
@@ -218,6 +220,7 @@ namespace Ryujinx.Graphics.Vulkan
         public void SetProgram(ShaderCollection program)
         {
             _program = program;
+            _updateDescriptorCacheCbIndex = true;
             _dirty = DirtyFlags.All;
         }
 
@@ -490,7 +493,13 @@ namespace Ryujinx.Graphics.Vulkan
 
             var dummyBuffer = _dummyBuffer?.GetBuffer();
 
-            var dsc = program.GetNewDescriptorSetCollection(_gd, cbs.CommandBufferIndex, setIndex, out var isNew).Get(cbs);
+            if (_updateDescriptorCacheCbIndex)
+            {
+                _updateDescriptorCacheCbIndex = false;
+                program.UpdateDescriptorCacheCommandBufferIndex(cbs.CommandBufferIndex);
+            }
+
+            var dsc = program.GetNewDescriptorSetCollection(setIndex, out var isNew).Get(cbs);
 
             if (!program.HasMinimalLayout)
             {
@@ -697,6 +706,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         public void SignalCommandBufferChange()
         {
+            _updateDescriptorCacheCbIndex = true;
             _dirty = DirtyFlags.All;
 
             _uniformSet.Clear();

src/Ryujinx.Graphics.Vulkan/MemoryAllocator.cs

@@ -1,6 +1,7 @@
 using Silk.NET.Vulkan;
 using System;
 using System.Collections.Generic;
+using System.Threading;
 
 namespace Ryujinx.Graphics.Vulkan
 {
@@ -13,6 +14,7 @@ namespace Ryujinx.Graphics.Vulkan
         private readonly Device _device;
         private readonly List<MemoryAllocatorBlockList> _blockLists;
         private readonly int _blockAlignment;
+        private readonly ReaderWriterLockSlim _lock;
 
         public MemoryAllocator(Vk api, VulkanPhysicalDevice physicalDevice, Device device)
         {
@@ -21,6 +23,7 @@ namespace Ryujinx.Graphics.Vulkan
             _device = device;
             _blockLists = new List<MemoryAllocatorBlockList>();
             _blockAlignment = (int)Math.Min(int.MaxValue, MaxDeviceMemoryUsageEstimate / _physicalDevice.PhysicalDeviceProperties.Limits.MaxMemoryAllocationCount);
+            _lock = new(LockRecursionPolicy.NoRecursion);
         }
 
         public MemoryAllocation AllocateDeviceMemory(
@@ -39,23 +42,39 @@ namespace Ryujinx.Graphics.Vulkan
         }
 
         private MemoryAllocation Allocate(int memoryTypeIndex, ulong size, ulong alignment, bool map, bool isBuffer)
+        {
+            _lock.EnterReadLock();
+
+            try
             {
                 for (int i = 0; i < _blockLists.Count; i++)
                 {
                     var bl = _blockLists[i];
                     if (bl.MemoryTypeIndex == memoryTypeIndex && bl.ForBuffer == isBuffer)
-                {
-                    lock (bl)
                     {
                         return bl.Allocate(size, alignment, map);
                     }
                 }
             }
+            finally
+            {
+                _lock.ExitReadLock();
+            }
 
+            _lock.EnterWriteLock();
+
+            try
+            {
                 var newBl = new MemoryAllocatorBlockList(_api, _device, memoryTypeIndex, _blockAlignment, isBuffer);
                 _blockLists.Add(newBl);
+
                 return newBl.Allocate(size, alignment, map);
             }
+            finally
+            {
+                _lock.ExitWriteLock();
+            }
+        }
 
         internal int FindSuitableMemoryTypeIndex(
             uint memoryTypeBits,

src/Ryujinx.Graphics.Vulkan/MemoryAllocatorBlockList.cs

@@ -3,6 +3,7 @@ using Silk.NET.Vulkan;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading;
 
 namespace Ryujinx.Graphics.Vulkan
 {
@@ -166,6 +167,8 @@ namespace Ryujinx.Graphics.Vulkan
 
         private readonly int _blockAlignment;
 
+        private readonly ReaderWriterLockSlim _lock;
+
         public MemoryAllocatorBlockList(Vk api, Device device, int memoryTypeIndex, int blockAlignment, bool forBuffer)
         {
             _blocks = new List<Block>();
@@ -174,6 +177,7 @@ namespace Ryujinx.Graphics.Vulkan
             MemoryTypeIndex = memoryTypeIndex;
             ForBuffer = forBuffer;
             _blockAlignment = blockAlignment;
+            _lock = new(LockRecursionPolicy.NoRecursion);
         }
 
         public unsafe MemoryAllocation Allocate(ulong size, ulong alignment, bool map)
@@ -184,6 +188,10 @@ namespace Ryujinx.Graphics.Vulkan
                 throw new ArgumentOutOfRangeException(nameof(alignment), $"Invalid alignment 0x{alignment:X}.");
             }
 
+            _lock.EnterReadLock();
+
+            try
+            {
                 for (int i = 0; i < _blocks.Count; i++)
                 {
                     var block = _blocks[i];
@@ -197,6 +205,11 @@ namespace Ryujinx.Graphics.Vulkan
                         }
                     }
                 }
+            }
+            finally
+            {
+                _lock.ExitReadLock();
+            }
 
             ulong blockAlignedSize = BitUtils.AlignUp(size, (ulong)_blockAlignment);
 
@@ -243,6 +256,10 @@ namespace Ryujinx.Graphics.Vulkan
             block.Free(offset, size);
 
             if (block.IsTotallyFree())
+            {
+                _lock.EnterWriteLock();
+
+                try
                 {
                     for (int i = 0; i < _blocks.Count; i++)
                     {
@@ -252,12 +269,21 @@ namespace Ryujinx.Graphics.Vulkan
                             break;
                         }
                     }
+                }
+                finally
+                {
+                    _lock.ExitWriteLock();
+                }
 
                 block.Destroy(_api, _device);
             }
         }
 
         private void InsertBlock(Block block)
+        {
+            _lock.EnterWriteLock();
+
+            try
             {
                 int index = _blocks.BinarySearch(block);
                 if (index < 0)
@@ -267,6 +293,11 @@ namespace Ryujinx.Graphics.Vulkan
 
                 _blocks.Insert(index, block);
             }
+            finally
+            {
+                _lock.ExitWriteLock();
+            }
+        }
 
         public void Dispose()
         {

src/Ryujinx.Graphics.Vulkan/PipelineLayoutCacheEntry.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 
@@ -7,15 +8,28 @@ namespace Ryujinx.Graphics.Vulkan
 {
     class PipelineLayoutCacheEntry
     {
+        // Those were adjusted based on current descriptor usage and the descriptor counts usually used on pipeline layouts.
+        // It might be a good idea to tweak them again if those change, or maybe find a way to calculate an optimal value dynamically.
+        private const uint DefaultUniformBufferPoolCapacity = 19 * DescriptorSetManager.MaxSets;
+        private const uint DefaultStorageBufferPoolCapacity = 16 * DescriptorSetManager.MaxSets;
+        private const uint DefaultTexturePoolCapacity = 128 * DescriptorSetManager.MaxSets;
+        private const uint DefaultImagePoolCapacity = 8 * DescriptorSetManager.MaxSets;
+
+        private const int MaxPoolSizesPerSet = 2;
+
         private readonly VulkanRenderer _gd;
         private readonly Device _device;
 
         public DescriptorSetLayout[] DescriptorSetLayouts { get; }
         public PipelineLayout PipelineLayout { get; }
 
+        private readonly int[] _consumedDescriptorsPerSet;
+
         private readonly List<Auto<DescriptorSetCollection>>[][] _dsCache;
+        private List<Auto<DescriptorSetCollection>>[] _currentDsCache;
         private readonly int[] _dsCacheCursor;
         private int _dsLastCbIndex;
+        private int _dsLastSubmissionCount;
 
         private PipelineLayoutCacheEntry(VulkanRenderer gd, Device device, int setsCount)
         {
@@ -44,29 +58,55 @@ namespace Ryujinx.Graphics.Vulkan
             bool usePushDescriptors) : this(gd, device, setDescriptors.Count)
         {
             (DescriptorSetLayouts, PipelineLayout) = PipelineLayoutFactory.Create(gd, device, setDescriptors, usePushDescriptors);
+
+            _consumedDescriptorsPerSet = new int[setDescriptors.Count];
+
+            for (int setIndex = 0; setIndex < setDescriptors.Count; setIndex++)
+            {
+                int count = 0;
+
+                foreach (var descriptor in setDescriptors[setIndex].Descriptors)
+                {
+                    count += descriptor.Count;
                 }
 
-        public Auto<DescriptorSetCollection> GetNewDescriptorSetCollection(
-            VulkanRenderer gd,
-            int commandBufferIndex,
-            int setIndex,
-            out bool isNew)
+                _consumedDescriptorsPerSet[setIndex] = count;
+            }
+        }
+
+        public void UpdateCommandBufferIndex(int commandBufferIndex)
         {
-            if (_dsLastCbIndex != commandBufferIndex)
+            int submissionCount = _gd.CommandBufferPool.GetSubmissionCount(commandBufferIndex);
+
+            if (_dsLastCbIndex != commandBufferIndex || _dsLastSubmissionCount != submissionCount)
             {
                 _dsLastCbIndex = commandBufferIndex;
+                _dsLastSubmissionCount = submissionCount;
+                Array.Clear(_dsCacheCursor);
+            }
 
-                for (int i = 0; i < _dsCacheCursor.Length; i++)
+            _currentDsCache = _dsCache[commandBufferIndex];
+        }
+
+        public Auto<DescriptorSetCollection> GetNewDescriptorSetCollection(int setIndex, out bool isNew)
         {
-                    _dsCacheCursor[i] = 0;
-                }
-            }
-
-            var list = _dsCache[commandBufferIndex][setIndex];
+            var list = _currentDsCache[setIndex];
             int index = _dsCacheCursor[setIndex]++;
             if (index == list.Count)
             {
-                var dsc = gd.DescriptorSetManager.AllocateDescriptorSet(gd.Api, DescriptorSetLayouts[setIndex]);
+                Span<DescriptorPoolSize> poolSizes = stackalloc DescriptorPoolSize[MaxPoolSizesPerSet];
+                poolSizes = GetDescriptorPoolSizes(poolSizes, setIndex);
+
+                int consumedDescriptors = _consumedDescriptorsPerSet[setIndex];
+
+                var dsc = _gd.DescriptorSetManager.AllocateDescriptorSet(
+                    _gd.Api,
+                    DescriptorSetLayouts[setIndex],
+                    poolSizes,
+                    setIndex,
+                    consumedDescriptors,
+                    false);
+
                 list.Add(dsc);
                 isNew = true;
                 return dsc;
@@ -76,6 +116,33 @@ namespace Ryujinx.Graphics.Vulkan
             return list[index];
         }
 
+        private static Span<DescriptorPoolSize> GetDescriptorPoolSizes(Span<DescriptorPoolSize> output, int setIndex)
+        {
+            int count = 1;
+
+            switch (setIndex)
+            {
+                case PipelineBase.UniformSetIndex:
+                    output[0] = new(DescriptorType.UniformBuffer, DefaultUniformBufferPoolCapacity);
+                    break;
+                case PipelineBase.StorageSetIndex:
+                    output[0] = new(DescriptorType.StorageBuffer, DefaultStorageBufferPoolCapacity);
+                    break;
+                case PipelineBase.TextureSetIndex:
+                    output[0] = new(DescriptorType.CombinedImageSampler, DefaultTexturePoolCapacity);
+                    output[1] = new(DescriptorType.UniformTexelBuffer, DefaultTexturePoolCapacity);
+                    count = 2;
+                    break;
+                case PipelineBase.ImageSetIndex:
+                    output[0] = new(DescriptorType.StorageImage, DefaultImagePoolCapacity);
+                    output[1] = new(DescriptorType.StorageTexelBuffer, DefaultImagePoolCapacity);
+                    count = 2;
+                    break;
+            }
+
+            return output[..count];
+        }
+
         protected virtual unsafe void Dispose(bool disposing)
         {
             if (disposing)

src/Ryujinx.Graphics.Vulkan/ShaderCollection.cs

@@ -464,13 +464,14 @@ namespace Ryujinx.Graphics.Vulkan
             return true;
         }
 
-        public Auto<DescriptorSetCollection> GetNewDescriptorSetCollection(
-            VulkanRenderer gd,
-            int commandBufferIndex,
-            int setIndex,
-            out bool isNew)
+        public void UpdateDescriptorCacheCommandBufferIndex(int commandBufferIndex)
         {
-            return _plce.GetNewDescriptorSetCollection(gd, commandBufferIndex, setIndex, out isNew);
+            _plce.UpdateCommandBufferIndex(commandBufferIndex);
+        }
+
+        public Auto<DescriptorSetCollection> GetNewDescriptorSetCollection(int setIndex, out bool isNew)
+        {
+            return _plce.GetNewDescriptorSetCollection(setIndex, out isNew);
         }
 
         protected virtual void Dispose(bool disposing)

src/Ryujinx.Graphics.Vulkan/VulkanRenderer.cs

@@ -347,7 +347,7 @@ namespace Ryujinx.Graphics.Vulkan
 
             CommandBufferPool = new CommandBufferPool(Api, _device, Queue, QueueLock, queueFamilyIndex);
 
-            DescriptorSetManager = new DescriptorSetManager(_device);
+            DescriptorSetManager = new DescriptorSetManager(_device, PipelineBase.DescriptorSetLayouts);
 
             PipelineLayoutCache = new PipelineLayoutCache();