From 4fe2f2bde343eb7342e4c1c463b82e0c120da202 Mon Sep 17 00:00:00 2001 From: Kevin Yonan Date: Mon, 24 Jun 2019 20:05:16 -0700 Subject: [PATCH] implementing changes --- src/rmem.c | 187 +++++++++++++++++++++++------------------------------ 1 file changed, 80 insertions(+), 107 deletions(-) diff --git a/src/rmem.c b/src/rmem.c index 95122fc4d..3181dd399 100644 --- a/src/rmem.c +++ b/src/rmem.c @@ -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; istack.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; } } }