Changeset feb999f


Ignore:
Timestamp:
Apr 12, 2024, 7:49:05 AM (5 weeks ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
master
Children:
b78c54f
Parents:
6dd4091
Message:

formatting, change free null statistic to also count malloc(0), remove spurious union/struct in header, remove spurious CALIGN after attribute fix, update the PROLOG macro

Location:
libcfa/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/heap.cfa

    r6dd4091 rfeb999f  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jan  3 21:30:54 2024
    13 // Update Count     : 1619
     12// Last Modified On : Sun Apr  7 21:54:29 2024
     13// Update Count     : 1644
    1414//
    1515
     
    114114
    115115
    116 // generic Bsearchl does not inline, so substitute with hand-coded binary-search.
     116// CFA generic Bsearchl does not inline, so substitute with hand-coded binary-search.
    117117inline __attribute__((always_inline))
    118118static size_t Bsearchl( unsigned int key, const unsigned int vals[], size_t dim ) {
     
    190190                unsigned int realloc_calls, realloc_0_calls;
    191191                unsigned long long int realloc_storage_request, realloc_storage_alloc;
    192                 unsigned int free_calls, free_null_calls;
     192                unsigned int free_calls, free_null_0_calls;
    193193                unsigned long long int free_storage_request, free_storage_alloc;
    194194                unsigned int return_pulls, return_pushes;
     
    232232                struct Header {                                                                 // header
    233233                        union Kind {
    234                                 struct RealHeader {
     234                                struct RealHeader {                                             // 4-byte word => 8-byte header, 8-byte word => 16-byte header
    235235                                        union {
    236                                                 struct {                                                // 4-byte word => 8-byte header, 8-byte word => 16-byte header
    237                                                         union {
    238                                                                 // 2nd low-order bit => zero filled, 3rd low-order bit => mmapped
    239                                                                 // FreeHeader * home;           // allocated block points back to home locations (must overlay alignment)
    240                                                                 void * home;                    // allocated block points back to home locations (must overlay alignment)
    241                                                                 size_t blockSize;               // size for munmap (must overlay alignment)
    242                                                                 Storage * next;                 // freed block points to next freed block of same size
    243                                                         };
    244                                                         size_t size;                            // allocation size in bytes
    245                                                 };
     236                                                // 2nd low-order bit => zero filled, 3rd low-order bit => mmapped
     237                                                // FreeHeader * home;                   // allocated block points back to home locations (must overlay alignment)
     238                                                void * home;                                    // allocated block points back to home locations (must overlay alignment)
     239                                                size_t blockSize;                               // size for munmap (must overlay alignment)
     240                                                Storage * next;                                 // freed block points to next freed block of same size
    246241                                        };
     242                                        size_t size;                                            // allocation size in bytes
    247243                                } real; // RealHeader
    248244
     
    261257
    262258        struct CALIGN FreeHeader {
    263                 size_t blockSize CALIGN;                                                // size of allocations on this list
    264259                #ifdef OWNERSHIP
    265260                #ifdef RETURNSPIN
     
    271266                Storage * freeList;                                                             // thread free list
    272267                Heap * homeManager;                                                             // heap owner (free storage to bucket, from bucket to heap)
     268                size_t blockSize;                                                               // size of allocations on this list
    273269        }; // FreeHeader
    274270
     
    369365static __thread size_t PAD1 CALIGN TLSMODEL __attribute__(( unused )); // protect false sharing
    370366static __thread Heap * heapManager CALIGN TLSMODEL;
    371 static  __thread bool heapManagerBootFlag CALIGN TLSMODEL = false;
     367static __thread bool heapManagerBootFlag CALIGN TLSMODEL = false;
    372368static __thread size_t PAD2 CALIGN TLSMODEL __attribute__(( unused )); // protect further false sharing
    373369
     
    595591
    596592#ifdef __STATISTICS__
    597 static HeapStatistics stats;                                                    // zero filled
    598 
    599593#define prtFmt \
    600594        "\nHeap statistics: (storage request / allocation)\n" \
     
    607601        "  resize    >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n" \
    608602        "  realloc   >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n" \
    609         "  free      !null calls %'u; null calls %'u; storage %'llu / %'llu bytes\n" \
     603        "  free      !null calls %'u; null/0 calls %'u; storage %'llu / %'llu bytes\n" \
    610604        "  return    pulls %'u; pushes %'u; storage %'llu / %'llu bytes\n" \
    611605        "  sbrk      calls %'u; storage %'llu bytes\n" \
     
    627621                        resize_calls, resize_0_calls, resize_storage_request, resize_storage_alloc,
    628622                        realloc_calls, realloc_0_calls, realloc_storage_request, realloc_storage_alloc,
    629                         free_calls, free_null_calls, free_storage_request, free_storage_alloc,
     623                        free_calls, free_null_0_calls, free_storage_request, free_storage_alloc,
    630624                        return_pulls, return_pushes, return_storage_request, return_storage_alloc,
    631625                        sbrk_calls, sbrk_storage,
     
    650644        "<total type=\"resize\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
    651645        "<total type=\"realloc\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
    652         "<total type=\"free\" !null=\"%'u;\" 0 null=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
     646        "<total type=\"free\" !null=\"%'u;\" 0 null/0=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
    653647        "<total type=\"return\" pulls=\"%'u;\" 0 pushes=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
    654648        "<total type=\"sbrk\" count=\"%'u;\" size=\"%'llu\"/> bytes\n" \
     
    670664                        resize_calls, resize_0_calls, resize_storage_request, resize_storage_alloc,
    671665                        realloc_calls, realloc_0_calls, realloc_storage_request, realloc_storage_alloc,
    672                         free_calls, free_null_calls, free_storage_request, free_storage_alloc,
     666                        free_calls, free_null_0_calls, free_storage_request, free_storage_alloc,
    673667                        return_pulls, return_pushes, return_storage_request, return_storage_alloc,
    674668                        sbrk_calls, sbrk_storage,
     
    799793        } else {
    800794                fakeHeader( header, alignment );
    801                 if ( unlikely( MmappedBit( header ) ) ) {               // mmapped ?
     795                if ( unlikely( MmappedBit( header ) ) ) {               // mmapped storage ?
    802796                        verify( addr < heapBegin || heapEnd < addr );
    803797                        size = ClearStickyBits( header->kind.real.blockSize ); // mmap size
     798                        freeHead = 0p;                                                          // prevent uninitialized warning
    804799                        return true;
    805800                } // if
     
    904899
    905900
    906 #define BOOT_HEAP_MANAGER \
    907         if ( unlikely( ! heapMasterBootFlag ) ) { \
    908                 heapManagerCtor(); /* trigger for first heap */ \
    909         } /* if */
    910 
    911901#ifdef __STATISTICS__
    912902#define STAT_NAME __counter
    913903#define STAT_PARM , unsigned int STAT_NAME
    914904#define STAT_ARG( name ) , name
    915 #define STAT_0_CNT( counter ) stats.counters[counter].calls_0 += 1
     905#define STAT_0_CNT( counter ) heapManager->stats.counters[counter].calls_0 += 1
    916906#else
    917907#define STAT_NAME
     
    921911#endif // __STATISTICS__
    922912
    923 // Uncomment to get allocation addresses for a 0-sized allocation rather than a null pointer.
    924 //#define __NONNULL_0_ALLOC__
    925 #if ! defined( __NONNULL_0_ALLOC__ )
    926 #define __NULL_0_ALLOC__ unlikely( size == 0 ) ||               /* 0 BYTE ALLOCATION RETURNS NULL POINTER */
     913#define BOOT_HEAP_MANAGER \
     914        if ( unlikely( ! heapMasterBootFlag ) ) { \
     915                heapManagerCtor(); /* trigger for first heap */ \
     916        } /* if */ \
     917        verify( heapManager );
     918
     919#define __NONNULL_0_ALLOC__ /* Uncomment to return non-null address for malloc( 0 ). */
     920#ifndef __NONNULL_0_ALLOC__
     921#define __NULL_0_ALLOC__( counter, ... ) /* 0 byte allocation returns null pointer */ \
     922        if ( unlikely( size == 0 ) ) { \
     923                STAT_0_CNT( counter ); \
     924                __VA_ARGS__; /* call routine, if specified */ \
     925                return 0p; \
     926        } /* if */
    927927#else
    928 #define __NULL_0_ALLOC__
     928#define __NULL_0_ALLOC__( counter, ... )
    929929#endif // __NONNULL_0_ALLOC__
     930
     931#ifdef __DEBUG__
     932#define __OVERFLOW_MALLOC__( ... ) \
     933        if ( unlikely( size > ULONG_MAX - sizeof(Heap.Storage) ) ) { /* error check */ \
     934                __VA_ARGS__; /* call routine, if specified */ \
     935                return 0p; \
     936        } /* if */
     937#else
     938#define __OVERFLOW_MALLOC__( ... )
     939#endif // __DEBUG__
    930940
    931941#define PROLOG( counter, ... ) \
    932942        BOOT_HEAP_MANAGER; \
    933         if ( \
    934                 __NULL_0_ALLOC__ \
    935                 unlikely( size > ULONG_MAX - sizeof(Heap.Storage) ) ) { /* error check */ \
    936                 STAT_0_CNT( counter ); \
    937                 __VA_ARGS__; \
    938                 return 0p; \
    939         } /* if */
    940 
     943        __NULL_0_ALLOC__( counter, __VA_ARGS__ ) \
     944        __OVERFLOW_MALLOC__( __VA_ARGS__ )
    941945
    942946#define SCRUB_SIZE 1024lu
     
    948952        PROLOG( STAT_NAME );
    949953
    950         verify( heapManager );
    951954        Heap.Storage * block;                                                           // pointer to new block of storage
    952955
     
    956959
    957960        #ifdef __STATISTICS__
    958         stats.counters[STAT_NAME].calls += 1;
     961        #ifdef __NONNULL_0_ALLOC__
     962        if ( unlikely( size == 0 ) )                                            // malloc( 0 ) ?
     963                stats.counters[STAT_NAME].calls_0 += 1;
     964        else
     965        #endif // __NONNULL_0_ALLOC__
     966                stats.counters[STAT_NAME].calls += 1;
    959967        stats.counters[STAT_NAME].request += size;
    960968        #endif // __STATISTICS__
     
    10781086
    10791087static void doFree( void * addr ) libcfa_nopreempt with( *heapManager ) {
     1088        // char buf[64];
     1089        // int len = sprintf( buf, "doFree addr %p\n", addr );
     1090        // write( 2, buf, len );
     1091
    10801092        verify( addr );
    10811093
     
    10911103        #endif // __STATISTICS__ || __CFA_DEBUG__
    10921104
     1105        // Do not move these down because heap can be null!
    10931106        #ifdef __STATISTICS__
     1107        #ifdef __NONNULL_0_ALLOC__
     1108        if ( unlikely( rsize == 0 ) )                                           // malloc( 0 ) ?
     1109                stats.free_null_0_calls += 1;
     1110        else
     1111        #endif // __NONNULL_0_ALLOC__
     1112                heapManager->stats.free_calls += 1;                             // count free amd implicit frees from resize/realloc
    10941113        stats.free_storage_request += rsize;
    10951114        stats.free_storage_alloc += size;
     
    11171136                } // if
    11181137        } else {
     1138                assert( freeHead );
    11191139                #ifdef __CFA_DEBUG__
    11201140                // memset is NOT always inlined!
     
    13211341        // call to malloc(), alloc(), calloc() or realloc(). If the area pointed to was moved, a free(oaddr) is done.
    13221342        void * resize( void * oaddr, size_t size ) libcfa_public {
    1323           if ( unlikely( oaddr == 0p ) ) {                              // => malloc( size )
     1343          if ( unlikely( oaddr == 0p ) ) {                                      // => malloc( size )
    13241344                        return doMalloc( size STAT_ARG( RESIZE ) );
    13251345                } // if
     
    13331353
    13341354                size_t odsize = DataStorage( bsize, oaddr, header ); // data storage available in bucket
    1335                 // same size, DO NOT preserve STICKY PROPERTIES.
     1355                // same size, DO NOT PRESERVE STICKY PROPERTIES.
    13361356                if ( oalign == libAlign() && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
    13371357                        ClearZeroFillBit( header );                                     // no alignment and turn off 0 fill
     
    13461366                } // if
    13471367
    1348                 // change size, DO NOT preserve STICKY PROPERTIES.
     1368                // change size, DO NOT PRESERVE STICKY PROPERTIES.
    13491369                doFree( oaddr );                                                                // free previous storage
    13501370
     
    13561376        // the old and new sizes.
    13571377        void * realloc( void * oaddr, size_t size ) libcfa_public {
     1378                // char buf[64];
     1379                // int len = sprintf( buf, "realloc1 oaddr %p size %d\n", oaddr, size );
     1380                // write( 2, buf, len );
    13581381          if ( unlikely( oaddr == 0p ) ) {                                      // => malloc( size )
    13591382                  return doMalloc( size STAT_ARG( REALLOC ) );
     
    14981521                } // if
    14991522
    1500                 #ifdef __STATISTICS__
    1501                 incCalls( FREE );
    1502                 #endif // __STATISTICS__
    1503 
    15041523                doFree( addr );                                                                 // handles heapManager == nullptr
    15051524        } // free
     
    15791598                #endif // __STATISTICS__
    15801599        } // malloc_stats_clear
    1581 
    15821600
    15831601        // Changes the file descriptor where malloc_stats() writes statistics.
     
    17001718        } // if
    17011719
    1702         // change size, DO NOT preserve STICKY PROPERTIES.
     1720        // change size, DO NOT PRESERVE STICKY PROPERTIES.
    17031721        doFree( oaddr );                                                                        // free previous storage
    17041722        return memalignNoStats( nalign, size STAT_ARG( RESIZE ) ); // create new aligned area
     
    17071725
    17081726void * realloc( void * oaddr, size_t nalign, size_t size ) libcfa_public {
     1727        // char buf[64];
     1728        // int len = sprintf( buf, "realloc2 oaddr %p size %d\n", oaddr, size );
     1729        // write( 2, buf, len );
    17091730  if ( unlikely( oaddr == 0p ) ) {                                              // => malloc( size )
    17101731                return memalignNoStats( nalign, size STAT_ARG( REALLOC ) );
  • libcfa/src/heap.hfa

    r6dd4091 rfeb999f  
    1010// Created On       : Tue May 26 11:23:55 2020
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 11 11:18:18 2023
    13 // Update Count     : 24
     12// Last Modified On : Mon Apr  1 09:36:20 2024
     13// Update Count     : 25
    1414//
    1515
     
    4646} // extern "C"
    4747
     48// New allocation operations.
    4849void * resize( void * oaddr, size_t alignment, size_t size );
    4950void * realloc( void * oaddr, size_t alignment, size_t size );
     
    5152
    5253// Local Variables: //
    53 // mode: c //
    5454// tab-width: 4 //
    5555// End: //
Note: See TracChangeset for help on using the changeset viewer.