/// <summary>
/// 索引池
/// </summary>
public indexPool()
{
int size = fastCSharp.config.appSetting.PoolSize * sizeof(int);
currentFreeIndex = (freeIndexs = unmanaged.Get(size, false)).Int;
endFreeIndex = freeIndexs.Byte + size;
}
/// <summary>
/// 内存数据流转换
/// </summary>
/// <param name="stream">内存数据流</param>
protected internal unmanagedStreamBase(unmanagedStreamBase stream)
{
data = stream.data;
length = stream.length;
IsUnmanaged = stream.IsUnmanaged;
stream.IsUnmanaged = false;
}
/// <summary>
/// 释放对象
/// </summary>
/// <param name="index"></param>
public void UnsafeFree(int index)
{
Monitor.Enter(poolLock);
if (currentFreeIndex != null)
{
if (currentFreeIndex == endFreeIndex)
{
pointer.size oldIndex = new pointer.size();
int size = (int)(endFreeIndex - freeIndexs.Byte);
try
{
pointer.size newIndex = unmanaged.Get(size <<= 1, false);
byte * newEnd = newIndex.Byte + size;
oldIndex = freeIndexs;
fastCSharp.unsafer.memory.Copy(oldIndex.data, newIndex.data, size = (int)((byte *)currentFreeIndex - oldIndex.Byte));
endFreeIndex = newEnd;
freeIndexs = newIndex;
currentFreeIndex = (int *)(newIndex.Byte + size);
}
finally
{
if (oldIndex.data == null)
{
Monitor.Exit(poolLock);
}
}
unmanaged.Free(ref oldIndex);
}
pool[index] = null;
*currentFreeIndex++ = index;
}
Monitor.Exit(poolLock);
}
/// <summary>
/// 内存数据流转换
/// </summary>
/// <param name="stream">内存数据流</param>
internal virtual void From(unmanagedStreamBase stream)
{
IsUnmanaged = stream.IsUnmanaged;
data = stream.data;
length = stream.length;
stream.IsUnmanaged = false;
}
/// <summary>
/// 重建数据
/// </summary>
protected void create()
{
int heapIndex = array.Length, newCount = heapIndex << 1, newHeapSize = newCount * sizeof(int);
keyValue <keyType, valueType>[] newArray = new keyValue <keyType, valueType> [newCount];
pointer.size newHeap = isStaticUnmanaged ? unmanaged.GetStaticSize(newHeapSize, false) : unmanaged.Get(newHeapSize, false), oldHeap = heap;
int * newHeapFixed = newHeap.Int;
array.CopyTo(newArray, 0);
fastCSharp.unsafer.memory.Copy(heap.Byte, newHeapFixed, newHeapSize >> 1);
do
{
--newCount;
newHeapFixed[newCount] = newCount;
}while (newCount != heapIndex);
array = newArray;
heap = newHeap;
if (isStaticUnmanaged)
{
unmanaged.FreeStatic(ref oldHeap);
}
else
{
unmanaged.Free(ref oldHeap);
}
}
public static void FreeStatic(ref pointer.size data)
{
if (data.data != null)
{
Interlocked.Add(ref staticSize, -data.sizeValue);
Marshal.FreeHGlobal((IntPtr)data.data);
data.Null();
}
}
public void Push(ref pointer.size buffer)
{
if (buffer.sizeValue == Size)
{
push(ref buffer.data);
}
else
{
unmanaged.Free(ref buffer);
}
}
/// <summary>
/// 数组模拟最小堆
/// </summary>
/// <param name="isStaticUnmanaged">是否固定内存申请</param>
internal arrayHeap(bool isStaticUnmanaged)
{
this.isStaticUnmanaged = isStaticUnmanaged;
array = new keyValue <keyType, valueType> [defaultArrayLength];
heap = isStaticUnmanaged ? unmanaged.GetStaticSize(defaultArrayLength * sizeof(int), false) : unmanaged.Get(defaultArrayLength * sizeof(int), false);
int *heapFixed = heap.Int;
for (int index = defaultArrayLength; index != 0; heapFixed[index] = index)
{
--index;
}
}
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
if (currentFreeIndex != null)
{
Monitor.Enter(poolLock);
pointer.size indexs = freeIndexs;
pool = nullValue <valueType> .Array;
poolIndex = 0;
currentFreeIndex = null;
endFreeIndex = null;
freeIndexs.Null();
Monitor.Exit(poolLock);
unmanaged.Free(ref indexs);
}
}
/// <summary>
/// 设置容器尺寸
/// </summary>
/// <param name="length">容器尺寸</param>
protected void setStreamLength(int length)
{
if (length < DefaultLength)
{
length = DefaultLength;
}
pointer.size newData = unmanaged.Get(length, false);
fastCSharp.unsafer.memory.Copy(data.data, newData.data, this.length);
if (IsUnmanaged)
{
unmanaged.Free(ref data);
}
data = newData;
IsUnmanaged = true;
}
/// <summary>
/// 清除缓冲区集合
/// </summary>
/// <param name="count">保留清除缓冲区数量</param>
private void clear(int count)
{
pointer.size pointerSize = new pointer.size();
foreach (pointer pointer in pool.GetClear(count, false))
{
try
{
pointerSize.Set(pointer.Data, Size);
unmanaged.Free(ref pointerSize);
}
catch (Exception error)
{
log.Error.Add(error, null, false);
}
}
}
/// <summary>
/// 静态哈希集合
/// </summary>
/// <param name="values">哈希数据集合</param>
public unsafe staticHashSet(valueType[] values)
{
if (values.length() != 0)
{
unmanagedPool pool = fastCSharp.unmanagedPool.GetDefaultPool(values.Length * sizeof(int));
pointer.size data = pool.Get(values.Length * sizeof(int));
try
{
getValues(values, data.Int);
}
finally { pool.Push(ref data); }
}
else
{
indexs = defaultIndexs;
array = nullValue <valueType> .Array;
}
}
/// <summary>
/// 非托管内存数据流
/// </summary>
/// <param name="length">容器初始尺寸</param>
protected unmanagedStreamBase(int length)
{
data = unmanaged.Get(length > 0 ? length : DefaultLength, false);
IsUnmanaged = true;
}
