Changeset 14d8a9b for libcfa/src


Ignore:
Timestamp:
Sep 8, 2020, 1:33:50 PM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
2b7f6f0
Parents:
ce55a81 (diff), dfc13bb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:
1 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/heap.cfa

    rce55a81 r14d8a9b  
    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 22:17:46 2020
     13// Update Count     : 957
    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         if ( unlikely ( ( header->kind.fake.alignment & 1 == 1 &&       // old fake header ?
    1236                                  (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
    1237                                  header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
    1238                                  nalign <= 128 )                                                                // not too much alignment storage wasted ?
    1239                         ||   ( header->kind.fake.alignment & 1 != 1 &&          // old real header ( aligned on libAlign ) ?
    1240                                  nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
    1241 
    1242                 HeapManager.FreeHeader * freeElem;
    1243                 size_t bsize, oalign;
    1244                 headers( "resize", oaddr, header, freeElem, bsize, oalign );
    1245                 size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
    1246 
    1247                 if ( size <= odsize && odsize <= size * 2 ) { // allow 50% wasted data storage
     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                        ) {
    12481243                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
    1249 
    1250                         header->kind.real.blockSize &= -2;              // turn off 0 fill
    1251                         header->kind.real.size = size;                  // reset allocation size
    1252                         return oaddr;
    1253                 } // if
     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
     1250                                headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
     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                return resize( oaddr, size );                                   // duplicate special case checks
    12541260        } // if
    12551261
    … …  
    12811287        } // if
    12821288
    1283         HeapManager.Storage.Header * header;
    1284         HeapManager.FreeHeader * freeElem;
    1285         size_t bsize, oalign;
    1286         headers( "realloc", oaddr, header, freeElem, bsize, oalign );
    1287 
    1288         // Attempt to reuse existing storage.
    1289         if ( unlikely ( ( header->kind.fake.alignment & 1 == 1 &&       // old fake header ?
    1290                                  (uintptr_t)oaddr % nalign == 0 &&                              // lucky match ?
    1291                                  header->kind.fake.alignment <= nalign &&               // ok to leave LSB at 1
    1292                                  nalign <= 128 )                                                                // not too much alignment storage wasted ?
    1293                         ||   ( header->kind.fake.alignment & 1 != 1 &&          // old real header ( aligned on libAlign ) ?
    1294                                  nalign == libAlign() ) ) ) {                                   // new alignment also on libAlign
    1295 
    1296                 headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
    1297                 return realloc( oaddr, size );
    1298 
    1299         } // if
    1300 
    1301         // change size and copy old content to new storage
     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                        ) {
     1299                        headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
     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
    13021305
    13031306        #ifdef __STATISTICS__
    … …  
    13061309        #endif // __STATISTICS__
    13071310
     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
    13081317        size_t osize = header->kind.real.size;                          // old allocation size
    1309         bool ozfill = (header->kind.real.blockSize & 2) != 0; // old allocation zero filled
     1318        bool ozfill = (header->kind.real.blockSize & 2);        // old allocation zero filled
    13101319
    13111320        void * naddr = memalignNoStats( nalign, size );         // create new aligned area
Note: See TracChangeset for help on using the changeset viewer.