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"
// 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 size_t _AlignSize(const size_t size, const size_t align)
static inline size_t __AlignSize(const size_t size, const size_t 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 = {0};
if( size==0UL )
if (size==0UL)
return mempool;
else {
// 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);
if( mempool.stack.mem==NULL ) {
if (mempool.stack.mem==NULL) {
mempool.stack.size = 0UL;
return mempool;
} 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};
if( size==0UL || buf==NULL || size<=sizeof(struct MemNode) )
if (size==0UL || buf==NULL || size<=sizeof(struct MemNode))
return mempool;
else {
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)
{
if( mempool==NULL || mempool->stack.mem==NULL )
if (mempool==NULL || mempool->stack.mem==NULL)
return;
else {
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)
{
if( mempool==NULL || size==0UL || size > mempool->stack.size )
if (mempool==NULL || size==0UL || size > mempool->stack.size)
return NULL;
else {
struct MemNode *new_mem = NULL;
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);
// if the freelist is valid, let's allocate FROM the freelist then!
for( struct MemNode **inode = &mempool->freeList.head; *inode != NULL; inode = &(*inode)->next ) {
if( (*inode)->size < ALLOC_SIZE )
for (struct 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 ) {
else if ((*inode)->size <= ALLOC_SIZE + MEM_SPLIT_THRESHOLD) {
// close in size - reduce fragmentation by not splitting.
new_mem = *inode;
_RemoveNode(inode);
@ -81,7 +85,7 @@ void *MemPool_Alloc(struct MemPool *const mempool, const size_t size)
break;
} else {
// 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;
new_mem->size = ALLOC_SIZE;
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!
if( mempool->stack.base - ALLOC_SIZE < mempool->stack.mem )
if (mempool->stack.base - ALLOC_SIZE < mempool->stack.mem)
return NULL;
else {
// 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;
// NULL ptr should make this work like regular Allocation.
else if( ptr==NULL )
else if (ptr==NULL)
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;
else {
struct MemNode *node = (struct MemNode *)((uint8_t *)ptr - sizeof *node);
const size_t NODE_SIZE = sizeof *node;
uint8_t *resized_block = MemPool_Alloc(mempool, size);
if( resized_block==NULL )
if (resized_block==NULL)
return NULL;
else {
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;
else {
// behind the actual pointer data is the allocation info.
struct MemNode *mem_node = (struct MemNode *)((uint8_t *)ptr - sizeof *mem_node);
// 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;
// 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;
}
// 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 || ((ptrcmp)mempool->freeList.head >= (ptrcmp)mempool->stack.mem && (ptrcmp)mempool->freeList.head - (ptrcmp)mempool->stack.mem < mempool->stack.size) ) {
for( struct MemNode *n = mempool->freeList.head; n != NULL; n = n->next )
if( n==mem_node )
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)
if (n==mem_node)
return;
// 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;
mempool->freeList.head = mem_node;
mempool->freeList.len++;
*/
// 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.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->prev = mem_node;
mempool->freeList.head = mem_node;
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;
mempool->freeList.tail->next = mem_node;
mempool->freeList.tail = mem_node;
mempool->freeList.len++;
} else {
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;
mem_node->next = n->next;
if( n->next != NULL )
if (n->next != NULL)
mem_node->next->prev = mem_node;
n->next = mem_node;
@ -202,30 +206,31 @@ void MemPool_Free(struct MemPool *const __restrict mempool, void *ptr)
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);
}
}
}
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;
else {
void *__restrict *p = ptrref;
if( *p==NULL ) {
void *restrict *p = ptrref;
if (*p==NULL) {
return;
} else {
MemPool_Free(mempool, *p), *p = NULL;
MemPool_Free(mempool, *p);
*p = NULL;
}
}
}
size_t MemPool_MemoryRemaining(const MemPool mempool)
{
size_t total_remaining = (ptrcmp)mempool.stack.base - (ptrcmp)mempool.stack.mem;
for( struct MemNode *n=mempool.freeList.head; n != NULL; n = n->next )
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)
total_remaining += n->size;
return total_remaining;
}
@ -233,26 +238,26 @@ size_t MemPool_MemoryRemaining(const MemPool mempool)
bool MemPool_DeFrag(struct MemPool *const mempool)
{
if( mempool==NULL )
if (mempool==NULL)
return false;
else {
// 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);
mempool->stack.base = mempool->stack.mem + mempool->stack.size;
return true;
} else {
const size_t PRE_DEFRAG_LEN = mempool->freeList.len;
struct MemNode **node = &mempool->freeList.head;
while( *node != NULL ) {
if( (ptrcmp)*node == (ptrcmp)mempool->stack.base ) {
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;
_RemoveNode(node);
mempool->freeList.len--;
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.
(*node)->size += (*node)->next->size;
(*node)->next->size = 0UL;
@ -261,7 +266,7 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
//
// |--------------------|
// <-[P Curr N]-> <-[P Next N]-> [P NextNext N]->
if( (*node)->next->next != NULL )
if ((*node)->next->next != NULL)
(*node)->next->next->prev = *node;
// <-[P Curr N]-> <-[P NextNext N]->
@ -269,7 +274,7 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
mempool->freeList.len--;
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.
(*node)->size += (*node)->prev->size;
(*node)->prev->size = 0UL;
@ -285,7 +290,7 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
mempool->freeList.len--;
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.
(*node)->next->size += (*node)->size;
@ -295,7 +300,7 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
mempool->freeList.len--;
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.
(*node)->prev->size += (*node)->size;
@ -317,44 +322,10 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
void MemPool_ToggleAutoDefrag(struct MemPool *const mempool)
{
if( mempool==NULL )
if (mempool==NULL)
return;
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 = {0};
if( len==0UL || objsize==0UL )
if (len==0UL || objsize==0UL)
return objpool;
else {
objpool.objSize = _AlignSize(objsize, sizeof(size_t));
objpool.objSize = __AlignSize(objsize, sizeof(size_t));
objpool.stack.size = objpool.freeBlocks = len;
objpool.stack.mem = calloc(objpool.stack.size, objpool.objSize);
if( objpool.stack.mem==NULL ) {
if (objpool.stack.mem==NULL) {
objpool.stack.size = 0UL;
return objpool;
} 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] };
*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};
// 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;
else {
objpool.objSize = _AlignSize(objsize, sizeof(size_t));
objpool.objSize = __AlignSize(objsize, sizeof(size_t));
objpool.stack.size = objpool.freeBlocks = len;
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] };
*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)
{
if( objpool==NULL || objpool->stack.mem==NULL )
if (objpool==NULL || objpool->stack.mem==NULL)
return;
else {
free(objpool->stack.mem);
@ -418,10 +389,10 @@ void ObjPool_Destroy(struct ObjPool *const objpool)
void *ObjPool_Alloc(struct ObjPool *const objpool)
{
if( objpool==NULL )
if (objpool==NULL)
return NULL;
else {
if( objpool->freeBlocks>0UL ) {
if (objpool->freeBlocks>0UL) {
// for first allocation, head points to the very first index.
// Head = &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.
// 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);
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 };
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;
else {
// 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;
else {
void *__restrict *p = ptrref;
if( *p==NULL ) {
void *restrict *p = ptrref;
if (*p==NULL) {
return;
} else {
ObjPool_Free(objpool, *p), *p = NULL;
ObjPool_Free(objpool, *p);
*p = NULL;
}
}
}