public static void Init(Pool *self, int len)
{
#if FDB
Should.NotNull("self", self);
Should.GreaterThanZero("len", len);
self->type = Type;
#endif
self->len = len;
byte *arr = self->arr = (byte *)Mem.Malloc(len);
self->shift = 0;
// sentinel
int *head = (int *)arr;
head[0] = -1; // sentinelHead.prev = -1;
head[1] = HeadSize + TailSize; // sentinelhead.next = HeadSize + TailSize;
head[2] = 0; // sentinelHead.size = 0;
head[3] = -1; // sentinelTail.size = -1; // to prevent merging
// Fdb.Dump(arr, len);
// sentinel firstFree sentinel
int size = len - HeadSize - TailSize - HeadSize - TailSize - HeadSize;
SetFreeMeta((int *)(arr + HeadSize + TailSize), 0, -1, size);
// sentinel
head = (int *)(arr + len - HeadSize);
head[0] = -1; // prev = -1 will prevent merging
head[1] = -1;
head[2] = 0;
PtrLst.Init(&self->dependentLst);
#if FDB
Verify(self);
#endif
}
public static void QuickSort(void **arr, int len, Cmp cmp)
{
#if FDB
Should.NotNull("arr", arr);
Should.GreaterThanZero("len", len);
Should.NotNull("cmp", cmp);
#endif
QuickSort(arr, 0, len - 1, cmp);
}
public static int BinarySearch(void **arr, int len, void *val, Cmp cmp)
{
#if FDB
Should.NotNull("arr", arr);
Should.GreaterThanZero("len", len);
Should.NotNull("cmp", cmp);
#endif
return(BinarySearch(arr, 0, len - 1, val, cmp));
}
public static void MergeSort(void **arr, int len, Cmp cmp)
{
#if FDB
Should.NotNull("arr", arr);
Should.GreaterThanZero("len", len);
Should.NotNull("cmp", cmp);
#endif
void **temp = stackalloc void *[len];
MergeSort(arr, temp, 0, len - 1, cmp);
}
/**
* | -1 | -1 | size | data... | -1 |
* | size |
*/
static void SetUsedMeta(int *head, int size)
{
#if FDB
Should.NotNull("head", head);
Should.GreaterThanZero("size", size);
#endif
head[0] = -1; head[1] = -1; head[2] = size;
int *tail = (int *)((byte *)(head + 3) + size);
tail[0] = -1;
}
/**
* | prev | next | size | data... | size |
* | size |
*/
static void SetFreeMeta(int *head, int prev, int next, int size)
{
#if FDB
Should.NotNull("head", head);
Should.GreaterThanOrEqualTo("prev", prev, -1);
Should.GreaterThanOrEqualTo("next", next, -1);
Should.GreaterThanZero("size", size);
#endif
head[0] = prev; head[1] = next; head[2] = size;
int *tail = (int *)((byte *)(head + 3) + size);
tail[0] = size;
}
public static void Init(PtrLst *self, int len)
{
#if FDB
Should.NotNull("self", self);
Should.GreaterThanZero("len", len);
self->type = Type;
#endif
self->tag = Tag.PtrLst;
self->len = len;
self->count = 0;
int size = self->size = sizeof(void *);
self->arr = (void **)Mem.Malloc(len * size);
}
/**
* | 0 | firstFreeHead.next | size | data... | size |
* | size |
*/
static void SetFreeMetaAndInsert(byte *arr, int *head, int size)
{
#if FDB
Should.NotNull("arr", arr);
Should.NotNull("head", head);
Should.GreaterThanZero("size", size);
#endif
int *firstFreeHead = (int *)arr;
int firstFreeHeadNext;
head[0] = 0; firstFreeHeadNext = head[1] = firstFreeHead[1]; head[2] = size;
int pos = (int)((byte *)head - arr);
if (firstFreeHeadNext != -1)
{
*(int *)(arr + firstFreeHeadNext) = pos; // firstFreeHead.next.prev = head
}
firstFreeHead[1] = pos; // firstFreeHead.next = head
int *tail = (int *)((byte *)(head + 3) + size);
tail[0] = size;
}
public static void Verify(Pool *self)
{
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
Should.GreaterThanZero("self->len", self->len);
Should.Equal("self->HeadSize", HeadSize, 3 * sizeof(int));
Should.Equal("self->TailSize", TailSize, sizeof(int));
int len = Mem.Verify(self->arr);
Should.Equal("self->len", self->len, len);
// Fdb.Dump(self->arr, len);
byte *arr = self->arr;
int * head;
head = (int *)(arr + self->len - HeadSize);
Should.Equal("endHead->prev", head[0], -1); // head.prev = -1
Should.Equal("endHead->next", head[1], -1); // head.next = -1
Should.Equal("endHead->size", head[2], 0); // head.size = 0
head = (int *)arr;
Should.Equal("firstHead->prev", head[0], -1); // head.prev = -1
Should.Equal("firstHead->size", head[2], 0); // head.size = 0
Should.Equal("firstTail->size", head[3], -1); // tail.size = -1
int curFree = head[1], lastFree = 0;
var dict = new System.Collections.Generic.Dictionary <int, int>();
while (curFree != -1)
{
head = (int *)(arr + curFree);
Should.Equal("head" + curFree + "->prev", head[0], lastFree);
Should.Equal("tail->size", *(int *)((byte *)head + HeadSize + head[2]), head[2]);
dict.Add(curFree, head[2]);
lastFree = curFree;
curFree = head[1];
}
head = (int *)(arr + HeadSize + TailSize);
int *end = (int *)(arr + self->len);
while (head < end)
{
int pos = (int)((byte *)head - self->arr);
int prev = head[0], next = head[1], size = head[2];
int *tail = (int *)((byte *)head + HeadSize + size);
if (tail < end)
{
int tailVal = tail[0];
if (tailVal == -1) // in use
{
Should.False("dict.ContainsKey(pos)", dict.ContainsKey(pos));
Should.Equal("prev", prev, -1);
Should.Equal("next", next, -1);
Should.GreaterThanZero("size", size);
}
else // free
{
Should.True("dict.ContainsKey(pos)" + pos, dict.ContainsKey(pos));
Should.GreaterThanOrEqualTo("prev", prev, 0);
Should.GreaterThanOrEqualTo("next", next, -1);
Should.Equal("size", size, dict[pos]);
dict.Remove(pos);
}
}
else // head is end sentinel, no tail
{
Should.Equal("head", head, (int *)(arr + len - HeadSize));
Should.Equal("endHead->prev", head[0], -1); // head.prev = -1
Should.Equal("endHead->next", head[1], -1); // head.next = -1
Should.Equal("endHead->size", head[2], 0); // head.size = 0
}
head = (int *)((byte *)head + HeadSize + size + TailSize);
}
Should.Zero("dict.Count", dict.Count);
}
public static void *Alloc(Pool *self, int size)
{
if ((size & 0x3) != 0) // align to 4
{
size = (((size >> 2) + 1) << 2);
}
#if FDB
Verify(self);
Should.GreaterThanZero("size", size);
#endif
byte *arr = self->arr;
int *head;
int *freeHead;
int freeSize;
int curFree = 0;
while (curFree != -1) // foreach free block
{
head = (int *)(arr + curFree);
int blockSize = head[2];
if (blockSize >= size) // found a block that can fit
// | head | data... | tail |
// | blockSize |
// | head | data... | tail | freeHead | data... | tail |
// | size | | freeSize |
{
freeSize = blockSize - size - TailSize - HeadSize;
if (freeSize > 0) // split
{
freeHead = (int *)((byte *)head + HeadSize + size + TailSize);
SetFreeMetaAndInsert(arr, freeHead, freeSize);
MergeRight(arr, freeHead);
RemoveFromFreeList(arr, head);
SetUsedMeta(head, size);
}
else
{
RemoveFromFreeList(arr, head);
SetUsedMeta(head, blockSize);
}
#if FDB
Verify(self);
#endif
return(head + 3);
}
curFree = head[1];
}
// expand and split
// | data... | endHead |
// | data... | freeHead | data... | freeTail | head | data... | tail | endHead |
// | len |
// | oldLen | freeSize | | size |
int oldLen = self->len, len = oldLen, minLen = oldLen + HeadSize + size + TailSize + HeadSize + TailSize;
while (len < minLen)
{
len <<= 1;
}
self->len = len;
// Fdb.Log("{0:X}", (long)arr);
// Fdb.Log("len: {0}", Mem.Verify(arr));
byte *oldArr = arr;
arr = self->arr = (byte *)Mem.Realloc(arr, len);
long shift = self->shift = arr - oldArr;
if (shift != 0)
{
var dependentLst = &self->dependentLst;
void **dependentArr = dependentLst->arr;
for (int i = 0, dependentLen = dependentLst->count; i < dependentLen; i += 1)
{
PtrCollection.ShiftBase(dependentArr[i], shift);
}
}
// Fdb.Log("{0:X}", (long)arr);
// Fdb.Log("len: {0}", Mem.Verify(self->arr));
freeHead = (int *)(arr + oldLen - HeadSize);
freeSize = len - oldLen - TailSize - HeadSize - size - TailSize - HeadSize;
SetFreeMetaAndInsert(arr, freeHead, freeSize);
// Fdb.Dump(arr, len);
MergeLeft(arr, freeHead);
int *endHead = (int *)(arr + len - HeadSize);
endHead[0] = -1;
endHead[1] = -1;
endHead[2] = 0;
head = (int *)((byte *)freeHead + HeadSize + freeSize + TailSize);
SetUsedMeta(head, size);
#if FDB
Verify(self);
#endif
return(head + 3);
}
