From f8db8a3faa30b71dca33ced38be16d3f93f43e8a Mon Sep 17 00:00:00 2001 From: Rémi Verschelde Date: Sun, 19 Mar 2017 00:36:26 +0100 Subject: Bring that Whole New World to the Old Continent too Applies the clang-format style to the 2.1 branch as done for master in 5dbf1809c6e3e905b94b8764e99491e608122261. --- drivers/unix/memory_pool_static_malloc.cpp | 413 ++++++++++++++--------------- 1 file changed, 199 insertions(+), 214 deletions(-) (limited to 'drivers/unix/memory_pool_static_malloc.cpp') diff --git a/drivers/unix/memory_pool_static_malloc.cpp b/drivers/unix/memory_pool_static_malloc.cpp index a7720cd44..fa6bddb14 100644 --- a/drivers/unix/memory_pool_static_malloc.cpp +++ b/drivers/unix/memory_pool_static_malloc.cpp @@ -28,11 +28,11 @@ /*************************************************************************/ #include "memory_pool_static_malloc.h" #include "error_macros.h" -#include "os/memory.h" -#include -#include #include "os/copymem.h" +#include "os/memory.h" #include "os/os.h" +#include +#include /** * NOTE NOTE NOTE NOTE @@ -40,62 +40,62 @@ * so BE CAREFUL! */ -void* MemoryPoolStaticMalloc::alloc(size_t p_bytes,const char *p_description) { +void *MemoryPoolStaticMalloc::alloc(size_t p_bytes, const char *p_description) { - #if DEFAULT_ALIGNMENT == 1 +#if DEFAULT_ALIGNMENT == 1 - return _alloc(p_bytes, p_description); + return _alloc(p_bytes, p_description); - #else +#else - size_t total; - #if defined(_add_overflow) - if (_add_overflow(p_bytes, DEFAULT_ALIGNMENT, &total)) return NULL; - #else - total = p_bytes + DEFAULT_ALIGNMENT; - #endif - uint8_t* ptr = (uint8_t*)_alloc(total, p_description); - ERR_FAIL_COND_V( !ptr, ptr ); - int ofs = (DEFAULT_ALIGNMENT - ((uintptr_t)ptr & (DEFAULT_ALIGNMENT - 1))); - ptr[ofs-1] = ofs; - return (void*)(ptr + ofs); - #endif + size_t total; +#if defined(_add_overflow) + if (_add_overflow(p_bytes, DEFAULT_ALIGNMENT, &total)) return NULL; +#else + total = p_bytes + DEFAULT_ALIGNMENT; +#endif + uint8_t *ptr = (uint8_t *)_alloc(total, p_description); + ERR_FAIL_COND_V(!ptr, ptr); + int ofs = (DEFAULT_ALIGNMENT - ((uintptr_t)ptr & (DEFAULT_ALIGNMENT - 1))); + ptr[ofs - 1] = ofs; + return (void *)(ptr + ofs); +#endif }; - -void* MemoryPoolStaticMalloc::_alloc(size_t p_bytes,const char *p_description) { - - ERR_FAIL_COND_V(p_bytes==0,0); - + +void *MemoryPoolStaticMalloc::_alloc(size_t p_bytes, const char *p_description) { + + ERR_FAIL_COND_V(p_bytes == 0, 0); + MutexLock lock(mutex); - + #ifdef DEBUG_MEMORY_ENABLED size_t total; - #if defined(_add_overflow) - if (_add_overflow(p_bytes, sizeof(RingPtr), &total)) return NULL; - #else - total = p_bytes + sizeof(RingPtr); - #endif - void *mem=malloc(total); /// add for size and ringlist +#if defined(_add_overflow) + if (_add_overflow(p_bytes, sizeof(RingPtr), &total)) return NULL; +#else + total = p_bytes + sizeof(RingPtr); +#endif + void *mem = malloc(total); /// add for size and ringlist if (!mem) { - printf("**ERROR: out of memory while allocating %lu bytes by %s?\n", (unsigned long) p_bytes, p_description); - printf("**ERROR: memory usage is %lu\n", (unsigned long) get_total_usage()); + printf("**ERROR: out of memory while allocating %lu bytes by %s?\n", (unsigned long)p_bytes, p_description); + printf("**ERROR: memory usage is %lu\n", (unsigned long)get_total_usage()); }; - - ERR_FAIL_COND_V(!mem,0); //out of memory, or unreasonable request - + + ERR_FAIL_COND_V(!mem, 0); //out of memory, or unreasonable request + /* setup the ringlist element */ - - RingPtr *ringptr = (RingPtr*)mem; - + + RingPtr *ringptr = (RingPtr *)mem; + /* setup the ringlist element data (description and size ) */ - + ringptr->size = p_bytes; - ringptr->descr=p_description; - + ringptr->descr = p_description; + if (ringlist) { /* existing ringlist */ - + /* assign next */ ringptr->next = ringlist->next; ringlist->next = ringptr; @@ -103,161 +103,155 @@ void* MemoryPoolStaticMalloc::_alloc(size_t p_bytes,const char *p_description) { ringptr->prev = ringlist; ringptr->next->prev = ringptr; } else { /* non existing ringlist */ - - ringptr->next=ringptr; - ringptr->prev=ringptr; - ringlist=ringptr; - + + ringptr->next = ringptr; + ringptr->prev = ringptr; + ringlist = ringptr; } - - total_mem+=p_bytes; - + + total_mem += p_bytes; + /* update statistics */ - if (total_mem > max_mem ) + if (total_mem > max_mem) max_mem = total_mem; - + total_pointers++; - + if (total_pointers > max_pointers) - max_pointers=total_pointers; - + max_pointers = total_pointers; + return ringptr + 1; /* return memory after ringptr */ - -#else - void *mem=malloc(p_bytes); - ERR_FAIL_COND_V(!mem,0); //out of memory, or unreasonable request - return mem; -#endif +#else + void *mem = malloc(p_bytes); + + ERR_FAIL_COND_V(!mem, 0); //out of memory, or unreasonable request + return mem; +#endif } +void *MemoryPoolStaticMalloc::realloc(void *p_memory, size_t p_bytes) { -void* MemoryPoolStaticMalloc::realloc(void *p_memory,size_t p_bytes) { - - #if DEFAULT_ALIGNMENT == 1 - - return _realloc(p_memory,p_bytes); - #else - if (!p_memory) - return alloc(p_bytes); - - size_t total; - #if defined(_add_overflow) - if (_add_overflow(p_bytes, DEFAULT_ALIGNMENT, &total)) return NULL; - #else - total = p_bytes + DEFAULT_ALIGNMENT; - #endif - uint8_t* mem = (uint8_t*)p_memory; - int ofs = *(mem-1); - mem = mem - ofs; - uint8_t* ptr = (uint8_t*)_realloc(mem, total); - ERR_FAIL_COND_V(ptr == NULL, NULL); - int new_ofs = (DEFAULT_ALIGNMENT - ((uintptr_t)ptr & (DEFAULT_ALIGNMENT - 1))); - if (new_ofs != ofs) { - - //printf("realloc moving %i bytes\n", p_bytes); - movemem((ptr + new_ofs), (ptr + ofs), p_bytes); - ptr[new_ofs-1] = new_ofs; - }; - return ptr + new_ofs; - #endif +#if DEFAULT_ALIGNMENT == 1 + + return _realloc(p_memory, p_bytes); +#else + if (!p_memory) + return alloc(p_bytes); + + size_t total; +#if defined(_add_overflow) + if (_add_overflow(p_bytes, DEFAULT_ALIGNMENT, &total)) return NULL; +#else + total = p_bytes + DEFAULT_ALIGNMENT; +#endif + uint8_t *mem = (uint8_t *)p_memory; + int ofs = *(mem - 1); + mem = mem - ofs; + uint8_t *ptr = (uint8_t *)_realloc(mem, total); + ERR_FAIL_COND_V(ptr == NULL, NULL); + int new_ofs = (DEFAULT_ALIGNMENT - ((uintptr_t)ptr & (DEFAULT_ALIGNMENT - 1))); + if (new_ofs != ofs) { + + //printf("realloc moving %i bytes\n", p_bytes); + movemem((ptr + new_ofs), (ptr + ofs), p_bytes); + ptr[new_ofs - 1] = new_ofs; + }; + return ptr + new_ofs; +#endif }; -void* MemoryPoolStaticMalloc::_realloc(void *p_memory,size_t p_bytes) { - - if (p_memory==NULL) { - - return alloc( p_bytes ); +void *MemoryPoolStaticMalloc::_realloc(void *p_memory, size_t p_bytes) { + + if (p_memory == NULL) { + + return alloc(p_bytes); } - - if (p_bytes==0) { - + + if (p_bytes == 0) { + this->free(p_memory); - ERR_FAIL_COND_V( p_bytes < 0 , NULL ); + ERR_FAIL_COND_V(p_bytes < 0, NULL); return NULL; } - + MutexLock lock(mutex); - + #ifdef DEBUG_MEMORY_ENABLED - - - RingPtr *ringptr = (RingPtr*)p_memory; + + RingPtr *ringptr = (RingPtr *)p_memory; ringptr--; /* go back an element to find the tingptr */ - + bool single_element = (ringptr->next == ringptr) && (ringptr->prev == ringptr); - bool is_list = ( ringlist == ringptr ); - - RingPtr *new_ringptr=(RingPtr*)::realloc(ringptr, p_bytes+sizeof(RingPtr)); - - ERR_FAIL_COND_V( new_ringptr == 0, NULL ); /// reallocation failed - + bool is_list = (ringlist == ringptr); + + RingPtr *new_ringptr = (RingPtr *)::realloc(ringptr, p_bytes + sizeof(RingPtr)); + + ERR_FAIL_COND_V(new_ringptr == 0, NULL); /// reallocation failed + /* actualize mem used */ total_mem -= new_ringptr->size; new_ringptr->size = p_bytes; - total_mem += new_ringptr->size; - - if (total_mem > max_mem ) //update statistics + total_mem += new_ringptr->size; + + if (total_mem > max_mem) //update statistics max_mem = total_mem; - - if (new_ringptr == ringptr ) + + if (new_ringptr == ringptr) return ringptr + 1; // block didn't move, don't do anything - + if (single_element) { - - new_ringptr->next=new_ringptr; - new_ringptr->prev=new_ringptr; + + new_ringptr->next = new_ringptr; + new_ringptr->prev = new_ringptr; } else { - - new_ringptr->next->prev=new_ringptr; - new_ringptr->prev->next=new_ringptr; + + new_ringptr->next->prev = new_ringptr; + new_ringptr->prev->next = new_ringptr; } - + if (is_list) - ringlist=new_ringptr; - - + ringlist = new_ringptr; + return new_ringptr + 1; - + #else - return ::realloc( p_memory, p_bytes ); + return ::realloc(p_memory, p_bytes); #endif } void MemoryPoolStaticMalloc::free(void *p_ptr) { - ERR_FAIL_COND( !MemoryPoolStatic::get_singleton()); + ERR_FAIL_COND(!MemoryPoolStatic::get_singleton()); - #if DEFAULT_ALIGNMENT == 1 +#if DEFAULT_ALIGNMENT == 1 - _free(p_ptr); - #else + _free(p_ptr); +#else - uint8_t* mem = (uint8_t*)p_ptr; - int ofs = *(mem-1); - mem = mem - ofs; + uint8_t *mem = (uint8_t *)p_ptr; + int ofs = *(mem - 1); + mem = mem - ofs; - _free(mem); - #endif + _free(mem); +#endif }; - void MemoryPoolStaticMalloc::_free(void *p_ptr) { - + MutexLock lock(mutex); - + #ifdef DEBUG_MEMORY_ENABLED - - if (p_ptr==0) { + + if (p_ptr == 0) { printf("**ERROR: STATIC ALLOC: Attempted free of NULL pointer.\n"); return; }; - - RingPtr *ringptr = (RingPtr*)p_ptr; - + + RingPtr *ringptr = (RingPtr *)p_ptr; + ringptr--; /* go back an element to find the ringptr */ - - + #if 0 { // check for existing memory on free. RingPtr *p = ringlist; @@ -280,155 +274,146 @@ void MemoryPoolStaticMalloc::_free(void *p_ptr) { return; } - } -#endif + } +#endif /* proceed to erase */ - + bool single_element = (ringptr->next == ringptr) && (ringptr->prev == ringptr); - bool is_list = ( ringlist == ringptr ); - + bool is_list = (ringlist == ringptr); + if (single_element) { /* just get rid of it */ - ringlist=0; - + ringlist = 0; + } else { /* auto-remove from ringlist */ if (is_list) - ringlist=ringptr->next; - + ringlist = ringptr->next; + ringptr->prev->next = ringptr->next; ringptr->next->prev = ringptr->prev; } - + total_mem -= ringptr->size; total_pointers--; // catch more errors - zeromem(ringptr,sizeof(RingPtr)+ringptr->size); + zeromem(ringptr, sizeof(RingPtr) + ringptr->size); ::free(ringptr); //just free that pointer - + #else - ERR_FAIL_COND(p_ptr==0); - + ERR_FAIL_COND(p_ptr == 0); + ::free(p_ptr); #endif } - size_t MemoryPoolStaticMalloc::get_available_mem() const { return 0xffffffff; } size_t MemoryPoolStaticMalloc::get_total_usage() { - + #ifdef DEBUG_MEMORY_ENABLED - + return total_mem; -#else +#else return 0; #endif - } size_t MemoryPoolStaticMalloc::get_max_usage() { return max_mem; } - + /* Most likely available only if memory debugger was compiled in */ int MemoryPoolStaticMalloc::get_alloc_count() { - + return total_pointers; } -void * MemoryPoolStaticMalloc::get_alloc_ptr(int p_alloc_idx) { - +void *MemoryPoolStaticMalloc::get_alloc_ptr(int p_alloc_idx) { + return 0; } -const char* MemoryPoolStaticMalloc::get_alloc_description(int p_alloc_idx) { - - +const char *MemoryPoolStaticMalloc::get_alloc_description(int p_alloc_idx) { + return ""; } size_t MemoryPoolStaticMalloc::get_alloc_size(int p_alloc_idx) { - + return 0; } -void MemoryPoolStaticMalloc::dump_mem_to_file(const char* p_file) { +void MemoryPoolStaticMalloc::dump_mem_to_file(const char *p_file) { #ifdef DEBUG_MEMORY_ENABLED - - ERR_FAIL_COND( !ringlist ); /** WTF BUG !? */ + + ERR_FAIL_COND(!ringlist); /** WTF BUG !? */ RingPtr *p = ringlist; - FILE *f = fopen(p_file,"wb"); - + FILE *f = fopen(p_file, "wb"); + do { - fprintf(f,"%p-%i-%s\n", p+1, (int)p->size, (p->descr?p->descr:"") ); - p=p->next; - } while (p!=ringlist); + fprintf(f, "%p-%i-%s\n", p + 1, (int)p->size, (p->descr ? p->descr : "")); + p = p->next; + } while (p != ringlist); fclose(f); -#endif - +#endif } MemoryPoolStaticMalloc::MemoryPoolStaticMalloc() { - -#ifdef DEBUG_MEMORY_ENABLED - total_mem=0; - total_pointers=0; - ringlist=0; - max_mem=0; - max_pointers=0; +#ifdef DEBUG_MEMORY_ENABLED + total_mem = 0; + total_pointers = 0; + ringlist = 0; + max_mem = 0; + max_pointers = 0; #endif - - mutex=NULL; + + mutex = NULL; #ifndef NO_THREADS - mutex=Mutex::create(); // at this point, this should work + mutex = Mutex::create(); // at this point, this should work #endif - } - MemoryPoolStaticMalloc::~MemoryPoolStaticMalloc() { - - Mutex *old_mutex=mutex; - mutex=NULL; + + Mutex *old_mutex = mutex; + mutex = NULL; if (old_mutex) memdelete(old_mutex); - + #ifdef DEBUG_MEMORY_ENABLED if (OS::get_singleton()->is_stdout_verbose()) { - if (total_mem > 0 ) { + if (total_mem > 0) { printf("**ERROR: STATIC ALLOC: ** MEMORY LEAKS DETECTED **\n"); - printf("**ERROR: STATIC ALLOC: %i bytes of memory in use at exit.\n",(int)total_mem); + printf("**ERROR: STATIC ALLOC: %i bytes of memory in use at exit.\n", (int)total_mem); - if (1){ + if (1) { printf("**ERROR: STATIC ALLOC: Following is the list of leaked allocations: \n"); - ERR_FAIL_COND( !ringlist ); /** WTF BUG !? */ + ERR_FAIL_COND(!ringlist); /** WTF BUG !? */ RingPtr *p = ringlist; do { - printf("\t%p - %i bytes - %s\n", (RingPtr*)(p+1), (int)p->size, (p->descr?p->descr:"") ); - p=p->next; - } while (p!=ringlist); + printf("\t%p - %i bytes - %s\n", (RingPtr *)(p + 1), (int)p->size, (p->descr ? p->descr : "")); + p = p->next; + } while (p != ringlist); printf("**ERROR: STATIC ALLOC: End of Report.\n"); }; - printf("mem - max %i, pointers %i, leaks %i.\n",(int)max_mem,max_pointers,(int)total_mem); + printf("mem - max %i, pointers %i, leaks %i.\n", (int)max_mem, max_pointers, (int)total_mem); } else { - printf("INFO: mem - max %i, pointers %i, no leaks.\n",(int)max_mem,max_pointers); + printf("INFO: mem - max %i, pointers %i, no leaks.\n", (int)max_mem, max_pointers); } } - + #endif } - - -- cgit v1.2.3-70-g09d2