Changeset 47dd0d2

Timestamp:

Sep 3, 2020, 4:28:10 PM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

9617533

Parents:

41096dc

Message:

use math.hfa 'min' routine, work on code to reuse existing storage in aligned resize

File:

• libcfa/src/heap.cfa (modified) (5 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 : Tue Sep  1 21:58:36 2020
-// Update Count     : 927
+// 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 );
 
@@ -1233 +1231 @@
         } // if
 
-        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 && size <= odsize && odsize <= size * 2 ) { // <= alignment and new alignment are same, allow 50% wasted storage for smaller size
-                header->kind.real.blockSize &= -2;                      // turn off 0 fill
-                header->kind.real.size = size;                          // reset allocation size
-                return oaddr;
-        } // if
-        if ( oalign < nalign && (uintptr_t)oaddr % nalign == 0 && oalign > libAlign() ) { // <= alignment and new alignment happens to match, and oaddr has a fake header
-                headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
-                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
-                        return oaddr;
+        // Attempt to reuse existing storage.
+        HeapManager.Storage.Header * header = headerAddr( oaddr );
+        if ( header->kind.fake.alignment & 1 == 1 ) {           // old fake header ?
+                if ( unlikely( (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 ?
+
+                        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)
+
+                                header->kind.real.blockSize &= -2;              // turn off 0 fill
+                                header->kind.real.size = size;                  // reset allocation size
+                                return oaddr;
+                        } // if
+                } // if
+        } else {                                                                                        // no old fake header
+                if ( nalign == libAlign() ) {                                   // no new fake header needed => try to reuse storage
+                        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
+                                header->kind.real.blockSize &= -2;              // turn off 0 fill
+                                header->kind.real.size = size;                  // reset allocation size
+                                return oaddr;
+                        } // if
                 } // if
         } // if
@@ -1306 +1319 @@
 
         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 );