From a17605b292e2a56a92312fde6c26ad78be741352 Mon Sep 17 00:00:00 2001 From: Alex Barney Date: Mon, 20 Dec 2021 15:12:34 -0700 Subject: [PATCH] Fixup FileSystemBufferManager --- src/LibHac/Fs/Buffers/IBufferManager.cs | 13 +- src/LibHac/FsSystem/BufferedStorage.cs | 1 + .../Buffers/FileSystemBufferManager.cs | 320 ++++++++++-------- src/LibHac/FsSystem/CompressedStorage.cs | 4 +- src/LibHac/FsSystem/Impl/BlockCacheManager.cs | 3 +- .../FsSystem/FileSystemBufferManagerTests.cs | 16 +- 6 files changed, 190 insertions(+), 167 deletions(-) diff --git a/src/LibHac/Fs/Buffers/IBufferManager.cs b/src/LibHac/Fs/Buffers/IBufferManager.cs index 27c94fc8..63e03365 100644 --- a/src/LibHac/Fs/Buffers/IBufferManager.cs +++ b/src/LibHac/Fs/Buffers/IBufferManager.cs @@ -1,4 +1,5 @@ using System; + using Buffer = LibHac.Mem.Buffer; using CacheHandle = System.Int64; @@ -28,6 +29,8 @@ public abstract class IBufferManager : IDisposable public const int BufferLevelMin = 0; + public virtual void Dispose() { } + public Buffer AllocateBuffer(int size, BufferAttribute attribute) => DoAllocateBuffer(size, attribute); @@ -118,12 +121,4 @@ public abstract class IBufferManager : IDisposable protected abstract int DoGetTotalAllocatableSizePeak(); protected abstract int DoGetRetriedCount(); protected abstract void DoClearPeak(); - - protected virtual void Dispose(bool disposing) { } - - public void Dispose() - { - Dispose(true); - GC.SuppressFinalize(this); - } -} +} \ No newline at end of file diff --git a/src/LibHac/FsSystem/BufferedStorage.cs b/src/LibHac/FsSystem/BufferedStorage.cs index e7db9bbd..153b91dd 100644 --- a/src/LibHac/FsSystem/BufferedStorage.cs +++ b/src/LibHac/FsSystem/BufferedStorage.cs @@ -7,6 +7,7 @@ using LibHac.Diag; using LibHac.Fs; using LibHac.FsSystem.Buffers; using LibHac.Util; + using Buffer = LibHac.Mem.Buffer; using CacheHandle = System.Int64; diff --git a/src/LibHac/FsSystem/Buffers/FileSystemBufferManager.cs b/src/LibHac/FsSystem/Buffers/FileSystemBufferManager.cs index b405c64f..4c1b851a 100644 --- a/src/LibHac/FsSystem/Buffers/FileSystemBufferManager.cs +++ b/src/LibHac/FsSystem/Buffers/FileSystemBufferManager.cs @@ -5,16 +5,21 @@ using System.Runtime.InteropServices; using LibHac.Common; using LibHac.Diag; using LibHac.Fs; +using LibHac.Os; using LibHac.Util; + using Buffer = LibHac.Mem.Buffer; using CacheHandle = System.Int64; // ReSharper disable once CheckNamespace namespace LibHac.FsSystem; +/// +/// An that uses a as an allocator. +/// public class FileSystemBufferManager : IBufferManager { - private class CacheHandleTable + private class CacheHandleTable : IDisposable { private struct Entry { @@ -62,14 +67,24 @@ public class FileSystemBufferManager : IBufferManager } } - private Entry[] Entries { get; set; } - private int EntryCount { get; set; } - private int EntryCountMax { get; set; } - private LinkedList AttrList { get; set; } = new(); - private int CacheCountMin { get; set; } - private int CacheSizeMin { get; set; } - private int TotalCacheSize { get; set; } - private CacheHandle CurrentHandle { get; set; } + private Entry[] _entries; + private int _entryCount; + private int _entryCountMax; + private LinkedList _attrList; + private int _cacheCountMin; + private int _cacheSizeMin; + private int _totalCacheSize; + private CacheHandle _currentHandle; + + public CacheHandleTable() + { + _attrList = new LinkedList(); + } + + public void Dispose() + { + FinalizeObject(); + } // ReSharper disable once UnusedMember.Local // We can't use an external buffer in C# without ensuring all allocated buffers are pinned. @@ -90,41 +105,53 @@ public class FileSystemBufferManager : IBufferManager public Result Initialize(int maxCacheCount) { // Validate pre-conditions. - Assert.SdkRequiresNull(Entries); + Assert.SdkRequiresNull(_entries); // Note: We don't have the option of using an external Entry buffer like the original C++ code // because Entry includes managed references so we can't cast a byte* to Entry* without pinning. // If we don't have an external buffer, try to allocate an internal one. - Entries = new Entry[maxCacheCount]; + _entries = new Entry[maxCacheCount]; - if (Entries == null) + if (_entries == null) { return ResultFs.AllocationMemoryFailedInFileSystemBufferManagerA.Log(); } // Set entries. - EntryCount = 0; - EntryCountMax = maxCacheCount; + _entryCount = 0; + _entryCountMax = maxCacheCount; - Assert.SdkNotNull(Entries); + Assert.SdkNotNull(_entries); - CacheCountMin = maxCacheCount / 16; - CacheSizeMin = CacheCountMin * 0x100; + _cacheCountMin = maxCacheCount / 16; + _cacheSizeMin = _cacheCountMin * 0x100; return Result.Success; } + public void FinalizeObject() + { + if (_entries is null) + return; + + Assert.SdkAssert(_entryCount == 0); + + _attrList.Clear(); + _entries = null; + _totalCacheSize = 0; + } + // ReSharper disable once UnusedParameter.Local private int GetCacheCountMin(BufferAttribute attr) { - return CacheCountMin; + return _cacheCountMin; } // ReSharper disable once UnusedParameter.Local private int GetCacheSizeMin(BufferAttribute attr) { - return CacheSizeMin; + return _cacheSizeMin; } public bool Register(out CacheHandle handle, Buffer buffer, BufferAttribute attr) @@ -132,7 +159,7 @@ public class FileSystemBufferManager : IBufferManager UnsafeHelpers.SkipParamInit(out handle); // Validate pre-conditions. - Assert.SdkRequiresNotNull(Entries); + Assert.SdkRequiresNotNull(_entries); Assert.SdkRequiresNotNull(ref handle); // Get the entry. @@ -154,10 +181,10 @@ public class FileSystemBufferManager : IBufferManager // Make a new attr info and add it to the list. // Note: Not using attr info buffer var newInfo = new AttrInfo(attr.Level, 1, buffer.Length); - AttrList.AddLast(newInfo); + _attrList.AddLast(newInfo); } - TotalCacheSize += buffer.Length; + _totalCacheSize += buffer.Length; handle = entry.GetHandle(); return true; } @@ -166,17 +193,17 @@ public class FileSystemBufferManager : IBufferManager { // Validate pre-conditions. Unsafe.SkipInit(out buffer); - Assert.SdkRequiresNotNull(Entries); + Assert.SdkRequiresNotNull(_entries); Assert.SdkRequiresNotNull(ref buffer); UnsafeHelpers.SkipParamInit(out buffer); // Find the lower bound for the entry. - for (int i = 0; i < EntryCount; i++) + for (int i = 0; i < _entryCount; i++) { - if (Entries[i].GetHandle() == handle) + if (_entries[i].GetHandle() == handle) { - UnregisterCore(out buffer, ref Entries[i]); + UnregisterCore(out buffer, ref _entries[i]); return true; } } @@ -190,13 +217,13 @@ public class FileSystemBufferManager : IBufferManager { // Validate pre-conditions. Unsafe.SkipInit(out buffer); - Assert.SdkRequiresNotNull(Entries); + Assert.SdkRequiresNotNull(_entries); Assert.SdkRequiresNotNull(ref buffer); UnsafeHelpers.SkipParamInit(out buffer); // If we have no entries, we can't unregister any. - if (EntryCount == 0) + if (_entryCount == 0) { return false; } @@ -214,18 +241,18 @@ public class FileSystemBufferManager : IBufferManager // Find an entry, falling back to the first entry. ref Entry entry = ref Unsafe.NullRef(); - for (int i = 0; i < EntryCount; i++) + for (int i = 0; i < _entryCount; i++) { - if (CanUnregister(this, ref Entries[i])) + if (CanUnregister(this, ref _entries[i])) { - entry = ref Entries[i]; + entry = ref _entries[i]; break; } } if (Unsafe.IsNullRef(ref entry)) { - entry = ref Entries[0]; + entry = ref _entries[0]; } Assert.SdkNotNull(ref entry); @@ -237,7 +264,7 @@ public class FileSystemBufferManager : IBufferManager { // Validate pre-conditions. Unsafe.SkipInit(out buffer); - Assert.SdkRequiresNotNull(Entries); + Assert.SdkRequiresNotNull(_entries); Assert.SdkRequiresNotNull(ref buffer); Assert.SdkRequiresNotNull(ref entry); @@ -254,8 +281,8 @@ public class FileSystemBufferManager : IBufferManager attrInfo.SubtractCacheSize(entry.GetSize()); // Release from cached size. - Assert.SdkGreaterEqual(TotalCacheSize, entry.GetSize()); - TotalCacheSize -= entry.GetSize(); + Assert.SdkGreaterEqual(_totalCacheSize, entry.GetSize()); + _totalCacheSize -= entry.GetSize(); // Release the entry. buffer = entry.GetBuffer(); @@ -264,27 +291,27 @@ public class FileSystemBufferManager : IBufferManager public CacheHandle PublishCacheHandle() { - Assert.SdkRequires(Entries != null); - return ++CurrentHandle; + Assert.SdkRequires(_entries != null); + return ++_currentHandle; } public int GetTotalCacheSize() { - return TotalCacheSize; + return _totalCacheSize; } private ref Entry AcquireEntry(Buffer buffer, BufferAttribute attr) { // Validate pre-conditions. - Assert.SdkRequiresNotNull(Entries); + Assert.SdkRequiresNotNull(_entries); ref Entry entry = ref Unsafe.NullRef(); - if (EntryCount < EntryCountMax) + if (_entryCount < _entryCountMax) { - entry = ref Entries[EntryCount]; + entry = ref _entries[_entryCount]; entry.Initialize(PublishCacheHandle(), buffer, attr); - EntryCount++; - Assert.SdkAssert(EntryCount == 1 || Entries[EntryCount - 2].GetHandle() < entry.GetHandle()); + _entryCount++; + Assert.SdkAssert(_entryCount == 1 || _entries[_entryCount - 2].GetHandle() < entry.GetHandle()); } return ref entry; @@ -293,11 +320,11 @@ public class FileSystemBufferManager : IBufferManager private void ReleaseEntry(ref Entry entry) { // Validate pre-conditions. - Assert.SdkRequiresNotNull(Entries); + Assert.SdkRequiresNotNull(_entries); Assert.SdkRequiresNotNull(ref entry); // Ensure the entry is valid. - Span entryBuffer = Entries; + Span entryBuffer = _entries; Assert.SdkAssert(!Unsafe.IsAddressLessThan(ref entry, ref MemoryMarshal.GetReference(entryBuffer))); Assert.SdkAssert(Unsafe.IsAddressLessThan(ref entry, ref Unsafe.Add(ref MemoryMarshal.GetReference(entryBuffer), entryBuffer.Length))); @@ -307,17 +334,17 @@ public class FileSystemBufferManager : IBufferManager Unsafe.SizeOf(); // Copy the entries back by one. - Span source = entryBuffer.Slice(index + 1, EntryCount - (index + 1)); + Span source = entryBuffer.Slice(index + 1, _entryCount - (index + 1)); Span dest = entryBuffer.Slice(index); source.CopyTo(dest); // Decrement our entry count. - EntryCount--; + _entryCount--; } private ref AttrInfo FindAttrInfo(BufferAttribute attr) { - LinkedListNode curNode = AttrList.First; + LinkedListNode curNode = _attrList.First; while (curNode != null) { @@ -333,50 +360,54 @@ public class FileSystemBufferManager : IBufferManager } } - private FileSystemBuddyHeap BuddyHeap { get; } = new(); - private CacheHandleTable CacheTable { get; } = new(); - private int TotalSize { get; set; } - private int PeakFreeSize { get; set; } - private int PeakTotalAllocatableSize { get; set; } - private int RetriedCount { get; set; } - private object Locker { get; } = new(); + private FileSystemBuddyHeap _buddyHeap; + private CacheHandleTable _cacheTable; + private int _totalSize; + private int _peakFreeSize; + private int _peakTotalAllocatableSize; + private int _retriedCount; + private SdkMutexType _mutex; - protected override void Dispose(bool disposing) + public FileSystemBufferManager() { - if (disposing) - { - BuddyHeap.Dispose(); - } + _buddyHeap = new FileSystemBuddyHeap(); + _cacheTable = new CacheHandleTable(); + _mutex = new SdkMutexType(); + } - base.Dispose(disposing); + public override void Dispose() + { + _cacheTable.Dispose(); + _buddyHeap.Dispose(); + base.Dispose(); } public Result Initialize(int maxCacheCount, Memory heapBuffer, int blockSize) { - Result rc = CacheTable.Initialize(maxCacheCount); + Result rc = _cacheTable.Initialize(maxCacheCount); if (rc.IsFailure()) return rc; - rc = BuddyHeap.Initialize(heapBuffer, blockSize); + rc = _buddyHeap.Initialize(heapBuffer, blockSize); if (rc.IsFailure()) return rc; - TotalSize = (int)BuddyHeap.GetTotalFreeSize(); - PeakFreeSize = TotalSize; - PeakTotalAllocatableSize = TotalSize; + _totalSize = (int)_buddyHeap.GetTotalFreeSize(); + _peakFreeSize = _totalSize; + _peakTotalAllocatableSize = _totalSize; return Result.Success; } public Result Initialize(int maxCacheCount, Memory heapBuffer, int blockSize, int maxOrder) { - Result rc = CacheTable.Initialize(maxCacheCount); + Result rc = _cacheTable.Initialize(maxCacheCount); if (rc.IsFailure()) return rc; - rc = BuddyHeap.Initialize(heapBuffer, blockSize, maxOrder); + rc = _buddyHeap.Initialize(heapBuffer, blockSize, maxOrder); if (rc.IsFailure()) return rc; - TotalSize = (int)BuddyHeap.GetTotalFreeSize(); - PeakFreeSize = TotalSize; - PeakTotalAllocatableSize = TotalSize; + _totalSize = (int)_buddyHeap.GetTotalFreeSize(); + _peakFreeSize = _totalSize; + _peakTotalAllocatableSize = _totalSize; return Result.Success; } @@ -386,15 +417,15 @@ public class FileSystemBufferManager : IBufferManager // Note: We can't use an external buffer for the cache handle table since it contains managed pointers, // so pass the work buffer directly to the buddy heap. - Result rc = CacheTable.Initialize(maxCacheCount); + Result rc = _cacheTable.Initialize(maxCacheCount); if (rc.IsFailure()) return rc; - rc = BuddyHeap.Initialize(heapBuffer, blockSize, workBuffer); + rc = _buddyHeap.Initialize(heapBuffer, blockSize, workBuffer); if (rc.IsFailure()) return rc; - TotalSize = (int)BuddyHeap.GetTotalFreeSize(); - PeakFreeSize = TotalSize; - PeakTotalAllocatableSize = TotalSize; + _totalSize = (int)_buddyHeap.GetTotalFreeSize(); + _peakFreeSize = _totalSize; + _peakTotalAllocatableSize = _totalSize; return Result.Success; } @@ -405,40 +436,39 @@ public class FileSystemBufferManager : IBufferManager // Note: We can't use an external buffer for the cache handle table since it contains managed pointers, // so pass the work buffer directly to the buddy heap. - Result rc = CacheTable.Initialize(maxCacheCount); + Result rc = _cacheTable.Initialize(maxCacheCount); if (rc.IsFailure()) return rc; - rc = BuddyHeap.Initialize(heapBuffer, blockSize, maxOrder, workBuffer); + rc = _buddyHeap.Initialize(heapBuffer, blockSize, maxOrder, workBuffer); if (rc.IsFailure()) return rc; - TotalSize = (int)BuddyHeap.GetTotalFreeSize(); - PeakFreeSize = TotalSize; - PeakTotalAllocatableSize = TotalSize; + _totalSize = (int)_buddyHeap.GetTotalFreeSize(); + _peakFreeSize = _totalSize; + _peakTotalAllocatableSize = _totalSize; return Result.Success; } protected override Buffer DoAllocateBuffer(int size, BufferAttribute attribute) { - lock (Locker) - { - return AllocateBufferImpl(size, attribute); - } + using var lk = new ScopedLock(ref _mutex); + + return AllocateBufferImpl(size, attribute); } private Buffer AllocateBufferImpl(int size, BufferAttribute attribute) { - int order = BuddyHeap.GetOrderFromBytes((nuint)size); + int order = _buddyHeap.GetOrderFromBytes((nuint)size); Assert.SdkAssert(order >= 0); // Allocate space on the heap Buffer buffer; - while ((buffer = BuddyHeap.AllocateBufferByOrder(order)).IsNull) + while ((buffer = _buddyHeap.AllocateBufferByOrder(order)).IsNull) { // Not enough space in heap. Deallocate cached buffer and try again. - RetriedCount++; + _retriedCount++; - if (!CacheTable.UnregisterOldest(out Buffer deallocateBuffer, attribute, size)) + if (!_cacheTable.UnregisterOldest(out Buffer deallocateBuffer, attribute, size)) { // No cached buffers left to deallocate. return Buffer.Empty; @@ -448,57 +478,56 @@ public class FileSystemBufferManager : IBufferManager } // Successfully allocated a buffer. - int allocatedSize = (int)BuddyHeap.GetBytesFromOrder(order); + int allocatedSize = (int)_buddyHeap.GetBytesFromOrder(order); Assert.SdkAssert(size <= allocatedSize); // Update heap stats - int freeSize = (int)BuddyHeap.GetTotalFreeSize(); - PeakFreeSize = Math.Min(PeakFreeSize, freeSize); + int freeSize = (int)_buddyHeap.GetTotalFreeSize(); + _peakFreeSize = Math.Min(_peakFreeSize, freeSize); - int totalAllocatableSize = freeSize + CacheTable.GetTotalCacheSize(); - PeakTotalAllocatableSize = Math.Min(PeakTotalAllocatableSize, totalAllocatableSize); + int totalAllocatableSize = freeSize + _cacheTable.GetTotalCacheSize(); + _peakTotalAllocatableSize = Math.Min(_peakTotalAllocatableSize, totalAllocatableSize); return buffer; } protected override void DoDeallocateBuffer(Buffer buffer) { - lock (Locker) - { - DeallocateBufferImpl(buffer); - } + using var lk = new ScopedLock(ref _mutex); + + DeallocateBufferImpl(buffer); } private void DeallocateBufferImpl(Buffer buffer) { Assert.SdkRequires(BitUtil.IsPowerOfTwo(buffer.Length)); - BuddyHeap.Free(buffer); + _buddyHeap.Free(buffer); } protected override CacheHandle DoRegisterCache(Buffer buffer, BufferAttribute attribute) { - lock (Locker) - { - return RegisterCacheImpl(buffer, attribute); - } + using var lk = new ScopedLock(ref _mutex); + + return RegisterCacheImpl(buffer, attribute); } private CacheHandle RegisterCacheImpl(Buffer buffer, BufferAttribute attribute) { - CacheHandle handle; + // ReSharper disable once RedundantAssignment + CacheHandle handle = 0; // Try to register the handle. - while (!CacheTable.Register(out handle, buffer, attribute)) + while (!_cacheTable.Register(out handle, buffer, attribute)) { // Unregister a buffer and try registering again. - RetriedCount++; - if (!CacheTable.UnregisterOldest(out Buffer deallocateBuffer, attribute)) + _retriedCount++; + if (!_cacheTable.UnregisterOldest(out Buffer deallocateBuffer, attribute)) { // Can't unregister any existing buffers. // Register the input buffer to /dev/null. DeallocateBufferImpl(buffer); - return CacheTable.PublishCacheHandle(); + return _cacheTable.PublishCacheHandle(); } // Deallocate the unregistered buffer. @@ -510,18 +539,17 @@ public class FileSystemBufferManager : IBufferManager protected override Buffer DoAcquireCache(CacheHandle handle) { - lock (Locker) - { - return AcquireCacheImpl(handle); - } + using var lk = new ScopedLock(ref _mutex); + + return AcquireCacheImpl(handle); } private Buffer AcquireCacheImpl(CacheHandle handle) { - if (CacheTable.Unregister(out Buffer range, handle)) + if (_cacheTable.Unregister(out Buffer range, handle)) { - int totalAllocatableSize = (int)BuddyHeap.GetTotalFreeSize() + CacheTable.GetTotalCacheSize(); - PeakTotalAllocatableSize = Math.Min(PeakTotalAllocatableSize, totalAllocatableSize); + int totalAllocatableSize = (int)_buddyHeap.GetTotalFreeSize() + _cacheTable.GetTotalCacheSize(); + _peakTotalAllocatableSize = Math.Min(_peakTotalAllocatableSize, totalAllocatableSize); } else { @@ -533,86 +561,80 @@ public class FileSystemBufferManager : IBufferManager protected override int DoGetTotalSize() { - return TotalSize; + return _totalSize; } protected override int DoGetFreeSize() { - lock (Locker) - { - return GetFreeSizeImpl(); - } + using var lk = new ScopedLock(ref _mutex); + + return GetFreeSizeImpl(); } private int GetFreeSizeImpl() { - return (int)BuddyHeap.GetTotalFreeSize(); + return (int)_buddyHeap.GetTotalFreeSize(); } protected override int DoGetTotalAllocatableSize() { - lock (Locker) - { - return GetTotalAllocatableSizeImpl(); - } + using var lk = new ScopedLock(ref _mutex); + + return GetTotalAllocatableSizeImpl(); } private int GetTotalAllocatableSizeImpl() { - return GetFreeSizeImpl() + CacheTable.GetTotalCacheSize(); + return GetFreeSizeImpl() + _cacheTable.GetTotalCacheSize(); } protected override int DoGetFreeSizePeak() { - lock (Locker) - { - return GetFreeSizePeakImpl(); - } + using var lk = new ScopedLock(ref _mutex); + + return GetFreeSizePeakImpl(); } private int GetFreeSizePeakImpl() { - return PeakFreeSize; + return _peakFreeSize; } protected override int DoGetTotalAllocatableSizePeak() { - lock (Locker) - { - return GetTotalAllocatableSizePeakImpl(); - } + using var lk = new ScopedLock(ref _mutex); + + return GetTotalAllocatableSizePeakImpl(); } private int GetTotalAllocatableSizePeakImpl() { - return PeakTotalAllocatableSize; + return _peakTotalAllocatableSize; } protected override int DoGetRetriedCount() { - lock (Locker) - { - return GetRetriedCountImpl(); - } + using var lk = new ScopedLock(ref _mutex); + + return GetRetriedCountImpl(); } private int GetRetriedCountImpl() { - return RetriedCount; + return _retriedCount; } protected override void DoClearPeak() { - lock (Locker) - { - ClearPeakImpl(); - } + using var lk = new ScopedLock(ref _mutex); + + ClearPeakImpl(); } private void ClearPeakImpl() { - PeakFreeSize = GetFreeSizeImpl(); - PeakTotalAllocatableSize = GetTotalAllocatableSizeImpl(); - RetriedCount = 0; + _peakFreeSize = GetFreeSizeImpl(); + _peakTotalAllocatableSize = GetTotalAllocatableSizeImpl(); + _retriedCount = 0; } -} +} \ No newline at end of file diff --git a/src/LibHac/FsSystem/CompressedStorage.cs b/src/LibHac/FsSystem/CompressedStorage.cs index 8c64f0fd..51392f20 100644 --- a/src/LibHac/FsSystem/CompressedStorage.cs +++ b/src/LibHac/FsSystem/CompressedStorage.cs @@ -4,7 +4,9 @@ using LibHac.Diag; using LibHac.Fs; using LibHac.FsSystem.Impl; using LibHac.Os; + using Buffer = LibHac.Mem.Buffer; +using CacheHandle = System.Int64; namespace LibHac.FsSystem; @@ -135,7 +137,7 @@ public class CompressedStorage : IStorage, IAsynchronousAccessSplitter public struct CacheEntry : IBlockCacheManagerEntry { public Range Range { get; set; } - public long Handle { get; set; } + public CacheHandle Handle { get; set; } public Buffer Buffer { get; set; } public bool IsValid { get; set; } public bool IsCached { get; set; } diff --git a/src/LibHac/FsSystem/Impl/BlockCacheManager.cs b/src/LibHac/FsSystem/Impl/BlockCacheManager.cs index 1f2bf195..237f07ef 100644 --- a/src/LibHac/FsSystem/Impl/BlockCacheManager.cs +++ b/src/LibHac/FsSystem/Impl/BlockCacheManager.cs @@ -3,6 +3,7 @@ using LibHac.Diag; using LibHac.Fs; using Buffer = LibHac.Mem.Buffer; +using CacheHandle = System.Int64; namespace LibHac.FsSystem.Impl; @@ -13,7 +14,7 @@ public interface IBlockCacheManagerEntry where TRange : struct, IBlockCa bool IsWriteBack { get; set; } bool IsCached { get; set; } bool IsFlushing { set; } - long Handle { get; set; } + CacheHandle Handle { get; set; } Buffer Buffer { get; set; } short Age { get; set; } diff --git a/tests/LibHac.Tests/FsSystem/FileSystemBufferManagerTests.cs b/tests/LibHac.Tests/FsSystem/FileSystemBufferManagerTests.cs index e98150f6..55df93e7 100644 --- a/tests/LibHac.Tests/FsSystem/FileSystemBufferManagerTests.cs +++ b/tests/LibHac.Tests/FsSystem/FileSystemBufferManagerTests.cs @@ -3,6 +3,8 @@ using LibHac.FsSystem; using LibHac.Mem; using Xunit; +using CacheHandle = System.Int64; + namespace LibHac.Tests.FsSystem; public class FileSystemBufferManagerTests @@ -38,7 +40,7 @@ public class FileSystemBufferManagerTests FileSystemBufferManager manager = CreateManager(0x20000); Buffer buffer1 = manager.AllocateBuffer(0x10000); - long handle = manager.RegisterCache(buffer1, new IBufferManager.BufferAttribute()); + CacheHandle handle = manager.RegisterCache(buffer1, new IBufferManager.BufferAttribute()); manager.AllocateBuffer(0x10000); Buffer buffer3 = manager.AcquireCache(handle); @@ -52,7 +54,7 @@ public class FileSystemBufferManagerTests FileSystemBufferManager manager = CreateManager(0x20000); Buffer buffer1 = manager.AllocateBuffer(0x10000); - long handle = manager.RegisterCache(buffer1, new IBufferManager.BufferAttribute()); + CacheHandle handle = manager.RegisterCache(buffer1, new IBufferManager.BufferAttribute()); manager.AllocateBuffer(0x20000); Buffer buffer3 = manager.AcquireCache(handle); @@ -69,10 +71,10 @@ public class FileSystemBufferManagerTests Buffer buffer3 = manager.AllocateBuffer(0x8000); Buffer buffer4 = manager.AllocateBuffer(0x8000); - long handle1 = manager.RegisterCache(buffer1, new IBufferManager.BufferAttribute()); - long handle2 = manager.RegisterCache(buffer2, new IBufferManager.BufferAttribute()); - long handle3 = manager.RegisterCache(buffer3, new IBufferManager.BufferAttribute()); - long handle4 = manager.RegisterCache(buffer4, new IBufferManager.BufferAttribute()); + CacheHandle handle1 = manager.RegisterCache(buffer1, new IBufferManager.BufferAttribute()); + CacheHandle handle2 = manager.RegisterCache(buffer2, new IBufferManager.BufferAttribute()); + CacheHandle handle3 = manager.RegisterCache(buffer3, new IBufferManager.BufferAttribute()); + CacheHandle handle4 = manager.RegisterCache(buffer4, new IBufferManager.BufferAttribute()); manager.AllocateBuffer(0x10000); @@ -86,4 +88,4 @@ public class FileSystemBufferManagerTests Assert.Equal(buffer3, buffer3B); Assert.Equal(buffer4, buffer4B); } -} +} \ No newline at end of file