/// <summary>
/// Get a HeapHandle
/// </summary>
public SafeHeapHandle Acquire(ulong minSize = 0)
{
if (minSize < _minSize) minSize = _minSize;
SafeHeapHandle handle = null;
for (int i = 0; i < _handleCache.Length; i++)
{
handle = Interlocked.Exchange(ref _handleCache[i], null);
if (handle != null) break;
}
if (handle != null)
{
// One possible future consideration is to attempt cycling through to
// find one that might already have sufficient capacity
if (handle.ByteLength < minSize)
handle.Resize(minSize);
}
else
{
handle = new SafeHeapHandle(minSize);
}
return handle;
}
/// <summary>
/// Get a HeapHandle
/// </summary>
public SafeHeapHandle Acquire(ulong minSize = 0)
{
if (minSize < _minSize)
{
minSize = _minSize;
}
SafeHeapHandle handle = null;
for (int i = 0; i < _handleCache.Length; i++)
{
handle = Interlocked.Exchange(ref _handleCache[i], null);
if (handle != null)
{
break;
}
}
if (handle != null)
{
// One possible future consideration is to attempt cycling through to
// find one that might already have sufficient capacity
if (handle.ByteLength < minSize)
{
handle.Resize(minSize);
}
}
else
{
handle = new SafeHeapHandle(minSize);
}
return(handle);
}
public SafeHeapHandle Acquire(ulong minSize = 0UL)
{
if (minSize < this._minSize)
{
minSize = this._minSize;
}
SafeHeapHandle safeHeapHandle = null;
for (int i = 0; i < this._handleCache.Length; i++)
{
safeHeapHandle = Interlocked.Exchange <SafeHeapHandle>(ref this._handleCache[i], null);
if (safeHeapHandle != null)
{
break;
}
}
if (safeHeapHandle != null)
{
if (safeHeapHandle.ByteLength < minSize)
{
safeHeapHandle.Resize(minSize);
}
}
else
{
safeHeapHandle = new SafeHeapHandle(minSize);
}
return(safeHeapHandle);
}
private void ReleaseHandle()
{
if (_handle != null)
{
_capacity = 0;
_handle = null;
}
}
private void ReleaseHandle()
{
if (_handle != null)
{
s_handleCache.Release(_handle);
_capacity = 0;
_handle = null;
}
}
private void Dispose(bool disposing)
{
if (_handleCache != null)
{
for (int i = 0; i < _handleCache.Length; i++)
{
SafeHeapHandle handle = _handleCache[i];
_handleCache[i] = null;
if (handle != null && disposing)
{
handle.Dispose();
}
}
}
}
/// <summary>
/// Give a HeapHandle back for potential reuse
/// </summary>
public void Release(SafeHeapHandle handle)
{
if (handle.ByteLength <= _maxSize)
{
for (int i = 0; i < _handleCache.Length; i++)
{
// Push the handles down, walking the last one off the end to keep
// the top of the "stack" fresh
handle = Interlocked.Exchange(ref _handleCache[i], handle);
if (handle == null) return;
}
}
handle.Dispose();
}
private void Dispose(bool disposing)
{
if (this._handleCache != null)
{
for (int i = 0; i < this._handleCache.Length; i++)
{
SafeHeapHandle safeHeapHandle = this._handleCache[i];
this._handleCache[i] = null;
if (safeHeapHandle != null && disposing)
{
safeHeapHandle.Dispose();
}
}
}
}
public void Release(SafeHeapHandle handle)
{
if (handle.ByteLength <= this._maxSize)
{
for (int i = 0; i < this._handleCache.Length; i++)
{
handle = Interlocked.Exchange <SafeHeapHandle>(ref this._handleCache[i], handle);
if (handle == null)
{
return;
}
}
}
handle.Dispose();
}
private unsafe void Resize(ulong byteLength)
{
if (byteLength == 0)
{
ReleaseHandle();
return;
}
if (_handle == null)
{
_handle = s_handleCache.Acquire(byteLength);
}
else
{
_handle.Resize(byteLength);
}
}
private unsafe void Resize(ulong byteLength)
{
if (byteLength == 0)
{
ReleaseHandle();
return;
}
if (_handle == null)
{
_handle = new SafeHeapHandle(byteLength);
}
else
{
_handle.Resize(byteLength);
}
}
/// <summary>
/// Give a HeapHandle back for potential reuse
/// </summary>
public void Release(SafeHeapHandle handle)
{
if (handle.ByteLength <= _maxSize)
{
for (int i = 0; i < _handleCache.Length; i++)
{
// Push the handles down, walking the last one off the end to keep
// the top of the "stack" fresh
handle = Interlocked.Exchange(ref _handleCache[i], handle);
if (handle == null)
{
return;
}
}
}
handle.Dispose();
}
private unsafe void Resize(ulong byteLength)
{
if (byteLength == 0)
{
ReleaseHandle();
return;
}
if (_handle == null)
{
_handle = s_handleCache.Acquire(byteLength);
}
else
{
_handle.Resize(byteLength);
}
}
private void ReleaseHandle()
{
if (_handle != null)
{
s_handleCache.Release(_handle);
_capacity = 0;
_handle = null;
}
}
private void ReleaseHandle()
{
if (_handle != null)
{
_capacity = 0;
_handle = null;
}
}
private unsafe void Resize(ulong byteLength)
{
if (byteLength == 0)
{
ReleaseHandle();
return;
}
if (_handle == null)
{
_handle = new SafeHeapHandle(byteLength);
}
else
{
_handle.Resize(byteLength);
}
}