Ignore:
Timestamp:
Sep 7, 2020, 5:48:02 PM (14 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
943a079
Parents:
d2bb298
Message:

corrections for resize/realloc with alignment

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/heap.cfa

    rd2bb298 r92847f7  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Sep  3 16:22:54 2020
    13 // Update Count     : 943
     12// Last Modified On : Mon Sep  7 15:17:13 2020
     13// Update Count     : 956
    1414//
    1515
     
    889889                size_t bsize, oalign;
    890890                headers( "resize", oaddr, header, freeElem, bsize, oalign );
    891 
    892891                size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
     892
    893893                // same size, DO NOT preserve STICKY PROPERTIES.
    894                 if ( oalign <= libAlign() && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
     894                if ( oalign == libAlign() && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
    895895                        header->kind.real.blockSize &= -2;                      // no alignment and turn off 0 fill
    896896                        header->kind.real.size = size;                          // reset allocation size
     
    931931                size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
    932932                size_t osize = header->kind.real.size;                  // old allocation size
    933                 bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
    934           if ( unlikely( size <= odsize ) && size > odsize / 2 ) { // allow up to 50% wasted storage
     933                bool ozfill = (header->kind.real.blockSize & 2); // old allocation zero filled
     934          if ( unlikely( size <= odsize ) && odsize <= size * 2 ) { // allow up to 50% wasted storage
    935935                        header->kind.real.size = size;                          // reset allocation size
    936936                        if ( unlikely( ozfill ) && size > osize ) {     // previous request zero fill and larger ?
     
    947947
    948948                void * naddr;
    949                 if ( likely( oalign <= libAlign() ) ) {                 // previous request not aligned ?
     949                if ( likely( oalign == libAlign() ) ) {                 // previous request not aligned ?
    950950                        naddr = mallocNoStats( size );                          // create new area
    951951                } else {
     
    12311231        } // if
    12321232
    1233         // Attempt to reuse existing storage.
     1233        // Attempt to reuse existing alignment.
    12341234        HeapManager.Storage.Header * header = headerAddr( oaddr );
    1235         bool isFakeHeader = header->kind.fake.alignment & 1 == 1;       // old fake header ?
    1236         if ( unlikely ( ( isFakeHeader &&
    1237                                  (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
    1238                                  header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
    1239                                  nalign <= 128 )                                                                // not too much alignment storage wasted ?
    1240                         ||   ( (!isFakeHeader) &&                                                       // old real header ( aligned on libAlign ) ?
    1241                                  nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
    1242 
    1243                 HeapManager.FreeHeader * freeElem;
    1244                 size_t bsize, oalign;
    1245                 headers( "resize", oaddr, header, freeElem, bsize, oalign );
    1246                 size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
    1247 
    1248                 if ( size <= odsize && odsize <= size * 2 ) { // allow 50% wasted data storage
    1249                         if ( isFakeHeader ) {
     1235        bool isFakeHeader = header->kind.fake.alignment & 1; // old fake header ?
     1236        size_t oalign;
     1237        if ( isFakeHeader ) {
     1238                oalign = header->kind.fake.alignment & -2;              // old alignment
     1239                if ( (uintptr_t)oaddr % nalign == 0                             // lucky match ?
     1240                         && ( oalign <= nalign                                          // going down
     1241                                  || (oalign >= nalign && oalign <= 256) ) // little alignment storage wasted ?
     1242                        ) {
     1243                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
     1244                        HeapManager.FreeHeader * freeElem;
     1245                        size_t bsize, oalign;
     1246                        headers( "resize", oaddr, header, freeElem, bsize, oalign );
     1247                        size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
     1248
     1249                        if ( size <= odsize && odsize <= size * 2 ) { // allow 50% wasted data storage
    12501250                                headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
    1251                         }
    1252 
    1253                         header->kind.real.blockSize &= -2;              // turn off 0 fill
    1254                         header->kind.real.size = size;                  // reset allocation size
    1255                         return oaddr;
    1256                 } // if
     1251
     1252                                header->kind.real.blockSize &= -2;              // turn off 0 fill
     1253                                header->kind.real.size = size;                  // reset allocation size
     1254                                return oaddr;
     1255                        } // if
     1256                } // if
     1257        } else if ( ! isFakeHeader                                                      // old real header (aligned on libAlign) ?
     1258                                && nalign == libAlign() ) {                             // new alignment also on libAlign => no fake header needed
     1259                resize( oaddr, size );                                                  // duplicate special case checks
    12571260        } // if
    12581261
     
    12841287        } // if
    12851288
    1286         HeapManager.Storage.Header * header;
    1287         HeapManager.FreeHeader * freeElem;
    1288         size_t bsize, oalign;
    1289         headers( "realloc", oaddr, header, freeElem, bsize, oalign );
    1290 
    1291         // Attempt to reuse existing storage.
    1292         bool isFakeHeader = header->kind.fake.alignment & 1 == 1;       // old fake header ?
    1293         if ( unlikely ( ( isFakeHeader &&
    1294                                  (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
    1295                                  header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
    1296                                  nalign <= 128 )                                                                // not too much alignment storage wasted ?
    1297                         ||   ( (!isFakeHeader) &&                                                       // old real header ( aligned on libAlign ) ?
    1298                                  nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
    1299 
    1300                 if ( isFakeHeader ) {
     1289        // Attempt to reuse existing alignment.
     1290        HeapManager.Storage.Header * header = headerAddr( oaddr );
     1291        bool isFakeHeader = header->kind.fake.alignment & 1; // old fake header ?
     1292        size_t oalign;
     1293        if ( isFakeHeader ) {
     1294                oalign = header->kind.fake.alignment & -2;              // old alignment
     1295                if ( (uintptr_t)oaddr % nalign == 0                             // lucky match ?
     1296                         && ( oalign <= nalign                                          // going down
     1297                                  || (oalign >= nalign && oalign <= 256) ) // little alignment storage wasted ?
     1298                        ) {
    13011299                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
    1302                 }
    1303                 return realloc( oaddr, size );
    1304 
    1305         } // if
    1306 
    1307         // change size and copy old content to new storage
     1300                        return realloc( oaddr, size );                          // duplicate alignment and special case checks
     1301                } // if
     1302        } else if ( ! isFakeHeader                                                      // old real header (aligned on libAlign) ?
     1303                                && nalign == libAlign() )                               // new alignment also on libAlign => no fake header needed
     1304                return realloc( oaddr, size );                                  // duplicate alignment and special case checks
    13081305
    13091306        #ifdef __STATISTICS__
     
    13121309        #endif // __STATISTICS__
    13131310
     1311        HeapManager.FreeHeader * freeElem;
     1312        size_t bsize;
     1313        headers( "realloc", oaddr, header, freeElem, bsize, oalign );
     1314
     1315        // change size and copy old content to new storage
     1316
    13141317        size_t osize = header->kind.real.size;                          // old allocation size
    1315         bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
     1318        bool ozfill = (header->kind.real.blockSize & 2);        // old allocation zero filled
    13161319
    13171320        void * naddr = memalignNoStats( nalign, size );         // create new aligned area
Note: See TracChangeset for help on using the changeset viewer.