Changeset 92847f7 for libcfa/src/heap.cfa

Timestamp:

Sep 7, 2020, 5:48:02 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:

943a079

Parents:

d2bb298

Message:

corrections for resize/realloc with alignment

File:

• libcfa/src/heap.cfa (modified) (7 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 : Thu Sep  3 16:22:54 2020
-// Update Count     : 943
+// Last Modified On : Mon Sep  7 15:17:13 2020
+// Update Count     : 956
 //
 
@@ -889 +889 @@
                 size_t bsize, oalign;
                 headers( "resize", oaddr, header, freeElem, bsize, oalign );
-
                 size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
+
                 // same size, DO NOT preserve STICKY PROPERTIES.
-                if ( oalign <= libAlign() && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
+                if ( oalign == libAlign() && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
                         header->kind.real.blockSize &= -2;                      // no alignment and turn off 0 fill
                         header->kind.real.size = size;                          // reset allocation size
@@ -931 +931 @@
                 size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
                 size_t osize = header->kind.real.size;                  // old allocation size
-                bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
-          if ( unlikely( size <= odsize ) && size > odsize / 2 ) { // allow up to 50% wasted storage
+                bool ozfill = (header->kind.real.blockSize & 2); // old allocation zero filled
+          if ( unlikely( size <= odsize ) && odsize <= size * 2 ) { // allow up to 50% wasted storage
                         header->kind.real.size = size;                          // reset allocation size
                         if ( unlikely( ozfill ) && size > osize ) {     // previous request zero fill and larger ?
@@ -947 +947 @@
 
                 void * naddr;
-                if ( likely( oalign <= libAlign() ) ) {                 // previous request not aligned ?
+                if ( likely( oalign == libAlign() ) ) {                 // previous request not aligned ?
                         naddr = mallocNoStats( size );                          // create new area
                 } else {
@@ -1231 +1231 @@
         } // if
 
-        // Attempt to reuse existing storage.
+        // Attempt to reuse existing alignment.
         HeapManager.Storage.Header * header = headerAddr( oaddr );
-        bool isFakeHeader = header->kind.fake.alignment & 1 == 1;       // old fake header ?
-        if ( unlikely ( ( isFakeHeader &&
-                                 (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 ?
-                        ||   ( (!isFakeHeader) &&                                                       // 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
-                        if ( isFakeHeader ) {
+        bool isFakeHeader = header->kind.fake.alignment & 1; // old fake header ?
+        size_t oalign;
+        if ( isFakeHeader ) {
+                oalign = header->kind.fake.alignment & -2;              // old alignment
+                if ( (uintptr_t)oaddr % nalign == 0                             // lucky match ?
+                         && ( oalign <= nalign                                          // going down
+                                  || (oalign >= nalign && oalign <= 256) ) // little alignment storage wasted ?
+                        ) {
+                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
+                        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
+
+                                header->kind.real.blockSize &= -2;              // turn off 0 fill
+                                header->kind.real.size = size;                  // reset allocation size
+                                return oaddr;
+                        } // if
+                } // if
+        } else if ( ! isFakeHeader                                                      // old real header (aligned on libAlign) ?
+                                && nalign == libAlign() ) {                             // new alignment also on libAlign => no fake header needed
+                resize( oaddr, size );                                                  // duplicate special case checks
         } // if
 
@@ -1284 +1287 @@
         } // if
 
-        HeapManager.Storage.Header * header;
-        HeapManager.FreeHeader * freeElem;
-        size_t bsize, oalign;
-        headers( "realloc", oaddr, header, freeElem, bsize, oalign );
-
-        // Attempt to reuse existing storage.
-        bool isFakeHeader = header->kind.fake.alignment & 1 == 1;       // old fake header ?
-        if ( unlikely ( ( isFakeHeader &&
-                                 (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 ?
-                        ||   ( (!isFakeHeader) &&                                                       // old real header ( aligned on libAlign ) ?
-                                 nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
-
-                if ( isFakeHeader ) {
+        // Attempt to reuse existing alignment.
+        HeapManager.Storage.Header * header = headerAddr( oaddr );
+        bool isFakeHeader = header->kind.fake.alignment & 1; // old fake header ?
+        size_t oalign;
+        if ( isFakeHeader ) {
+                oalign = header->kind.fake.alignment & -2;              // old alignment
+                if ( (uintptr_t)oaddr % nalign == 0                             // lucky match ?
+                         && ( oalign <= nalign                                          // going down
+                                  || (oalign >= nalign && oalign <= 256) ) // little alignment storage wasted ?
+                        ) {
                         headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
-                }
-                return realloc( oaddr, size );
-
-        } // if
-
-        // change size and copy old content to new storage
+                        return realloc( oaddr, size );                          // duplicate alignment and special case checks
+                } // if
+        } else if ( ! isFakeHeader                                                      // old real header (aligned on libAlign) ?
+                                && nalign == libAlign() )                               // new alignment also on libAlign => no fake header needed
+                return realloc( oaddr, size );                                  // duplicate alignment and special case checks
 
         #ifdef __STATISTICS__
@@ -1312 +1309 @@
         #endif // __STATISTICS__
 
+        HeapManager.FreeHeader * freeElem;
+        size_t bsize;
+        headers( "realloc", oaddr, header, freeElem, bsize, oalign );
+
+        // change size and copy old content to new storage
+
         size_t osize = header->kind.real.size;                          // old allocation size
-        bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
+        bool ozfill = (header->kind.real.blockSize & 2);        // old allocation zero filled
 
         void * naddr = memalignNoStats( nalign, size );         // create new aligned area