MrMonopoly/raylib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implementing changes

Browse Source
This commit is contained in:
Kevin Yonan 2019-06-24 20:05:16 -07:00 committed by GitHub
parent 3235369e74
commit 4fe2f2bde3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 80 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
src/rmem.c
View File

@ -1,9 +1,13 @@
#include "rmem.h" #include "rmem.h"
// excessive but just in case.
#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) || defined(_MSC_VER)
# ifndef restrict
# define restrict __restrict
# endif
#endif
typedef uintptr_t ptrcmp; static inline size_t __AlignSize(const size_t size, const size_t align)
static size_t _AlignSize(const size_t size, const size_t align)
{ {
return (size + (align-1)) & -align; return (size + (align-1)) & -align;
} }
@ -20,13 +24,13 @@ static void _RemoveNode(struct MemNode **const node)
struct MemPool MemPool_Create(const size_t size) struct MemPool MemPool_Create(const size_t size)
{ {
struct MemPool mempool = {0}; struct MemPool mempool = {0};
if( size==0UL ) if (size==0UL)
return mempool; return mempool;
else { else {
// align the mempool size to at least the size of an alloc node. // align the mempool size to at least the size of an alloc node.
mempool.stack.size = _AlignSize(size, sizeof(struct MemNode)); mempool.stack.size = __AlignSize(size, sizeof(struct MemNode));
mempool.stack.mem = malloc(1 + mempool.stack.size*sizeof *mempool.stack.mem); mempool.stack.mem = malloc(1 + mempool.stack.size*sizeof *mempool.stack.mem);
if( mempool.stack.mem==NULL ) { if (mempool.stack.mem==NULL) {
mempool.stack.size = 0UL; mempool.stack.size = 0UL;
return mempool; return mempool;
} else { } else {
@ -36,10 +40,10 @@ struct MemPool MemPool_Create(const size_t size)
} }
} }
struct MemPool MemPool_FromBuffer(const size_t size, void *buf) struct MemPool MemPool_FromBuffer(void *buf, const size_t size)
{ {
struct MemPool mempool = {0}; struct MemPool mempool = {0};
if( size==0UL || buf==NULL || size<=sizeof(struct MemNode) ) if (size==0UL || buf==NULL || size<=sizeof(struct MemNode))
return mempool; return mempool;
else { else {
mempool.stack.size = size; mempool.stack.size = size;
@ -51,7 +55,7 @@ struct MemPool MemPool_FromBuffer(const size_t size, void *buf)
void MemPool_Destroy(struct MemPool *const mempool) void MemPool_Destroy(struct MemPool *const mempool)
{ {
if( mempool==NULL || mempool->stack.mem==NULL ) if (mempool==NULL || mempool->stack.mem==NULL)
return; return;
else { else {
free(mempool->stack.mem); free(mempool->stack.mem);
@ -61,18 +65,18 @@ void MemPool_Destroy(struct MemPool *const mempool)
void *MemPool_Alloc(struct MemPool *const mempool, const size_t size) void *MemPool_Alloc(struct MemPool *const mempool, const size_t size)
{ {
if( mempool==NULL || size==0UL || size > mempool->stack.size ) if (mempool==NULL || size==0UL || size > mempool->stack.size)
return NULL; return NULL;
else { else {
struct MemNode *new_mem = NULL; struct MemNode *new_mem = NULL;
const size_t ALLOC_SIZE = size + sizeof *new_mem; const size_t ALLOC_SIZE = size + sizeof *new_mem;
if( mempool->freeList.head != NULL ) { if (mempool->freeList.head != NULL) {
const size_t MEM_SPLIT_THRESHOLD = sizeof(intptr_t); const size_t MEM_SPLIT_THRESHOLD = sizeof(intptr_t);
// if the freelist is valid, let's allocate FROM the freelist then! // if the freelist is valid, let's allocate FROM the freelist then!
for( struct MemNode **inode = &mempool->freeList.head; *inode != NULL; inode = &(*inode)->next ) { for (struct MemNode **inode = &mempool->freeList.head; *inode != NULL; inode = &(*inode)->next) {
if( (*inode)->size < ALLOC_SIZE ) if ((*inode)->size < ALLOC_SIZE)
continue; continue;
else if( (*inode)->size <= ALLOC_SIZE + MEM_SPLIT_THRESHOLD ) { else if ((*inode)->size <= ALLOC_SIZE + MEM_SPLIT_THRESHOLD) {
// close in size - reduce fragmentation by not splitting. // close in size - reduce fragmentation by not splitting.
new_mem = *inode; new_mem = *inode;
_RemoveNode(inode); _RemoveNode(inode);
@ -81,7 +85,7 @@ void *MemPool_Alloc(struct MemPool *const mempool, const size_t size)
break; break;
} else { } else {
// split the memory chunk. // split the memory chunk.
new_mem = (struct MemNode *)( (uint8_t *)*inode + ((*inode)->size - ALLOC_SIZE) ); new_mem = (struct MemNode *)( (uint8_t *)*inode + ((*inode)->size - ALLOC_SIZE));
(*inode)->size -= ALLOC_SIZE; (*inode)->size -= ALLOC_SIZE;
new_mem->size = ALLOC_SIZE; new_mem->size = ALLOC_SIZE;
new_mem->next = new_mem->prev = NULL; new_mem->next = new_mem->prev = NULL;
@ -90,9 +94,9 @@ void *MemPool_Alloc(struct MemPool *const mempool, const size_t size)
} }
} }
if( new_mem==NULL ) { if (new_mem==NULL) {
// not enough memory to support the size! // not enough memory to support the size!
if( mempool->stack.base - ALLOC_SIZE < mempool->stack.mem ) if (mempool->stack.base - ALLOC_SIZE < mempool->stack.mem)
return NULL; return NULL;
else { else {
// couldn't allocate from a freelist, allocate from available mempool. // couldn't allocate from a freelist, allocate from available mempool.
@ -121,20 +125,20 @@ void *MemPool_Alloc(struct MemPool *const mempool, const size_t size)
} }
} }
void *MemPool_Realloc(struct MemPool *const __restrict mempool, void *ptr, const size_t size) void *MemPool_Realloc(struct MemPool *const restrict mempool, void *ptr, const size_t size)
{ {
if( mempool==NULL || size > mempool->stack.size ) if (mempool==NULL || size > mempool->stack.size)
return NULL; return NULL;
// NULL ptr should make this work like regular Allocation. // NULL ptr should make this work like regular Allocation.
else if( ptr==NULL ) else if (ptr==NULL)
return MemPool_Alloc(mempool, size); return MemPool_Alloc(mempool, size);
else if( (ptrcmp)ptr <= (ptrcmp)mempool->stack.mem ) else if ((uintptr_t)ptr <= (uintptr_t)mempool->stack.mem)
return NULL; return NULL;
else { else {
struct MemNode *node = (struct MemNode *)((uint8_t *)ptr - sizeof *node); struct MemNode *node = (struct MemNode *)((uint8_t *)ptr - sizeof *node);
const size_t NODE_SIZE = sizeof *node; const size_t NODE_SIZE = sizeof *node;
uint8_t *resized_block = MemPool_Alloc(mempool, size); uint8_t *resized_block = MemPool_Alloc(mempool, size);
if( resized_block==NULL ) if (resized_block==NULL)
return NULL; return NULL;
else { else {
struct MemNode *resized = (struct MemNode *)(resized_block - sizeof *resized); struct MemNode *resized = (struct MemNode *)(resized_block - sizeof *resized);
@ -145,56 +149,56 @@ void *MemPool_Realloc(struct MemPool *const __restrict mempool, void *ptr, const
} }
} }
void MemPool_Free(struct MemPool *const __restrict mempool, void *ptr) void MemPool_Free(struct MemPool *const restrict mempool, void *ptr)
{ {
if( mempool==NULL || ptr==NULL || (ptrcmp)ptr <= (ptrcmp)mempool->stack.mem ) if (mempool==NULL || ptr==NULL || (uintptr_t)ptr <= (uintptr_t)mempool->stack.mem)
return; return;
else { else {
// behind the actual pointer data is the allocation info. // behind the actual pointer data is the allocation info.
struct MemNode *mem_node = (struct MemNode *)((uint8_t *)ptr - sizeof *mem_node); struct MemNode *mem_node = (struct MemNode *)((uint8_t *)ptr - sizeof *mem_node);
// make sure the pointer data is valid. // make sure the pointer data is valid.
if( (ptrcmp)mem_node < (ptrcmp)mempool->stack.base || ((ptrcmp)mem_node - (ptrcmp)mempool->stack.mem) > mempool->stack.size || mem_node->size==0UL || mem_node->size > mempool->stack.size ) 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; return;
// if the mem_node is right at the stack base ptr, then add it to the stack. // if the mem_node is right at the stack base ptr, then add it to the stack.
else if( (ptrcmp)mem_node == (ptrcmp)mempool->stack.base ) { else if ((uintptr_t)mem_node == (uintptr_t)mempool->stack.base) {
mempool->stack.base += mem_node->size; mempool->stack.base += mem_node->size;
} }
// otherwise, we add it to the free list. // otherwise, we add it to the free list.
// We also check if the freelist already has the pointer so we can prevent double frees. // We also check if the freelist already has the pointer so we can prevent double frees.
else if( mempool->freeList.len==0UL || ((ptrcmp)mempool->freeList.head >= (ptrcmp)mempool->stack.mem && (ptrcmp)mempool->freeList.head - (ptrcmp)mempool->stack.mem < mempool->stack.size) ) { 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( struct MemNode *n = mempool->freeList.head; n != NULL; n = n->next ) for (struct MemNode *n = mempool->freeList.head; n != NULL; n = n->next)
if( n==mem_node ) if (n==mem_node)
return; return;
// this code inserts at head. // this code inserts at head.
/* /*
( mempool->freeList.head==NULL )? (mempool->freeList.tail = mem_node) : (mempool->freeList.head->prev = mem_node); ( mempool->freeList.head==NULL)? (mempool->freeList.tail = mem_node) : (mempool->freeList.head->prev = mem_node);
mem_node->next = mempool->freeList.head; mem_node->next = mempool->freeList.head;
mempool->freeList.head = mem_node; mempool->freeList.head = mem_node;
mempool->freeList.len++; mempool->freeList.len++;
*/ */
// this code insertion sorts where largest size is first. // this code insertion sorts where largest size is first.
if( mempool->freeList.head==NULL ) { if (mempool->freeList.head==NULL) {
mempool->freeList.head = mempool->freeList.tail = mem_node; mempool->freeList.head = mempool->freeList.tail = mem_node;
mempool->freeList.len++; mempool->freeList.len++;
} else if( mempool->freeList.head->size <= mem_node->size ) { } else if (mempool->freeList.head->size <= mem_node->size) {
mem_node->next = mempool->freeList.head; mem_node->next = mempool->freeList.head;
mem_node->next->prev = mem_node; mem_node->next->prev = mem_node;
mempool->freeList.head = mem_node; mempool->freeList.head = mem_node;
mempool->freeList.len++; mempool->freeList.len++;
} else if( mempool->freeList.tail->size > mem_node->size ) { } else if (mempool->freeList.tail->size > mem_node->size) {
mem_node->prev = mempool->freeList.tail; mem_node->prev = mempool->freeList.tail;
mempool->freeList.tail->next = mem_node; mempool->freeList.tail->next = mem_node;
mempool->freeList.tail = mem_node; mempool->freeList.tail = mem_node;
mempool->freeList.len++; mempool->freeList.len++;
} else { } else {
struct MemNode *n = mempool->freeList.head; struct MemNode *n = mempool->freeList.head;
while( n->next != NULL && n->next->size > mem_node->size ) while (n->next != NULL && n->next->size > mem_node->size)
n = n->next; n = n->next;
mem_node->next = n->next; mem_node->next = n->next;
if( n->next != NULL ) if (n->next != NULL)
mem_node->next->prev = mem_node; mem_node->next->prev = mem_node;
n->next = mem_node; n->next = mem_node;
@ -202,30 +206,31 @@ void MemPool_Free(struct MemPool *const __restrict mempool, void *ptr)
mempool->freeList.len++; mempool->freeList.len++;
} }
if( mempool->freeList.autoDefrag && mempool->freeList.maxNodes != 0UL && mempool->freeList.len > mempool->freeList.maxNodes ) if (mempool->freeList.autoDefrag && mempool->freeList.maxNodes != 0UL && mempool->freeList.len > mempool->freeList.maxNodes)
MemPool_DeFrag(mempool); MemPool_DeFrag(mempool);
} }
} }
} }
void MemPool_CleanUp(struct MemPool *const __restrict mempool, void *ptrref) void MemPool_CleanUp(struct MemPool *const restrict mempool, void *ptrref)
{ {
if( mempool==NULL || ptrref==NULL ) if (mempool==NULL || ptrref==NULL)
return; return;
else { else {
void *__restrict *p = ptrref; void *restrict *p = ptrref;
if( *p==NULL ) { if (*p==NULL) {
return; return;
} else { } else {
MemPool_Free(mempool, *p), *p = NULL; MemPool_Free(mempool, *p);
*p = NULL;
} }
} }
} }
size_t MemPool_MemoryRemaining(const MemPool mempool) size_t MemPool_MemoryRemaining(const MemPool mempool)
{ {
size_t total_remaining = (ptrcmp)mempool.stack.base - (ptrcmp)mempool.stack.mem; size_t total_remaining = (uintptr_t)mempool.stack.base - (uintptr_t)mempool.stack.mem;
for( struct MemNode *n=mempool.freeList.head; n != NULL; n = n->next ) for (struct MemNode *n=mempool.freeList.head; n != NULL; n = n->next)
total_remaining += n->size; total_remaining += n->size;
return total_remaining; return total_remaining;
} }
@ -233,26 +238,26 @@ size_t MemPool_MemoryRemaining(const MemPool mempool)
bool MemPool_DeFrag(struct MemPool *const mempool) bool MemPool_DeFrag(struct MemPool *const mempool)
{ {
if( mempool==NULL ) if (mempool==NULL)
return false; return false;
else { else {
// if the memory pool has been entirely released, fully defrag it. // if the memory pool has been entirely released, fully defrag it.
if( mempool->stack.size == MemPool_MemoryRemaining(*mempool) ) { if (mempool->stack.size == MemPool_MemoryRemaining(*mempool)) {
memset(&mempool->freeList, 0, sizeof mempool->freeList); memset(&mempool->freeList, 0, sizeof mempool->freeList);
mempool->stack.base = mempool->stack.mem + mempool->stack.size; mempool->stack.base = mempool->stack.mem + mempool->stack.size;
return true; return true;
} else { } else {
const size_t PRE_DEFRAG_LEN = mempool->freeList.len; const size_t PRE_DEFRAG_LEN = mempool->freeList.len;
struct MemNode **node = &mempool->freeList.head; struct MemNode **node = &mempool->freeList.head;
while( *node != NULL ) { while (*node != NULL) {
if( (ptrcmp)*node == (ptrcmp)mempool->stack.base ) { if ((uintptr_t)*node == (uintptr_t)mempool->stack.base) {
// if node is right at the stack, merge it back into the stack. // if node is right at the stack, merge it back into the stack.
mempool->stack.base += (*node)->size; mempool->stack.base += (*node)->size;
(*node)->size = 0UL; (*node)->size = 0UL;
_RemoveNode(node); _RemoveNode(node);
mempool->freeList.len--; mempool->freeList.len--;
node = &mempool->freeList.head; node = &mempool->freeList.head;
} else if( (ptrcmp)*node + (*node)->size == (ptrcmp)(*node)->next ) { } else if ((uintptr_t)*node + (*node)->size == (uintptr_t)(*node)->next) {
// next node is at a higher address. // next node is at a higher address.
(*node)->size += (*node)->next->size; (*node)->size += (*node)->next->size;
(*node)->next->size = 0UL; (*node)->next->size = 0UL;
@ -261,7 +266,7 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
// //
// |--------------------| // |--------------------|
// <-[P Curr N]-> <-[P Next N]-> [P NextNext N]-> // <-[P Curr N]-> <-[P Next N]-> [P NextNext N]->
if( (*node)->next->next != NULL ) if ((*node)->next->next != NULL)
(*node)->next->next->prev = *node; (*node)->next->next->prev = *node;
// <-[P Curr N]-> <-[P NextNext N]-> // <-[P Curr N]-> <-[P NextNext N]->
@ -269,7 +274,7 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
mempool->freeList.len--; mempool->freeList.len--;
node = &mempool->freeList.head; node = &mempool->freeList.head;
} else if( (ptrcmp)*node + (*node)->size == (ptrcmp)(*node)->prev && (*node)->prev->prev != NULL ) { } else if ((uintptr_t)*node + (*node)->size == (uintptr_t)(*node)->prev && (*node)->prev->prev != NULL) {
// prev node is at a higher address. // prev node is at a higher address.
(*node)->size += (*node)->prev->size; (*node)->size += (*node)->prev->size;
(*node)->prev->size = 0UL; (*node)->prev->size = 0UL;
@ -285,7 +290,7 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
mempool->freeList.len--; mempool->freeList.len--;
node = &mempool->freeList.head; node = &mempool->freeList.head;
} else if( (*node)->prev != NULL && (*node)->next != NULL && (ptrcmp)*node - (*node)->next->size == (ptrcmp)(*node)->next ) { } 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. // next node is at a lower address.
(*node)->next->size += (*node)->size; (*node)->next->size += (*node)->size;
@ -295,7 +300,7 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
mempool->freeList.len--; mempool->freeList.len--;
node = &mempool->freeList.head; node = &mempool->freeList.head;
} else if( (*node)->prev != NULL && (*node)->next != NULL && (ptrcmp)*node - (*node)->prev->size == (ptrcmp)(*node)->prev ) { } 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. // prev node is at a lower address.
(*node)->prev->size += (*node)->size; (*node)->prev->size += (*node)->size;
@ -317,44 +322,10 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
void MemPool_ToggleAutoDefrag(struct MemPool *const mempool) void MemPool_ToggleAutoDefrag(struct MemPool *const mempool)
{ {
if( mempool==NULL ) if (mempool==NULL)
return; return;
else mempool->freeList.autoDefrag ^= true; else mempool->freeList.autoDefrag ^= true;
} }
#if 0
size_t MemPool_GetPoolSize(const MemPool mempool);
size_t MemPool_GetPoolSize(const MemPool mempool)
{
return (mempool.stack.mem==NULL)? 0UL : mempool.stack.size;
}
void MemPool_SetMaxNodes(struct MemPool *mempool, size_t maxNodes);
void MemPool_SetMaxNodes(struct MemPool *const mempool, const size_t maxNodes)
{
if( mempool==NULL )
return;
else mempool->freeList.maxNodes = maxNodes;
}
intptr_t MemPool_IsValidPtr(const MemPool mempool, void *ptr);
intptr_t MemPool_IsValidPtr(const MemPool mempool, void *ptr)
{
if( mempool==NULL || mempool->stack.mem==NULL )
return -1;
else if( ptr==NULL || (ptrcmp)ptr < (ptrcmp)mempool->stack.mem || (ptrcmp)ptr > (ptrcmp)mempool->stack.mem + mempool->stack.size || (ptrcmp)ptr < (ptrcmp)mempool->stack.base )
return false;
else if( mempool->freeList.len != 0UL ) {
struct MemNode *mem = (struct MemNode *)((uint8_t *)ptr - sizeof *mem);
for( struct MemNode *n=mempool.freeList.head; n != NULL; n = n->next )
if( mem==n )
return false;
return true;
} else return true;
}
#endif
/***************************************************/ /***************************************************/
@ -367,17 +338,17 @@ union ObjInfo {
struct ObjPool ObjPool_Create(const size_t objsize, const size_t len) struct ObjPool ObjPool_Create(const size_t objsize, const size_t len)
{ {
struct ObjPool objpool = {0}; struct ObjPool objpool = {0};
if( len==0UL || objsize==0UL ) if (len==0UL || objsize==0UL)
return objpool; return objpool;
else { else {
objpool.objSize = _AlignSize(objsize, sizeof(size_t)); objpool.objSize = __AlignSize(objsize, sizeof(size_t));
objpool.stack.size = objpool.freeBlocks = len; objpool.stack.size = objpool.freeBlocks = len;
objpool.stack.mem = calloc(objpool.stack.size, objpool.objSize); objpool.stack.mem = calloc(objpool.stack.size, objpool.objSize);
if( objpool.stack.mem==NULL ) { if (objpool.stack.mem==NULL) {
objpool.stack.size = 0UL; objpool.stack.size = 0UL;
return objpool; return objpool;
} else { } else {
for( size_t 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] }; union ObjInfo block = { .byte = &objpool.stack.mem[i*objpool.objSize] };
*block.size = i + 1; *block.size = i + 1;
} }
@ -387,17 +358,17 @@ struct ObjPool ObjPool_Create(const size_t objsize, const size_t len)
} }
} }
struct ObjPool ObjPool_FromBuffer(const size_t objsize, const size_t len, void *const buf) struct ObjPool ObjPool_FromBuffer(void *const buf, const size_t objsize, const size_t len)
{ {
struct ObjPool objpool = {0}; struct ObjPool objpool = {0};
// If the object size isn't large enough to align to a size_t, then we can't use it. // 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 ) if (buf==NULL || len==0UL || objsize<sizeof(size_t) || objsize*len != __AlignSize(objsize, sizeof(size_t))*len)
return objpool; return objpool;
else { else {
objpool.objSize = _AlignSize(objsize, sizeof(size_t)); objpool.objSize = __AlignSize(objsize, sizeof(size_t));
objpool.stack.size = objpool.freeBlocks = len; objpool.stack.size = objpool.freeBlocks = len;
objpool.stack.mem = buf; objpool.stack.mem = buf;
for( size_t 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] }; union ObjInfo block = { .byte = &objpool.stack.mem[i*objpool.objSize] };
*block.size = i + 1; *block.size = i + 1;
} }
@ -408,7 +379,7 @@ struct ObjPool ObjPool_FromBuffer(const size_t objsize, const size_t len, void *
void ObjPool_Destroy(struct ObjPool *const objpool) void ObjPool_Destroy(struct ObjPool *const objpool)
{ {
if( objpool==NULL || objpool->stack.mem==NULL ) if (objpool==NULL || objpool->stack.mem==NULL)
return; return;
else { else {
free(objpool->stack.mem); free(objpool->stack.mem);
@ -418,10 +389,10 @@ void ObjPool_Destroy(struct ObjPool *const objpool)
void *ObjPool_Alloc(struct ObjPool *const objpool) void *ObjPool_Alloc(struct ObjPool *const objpool)
{ {
if( objpool==NULL ) if (objpool==NULL)
return NULL; return NULL;
else { else {
if( objpool->freeBlocks>0UL ) { if (objpool->freeBlocks>0UL) {
// for first allocation, head points to the very first index. // for first allocation, head points to the very first index.
// Head = &pool[0]; // Head = &pool[0];
// ret = Head == ret = &pool[0]; // ret = Head == ret = &pool[0];
@ -430,17 +401,18 @@ void *ObjPool_Alloc(struct ObjPool *const objpool)
// after allocating, we set head to the address of the index that *Head holds. // after allocating, we set head to the address of the index that *Head holds.
// Head = &pool[*Head * pool.objsize]; // Head = &pool[*Head * pool.objsize];
objpool->stack.base = (objpool->freeBlocks != 0UL)? objpool->stack.mem + ( *ret.size*objpool->objSize ) : NULL; objpool->stack.base = (objpool->freeBlocks != 0UL)? objpool->stack.mem + ( *ret.size*objpool->objSize) : NULL;
memset(ret.byte, 0, objpool->objSize); memset(ret.byte, 0, objpool->objSize);
return ret.byte; return ret.byte;
} else return NULL; }
else return NULL;
} }
} }
void ObjPool_Free(struct ObjPool *const __restrict objpool, void *ptr) void ObjPool_Free(struct ObjPool *const restrict objpool, void *ptr)
{ {
union ObjInfo p = { .byte = 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 ) if (objpool==NULL || ptr==NULL || p.byte <= objpool->stack.mem || p.byte > objpool->stack.mem + objpool->stack.size*objpool->objSize)
return; return;
else { else {
// when we free our Bointer, we recycle the pointer space to store the previous index // when we free our Bointer, we recycle the pointer space to store the previous index
@ -454,16 +426,17 @@ void ObjPool_Free(struct ObjPool *const __restrict objpool, void *ptr)
} }
} }
void ObjPool_CleanUp(struct ObjPool *const __restrict objpool, void *ptrref) void ObjPool_CleanUp(struct ObjPool *const restrict objpool, void *ptrref)
{ {
if( objpool==NULL || ptrref==NULL ) if (objpool==NULL || ptrref==NULL)
return; return;
else { else {
void *__restrict *p = ptrref; void *restrict *p = ptrref;
if( *p==NULL ) { if (*p==NULL) {
return; return;
} else { } else {
ObjPool_Free(objpool, *p), *p = NULL; ObjPool_Free(objpool, *p);
*p = NULL;
} }
} }
} }