Mempool and other Allocators Optimization
Optimizations of allocators. Renamed 'Stack' to 'Arena'. Replaced certain define constants with an anonymous enum. Refactored MemPool to no longer require active or deferred defragging.
This commit is contained in:
Kevin Yonan
GitHub
parent
3494a29603
commit
d075b30b15
662
src/rmem.h
662
src/rmem.h
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* rmem - raylib memory pool and objects pool
|
||||
*
|
||||
* A quick, efficient, and minimal free list and stack-based allocator
|
||||
* A quick, efficient, and minimal free list and arena-based allocator
|
||||
*
|
||||
* PURPOSE:
|
||||
* - A quicker, efficient memory allocator alternative to 'malloc' and friends.
|
||||
|
|
@ -55,6 +55,8 @@
|
|||
#define RMEMAPI // We are building or using library as a static library (or Linux shared library)
|
||||
#endif
|
||||
|
||||
#define RMEM_VERSION "v1.3" // changelog at bottom of header.
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Types and Structures Definition
|
||||
//----------------------------------------------------------------------------------
|
||||
|
|
@ -66,39 +68,45 @@ struct MemNode {
|
|||
MemNode *next, *prev;
|
||||
};
|
||||
|
||||
// Freelist implementation
|
||||
typedef struct AllocList {
|
||||
MemNode *head, *tail;
|
||||
size_t len, maxNodes;
|
||||
bool autoDefrag : 1;
|
||||
size_t len;
|
||||
} AllocList;
|
||||
|
||||
typedef struct Stack {
|
||||
uint8_t *mem, *base;
|
||||
// Arena allocator.
|
||||
typedef struct Arena {
|
||||
uintptr_t mem, offs;
|
||||
size_t size;
|
||||
} Stack;
|
||||
} Arena;
|
||||
|
||||
#define MEMPOOL_BUCKET_SIZE 8
|
||||
#define MEMPOOL_BUCKET_BITS 3
|
||||
|
||||
enum {
|
||||
MEMPOOL_BUCKET_SIZE = 8,
|
||||
MEMPOOL_BUCKET_BITS = (sizeof(uintptr_t) >> 1) + 1,
|
||||
MEM_SPLIT_THRESHOLD = sizeof(uintptr_t) * 4
|
||||
};
|
||||
|
||||
typedef struct MemPool {
|
||||
AllocList freeList;
|
||||
Stack stack;
|
||||
MemNode *buckets[MEMPOOL_BUCKET_SIZE];
|
||||
AllocList large, buckets[MEMPOOL_BUCKET_SIZE];
|
||||
Arena arena;
|
||||
} MemPool;
|
||||
|
||||
|
||||
// Object Pool
|
||||
typedef struct ObjPool {
|
||||
Stack stack;
|
||||
size_t objSize, freeBlocks;
|
||||
uintptr_t mem, offs;
|
||||
size_t objSize, freeBlocks, memSize;
|
||||
} ObjPool;
|
||||
|
||||
|
||||
// Double-Ended Stack aka Deque
|
||||
typedef struct BiStack {
|
||||
uint8_t *mem, *front, *back;
|
||||
uintptr_t mem, front, back;
|
||||
size_t size;
|
||||
} BiStack;
|
||||
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" { // Prevents name mangling of functions
|
||||
#endif
|
||||
|
|
@ -115,10 +123,7 @@ RMEMAPI void *MemPoolRealloc(MemPool *mempool, void *ptr, size_t bytes);
|
|||
RMEMAPI void MemPoolFree(MemPool *mempool, void *ptr);
|
||||
RMEMAPI void MemPoolCleanUp(MemPool *mempool, void **ptrref);
|
||||
RMEMAPI void MemPoolReset(MemPool *mempool);
|
||||
RMEMAPI bool MemPoolDefrag(MemPool *mempool);
|
||||
|
||||
RMEMAPI size_t GetMemPoolFreeMemory(const MemPool mempool);
|
||||
RMEMAPI void ToggleMemPoolAutoDefrag(MemPool *mempool);
|
||||
|
||||
//------------------------------------------------------------------------------------
|
||||
// Functions Declaration - Object Pool
|
||||
|
|
@ -161,7 +166,9 @@ RMEMAPI intptr_t BiStackMargins(BiStack destack);
|
|||
|
||||
#if defined(RMEM_IMPLEMENTATION)
|
||||
|
||||
#include <stdio.h> // Required for: malloc(), calloc(), free()
|
||||
#include <stdio.h> // Required for:
|
||||
#include <stdlib.h> // Required for:
|
||||
#include <string.h> // Required for:
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Defines and Macros
|
||||
|
|
@ -188,6 +195,145 @@ static inline size_t __AlignSize(const size_t size, const size_t align)
|
|||
return (size + (align - 1)) & -align;
|
||||
}
|
||||
|
||||
static MemNode *__SplitMemNode(MemNode *const node, const size_t bytes)
|
||||
{
|
||||
uintptr_t n = ( uintptr_t )node;
|
||||
MemNode *const r = ( MemNode* )(n + (node->size - bytes));
|
||||
node->size -= bytes;
|
||||
r->size = bytes;
|
||||
return r;
|
||||
}
|
||||
|
||||
static void __InsertMemNodeBefore(AllocList *const list, MemNode *const insert, MemNode *const curr)
|
||||
{
|
||||
insert->next = curr;
|
||||
if (curr->prev==NULL) list->head = insert;
|
||||
else
|
||||
{
|
||||
insert->prev = curr->prev;
|
||||
curr->prev->next = insert;
|
||||
}
|
||||
curr->prev = insert;
|
||||
}
|
||||
|
||||
static void __ReplaceMemNode(MemNode *const old, MemNode *const replace)
|
||||
{
|
||||
replace->prev = old->prev;
|
||||
replace->next = old->next;
|
||||
if( old->prev != NULL )
|
||||
old->prev->next = replace;
|
||||
if( old->next != NULL )
|
||||
old->next->prev = replace;
|
||||
}
|
||||
|
||||
|
||||
static MemNode *__RemoveMemNode(AllocList *const list, MemNode *const node)
|
||||
{
|
||||
if (node->prev != NULL) node->prev->next = node->next;
|
||||
else
|
||||
{
|
||||
list->head = node->next;
|
||||
if (list->head != NULL) list->head->prev = NULL;
|
||||
else list->tail = NULL;
|
||||
}
|
||||
|
||||
if (node->next != NULL) node->next->prev = node->prev;
|
||||
else
|
||||
{
|
||||
list->tail = node->prev;
|
||||
if (list->tail != NULL) list->tail->next = NULL;
|
||||
else list->head = NULL;
|
||||
}
|
||||
list->len--;
|
||||
return node;
|
||||
}
|
||||
|
||||
static MemNode *__FindMemNode(AllocList *const list, const size_t bytes)
|
||||
{
|
||||
for (MemNode *node = list->head; node != NULL; node = node->next)
|
||||
{
|
||||
if (node->size < bytes) continue;
|
||||
// close in size - reduce fragmentation by not splitting.
|
||||
else if (node->size <= bytes + MEM_SPLIT_THRESHOLD) return __RemoveMemNode(list, node);
|
||||
else return __SplitMemNode(node, bytes);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void __InsertMemNode(MemPool *const mempool, AllocList *const list, MemNode *const node, const bool is_bucket)
|
||||
{
|
||||
if (list->head == NULL)
|
||||
{
|
||||
list->head = node;
|
||||
list->len++;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (MemNode *iter = list->head; iter != NULL; iter = iter->next)
|
||||
{
|
||||
if (( uintptr_t )iter == mempool->arena.offs)
|
||||
{
|
||||
mempool->arena.offs += iter->size;
|
||||
__RemoveMemNode(list, iter);
|
||||
iter = list->head;
|
||||
}
|
||||
const uintptr_t inode = ( uintptr_t )node;
|
||||
const uintptr_t iiter = ( uintptr_t )iter;
|
||||
const uintptr_t iter_end = iiter + iter->size;
|
||||
const uintptr_t node_end = inode + node->size;
|
||||
if (iter==node) return;
|
||||
else if (iter < node)
|
||||
{
|
||||
// node was coalesced prior.
|
||||
if (iter_end > inode) return;
|
||||
else if (iter_end==inode && !is_bucket)
|
||||
{
|
||||
// if we can coalesce, do so.
|
||||
iter->size += node->size;
|
||||
return;
|
||||
}
|
||||
}
|
||||
else if (iter > node)
|
||||
{
|
||||
// Address sort, lowest to highest aka ascending order.
|
||||
if (iiter < node_end) return;
|
||||
else if (iter==list->head && !is_bucket)
|
||||
{
|
||||
if (iter_end==inode) iter->size += node->size;
|
||||
else if (node_end==iiter)
|
||||
{
|
||||
node->size += list->head->size;
|
||||
node->next = list->head->next;
|
||||
node->prev = NULL;
|
||||
list->head = node;
|
||||
}
|
||||
else
|
||||
{
|
||||
node->next = iter;
|
||||
node->prev = NULL;
|
||||
iter->prev = node;
|
||||
list->head = node;
|
||||
list->len++;
|
||||
}
|
||||
return;
|
||||
}
|
||||
else if (iter_end==inode && !is_bucket)
|
||||
{
|
||||
// if we can coalesce, do so.
|
||||
iter->size += node->size;
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
__InsertMemNodeBefore(list, iter, node);
|
||||
list->len++;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Module Functions Definition - Memory Pool
|
||||
//----------------------------------------------------------------------------------
|
||||
|
|
@ -196,114 +342,77 @@ MemPool CreateMemPool(const size_t size)
|
|||
{
|
||||
MemPool mempool = { 0 };
|
||||
|
||||
if (size == 0UL) return mempool;
|
||||
if (size == 0) return mempool;
|
||||
else
|
||||
{
|
||||
// Align the mempool size to at least the size of an alloc node.
|
||||
mempool.stack.size = size;
|
||||
mempool.stack.mem = malloc(mempool.stack.size*sizeof *mempool.stack.mem);
|
||||
|
||||
if (mempool.stack.mem == NULL)
|
||||
{
|
||||
mempool.stack.size = 0UL;
|
||||
return mempool;
|
||||
}
|
||||
uint8_t *const restrict buf = malloc(size*sizeof *buf);
|
||||
if (buf==NULL) return mempool;
|
||||
else
|
||||
{
|
||||
mempool.stack.base = mempool.stack.mem + mempool.stack.size;
|
||||
mempool.arena.size = size;
|
||||
mempool.arena.mem = ( uintptr_t )buf;
|
||||
mempool.arena.offs = mempool.arena.mem + mempool.arena.size;
|
||||
return mempool;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
MemPool CreateMemPoolFromBuffer(void *buf, const size_t size)
|
||||
MemPool CreateMemPoolFromBuffer(void *const restrict buf, const size_t size)
|
||||
{
|
||||
MemPool mempool = { 0 };
|
||||
|
||||
if ((size == 0UL) || (buf == NULL) || (size <= sizeof(MemNode))) return mempool;
|
||||
if ((size == 0) || (buf == NULL) || (size <= sizeof(MemNode))) return mempool;
|
||||
else
|
||||
{
|
||||
mempool.stack.size = size;
|
||||
mempool.stack.mem = buf;
|
||||
mempool.stack.base = mempool.stack.mem + mempool.stack.size;
|
||||
mempool.arena.size = size;
|
||||
mempool.arena.mem = ( uintptr_t )buf;
|
||||
mempool.arena.offs = mempool.arena.mem + mempool.arena.size;
|
||||
return mempool;
|
||||
}
|
||||
}
|
||||
|
||||
void DestroyMemPool(MemPool *const mempool)
|
||||
void DestroyMemPool(MemPool *const restrict mempool)
|
||||
{
|
||||
if ((mempool == NULL) || (mempool->stack.mem == NULL)) return;
|
||||
if (mempool->arena.mem == 0) return;
|
||||
else
|
||||
{
|
||||
free(mempool->stack.mem);
|
||||
void *const restrict ptr = ( void* )mempool->arena.mem;
|
||||
free(ptr);
|
||||
*mempool = (MemPool){ 0 };
|
||||
}
|
||||
}
|
||||
|
||||
void *MemPoolAlloc(MemPool *const mempool, const size_t size)
|
||||
{
|
||||
if ((mempool == NULL) || (size == 0UL) || (size > mempool->stack.size)) return NULL;
|
||||
if ((size == 0) || (size > mempool->arena.size)) return NULL;
|
||||
else
|
||||
{
|
||||
MemNode *new_mem = NULL;
|
||||
const size_t ALLOC_SIZE = __AlignSize(size + sizeof *new_mem, sizeof(intptr_t));
|
||||
const size_t BUCKET_INDEX = (ALLOC_SIZE >> MEMPOOL_BUCKET_BITS) - 1;
|
||||
const size_t BUCKET_SLOT = (ALLOC_SIZE >> MEMPOOL_BUCKET_BITS) - 1;
|
||||
|
||||
// If the size is small enough, let's check if our buckets has a fitting memory block.
|
||||
if ((BUCKET_INDEX < MEMPOOL_BUCKET_SIZE) &&
|
||||
(mempool->buckets[BUCKET_INDEX] != NULL) &&
|
||||
(mempool->buckets[BUCKET_INDEX]->size >= ALLOC_SIZE))
|
||||
if (BUCKET_SLOT < MEMPOOL_BUCKET_SIZE)
|
||||
{
|
||||
new_mem = mempool->buckets[BUCKET_INDEX];
|
||||
mempool->buckets[BUCKET_INDEX] = mempool->buckets[BUCKET_INDEX]->next;
|
||||
if( mempool->buckets[BUCKET_INDEX] != NULL )
|
||||
mempool->buckets[BUCKET_INDEX]->prev = NULL;
|
||||
new_mem = __FindMemNode(&mempool->buckets[BUCKET_SLOT], ALLOC_SIZE);
|
||||
}
|
||||
else if (mempool->freeList.head != NULL)
|
||||
else if (mempool->large.head != NULL)
|
||||
{
|
||||
const size_t MEM_SPLIT_THRESHOLD = 16;
|
||||
|
||||
// If the freelist is valid, let's allocate FROM the freelist then!
|
||||
for (MemNode *inode = mempool->freeList.head; inode != NULL; inode = inode->next)
|
||||
{
|
||||
if (inode->size < ALLOC_SIZE) continue;
|
||||
else if (inode->size <= (ALLOC_SIZE + MEM_SPLIT_THRESHOLD))
|
||||
{
|
||||
// Close in size - reduce fragmentation by not splitting.
|
||||
new_mem = inode;
|
||||
(inode->prev != NULL)? (inode->prev->next = inode->next) : (mempool->freeList.head = inode->next);
|
||||
(inode->next != NULL)? (inode->next->prev = inode->prev) : (mempool->freeList.tail = inode->prev);
|
||||
|
||||
if (mempool->freeList.head != NULL) mempool->freeList.head->prev = NULL;
|
||||
else mempool->freeList.tail = NULL;
|
||||
|
||||
if (mempool->freeList.tail != NULL) mempool->freeList.tail->next = NULL;
|
||||
mempool->freeList.len--;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Split the memory chunk.
|
||||
new_mem = (MemNode *)((uint8_t *)inode + (inode->size - ALLOC_SIZE));
|
||||
inode->size -= ALLOC_SIZE;
|
||||
new_mem->size = ALLOC_SIZE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
new_mem = __FindMemNode(&mempool->large, ALLOC_SIZE);
|
||||
}
|
||||
|
||||
if (new_mem == NULL)
|
||||
{
|
||||
// not enough memory to support the size!
|
||||
if ((mempool->stack.base - ALLOC_SIZE) < mempool->stack.mem) return NULL;
|
||||
if ((mempool->arena.offs - ALLOC_SIZE) < mempool->arena.mem) return NULL;
|
||||
else
|
||||
{
|
||||
// Couldn't allocate from a freelist, allocate from available mempool.
|
||||
// Subtract allocation size from the mempool.
|
||||
mempool->stack.base -= ALLOC_SIZE;
|
||||
mempool->arena.offs -= ALLOC_SIZE;
|
||||
|
||||
// Use the available mempool space as the new node.
|
||||
new_mem = (MemNode *)mempool->stack.base;
|
||||
new_mem = ( MemNode* )mempool->arena.offs;
|
||||
new_mem->size = ALLOC_SIZE;
|
||||
}
|
||||
}
|
||||
|
|
@ -313,29 +422,28 @@ void *MemPoolAlloc(MemPool *const mempool, const size_t size)
|
|||
// | mem size | lowest addr of block
|
||||
// | next node | 12 byte (32-bit) header
|
||||
// | prev node | 24 byte (64-bit) header
|
||||
// --------------
|
||||
// |------------|
|
||||
// | alloc'd |
|
||||
// | memory |
|
||||
// | space | highest addr of block
|
||||
// --------------
|
||||
new_mem->next = new_mem->prev = NULL;
|
||||
uint8_t *const final_mem = (uint8_t *)new_mem + sizeof *new_mem;
|
||||
uint8_t *const restrict final_mem = ( uint8_t* )new_mem + sizeof *new_mem;
|
||||
return memset(final_mem, 0, new_mem->size - sizeof *new_mem);
|
||||
}
|
||||
}
|
||||
|
||||
void *MemPoolRealloc(MemPool *const restrict mempool, void *ptr, const size_t size)
|
||||
void *MemPoolRealloc(MemPool *const restrict mempool, void *const ptr, const size_t size)
|
||||
{
|
||||
if ((mempool == NULL) || (size > mempool->stack.size)) return NULL;
|
||||
if (size > mempool->arena.size) return NULL;
|
||||
// NULL ptr should make this work like regular Allocation.
|
||||
else if (ptr == NULL) return MemPoolAlloc(mempool, size);
|
||||
else if ((uintptr_t)ptr - sizeof(MemNode) < (uintptr_t)mempool->stack.mem) return NULL;
|
||||
else if ((uintptr_t)ptr - sizeof(MemNode) < mempool->arena.mem) return NULL;
|
||||
else
|
||||
{
|
||||
MemNode *const node = ( MemNode* )(( uint8_t* )ptr - sizeof *node);
|
||||
const size_t NODE_SIZE = sizeof *node;
|
||||
uint8_t *const resized_block = MemPoolAlloc(mempool, size);
|
||||
|
||||
if (resized_block == NULL) return NULL;
|
||||
else
|
||||
{
|
||||
|
|
@ -347,72 +455,39 @@ void *MemPoolRealloc(MemPool *const restrict mempool, void *ptr, const size_t si
|
|||
}
|
||||
}
|
||||
|
||||
void MemPoolFree(MemPool *const restrict mempool, void *ptr)
|
||||
void MemPoolFree(MemPool *const restrict mempool, void *const ptr)
|
||||
{
|
||||
if ((mempool == NULL) || (ptr == NULL) || ((uintptr_t)ptr - sizeof(MemNode) < (uintptr_t)mempool->stack.mem)) return;
|
||||
const uintptr_t p = ( uintptr_t )ptr;
|
||||
if ((ptr == NULL) || (p - sizeof(MemNode) < mempool->arena.mem)) return;
|
||||
else
|
||||
{
|
||||
// Behind the actual pointer data is the allocation info.
|
||||
MemNode *const mem_node = (MemNode *)((uint8_t *)ptr - sizeof *mem_node);
|
||||
const size_t BUCKET_INDEX = (mem_node->size >> MEMPOOL_BUCKET_BITS) - 1;
|
||||
const uintptr_t block = p - sizeof(MemNode);
|
||||
MemNode *const mem_node = ( MemNode* )block;
|
||||
const size_t BUCKET_SLOT = (mem_node->size >> MEMPOOL_BUCKET_BITS) - 1;
|
||||
|
||||
// Make sure the pointer data is valid.
|
||||
if (((uintptr_t)mem_node < (uintptr_t)mempool->stack.base) ||
|
||||
(((uintptr_t)mem_node - (uintptr_t)mempool->stack.mem) > mempool->stack.size) ||
|
||||
(mem_node->size == 0UL) ||
|
||||
(mem_node->size > mempool->stack.size)) return;
|
||||
// If the mem_node is right at the stack base ptr, then add it to the stack.
|
||||
else if ((uintptr_t)mem_node == (uintptr_t)mempool->stack.base)
|
||||
if ((block < mempool->arena.offs) ||
|
||||
((block - mempool->arena.mem) > mempool->arena.size) ||
|
||||
(mem_node->size == 0) ||
|
||||
(mem_node->size > mempool->arena.size)) return;
|
||||
// If the mem_node is right at the arena offs, then merge it back to the arena.
|
||||
else if (block == mempool->arena.offs)
|
||||
{
|
||||
mempool->stack.base += mem_node->size;
|
||||
mempool->arena.offs += mem_node->size;
|
||||
}
|
||||
// attempted stack merge failed, try to place it into the memnode buckets
|
||||
else if (BUCKET_INDEX < MEMPOOL_BUCKET_SIZE)
|
||||
{
|
||||
if (mempool->buckets[BUCKET_INDEX] == NULL) mempool->buckets[BUCKET_INDEX] = mem_node;
|
||||
else
|
||||
{
|
||||
for (MemNode *n = mempool->buckets[BUCKET_INDEX]; n != NULL; n = n->next) if( n==mem_node ) return;
|
||||
mempool->buckets[BUCKET_INDEX]->prev = mem_node;
|
||||
mem_node->next = mempool->buckets[BUCKET_INDEX];
|
||||
mempool->buckets[BUCKET_INDEX] = mem_node;
|
||||
}
|
||||
}
|
||||
// Otherwise, we add it to the free list.
|
||||
// We also check if the freelist already has the pointer so we can prevent double frees.
|
||||
else /*if ((mempool->freeList.len == 0UL) || ((uintptr_t)mempool->freeList.head >= (uintptr_t)mempool->stack.mem && (uintptr_t)mempool->freeList.head - (uintptr_t)mempool->stack.mem < mempool->stack.size))*/
|
||||
{
|
||||
for (MemNode *n = mempool->freeList.head; n != NULL; n = n->next) if (n == mem_node) return;
|
||||
|
||||
// This code insertion sorts where largest size is last.
|
||||
if (mempool->freeList.head == NULL)
|
||||
{
|
||||
mempool->freeList.head = mempool->freeList.tail = mem_node;
|
||||
mempool->freeList.len++;
|
||||
}
|
||||
else if (mempool->freeList.head->size >= mem_node->size)
|
||||
{
|
||||
mem_node->next = mempool->freeList.head;
|
||||
mem_node->next->prev = mem_node;
|
||||
mempool->freeList.head = mem_node;
|
||||
mempool->freeList.len++;
|
||||
}
|
||||
else //if (mempool->freeList.tail->size <= mem_node->size)
|
||||
{
|
||||
mem_node->prev = mempool->freeList.tail;
|
||||
mempool->freeList.tail->next = mem_node;
|
||||
mempool->freeList.tail = mem_node;
|
||||
mempool->freeList.len++;
|
||||
}
|
||||
|
||||
if (mempool->freeList.autoDefrag && (mempool->freeList.maxNodes != 0UL) && (mempool->freeList.len > mempool->freeList.maxNodes)) MemPoolDefrag(mempool);
|
||||
// try to place it into bucket or large freelist.
|
||||
struct AllocList *const l = (BUCKET_SLOT < MEMPOOL_BUCKET_SIZE) ? &mempool->buckets[BUCKET_SLOT] : &mempool->large;
|
||||
__InsertMemNode(mempool, l, mem_node, (BUCKET_SLOT < MEMPOOL_BUCKET_SIZE));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MemPoolCleanUp(MemPool *const restrict mempool, void **ptrref)
|
||||
void MemPoolCleanUp(MemPool *const restrict mempool, void **const ptrref)
|
||||
{
|
||||
if ((mempool == NULL) || (ptrref == NULL) || (*ptrref == NULL)) return;
|
||||
if ((ptrref == NULL) || (*ptrref == NULL)) return;
|
||||
else
|
||||
{
|
||||
MemPoolFree(mempool, *ptrref);
|
||||
|
|
@ -422,264 +497,127 @@ void MemPoolCleanUp(MemPool *const restrict mempool, void **ptrref)
|
|||
|
||||
size_t GetMemPoolFreeMemory(const MemPool mempool)
|
||||
{
|
||||
size_t total_remaining = (uintptr_t)mempool.stack.base - (uintptr_t)mempool.stack.mem;
|
||||
size_t total_remaining = mempool.arena.offs - mempool.arena.mem;
|
||||
|
||||
for (MemNode *n = mempool.freeList.head; n != NULL; n = n->next) total_remaining += n->size;
|
||||
for (MemNode *n=mempool.large.head; n != NULL; n = n->next) total_remaining += n->size;
|
||||
|
||||
for (int i = 0; i < MEMPOOL_BUCKET_SIZE; i++) for (MemNode *n = mempool.buckets[i]; n != NULL; n = n->next) total_remaining += n->size;
|
||||
for (size_t i=0; i<MEMPOOL_BUCKET_SIZE; i++) for (MemNode *n = mempool.buckets[i].head; n != NULL; n = n->next) total_remaining += n->size;
|
||||
|
||||
return total_remaining;
|
||||
}
|
||||
|
||||
void MemPoolReset(MemPool *const mempool)
|
||||
{
|
||||
if (mempool == NULL) return;
|
||||
mempool->freeList.head = mempool->freeList.tail = NULL;
|
||||
mempool->freeList.len = 0;
|
||||
for (int i = 0; i < MEMPOOL_BUCKET_SIZE; i++) mempool->buckets[i] = NULL;
|
||||
mempool->stack.base = mempool->stack.mem + mempool->stack.size;
|
||||
}
|
||||
|
||||
bool MemPoolDefrag(MemPool *const mempool)
|
||||
mempool->large.head = mempool->large.tail = NULL;
|
||||
mempool->large.len = 0;
|
||||
for (size_t i = 0; i < MEMPOOL_BUCKET_SIZE; i++)
|
||||
{
|
||||
if (mempool == NULL) return false;
|
||||
else
|
||||
{
|
||||
// If the memory pool has been entirely released, fully defrag it.
|
||||
if (mempool->stack.size == GetMemPoolFreeMemory(*mempool))
|
||||
{
|
||||
MemPoolReset(mempool);
|
||||
return true;
|
||||
mempool->buckets[i].head = mempool->buckets[i].tail = NULL;
|
||||
mempool->buckets[i].len = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int i = 0; i < MEMPOOL_BUCKET_SIZE; i++)
|
||||
{
|
||||
while (mempool->buckets[i] != NULL)
|
||||
{
|
||||
if ((uintptr_t)mempool->buckets[i] == (uintptr_t)mempool->stack.base)
|
||||
{
|
||||
mempool->stack.base += mempool->buckets[i]->size;
|
||||
mempool->buckets[i]->size = 0;
|
||||
mempool->buckets[i] = mempool->buckets[i]->next;
|
||||
if (mempool->buckets[i] != NULL) mempool->buckets[i]->prev = NULL;
|
||||
}
|
||||
else break;
|
||||
}
|
||||
}
|
||||
|
||||
const size_t PRE_DEFRAG_LEN = mempool->freeList.len;
|
||||
MemNode **node = &mempool->freeList.head;
|
||||
|
||||
while (*node != NULL)
|
||||
{
|
||||
if ((uintptr_t)*node == (uintptr_t)mempool->stack.base)
|
||||
{
|
||||
// If node is right at the stack, merge it back into the stack.
|
||||
mempool->stack.base += (*node)->size;
|
||||
(*node)->size = 0UL;
|
||||
((*node)->prev != NULL)? ((*node)->prev->next = (*node)->next) : (mempool->freeList.head = (*node)->next);
|
||||
((*node)->next != NULL)? ((*node)->next->prev = (*node)->prev) : (mempool->freeList.tail = (*node)->prev);
|
||||
|
||||
if (mempool->freeList.head != NULL) mempool->freeList.head->prev = NULL;
|
||||
else mempool->freeList.tail = NULL;
|
||||
|
||||
if (mempool->freeList.tail != NULL) mempool->freeList.tail->next = NULL;
|
||||
mempool->freeList.len--;
|
||||
node = &mempool->freeList.head;
|
||||
}
|
||||
else if (((uintptr_t)*node + (*node)->size) == (uintptr_t)(*node)->next)
|
||||
{
|
||||
// Next node is at a higher address.
|
||||
(*node)->size += (*node)->next->size;
|
||||
(*node)->next->size = 0UL;
|
||||
|
||||
// <-[P Curr N]-> <-[P Next N]-> <-[P NextNext N]->
|
||||
//
|
||||
// |--------------------|
|
||||
// <-[P Curr N]-> <-[P Next N]-> [P NextNext N]->
|
||||
if ((*node)->next->next != NULL) (*node)->next->next->prev = *node;
|
||||
|
||||
// <-[P Curr N]-> <-[P NextNext N]->
|
||||
(*node)->next = (*node)->next->next;
|
||||
|
||||
mempool->freeList.len--;
|
||||
node = &mempool->freeList.head;
|
||||
}
|
||||
else if ((((uintptr_t)*node + (*node)->size) == (uintptr_t)(*node)->prev) && ((*node)->prev->prev != NULL))
|
||||
{
|
||||
// Prev node is at a higher address.
|
||||
(*node)->size += (*node)->prev->size;
|
||||
(*node)->prev->size = 0UL;
|
||||
|
||||
// <-[P PrevPrev N]-> <-[P Prev N]-> <-[P Curr N]->
|
||||
//
|
||||
// |--------------------|
|
||||
// <-[P PrevPrev N] <-[P Prev N]-> <-[P Curr N]->
|
||||
(*node)->prev->prev->next = *node;
|
||||
|
||||
// <-[P PrevPrev N]-> <-[P Curr N]->
|
||||
(*node)->prev = (*node)->prev->prev;
|
||||
|
||||
mempool->freeList.len--;
|
||||
node = &mempool->freeList.head;
|
||||
}
|
||||
else if ((*node)->prev != NULL && (*node)->next != NULL && (uintptr_t)*node - (*node)->next->size == (uintptr_t)(*node)->next)
|
||||
{
|
||||
// Next node is at a lower address.
|
||||
(*node)->next->size += (*node)->size;
|
||||
|
||||
(*node)->size = 0UL;
|
||||
(*node)->next->prev = (*node)->prev;
|
||||
(*node)->prev->next = (*node)->next;
|
||||
*node = (*node)->next;
|
||||
|
||||
mempool->freeList.len--;
|
||||
node = &mempool->freeList.head;
|
||||
}
|
||||
else if ((*node)->prev != NULL && (*node)->next != NULL && (uintptr_t)*node - (*node)->prev->size == (uintptr_t)(*node)->prev)
|
||||
{
|
||||
// Prev node is at a lower address.
|
||||
(*node)->prev->size += (*node)->size;
|
||||
|
||||
(*node)->size = 0UL;
|
||||
(*node)->next->prev = (*node)->prev;
|
||||
(*node)->prev->next = (*node)->next;
|
||||
*node = (*node)->prev;
|
||||
|
||||
mempool->freeList.len--;
|
||||
node = &mempool->freeList.head;
|
||||
}
|
||||
else
|
||||
{
|
||||
node = &(*node)->next;
|
||||
}
|
||||
}
|
||||
|
||||
return PRE_DEFRAG_LEN > mempool->freeList.len;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ToggleMemPoolAutoDefrag(MemPool *const mempool)
|
||||
{
|
||||
if (mempool == NULL) return;
|
||||
else mempool->freeList.autoDefrag ^= true;
|
||||
mempool->arena.offs = mempool->arena.mem + mempool->arena.size;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Module Functions Definition - Object Pool
|
||||
//----------------------------------------------------------------------------------
|
||||
union ObjInfo {
|
||||
uint8_t *const byte;
|
||||
size_t *const index;
|
||||
};
|
||||
|
||||
ObjPool CreateObjPool(const size_t objsize, const size_t len)
|
||||
{
|
||||
ObjPool objpool = { 0 };
|
||||
|
||||
if ((len == 0UL) || (objsize == 0UL)) return objpool;
|
||||
if ((len == 0) || (objsize == 0)) return objpool;
|
||||
else
|
||||
{
|
||||
objpool.objSize = __AlignSize(objsize, sizeof(size_t));
|
||||
objpool.stack.size = objpool.freeBlocks = len;
|
||||
objpool.stack.mem = calloc(objpool.stack.size, objpool.objSize);
|
||||
const size_t aligned_size = __AlignSize(objsize, sizeof(size_t));
|
||||
uint8_t *const restrict buf = calloc(len, aligned_size);
|
||||
if (buf == NULL) return objpool;
|
||||
objpool.objSize = aligned_size;
|
||||
objpool.memSize = objpool.freeBlocks = len;
|
||||
objpool.mem = ( uintptr_t )buf;
|
||||
|
||||
if (objpool.stack.mem == NULL)
|
||||
for (size_t i=0; i<objpool.freeBlocks; i++)
|
||||
{
|
||||
objpool.stack.size = 0UL;
|
||||
return objpool;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int i = 0; i < objpool.freeBlocks; i++)
|
||||
{
|
||||
union ObjInfo block = { .byte = &objpool.stack.mem[i*objpool.objSize] };
|
||||
*block.index = i + 1;
|
||||
size_t *const restrict index = ( size_t* )(objpool.mem + (i*aligned_size));
|
||||
*index = i + 1;
|
||||
}
|
||||
|
||||
objpool.stack.base = objpool.stack.mem;
|
||||
objpool.offs = objpool.mem;
|
||||
return objpool;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ObjPool CreateObjPoolFromBuffer(void *const buf, const size_t objsize, const size_t len)
|
||||
ObjPool CreateObjPoolFromBuffer(void *const restrict buf, const size_t objsize, const size_t len)
|
||||
{
|
||||
ObjPool objpool = { 0 };
|
||||
|
||||
// If the object size isn't large enough to align to a size_t, then we can't use it.
|
||||
if ((buf == NULL) || (len == 0UL) || (objsize < sizeof(size_t)) || (objsize*len != __AlignSize(objsize, sizeof(size_t))*len)) return objpool;
|
||||
const size_t aligned_size = __AlignSize(objsize, sizeof(size_t));
|
||||
if ((buf == NULL) || (len == 0) || (objsize < sizeof(size_t)) || (objsize*len != aligned_size*len)) return objpool;
|
||||
else
|
||||
{
|
||||
objpool.objSize = __AlignSize(objsize, sizeof(size_t));
|
||||
objpool.stack.size = objpool.freeBlocks = len;
|
||||
objpool.stack.mem = buf;
|
||||
objpool.objSize = aligned_size;
|
||||
objpool.memSize = objpool.freeBlocks = len;
|
||||
objpool.mem = (uintptr_t)buf;
|
||||
|
||||
for (int i = 0; i < objpool.freeBlocks; i++)
|
||||
for (size_t i=0; i<objpool.freeBlocks; i++)
|
||||
{
|
||||
union ObjInfo block = { .byte = &objpool.stack.mem[i*objpool.objSize] };
|
||||
*block.index = i + 1;
|
||||
size_t *const restrict index = ( size_t* )(objpool.mem + (i*aligned_size));
|
||||
*index = i + 1;
|
||||
}
|
||||
|
||||
objpool.stack.base = objpool.stack.mem;
|
||||
objpool.offs = objpool.mem;
|
||||
return objpool;
|
||||
}
|
||||
}
|
||||
|
||||
void DestroyObjPool(ObjPool *const objpool)
|
||||
void DestroyObjPool(ObjPool *const restrict objpool)
|
||||
{
|
||||
if ((objpool == NULL) || (objpool->stack.mem == NULL)) return;
|
||||
if (objpool->mem == 0) return;
|
||||
else
|
||||
{
|
||||
free(objpool->stack.mem);
|
||||
void *const restrict ptr = ( void* )objpool->mem;
|
||||
free(ptr);
|
||||
*objpool = (ObjPool){0};
|
||||
}
|
||||
}
|
||||
|
||||
void *ObjPoolAlloc(ObjPool *const objpool)
|
||||
{
|
||||
if (objpool == NULL) return NULL;
|
||||
else
|
||||
{
|
||||
if (objpool->freeBlocks > 0UL)
|
||||
if (objpool->freeBlocks > 0)
|
||||
{
|
||||
// For first allocation, head points to the very first index.
|
||||
// Head = &pool[0];
|
||||
// ret = Head == ret = &pool[0];
|
||||
union ObjInfo ret = { .byte = objpool->stack.base };
|
||||
size_t *const restrict block = ( size_t* )objpool->offs;
|
||||
objpool->freeBlocks--;
|
||||
|
||||
// after allocating, we set head to the address of the index that *Head holds.
|
||||
// Head = &pool[*Head * pool.objsize];
|
||||
objpool->stack.base = (objpool->freeBlocks != 0UL)? objpool->stack.mem + (*ret.index*objpool->objSize) : NULL;
|
||||
memset(ret.byte, 0, objpool->objSize);
|
||||
|
||||
return ret.byte;
|
||||
objpool->offs = (objpool->freeBlocks != 0)? objpool->mem + (*block*objpool->objSize) : 0;
|
||||
return memset(block, 0, objpool->objSize);
|
||||
}
|
||||
else return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void ObjPoolFree(ObjPool *const restrict objpool, void *ptr)
|
||||
void ObjPoolFree(ObjPool *const restrict objpool, void *const ptr)
|
||||
{
|
||||
union ObjInfo p = { .byte = ptr };
|
||||
if ((objpool == NULL) || (ptr == NULL) || (p.byte < objpool->stack.mem) || (p.byte > objpool->stack.mem + objpool->stack.size*objpool->objSize)) return;
|
||||
uintptr_t block = (uintptr_t)ptr;
|
||||
if ((ptr == NULL) || (block < objpool->mem) || (block > objpool->mem + objpool->memSize*objpool->objSize)) return;
|
||||
else
|
||||
{
|
||||
// When we free our pointer, we recycle the pointer space to store the previous index and then we push it as our new head.
|
||||
// *p = index of Head in relation to the buffer;
|
||||
// Head = p;
|
||||
*p.index = (objpool->stack.base != NULL)? (objpool->stack.base - objpool->stack.mem)/objpool->objSize : objpool->stack.size;
|
||||
objpool->stack.base = p.byte;
|
||||
size_t *const restrict index = ( size_t* )block;
|
||||
*index = (objpool->offs != 0)? (objpool->offs - objpool->mem)/objpool->objSize : objpool->memSize;
|
||||
objpool->offs = block;
|
||||
objpool->freeBlocks++;
|
||||
}
|
||||
}
|
||||
|
||||
void ObjPoolCleanUp(ObjPool *const restrict objpool, void **ptrref)
|
||||
void ObjPoolCleanUp(ObjPool *const restrict objpool, void **const restrict ptrref)
|
||||
{
|
||||
if ((objpool == NULL) || (ptrref == NULL) || (*ptrref == NULL)) return;
|
||||
if (ptrref == NULL) return;
|
||||
else
|
||||
{
|
||||
ObjPoolFree(objpool, *ptrref);
|
||||
|
|
@ -694,71 +632,85 @@ void ObjPoolCleanUp(ObjPool *const restrict objpool, void **ptrref)
|
|||
BiStack CreateBiStack(const size_t len)
|
||||
{
|
||||
BiStack destack = { 0 };
|
||||
if (len == 0UL) return destack;
|
||||
if (len == 0) return destack;
|
||||
|
||||
uint8_t *const buf = malloc(len*sizeof *buf);
|
||||
if (buf==NULL) return destack;
|
||||
destack.size = len;
|
||||
destack.mem = malloc(len*sizeof *destack.mem);
|
||||
if (destack.mem==NULL) destack.size = 0UL;
|
||||
else
|
||||
{
|
||||
destack.mem = ( uintptr_t )buf;
|
||||
destack.front = destack.mem;
|
||||
destack.back = destack.mem + len;
|
||||
}
|
||||
return destack;
|
||||
}
|
||||
|
||||
BiStack CreateBiStackFromBuffer(void *const buf, const size_t len)
|
||||
{
|
||||
BiStack destack = { 0 };
|
||||
if (len == 0UL || buf == NULL) return destack;
|
||||
if (len == 0 || buf == NULL) return destack;
|
||||
else
|
||||
{
|
||||
destack.size = len;
|
||||
destack.mem = destack.front = buf;
|
||||
destack.mem = destack.front = ( uintptr_t )buf;
|
||||
destack.back = destack.mem + len;
|
||||
return destack;
|
||||
}
|
||||
|
||||
void DestroyBiStack(BiStack *const destack)
|
||||
{
|
||||
if ((destack == NULL) || (destack->mem == NULL)) return;
|
||||
free(destack->mem);
|
||||
*destack = (BiStack){0};
|
||||
}
|
||||
|
||||
void *BiStackAllocFront(BiStack *const destack, const size_t len)
|
||||
void DestroyBiStack(BiStack *const restrict destack)
|
||||
{
|
||||
if ((destack == NULL) || (destack->mem == NULL)) return NULL;
|
||||
if (destack->mem == 0) return;
|
||||
else
|
||||
{
|
||||
uint8_t *const restrict buf = ( uint8_t* )destack->mem;
|
||||
free(buf);
|
||||
*destack = (BiStack){0};
|
||||
}
|
||||
}
|
||||
|
||||
void *BiStackAllocFront(BiStack *const restrict destack, const size_t len)
|
||||
{
|
||||
if (destack->mem == 0) return NULL;
|
||||
else
|
||||
{
|
||||
const size_t ALIGNED_LEN = __AlignSize(len, sizeof(uintptr_t));
|
||||
// front end stack is too high!
|
||||
// front end arena is too high!
|
||||
if (destack->front + ALIGNED_LEN >= destack->back) return NULL;
|
||||
|
||||
uint8_t *ptr = destack->front;
|
||||
else
|
||||
{
|
||||
uint8_t *const restrict ptr = ( uint8_t* )destack->front;
|
||||
destack->front += ALIGNED_LEN;
|
||||
return ptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void *BiStackAllocBack(BiStack *const destack, const size_t len)
|
||||
void *BiStackAllocBack(BiStack *const restrict destack, const size_t len)
|
||||
{
|
||||
if (destack->mem == 0) return NULL;
|
||||
else
|
||||
{
|
||||
if ((destack == NULL) || (destack->mem == NULL)) return NULL;
|
||||
|
||||
const size_t ALIGNED_LEN = __AlignSize(len, sizeof(uintptr_t));
|
||||
// back end stack is too low
|
||||
// back end arena is too low
|
||||
if (destack->back - ALIGNED_LEN <= destack->front) return NULL;
|
||||
|
||||
else
|
||||
{
|
||||
destack->back -= ALIGNED_LEN;
|
||||
return destack->back;
|
||||
uint8_t *const restrict ptr = ( uint8_t* )destack->back;
|
||||
return ptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void BiStackResetFront(BiStack *const destack)
|
||||
{
|
||||
if ((destack == NULL) || (destack->mem == NULL)) return;
|
||||
destack->front = destack->mem;
|
||||
if (destack->mem == 0) return;
|
||||
else destack->front = destack->mem;
|
||||
}
|
||||
|
||||
void BiStackResetBack(BiStack *const destack)
|
||||
{
|
||||
if ((destack == NULL) || (destack->mem == NULL)) return;
|
||||
destack->back = destack->mem + destack->size;
|
||||
if (destack->mem == 0) return;
|
||||
else destack->back = destack->mem + destack->size;
|
||||
}
|
||||
|
||||
void BiStackResetAll(BiStack *const destack)
|
||||
|
|
@ -767,9 +719,21 @@ void BiStackResetAll(BiStack *const destack)
|
|||
BiStackResetFront(destack);
|
||||
}
|
||||
|
||||
intptr_t BiStackMargins(const BiStack destack)
|
||||
inline intptr_t BiStackMargins(const BiStack destack)
|
||||
{
|
||||
return destack.back - destack.front;
|
||||
}
|
||||
|
||||
#endif // RMEM_IMPLEMENTATION
|
||||
|
||||
/*******
|
||||
* Changelog
|
||||
* v1.0: First Creation.
|
||||
* v1.1: bug patches for the mempool and addition of object pool.
|
||||
* v1.2: addition of bidirectional arena.
|
||||
* v1.3:
|
||||
* optimizations of allocators.
|
||||
* renamed 'Stack' to 'Arena'.
|
||||
* replaced certain define constants with an anonymous enum.
|
||||
* refactored MemPool to no longer require active or deferred defragging.
|
||||
********/
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user