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

101
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;
}
@ -24,7 +28,7 @@ struct MemPool MemPool_Create(const size_t size)
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) {
mempool.stack.size = 0UL;
@ -36,7 +40,7 @@ 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))
@ -121,14 +125,14 @@ 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)
return NULL;
// NULL ptr should make this work like regular Allocation.
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);
@ -145,23 +149,23 @@ 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) ) {
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;
@ -208,23 +212,24 @@ void MemPool_Free(struct MemPool *const __restrict mempool, void *ptr)
}
}
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)
return;
else {
void *__restrict *p = ptrref;
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;
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;
@ -245,14 +250,14 @@ bool MemPool_DeFrag(struct MemPool *const mempool)
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 ) {
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;
@ -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;
@ -321,40 +326,6 @@ void MemPool_ToggleAutoDefrag(struct MemPool *const mempool)
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
/***************************************************/
@ -370,7 +341,7 @@ struct ObjPool ObjPool_Create(const size_t objsize, const size_t len)
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) {
@ -387,14 +358,14 @@ 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++) {
@ -433,11 +404,12 @@ void *ObjPool_Alloc(struct ObjPool *const objpool)
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)
@ -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)
return;
else {
void *__restrict *p = ptrref;
void *restrict *p = ptrref;
if (*p==NULL) {
return;
} else {
ObjPool_Free(objpool, *p), *p = NULL;
ObjPool_Free(objpool, *p);
*p = NULL;
}
}
}