Index: libcfa/src/heap.cfa =================================================================== --- libcfa/src/heap.cfa (revision b6830d74cf52c207d2a08ac866856197ee2e29b8) +++ libcfa/src/heap.cfa (revision 933933c7028ae75d883ec7f91df299e7ee478fc3) @@ -1,4 +1,2 @@ -// #comment TD : this file uses both spaces and tabs for indentation - // // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo @@ -12,6 +10,6 @@ // Created On : Tue Dec 19 21:58:35 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Aug 11 08:22:16 2018 -// Update Count : 495 +// Last Modified On : Thu Aug 23 06:11:44 2018 +// Update Count : 511 // @@ -25,9 +23,9 @@ // #comment TD : Many of these should be merged into math I believe -#include "bits/align.hfa" // libPow2 -#include "bits/defs.hfa" // likely, unlikely -#include "bits/locks.hfa" // __spinlock_t +#include "bits/align.hfa" // libPow2 +#include "bits/defs.hfa" // likely, unlikely +#include "bits/locks.hfa" // __spinlock_t #include "startup.hfa" // STARTUP_PRIORITY_MEMORY -#include "stdlib.hfa" // bsearchl +#include "stdlib.hfa" // bsearchl #include "malloc.h" @@ -151,12 +149,12 @@ extern "C" { -void heapAppStart() { // called by __cfaabi_appready_startup - allocFree = 0; -} // heapAppStart - -void heapAppStop() { // called by __cfaabi_appready_startdown - fclose( stdin ); fclose( stdout ); - checkUnfreed(); -} // heapAppStop + void heapAppStart() { // called by __cfaabi_appready_startup + allocFree = 0; + } // heapAppStart + + void heapAppStop() { // called by __cfaabi_appready_startdown + fclose( stdin ); fclose( stdout ); + checkUnfreed(); + } // heapAppStop } // extern "C" #endif // __CFA_DEBUG__ @@ -167,14 +165,12 @@ struct Storage { - struct Header { // header + struct Header { // header union Kind { struct RealHeader { union { - // #comment TD : this code use byte size but the comment uses bit size - - struct { // 32-bit word => 64-bit header, 64-bit word => 128-bit header + struct { // 4-byte word => 8-byte header, 8-byte word => 16-byte header #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ && __SIZEOF_POINTER__ == 4 uint32_t padding; // unused, force home/blocksize to overlay alignment in fake header - #endif // __ORDER_BIG_ENDIAN__ && __U_WORDSIZE__ == 32 + #endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ && __SIZEOF_POINTER__ == 4 union { @@ -189,9 +185,7 @@ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && __SIZEOF_POINTER__ == 4 uint32_t padding; // unused, force home/blocksize to overlay alignment in fake header - #endif // __ORDER_LITTLE_ENDIAN__ && __U_WORDSIZE__ == 32 - + #endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && __SIZEOF_POINTER__ == 4 }; - - // #comment TD : C++ code + // future code #if BUCKLOCK == LOCKFREE Stack::Link next; // freed block points next freed block of same size (double-wide) @@ -211,7 +205,7 @@ } fake; // FakeHeader } kind; // Kind - } header; // Header - char pad[ALIGN - sizeof( Header )]; - char data[0]; // storage + } header; // Header + char pad[ALIGN - sizeof( Header )]; + char data[0]; // storage }; // Storage @@ -220,13 +214,13 @@ struct FreeHeader { #if BUCKLOCK == SPINLOCK - __spinlock_t lock; // must be first field for alignment - Storage * freeList; + __spinlock_t lock; // must be first field for alignment + Storage * freeList; #elif BUCKLOCK == LOCKFREE - // #comment TD : C++ code - StackLF freeList; + // future code + StackLF freeList; #else - #error undefined lock type for bucket lock + #error undefined lock type for bucket lock #endif // SPINLOCK - size_t blockSize; // size of allocations on this list + size_t blockSize; // size of allocations on this list }; // FreeHeader @@ -249,7 +243,6 @@ static unsigned int maxBucketsUsed; // maximum number of buckets in use -// #comment TD : This array is not const but it feels like it should be // Powers of 2 are common allocation sizes, so make powers of 2 generate the minimum required size. -static unsigned int bucketSizes[NoBucketSizes] @= { // different bucket sizes +static const unsigned int bucketSizes[NoBucketSizes] @= { // different bucket sizes 16, 32, 48, 64, 64 + sizeof(HeapManager.Storage), 96, 112, 128, 128 + sizeof(HeapManager.Storage), 160, 192, 224, @@ -279,5 +272,5 @@ // #comment TD : The return type of this function should be commented static inline bool setMmapStart( size_t value ) { - if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true; + if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true; mmapStart = value; // set global @@ -313,5 +306,5 @@ sbrk( (char *)libCeiling( (long unsigned int)End, libAlign() ) - End ); // move start of heap to multiple of alignment heapBegin = heapEnd = sbrk( 0 ); // get new start point -} // HeapManager + } // HeapManager @@ -323,5 +316,5 @@ // } // if #endif // __STATISTICS__ -} // ~HeapManager + } // ~HeapManager @@ -329,5 +322,5 @@ void memory_startup( void ) { #ifdef __CFA_DEBUG__ - if ( unlikely( heapBoot ) ) { // check for recursion during system boot + if ( unlikely( heapBoot ) ) { // check for recursion during system boot // DO NOT USE STREAMS AS THEY MAY BE UNAVAILABLE AT THIS POINT. abort( "boot() : internal error, recursively invoked during system boot." ); @@ -336,6 +329,5 @@ #endif // __CFA_DEBUG__ - // #comment TD : This assertion seems redundent with the above code - assert( heapManager.heapBegin == 0 ); + assert( heapManager.heapBegin == 0 ); // always perform check, done once heapManager{}; } // memory_startup @@ -374,28 +366,27 @@ char helpText[512]; __cfaabi_dbg_bits_print_buffer( helpText, sizeof(helpText), - "\nHeap statistics:\n" - " malloc: calls %u / storage %llu\n" - " calloc: calls %u / storage %llu\n" - " memalign: calls %u / storage %llu\n" - " cmemalign: calls %u / storage %llu\n" - " realloc: calls %u / storage %llu\n" - " free: calls %u / storage %llu\n" - " mmap: calls %u / storage %llu\n" - " munmap: calls %u / storage %llu\n" - " sbrk: calls %u / storage %llu\n", - malloc_calls, malloc_storage, - calloc_calls, calloc_storage, - memalign_calls, memalign_storage, - cmemalign_calls, cmemalign_storage, - realloc_calls, realloc_storage, - free_calls, free_storage, - mmap_calls, mmap_storage, - munmap_calls, munmap_storage, - sbrk_calls, sbrk_storage + "\nHeap statistics:\n" + " malloc: calls %u / storage %llu\n" + " calloc: calls %u / storage %llu\n" + " memalign: calls %u / storage %llu\n" + " cmemalign: calls %u / storage %llu\n" + " realloc: calls %u / storage %llu\n" + " free: calls %u / storage %llu\n" + " mmap: calls %u / storage %llu\n" + " munmap: calls %u / storage %llu\n" + " sbrk: calls %u / storage %llu\n", + malloc_calls, malloc_storage, + calloc_calls, calloc_storage, + memalign_calls, memalign_storage, + cmemalign_calls, cmemalign_storage, + realloc_calls, realloc_storage, + free_calls, free_storage, + mmap_calls, mmap_storage, + munmap_calls, munmap_storage, + sbrk_calls, sbrk_storage ); } // printStats -// #comment TD : Why do we have this? -static int printStatsXML( FILE * stream ) { +static int printStatsXML( FILE * stream ) { // see malloc_info char helpText[512]; int len = snprintf( helpText, sizeof(helpText), @@ -431,6 +422,6 @@ static inline void noMemory() { abort( "Heap memory exhausted at %zu bytes.\n" - "Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.", - ((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) ); + "Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.", + ((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) ); } // noMemory @@ -444,5 +435,5 @@ static inline bool setHeapExpand( size_t value ) { - if ( heapExpand < pageSize ) return true; + if ( heapExpand < pageSize ) return true; heapExpand = value; return false; @@ -453,6 +444,6 @@ if ( unlikely( check ) ) { // bad address ? abort( "Attempt to %s storage %p with address outside the heap.\n" - "Possible cause is duplicate free on same block or overwriting of memory.", - name, addr ); + "Possible cause is duplicate free on same block or overwriting of memory.", + name, addr ); } // if } // checkHeader @@ -484,5 +475,5 @@ #ifdef __CFA_DEBUG__ - checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ? + checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ? #endif // __CFA_DEBUG__ @@ -490,20 +481,20 @@ // It's called as the first statement of both branches of the last if, with the same parameters in all cases - // header may be safe to dereference - fakeHeader( header, size, alignment ); + // header may be safe to dereference + fakeHeader( header, size, alignment ); #ifdef __CFA_DEBUG__ - checkHeader( header < (HeapManager.Storage.Header *)heapBegin || (HeapManager.Storage.Header *)heapEnd < header, name, addr ); // bad address ? (offset could be + or -) + checkHeader( header < (HeapManager.Storage.Header *)heapBegin || (HeapManager.Storage.Header *)heapEnd < header, name, addr ); // bad address ? (offset could be + or -) #endif // __CFA_DEBUG__ - freeElem = (HeapManager.FreeHeader *)((size_t)header->kind.real.home & -3); + freeElem = (HeapManager.FreeHeader *)((size_t)header->kind.real.home & -3); #ifdef __CFA_DEBUG__ - if ( freeElem < &freeLists[0] || &freeLists[NoBucketSizes] <= freeElem ) { - abort( "Attempt to %s storage %p with corrupted header.\n" - "Possible cause is duplicate free on same block or overwriting of header information.", - name, addr ); - } // if + if ( freeElem < &freeLists[0] || &freeLists[NoBucketSizes] <= freeElem ) { + abort( "Attempt to %s storage %p with corrupted header.\n" + "Possible cause is duplicate free on same block or overwriting of header information.", + name, addr ); + } // if #endif // __CFA_DEBUG__ - size = freeElem->blockSize; - return false; + size = freeElem->blockSize; + return false; } // headers @@ -521,12 +512,12 @@ return 0; } // if -#ifdef __STATISTICS__ + #ifdef __STATISTICS__ sbrk_calls += 1; sbrk_storage += increase; -#endif // __STATISTICS__ -#ifdef __CFA_DEBUG__ + #endif // __STATISTICS__ + #ifdef __CFA_DEBUG__ // Set new memory to garbage so subsequent uninitialized usages might fail. memset( (char *)heapEnd + heapRemaining, '\377', increase ); -#endif // __CFA_DEBUG__ + #endif // __CFA_DEBUG__ rem = heapRemaining + increase - size; } // if @@ -560,8 +551,8 @@ #if defined( SPINLOCK ) - lock( freeElem->lock __cfaabi_dbg_ctx2 ); - block = freeElem->freeList; // remove node from stack + lock( freeElem->lock __cfaabi_dbg_ctx2 ); + block = freeElem->freeList; // remove node from stack #else - block = freeElem->freeList.pop(); + block = freeElem->freeList.pop(); #endif // SPINLOCK if ( unlikely( block == 0 ) ) { // no free block ? @@ -569,9 +560,10 @@ unlock( freeElem->lock ); #endif // SPINLOCK + // Freelist for that size was empty, so carve it out of the heap if there's enough left, or get some more // and then carve it off. block = (HeapManager.Storage *)extend( tsize ); // mutual exclusion on call - if ( unlikely( block == 0 ) ) return 0; + if ( unlikely( block == 0 ) ) return 0; #if defined( SPINLOCK ) } else { @@ -582,9 +574,9 @@ block->header.kind.real.home = freeElem; // pointer back to free list of apropriate size - } else { // large size => mmap + } else { // large size => mmap tsize = libCeiling( tsize, pageSize ); // must be multiple of page size #ifdef __STATISTICS__ - __atomic_add_fetch( &mmap_calls, 1, __ATOMIC_SEQ_CST ); - __atomic_add_fetch( &mmap_storage, tsize, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &mmap_calls, 1, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &mmap_storage, tsize, __ATOMIC_SEQ_CST ); #endif // __STATISTICS__ block = (HeapManager.Storage *)mmap( 0, tsize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, mmapFd, 0 ); @@ -593,23 +585,23 @@ abort( "(HeapManager &)0x%p.doMalloc() : internal error, mmap failure, size:%zu error:%d.", &heapManager, tsize, errno ); } // if -#ifdef __CFA_DEBUG__ + #ifdef __CFA_DEBUG__ // Set new memory to garbage so subsequent uninitialized usages might fail. memset( block, '\377', tsize ); -#endif // __CFA_DEBUG__ + #endif // __CFA_DEBUG__ block->header.kind.real.blockSize = tsize; // storage size for munmap - } // if - - void * area = &(block->data); // adjust off header to user bytes + } // if + + void * area = &(block->data); // adjust off header to user bytes #ifdef __CFA_DEBUG__ - assert( ((uintptr_t)area & (libAlign() - 1)) == 0 ); // minimum alignment ? - __atomic_add_fetch( &allocFree, tsize, __ATOMIC_SEQ_CST ); - if ( traceHeap() ) { - enum { BufferSize = 64 }; - char helpText[BufferSize]; - int len = snprintf( helpText, BufferSize, "%p = Malloc( %zu ) (allocated %zu)\n", area, size, tsize ); - // int len = snprintf( helpText, BufferSize, "Malloc %p %zu\n", area, size ); - __cfaabi_dbg_bits_write( helpText, len ); - } // if + assert( ((uintptr_t)area & (libAlign() - 1)) == 0 ); // minimum alignment ? + __atomic_add_fetch( &allocFree, tsize, __ATOMIC_SEQ_CST ); + if ( traceHeap() ) { + enum { BufferSize = 64 }; + char helpText[BufferSize]; + int len = snprintf( helpText, BufferSize, "%p = Malloc( %zu ) (allocated %zu)\n", area, size, tsize ); + // int len = snprintf( helpText, BufferSize, "Malloc %p %zu\n", area, size ); + __cfaabi_dbg_bits_write( helpText, len ); + } // if #endif // __CFA_DEBUG__ @@ -620,7 +612,7 @@ static inline void doFree( void * addr ) with ( heapManager ) { #ifdef __CFA_DEBUG__ - if ( unlikely( heapManager.heapBegin == 0 ) ) { - abort( "doFree( %p ) : internal error, called before heap is initialized.", addr ); - } // if + if ( unlikely( heapManager.heapBegin == 0 ) ) { + abort( "doFree( %p ) : internal error, called before heap is initialized.", addr ); + } // if #endif // __CFA_DEBUG__ @@ -631,40 +623,40 @@ if ( headers( "free", addr, header, freeElem, size, alignment ) ) { // mmapped ? #ifdef __STATISTICS__ - __atomic_add_fetch( &munmap_calls, 1, __ATOMIC_SEQ_CST ); - __atomic_add_fetch( &munmap_storage, size, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &munmap_calls, 1, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &munmap_storage, size, __ATOMIC_SEQ_CST ); #endif // __STATISTICS__ if ( munmap( header, size ) == -1 ) { #ifdef __CFA_DEBUG__ abort( "Attempt to deallocate storage %p not allocated or with corrupt header.\n" - "Possible cause is invalid pointer.", - addr ); + "Possible cause is invalid pointer.", + addr ); #endif // __CFA_DEBUG__ } // if - } else { + } else { #ifdef __CFA_DEBUG__ - // Set free memory to garbage so subsequent usages might fail. - memset( ((HeapManager.Storage *)header)->data, '\377', freeElem->blockSize - sizeof( HeapManager.Storage ) ); + // Set free memory to garbage so subsequent usages might fail. + memset( ((HeapManager.Storage *)header)->data, '\377', freeElem->blockSize - sizeof( HeapManager.Storage ) ); #endif // __CFA_DEBUG__ #ifdef __STATISTICS__ - free_storage += size; + free_storage += size; #endif // __STATISTICS__ #if defined( SPINLOCK ) - lock( freeElem->lock __cfaabi_dbg_ctx2 ); // acquire spin lock - header->kind.real.next = freeElem->freeList; // push on stack - freeElem->freeList = (HeapManager.Storage *)header; - unlock( freeElem->lock ); // release spin lock + lock( freeElem->lock __cfaabi_dbg_ctx2 ); // acquire spin lock + header->kind.real.next = freeElem->freeList; // push on stack + freeElem->freeList = (HeapManager.Storage *)header; + unlock( freeElem->lock ); // release spin lock #else - freeElem->freeList.push( *(HeapManager.Storage *)header ); + freeElem->freeList.push( *(HeapManager.Storage *)header ); #endif // SPINLOCK - } // if + } // if #ifdef __CFA_DEBUG__ - __atomic_add_fetch( &allocFree, -size, __ATOMIC_SEQ_CST ); - if ( traceHeap() ) { - char helpText[64]; - int len = snprintf( helpText, sizeof(helpText), "Free( %p ) size:%zu\n", addr, size ); - __cfaabi_dbg_bits_write( helpText, len ); - } // if + __atomic_add_fetch( &allocFree, -size, __ATOMIC_SEQ_CST ); + if ( traceHeap() ) { + char helpText[64]; + int len = snprintf( helpText, sizeof(helpText), "Free( %p ) size:%zu\n", addr, size ); + __cfaabi_dbg_bits_write( helpText, len ); + } // if #endif // __CFA_DEBUG__ } // doFree @@ -674,6 +666,6 @@ size_t total = 0; #ifdef __STATISTICS__ - __cfaabi_dbg_bits_acquire(); - __cfaabi_dbg_bits_print_nolock( "\nBin lists (bin size : free blocks on list)\n" ); + __cfaabi_dbg_bits_acquire(); + __cfaabi_dbg_bits_print_nolock( "\nBin lists (bin size : free blocks on list)\n" ); #endif // __STATISTICS__ for ( unsigned int i = 0; i < maxBucketsUsed; i += 1 ) { @@ -695,31 +687,31 @@ #ifdef __STATISTICS__ - __cfaabi_dbg_bits_print_nolock( "%7zu, %-7u ", size, N ); - if ( (i + 1) % 8 == 0 ) __cfaabi_dbg_bits_print_nolock( "\n" ); + __cfaabi_dbg_bits_print_nolock( "%7zu, %-7u ", size, N ); + if ( (i + 1) % 8 == 0 ) __cfaabi_dbg_bits_print_nolock( "\n" ); #endif // __STATISTICS__ } // for #ifdef __STATISTICS__ - __cfaabi_dbg_bits_print_nolock( "\ntotal free blocks:%zu\n", total ); - __cfaabi_dbg_bits_release(); + __cfaabi_dbg_bits_print_nolock( "\ntotal free blocks:%zu\n", total ); + __cfaabi_dbg_bits_release(); #endif // __STATISTICS__ return (char *)heapEnd - (char *)heapBegin - total; } // checkFree -// #comment TD : This is not a good name, plus this feels like it could easily be folded into doMalloc -static inline void * malloc2( size_t size ) { // necessary for malloc statistics + +static inline void * mallocNoStats( size_t size ) { // necessary for malloc statistics assert( heapManager.heapBegin != 0 ); void * area = doMalloc( size ); if ( unlikely( area == 0 ) ) errno = ENOMEM; // POSIX return area; -} // malloc2 - - -static inline void * memalign2( size_t alignment, size_t size ) { // necessary for malloc statistics -#ifdef __CFA_DEBUG__ +} // mallocNoStats + + +static inline void * memalignNoStats( size_t alignment, size_t size ) { // necessary for malloc statistics + #ifdef __CFA_DEBUG__ checkAlign( alignment ); // check alignment -#endif // __CFA_DEBUG__ + #endif // __CFA_DEBUG__ // if alignment <= default alignment, do normal malloc as two headers are unnecessary - if ( unlikely( alignment <= libAlign() ) ) return malloc2( size ); + if ( unlikely( alignment <= libAlign() ) ) return mallocNoStats( size ); // Allocate enough storage to guarantee an address on the alignment boundary, and sufficient space before it for @@ -732,7 +724,7 @@ // subtract libAlign() because it is already the minimum alignment // add sizeof(Storage) for fake header - // #comment TD : this is the only place that calls doMalloc without calling malloc2, why ? + // #comment TD : this is the only place that calls doMalloc without calling mallocNoStats, why ? char * area = (char *)doMalloc( size + alignment - libAlign() + sizeof(HeapManager.Storage) ); - if ( unlikely( area == 0 ) ) return area; + if ( unlikely( area == 0 ) ) return area; // address in the block of the "next" alignment address @@ -749,34 +741,32 @@ return user; -} // memalign2 +} // memalignNoStats extern "C" { - // The malloc() function allocates size bytes and returns a pointer to the - // allocated memory. The memory is not initialized. If size is 0, then malloc() - // returns either NULL, or a unique pointer value that can later be successfully - // passed to free(). + // The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not + // initialized. If size is 0, then malloc() returns either NULL, or a unique pointer value that can later be + // successfully passed to free(). void * malloc( size_t size ) { #ifdef __STATISTICS__ - __atomic_add_fetch( &malloc_calls, 1, __ATOMIC_SEQ_CST ); - __atomic_add_fetch( &malloc_storage, size, __ATOMIC_SEQ_CST ); - #endif // __STATISTICS__ - - return malloc2( size ); - } // malloc - - // The calloc() function allocates memory for an array of nmemb elements of - // size bytes each and returns a pointer to the allocated memory. The memory - // is set to zero. If nmemb or size is 0, then calloc() returns either NULL, - // or a unique pointer value that can later be successfully passed to free(). - void * calloc( size_t noOfElems, size_t elemSize ) { + __atomic_add_fetch( &malloc_calls, 1, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &malloc_storage, size, __ATOMIC_SEQ_CST ); + #endif // __STATISTICS__ + + return mallocNoStats( size ); + } // malloc + + // The calloc() function allocates memory for an array of nmemb elements of size bytes each and returns a pointer to + // the allocated memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either NULL, or a + // unique pointer value that can later be successfully passed to free(). + void * calloc( size_t noOfElems, size_t elemSize ) { size_t size = noOfElems * elemSize; #ifdef __STATISTICS__ - __atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST ); - __atomic_add_fetch( &calloc_storage, size, __ATOMIC_SEQ_CST ); - #endif // __STATISTICS__ - - char * area = (char *)malloc2( size ); - if ( unlikely( area == 0 ) ) return 0; + __atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &calloc_storage, size, __ATOMIC_SEQ_CST ); + #endif // __STATISTICS__ + + char * area = (char *)mallocNoStats( size ); + if ( unlikely( area == 0 ) ) return 0; HeapManager.Storage.Header * header; @@ -790,7 +780,7 @@ memset( area, '\0', asize - sizeof(HeapManager.Storage) ); // set to zeros - header->kind.real.blockSize |= 2; // mark as zero filled + header->kind.real.blockSize |= 2; // mark as zero filled return area; - } // calloc + } // calloc // #comment TD : Document this function @@ -798,10 +788,10 @@ size_t size = noOfElems * elemSize; #ifdef __STATISTICS__ - __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST ); - __atomic_add_fetch( &cmemalign_storage, size, __ATOMIC_SEQ_CST ); - #endif // __STATISTICS__ - - char * area = (char *)memalign2( alignment, size ); - if ( unlikely( area == 0 ) ) return 0; + __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &cmemalign_storage, size, __ATOMIC_SEQ_CST ); + #endif // __STATISTICS__ + + char * area = (char *)memalignNoStats( alignment, size ); + if ( unlikely( area == 0 ) ) return 0; HeapManager.Storage.Header * header; HeapManager.FreeHeader * freeElem; @@ -811,27 +801,24 @@ // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero. if ( ! mapped ) - #endif // __CFA_DEBUG__ + #endif // __CFA_DEBUG__ memset( area, '\0', asize - ( (char *)area - (char *)header ) ); // set to zeros header->kind.real.blockSize |= 2; // mark as zero filled return area; - } // cmemalign - - // The realloc() function changes the size of the memory block pointed to by - // ptr to size bytes. The contents will be unchanged in the range from the - // start of the region up to the minimum of the old and new sizes. If the new - // size is larger than the old size, the added memory will not be initialized. - // If ptr is NULL, then the call is equivalent to malloc(size), for all values - // of size; if size is equal to zero, and ptr is not NULL, then the call is - // equivalent to free(ptr). Unless ptr is NULL, it must have been returned by - // an earlier call to malloc(), calloc() or realloc(). If the area pointed to - // was moved, a free(ptr) is done. - void * realloc( void * addr, size_t size ) { - #ifdef __STATISTICS__ - __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST ); - #endif // __STATISTICS__ - - if ( unlikely( addr == 0 ) ) return malloc2( size ); // special cases - if ( unlikely( size == 0 ) ) { free( addr ); return 0; } + } // cmemalign + + // The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be + // unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size + // is larger than the old size, the added memory will not be initialized. If ptr is NULL, then the call is + // equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not NULL, then the call + // is equivalent to free(ptr). Unless ptr is NULL, it must have been returned by an earlier call to malloc(), + // calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done. + void * realloc( void * addr, size_t size ) { + #ifdef __STATISTICS__ + __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST ); + #endif // __STATISTICS__ + + if ( unlikely( addr == 0 ) ) return mallocNoStats( size ); // special cases + if ( unlikely( size == 0 ) ) { free( addr ); return 0; } HeapManager.Storage.Header * header; @@ -848,5 +835,5 @@ #ifdef __STATISTICS__ - __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST ); #endif // __STATISTICS__ @@ -855,7 +842,7 @@ area = memalign( alignment, size ); // create new area } else { - area = malloc2( size ); // create new area + area = mallocNoStats( size ); // create new area } // if - if ( unlikely( area == 0 ) ) return 0; + if ( unlikely( area == 0 ) ) return 0; if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill (calloc/cmemalign) ? assert( (header->kind.real.blockSize & 1) == 0 ); @@ -864,5 +851,5 @@ // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero. if ( ! mapped ) - #endif // __CFA_DEBUG__ + #endif // __CFA_DEBUG__ memset( (char *)area + usize, '\0', asize - ( (char *)area - (char *)header ) - usize ); // zero-fill back part header->kind.real.blockSize |= 2; // mark new request as zero fill @@ -874,9 +861,7 @@ - // The obsolete function memalign() allocates size bytes and returns - // a pointer to the allocated memory. The memory address will be a - // multiple of alignment, which must be a power of two. - void * memalign( size_t alignment, size_t size ) __attribute__ ((deprecated)); - void * memalign( size_t alignment, size_t size ) { + // The obsolete function memalign() allocates size bytes and returns a pointer to the allocated memory. The memory + // address will be a multiple of alignment, which must be a power of two. + void * memalign( size_t alignment, size_t size ) { #ifdef __STATISTICS__ __atomic_add_fetch( &memalign_calls, 1, __ATOMIC_SEQ_CST ); @@ -884,11 +869,11 @@ #endif // __STATISTICS__ - void * area = memalign2( alignment, size ); + void * area = memalignNoStats( alignment, size ); return area; - } // memalign - - // The function aligned_alloc() is the same as memalign(), except for - // the added restriction that size should be a multiple of alignment. + } // memalign + + // The function aligned_alloc() is the same as memalign(), except for the added restriction that size should be a + // multiple of alignment. void * aligned_alloc( size_t alignment, size_t size ) { return memalign( alignment, size ); @@ -896,20 +881,17 @@ - // The function posix_memalign() allocates size bytes and places the address - // of the allocated memory in *memptr. The address of the allocated memory - // will be a multiple of alignment, which must be a power of two and a multiple - // of sizeof(void *). If size is 0, then posix_memalign() returns either NULL, - // or a unique pointer value that can later be successfully passed to free(3). + // The function posix_memalign() allocates size bytes and places the address of the allocated memory in *memptr. The + // address of the allocated memory will be a multiple of alignment, which must be a power of two and a multiple of + // sizeof(void *). If size is 0, then posix_memalign() returns either NULL, or a unique pointer value that can later + // be successfully passed to free(3). int posix_memalign( void ** memptr, size_t alignment, size_t size ) { - if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment + if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment * memptr = memalign( alignment, size ); - if ( unlikely( * memptr == 0 ) ) return ENOMEM; + if ( unlikely( * memptr == 0 ) ) return ENOMEM; return 0; } // posix_memalign - // The obsolete function valloc() allocates size bytes and returns a pointer - // to the allocated memory. The memory address will be a multiple of the page size. - // It is equivalent to memalign(sysconf(_SC_PAGESIZE),size). - void * valloc( size_t size ) __attribute__ ((deprecated)); + // The obsolete function valloc() allocates size bytes and returns a pointer to the allocated memory. The memory + // address will be a multiple of the page size. It is equivalent to memalign(sysconf(_SC_PAGESIZE),size). void * valloc( size_t size ) { return memalign( pageSize, size ); @@ -917,11 +899,10 @@ - // The free() function frees the memory space pointed to by ptr, which must - // have been returned by a previous call to malloc(), calloc() or realloc(). - // Otherwise, or if free(ptr) has already been called before, undefined - // behavior occurs. If ptr is NULL, no operation is performed. + // The free() function frees the memory space pointed to by ptr, which must have been returned by a previous call to + // malloc(), calloc() or realloc(). Otherwise, or if free(ptr) has already been called before, undefined behavior + // occurs. If ptr is NULL, no operation is performed. void free( void * addr ) { #ifdef __STATISTICS__ - __atomic_add_fetch( &free_calls, 1, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &free_calls, 1, __ATOMIC_SEQ_CST ); #endif // __STATISTICS__ @@ -931,9 +912,9 @@ if ( unlikely( addr == 0 ) ) { // special case #ifdef __CFA_DEBUG__ - if ( traceHeap() ) { - #define nullmsg "Free( 0x0 ) size:0\n" - // Do not debug print free( 0 ), as it can cause recursive entry from sprintf. - __cfaabi_dbg_bits_write( nullmsg, sizeof(nullmsg) - 1 ); - } // if + if ( traceHeap() ) { + #define nullmsg "Free( 0x0 ) size:0\n" + // Do not debug print free( 0 ), as it can cause recursive entry from sprintf. + __cfaabi_dbg_bits_write( nullmsg, sizeof(nullmsg) - 1 ); + } // if #endif // __CFA_DEBUG__ return; @@ -943,32 +924,30 @@ } // free - // The mallopt() function adjusts parameters that control the behavior of the - // memory-allocation functions (see malloc(3)). The param argument specifies - // the parameter to be modified, and value specifies the new value for that + // The mallopt() function adjusts parameters that control the behavior of the memory-allocation functions (see + // malloc(3)). The param argument specifies the parameter to be modified, and value specifies the new value for that // parameter. - int mallopt( int option, int value ) { + int mallopt( int option, int value ) { choose( option ) { - case M_TOP_PAD: - if ( setHeapExpand( value ) ) fallthru default; - case M_MMAP_THRESHOLD: - if ( setMmapStart( value ) ) fallthru default; - default: - // #comment TD : 1 for unsopported feels wrong - return 1; // success, or unsupported + case M_TOP_PAD: + if ( setHeapExpand( value ) ) fallthru default; + case M_MMAP_THRESHOLD: + if ( setMmapStart( value ) ) fallthru default; + default: + // #comment TD : 1 for unsopported feels wrong + return 1; // success, or unsupported } // switch return 0; // error } // mallopt - // The malloc_trim() function attempts to release free memory at the top - // of the heap (by calling sbrk(2) with a suitable argument). + // The malloc_trim() function attempts to release free memory at the top of the heap (by calling sbrk(2) with a + // suitable argument). int malloc_trim( size_t ) { return 0; // => impossible to release memory } // malloc_trim - // The malloc_usable_size() function returns the number of usable bytes in the - // block pointed to by ptr, a pointer to a block of memory allocated by - // malloc(3) or a related function. - size_t malloc_usable_size( void * addr ) { - if ( unlikely( addr == 0 ) ) return 0; // null allocation has 0 size + // The malloc_usable_size() function returns the number of usable bytes in the block pointed to by ptr, a pointer to + // a block of memory allocated by malloc(3) or a related function. + size_t malloc_usable_size( void * addr ) { + if ( unlikely( addr == 0 ) ) return 0; // null allocation has 0 size HeapManager.Storage.Header * header; @@ -982,7 +961,7 @@ - // #comment TD : Document this function + // The malloc_alignment() function returns the alignment of the allocation. size_t malloc_alignment( void * addr ) { - if ( unlikely( addr == 0 ) ) return libAlign(); // minimum alignment + if ( unlikely( addr == 0 ) ) return libAlign(); // minimum alignment HeapManager.Storage.Header * header = (HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) ); if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ? @@ -991,10 +970,10 @@ return libAlign (); // minimum alignment } // if - } // malloc_alignment - - - // #comment TD : Document this function + } // malloc_alignment + + + // The malloc_zero_fill() function returns true if the allocation is zero filled, i.e., initially allocated by calloc(). bool malloc_zero_fill( void * addr ) { - if ( unlikely( addr == 0 ) ) return false; // null allocation is not zero fill + if ( unlikely( addr == 0 ) ) return false; // null allocation is not zero fill HeapManager.Storage.Header * header = (HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) ); @@ -1003,28 +982,30 @@ } // if return (header->kind.real.blockSize & 2) != 0; // zero filled (calloc/cmemalign) ? - } // malloc_zero_fill - - - // #comment TD : Document this function + } // malloc_zero_fill + + + // The malloc_stats() function prints (on default standard error) statistics about memory allocated by malloc(3) and + // related functions. void malloc_stats( void ) { #ifdef __STATISTICS__ - printStats(); - if ( checkFree() ) checkFree( heapManager ); - #endif // __STATISTICS__ - } // malloc_stats - - // #comment TD : Document this function - int malloc_stats_fd( int fd ) { - #ifdef __STATISTICS__ - int temp = statfd; - statfd = fd; - return temp; + printStats(); + if ( checkFree() ) checkFree( heapManager ); + #endif // __STATISTICS__ + } // malloc_stats + + // The malloc_stats_fd() function changes the file descripter where malloc_stats() writes the statistics. + int malloc_stats_fd( int fd ) { + #ifdef __STATISTICS__ + int temp = statfd; + statfd = fd; + return temp; #else - return -1; - #endif // __STATISTICS__ - } // malloc_stats_fd - - - // #comment TD : Document this function + return -1; + #endif // __STATISTICS__ + } // malloc_stats_fd + + // The malloc_info() function exports an XML string that describes the current state of the memory-allocation + // implementation in the caller. The string is printed on the file stream stream. The exported string includes + // information about all arenas (see malloc(3)). int malloc_info( int options, FILE * stream ) { return printStatsXML( stream ); @@ -1032,11 +1013,17 @@ - // #comment TD : What are these two functions for? + // The malloc_get_state() function records the current state of all malloc(3) internal bookkeeping variables (but + // not the actual contents of the heap or the state of malloc_hook(3) functions pointers). The state is recorded in + // a system-dependent opaque data structure dynamically allocated via malloc(3), and a pointer to that data + // structure is returned as the function result. (It is the caller's responsibility to free(3) this memory.) void * malloc_get_state( void ) { - return 0; + return 0; // unsupported } // malloc_get_state + + // The malloc_set_state() function restores the state of all malloc(3) internal bookkeeping variables to the values + // recorded in the opaque data structure pointed to by state. int malloc_set_state( void * ptr ) { - return 0; + return 0; // unsupported } // malloc_set_state } // extern "C"