diff options
Diffstat (limited to 'extern/bullet2/src/LinearMath/btAlignedAllocator.cpp')
| -rw-r--r-- | extern/bullet2/src/LinearMath/btAlignedAllocator.cpp | 228 |
1 files changed, 155 insertions, 73 deletions
diff --git a/extern/bullet2/src/LinearMath/btAlignedAllocator.cpp b/extern/bullet2/src/LinearMath/btAlignedAllocator.cpp index a65296c6abe..be8f8aa6d0b 100644 --- a/extern/bullet2/src/LinearMath/btAlignedAllocator.cpp +++ b/extern/bullet2/src/LinearMath/btAlignedAllocator.cpp @@ -15,9 +15,11 @@ subject to the following restrictions: #include "btAlignedAllocator.h" +#ifdef BT_DEBUG_MEMORY_ALLOCATIONS int gNumAlignedAllocs = 0; int gNumAlignedFree = 0; -int gTotalBytesAlignedAllocs = 0;//detect memory leaks +int gTotalBytesAlignedAllocs = 0; //detect memory leaks +#endif //BT_DEBUG_MEMORY_ALLOCATIONST_DEBUG_ALLOCATIONS static void *btAllocDefault(size_t size) { @@ -32,9 +34,7 @@ static void btFreeDefault(void *ptr) static btAllocFunc *sAllocFunc = btAllocDefault; static btFreeFunc *sFreeFunc = btFreeDefault; - - -#if defined (BT_HAS_ALIGNED_ALLOCATOR) +#if defined(BT_HAS_ALIGNED_ALLOCATOR) #include <malloc.h> static void *btAlignedAllocDefault(size_t size, int alignment) { @@ -59,123 +59,205 @@ static inline void btAlignedFreeDefault(void *ptr) } #else - - - - static inline void *btAlignedAllocDefault(size_t size, int alignment) { - void *ret; - char *real; - real = (char *)sAllocFunc(size + sizeof(void *) + (alignment-1)); - if (real) { - ret = btAlignPointer(real + sizeof(void *),alignment); - *((void **)(ret)-1) = (void *)(real); - } else { - ret = (void *)(real); - } - return (ret); + void *ret; + char *real; + real = (char *)sAllocFunc(size + sizeof(void *) + (alignment - 1)); + if (real) + { + ret = btAlignPointer(real + sizeof(void *), alignment); + *((void **)(ret)-1) = (void *)(real); + } + else + { + ret = (void *)(real); + } + return (ret); } static inline void btAlignedFreeDefault(void *ptr) { - void* real; + void *real; - if (ptr) { - real = *((void **)(ptr)-1); - sFreeFunc(real); - } + if (ptr) + { + real = *((void **)(ptr)-1); + sFreeFunc(real); + } } #endif - static btAlignedAllocFunc *sAlignedAllocFunc = btAlignedAllocDefault; static btAlignedFreeFunc *sAlignedFreeFunc = btAlignedFreeDefault; void btAlignedAllocSetCustomAligned(btAlignedAllocFunc *allocFunc, btAlignedFreeFunc *freeFunc) { - sAlignedAllocFunc = allocFunc ? allocFunc : btAlignedAllocDefault; - sAlignedFreeFunc = freeFunc ? freeFunc : btAlignedFreeDefault; + sAlignedAllocFunc = allocFunc ? allocFunc : btAlignedAllocDefault; + sAlignedFreeFunc = freeFunc ? freeFunc : btAlignedFreeDefault; } void btAlignedAllocSetCustom(btAllocFunc *allocFunc, btFreeFunc *freeFunc) { - sAllocFunc = allocFunc ? allocFunc : btAllocDefault; - sFreeFunc = freeFunc ? freeFunc : btFreeDefault; + sAllocFunc = allocFunc ? allocFunc : btAllocDefault; + sFreeFunc = freeFunc ? freeFunc : btFreeDefault; } #ifdef BT_DEBUG_MEMORY_ALLOCATIONS -//this generic allocator provides the total allocated number of bytes + +static int allocations_id[10241024]; +static int allocations_bytes[10241024]; +static int mynumallocs = 0; #include <stdio.h> -void* btAlignedAllocInternal (size_t size, int alignment,int line,char* filename) +int btDumpMemoryLeaks() { - void *ret; - char *real; + int totalLeak = 0; + + for (int i = 0; i < mynumallocs; i++) + { + printf("Error: leaked memory of allocation #%d (%d bytes)\n", allocations_id[i], allocations_bytes[i]); + totalLeak += allocations_bytes[i]; + } + if (totalLeak) + { + printf("Error: memory leaks: %d allocations were not freed and leaked together %d bytes\n", mynumallocs, totalLeak); + } + return totalLeak; +} +//this generic allocator provides the total allocated number of bytes +#include <stdio.h> - gTotalBytesAlignedAllocs += size; - gNumAlignedAllocs++; +struct btDebugPtrMagic +{ + union { + void **vptrptr; + void *vptr; + int *iptr; + char *cptr; + }; +}; + +void *btAlignedAllocInternal(size_t size, int alignment, int line, const char *filename) +{ + if (size == 0) + { + printf("Whaat? size==0"); + return 0; + } + static int allocId = 0; + + void *ret; + char *real; + + // to find some particular memory leak, you could do something like this: + // if (allocId==172) + // { + // printf("catch me!\n"); + // } + // if (size>1024*1024) + // { + // printf("big alloc!%d\n", size); + // } + + gTotalBytesAlignedAllocs += size; + gNumAlignedAllocs++; - - real = (char *)sAllocFunc(size + 2*sizeof(void *) + (alignment-1)); - if (real) { - ret = (void*) btAlignPointer(real + 2*sizeof(void *), alignment); - *((void **)(ret)-1) = (void *)(real); - *((int*)(ret)-2) = size; + int sz4prt = 4 * sizeof(void *); - } else { - ret = (void *)(real);//?? - } + real = (char *)sAllocFunc(size + sz4prt + (alignment - 1)); + if (real) + { + ret = (void *)btAlignPointer(real + sz4prt, alignment); + btDebugPtrMagic p; + p.vptr = ret; + p.cptr -= sizeof(void *); + *p.vptrptr = (void *)real; + p.cptr -= sizeof(void *); + *p.iptr = size; + p.cptr -= sizeof(void *); + *p.iptr = allocId; + + allocations_id[mynumallocs] = allocId; + allocations_bytes[mynumallocs] = size; + mynumallocs++; + } + else + { + ret = (void *)(real); //?? + } - printf("allocation#%d at address %x, from %s,line %d, size %d\n",gNumAlignedAllocs,real, filename,line,size); + printf("allocation %d at address %x, from %s,line %d, size %d (total allocated = %d)\n", allocId, real, filename, line, size, gTotalBytesAlignedAllocs); + allocId++; - int* ptr = (int*)ret; - *ptr = 12; - return (ret); + int *ptr = (int *)ret; + *ptr = 12; + return (ret); } -void btAlignedFreeInternal (void* ptr,int line,char* filename) +void btAlignedFreeInternal(void *ptr, int line, const char *filename) { + void *real; - void* real; - gNumAlignedFree++; - - if (ptr) { - real = *((void **)(ptr)-1); - int size = *((int*)(ptr)-2); - gTotalBytesAlignedAllocs -= size; - - printf("free #%d at address %x, from %s,line %d, size %d\n",gNumAlignedFree,real, filename,line,size); - - sFreeFunc(real); - } else - { - printf("NULL ptr\n"); - } + if (ptr) + { + gNumAlignedFree++; + + btDebugPtrMagic p; + p.vptr = ptr; + p.cptr -= sizeof(void *); + real = *p.vptrptr; + p.cptr -= sizeof(void *); + int size = *p.iptr; + p.cptr -= sizeof(void *); + int allocId = *p.iptr; + + bool found = false; + + for (int i = 0; i < mynumallocs; i++) + { + if (allocations_id[i] == allocId) + { + allocations_id[i] = allocations_id[mynumallocs - 1]; + allocations_bytes[i] = allocations_bytes[mynumallocs - 1]; + mynumallocs--; + found = true; + break; + } + } + + gTotalBytesAlignedAllocs -= size; + + int diff = gNumAlignedAllocs - gNumAlignedFree; + printf("free %d at address %x, from %s,line %d, size %d (total remain = %d in %d non-freed allocations)\n", allocId, real, filename, line, size, gTotalBytesAlignedAllocs, diff); + + sFreeFunc(real); + } + else + { + //printf("deleting a NULL ptr, no effect\n"); + } } -#else //BT_DEBUG_MEMORY_ALLOCATIONS +#else //BT_DEBUG_MEMORY_ALLOCATIONS -void* btAlignedAllocInternal (size_t size, int alignment) +void *btAlignedAllocInternal(size_t size, int alignment) { - gNumAlignedAllocs++; - void* ptr; + void *ptr; ptr = sAlignedAllocFunc(size, alignment); -// printf("btAlignedAllocInternal %d, %x\n",size,ptr); + // printf("btAlignedAllocInternal %d, %x\n",size,ptr); return ptr; } -void btAlignedFreeInternal (void* ptr) +void btAlignedFreeInternal(void *ptr) { if (!ptr) { return; } - gNumAlignedFree++; -// printf("btAlignedFreeInternal %x\n",ptr); + // printf("btAlignedFreeInternal %x\n",ptr); sAlignedFreeFunc(ptr); } -#endif //BT_DEBUG_MEMORY_ALLOCATIONS - +#endif //BT_DEBUG_MEMORY_ALLOCATIONS |