Index: libcfa/src/heap.cfa =================================================================== --- libcfa/src/heap.cfa (revision d2bb298dc51f35355297c61ecdc1413c3094847d) +++ libcfa/src/heap.cfa (revision 92847f793843cc0d5dd7a0e512318148b570bda7) @@ -10,6 +10,6 @@ // 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,8 +889,8 @@ 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,6 +931,6 @@ 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,5 +947,5 @@ 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,28 +1231,31 @@ } // 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,26 +1287,20 @@ } // 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,6 +1309,12 @@ #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