public QuickSet(int initialCapacity, int tableSizePower, IUnmanagedMemoryPool pool, TEqualityComparer comparer) { pool.TakeAtLeast <T>(initialCapacity, out var span); pool.TakeAtLeast <int>(span.Length << tableSizePower, out var tableSpan); //No guarantee that the table is clean; clear it. tableSpan.Clear(0, tableSpan.Length); this = new QuickSet <T, TEqualityComparer>(ref span, ref tableSpan, comparer, tableSizePower); }
public QuickDictionary(int initialCapacity, int tableSizePower, IUnmanagedMemoryPool pool, TEqualityComparer comparer) { pool.TakeAtLeast <TKey>(initialCapacity, out var keySpan); pool.TakeAtLeast <TValue>(keySpan.Length, out var valueSpan); pool.TakeAtLeast <int>(keySpan.Length << tableSizePower, out var tableSpan); //No guarantee that the table is clean; clear it. tableSpan.Clear(0, tableSpan.Length); this = new QuickDictionary <TKey, TValue, TEqualityComparer>(ref keySpan, ref valueSpan, ref tableSpan, comparer, tableSizePower); }
public void Resize(int newSize, IUnmanagedMemoryPool pool) { var targetCapacity = pool.GetCapacityForCount <T>(newSize); if (targetCapacity != Span.Length) { var oldSet = this; pool.TakeAtLeast <T>(newSize, out var newSpan); pool.TakeAtLeast <int>(newSpan.Length << TablePowerOffset, out var newTableSpan); //There is no guarantee that the table retrieved from the pool is clean. Clear it! newTableSpan.Clear(0, newTableSpan.Length); Resize(ref newSpan, ref newTableSpan, out var oldSpan, out var oldTableSpan); oldSet.Dispose(pool); } }
public void Resize(int newSize, IUnmanagedMemoryPool pool) { var targetKeyCapacity = pool.GetCapacityForCount <TKey>(newSize); if (targetKeyCapacity != Keys.Length) { pool.TakeAtLeast <TKey>(newSize, out var newKeySpan); pool.TakeAtLeast <TValue>(newKeySpan.Length, out var newValueSpan); pool.TakeAtLeast <int>(newKeySpan.Length << TablePowerOffset, out var newTableSpan); //There is no guarantee that the table retrieved from the pool is clean. Clear it! newTableSpan.Clear(0, newTableSpan.Length); var oldDictionary = this; Resize(ref newKeySpan, ref newValueSpan, ref newTableSpan, out var oldKeySpan, out var oldValueSpan, out var oldTableSpan); oldDictionary.Dispose(pool); } }
public QuickQueue(int minimumInitialCount, IUnmanagedMemoryPool pool) { pool.TakeAtLeast(minimumInitialCount, out Span); Count = 0; CapacityMask = GetCapacityMask(Span.Length); FirstIndex = 0; LastIndex = CapacityMask; ValidateSpanCapacity(ref Span, CapacityMask); }
void InternalResize(int newSize, IUnmanagedMemoryPool pool) { var oldAvailableIds = availableIds; pool.TakeAtLeast(newSize, out availableIds); Debug.Assert(oldAvailableIds.Length != availableIds.Length, "Did you really mean to resize this? Nothing changed!"); oldAvailableIds.CopyTo(0, ref availableIds, 0, availableIdCount); pool.Return(ref oldAvailableIds); }
public void Resize(int newSize, IUnmanagedMemoryPool pool) { var targetCapacity = pool.GetCapacityForCount <T>(newSize); if (targetCapacity != Span.Length) { var oldQueue = this; pool.TakeAtLeast <T>(newSize, out var newSpan); Resize(ref newSpan, out var oldSpan); oldQueue.Dispose(pool); } }
public void Return(int id, IUnmanagedMemoryPool pool) { Debug.Assert(availableIds.Allocated); if (availableIdCount == availableIds.Length) { var oldAvailableIds = availableIds; pool.TakeAtLeast(Math.Max(availableIdCount * 2, availableIds.Length), out availableIds); oldAvailableIds.CopyTo(0, ref availableIds, 0, availableIdCount); pool.Return(ref oldAvailableIds); } ReturnUnsafely(id); }
public IdPool(int initialCapacity, IUnmanagedMemoryPool pool) { nextIndex = 0; availableIdCount = 0; pool.TakeAtLeast(initialCapacity, out availableIds); }