Changes in libcfa/src/heap.cfa [7cfef0d:a3ade94]

File:

• libcfa/src/heap.cfa (modified) (9 diffs)

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 24 20:29:24 2020
-// Update Count     : 926
+// Last Modified On : Thu Sep  3 16:22:54 2020
+// Update Count     : 943
 //
 
@@ -29 +29 @@
 #include "math.hfa"                                                                             // ceiling
 #include "bitmanip.hfa"                                                                 // is_pow2, ceiling2
-
-#define MIN(x, y) (y > x ? x : y)
 
 static bool traceHeap = false;
@@ -956 +954 @@
 
                 headers( "realloc", naddr, header, freeElem, bsize, oalign );
-                memcpy( naddr, oaddr, MIN( osize, size ) );             // copy bytes
+                memcpy( naddr, oaddr, min( osize, size ) );             // copy bytes
                 free( oaddr );
 
@@ -1218 +1216 @@
         #endif // __STATISTICS__
 
-        // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
-  if ( unlikely( size == 0 ) ) { free( oaddr ); return 0p; } // special cases
-  if ( unlikely( oaddr == 0p ) ) {
-                #ifdef __STATISTICS__
-                __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
-                #endif // __STATISTICS__
-                return memalignNoStats( nalign, size );
-        } // if
-
         if ( unlikely( nalign < libAlign() ) ) nalign = libAlign(); // reset alignment to minimum
         #ifdef __CFA_DEBUG__
@@ -1233 +1222 @@
         #endif // __CFA_DEBUG__
 
-        HeapManager.Storage.Header * header;
-        HeapManager.FreeHeader * freeElem;
-        size_t bsize, oalign;
-        headers( "resize", oaddr, header, freeElem, bsize, oalign );
-        size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
-
-        if ( oalign <= nalign && (uintptr_t)oaddr % nalign == 0 ) { // <= alignment and new alignment happens to match
-                if ( oalign > libAlign() ) {                                    // fake header ?
+        // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
+  if ( unlikely( size == 0 ) ) { free( oaddr ); return 0p; } // special cases
+  if ( unlikely( oaddr == 0p ) ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+                return memalignNoStats( nalign, size );
+        } // if
+
+        // Attempt to reuse existing storage.
+        HeapManager.Storage.Header * header = headerAddr( oaddr );
+        if ( unlikely ( ( header->kind.fake.alignment & 1 == 1 &&       // old fake header ?
+                                 (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
+                                 header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
+                                 nalign <= 128 )                                                                // not too much alignment storage wasted ?
+                        ||   ( header->kind.fake.alignment & 1 != 1 &&          // old real header ( aligned on libAlign ) ?
+                                 nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
+
+                HeapManager.FreeHeader * freeElem;
+                size_t bsize, oalign;
+                headers( "resize", oaddr, header, freeElem, bsize, oalign );
+                size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
+
+                if ( size <= odsize && odsize <= size * 2 ) { // allow 50% wasted data storage
                         headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
-                } // if
-                if ( size <= odsize && odsize <= size * 2 ) {   // allow 50% wasted storage for smaller size
-                        header->kind.real.blockSize &= -2;                      // turn off 0 fill
-                        header->kind.real.size = size;                          // reset allocation size
+
+                        header->kind.real.blockSize &= -2;              // turn off 0 fill
+                        header->kind.real.size = size;                  // reset allocation size
                         return oaddr;
                 } // if
@@ -1267 +1271 @@
         #endif // __CFA_DEBUG__
 
+        // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
+  if ( unlikely( size == 0 ) ) { free( oaddr ); return 0p; } // special cases
+  if ( unlikely( oaddr == 0p ) ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
+                __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+                return memalignNoStats( nalign, size );
+        } // if
+
         HeapManager.Storage.Header * header;
         HeapManager.FreeHeader * freeElem;
@@ -1272 +1286 @@
         headers( "realloc", oaddr, header, freeElem, bsize, oalign );
 
-        if ( oalign <= nalign && (uintptr_t)oaddr % nalign == 0 ) { // <= alignment and new alignment happens to match
-                if ( oalign > libAlign() ) {                                    // fake header ?
-                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
-                } // if
+        // Attempt to reuse existing storage.
+        if ( unlikely ( ( header->kind.fake.alignment & 1 == 1 &&       // old fake header ?
+                                 (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
+                                 header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
+                                 nalign <= 128 )                                                                // not too much alignment storage wasted ?
+                        ||   ( header->kind.fake.alignment & 1 != 1 &&          // old real header ( aligned on libAlign ) ?
+                                 nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
+
+                headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
                 return realloc( oaddr, size );
+
         } // if
 
@@ -1286 +1306 @@
         #endif // __STATISTICS__
 
-        // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
-  if ( unlikely( size == 0 ) ) { free( oaddr ); return 0p; } // special cases
-  if ( unlikely( oaddr == 0p ) ) return memalignNoStats( nalign, size );
-
         size_t osize = header->kind.real.size;                          // old allocation size
         bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
@@ -1296 +1312 @@
 
         headers( "realloc", naddr, header, freeElem, bsize, oalign );
-        memcpy( naddr, oaddr, MIN( osize, size ) );                     // copy bytes
+        memcpy( naddr, oaddr, min( osize, size ) );                     // copy bytes
         free( oaddr );