boost/build
2
0
Fork 0
mirror of https://github.com/boostorg/build.git synced 2026-02-18 01:52:17 +00:00
Code Issues Projects Releases Wiki Activity

Fix list alloc crashes.

Browse Source 
This is a brute force fix for the instability of list allocations. It
gets rid of the caching of lists in favor of straight de/alloc.
This commit is contained in:
Rene Rivera
2021-01-01 11:06:50 -06:00
parent 5fa06452bf
commit 6bba7e3bc4
1 changed files with 9 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
src/engine/lists.cpp
View File

@@ -14,47 +14,15 @@
#include <assert.h>
static const size_t freelist_size = 16;
static LIST * freelist[ freelist_size ]; /* junkpile for list_dealloc() */
static int32_t get_bucket_size( size_t bucket )
{
return int32_t(1) << ( bucket < freelist_size ? bucket : ( freelist_size - 1 ) );
}
static size_t get_bucket( int32_t size )
{
size_t bucket = 0;
while ( ( bucket < freelist_size ) && ( size > get_bucket_size( bucket ) ) ) ++bucket;
return bucket;
}
static LIST * list_alloc( int32_t size )
{
size_t bucket = get_bucket( size );
if ( freelist[ bucket ] )
{
LIST * result = freelist[ bucket ];
freelist[ bucket ] = result->impl.next;
return result;
}
return (LIST *)BJAM_MALLOC( sizeof( LIST ) + get_bucket_size( bucket ) *
sizeof( OBJECT * ) );
if ( size == 0 ) return L0;
return (LIST *)BJAM_MALLOC( sizeof( LIST ) + size * sizeof( OBJECT * ) );
}
static void list_dealloc( LIST * l )
{
int32_t size = list_length( l );
size_t bucket;
LIST * node = l;
if ( size == 0 ) return;
bucket = get_bucket( size );;
node->impl.next = freelist[ bucket ];
freelist[ bucket ] = node;
// if ( l ) BJAM_FREE( l );
}
/*
@@ -70,18 +38,11 @@ LIST * list_append( LIST * l, LIST * nl )
int32_t l_size = list_length( l );
int32_t nl_size = list_length( nl );
int32_t size = l_size + nl_size;
size_t bucket = get_bucket( size );
/* Do we need to reallocate? */
if ( l_size <= get_bucket_size( bucket ) )
{
LIST * result = list_alloc( size );
memcpy( list_begin( result ), list_begin( l ), l_size * sizeof(
OBJECT * ) );
list_dealloc( l );
l = result;
}
LIST * result = list_alloc( size );
memcpy( list_begin( result ), list_begin( l ), l_size * sizeof(
OBJECT * ) );
list_dealloc( l );
l = result;
l->impl.size = size;
memcpy( list_begin( l ) + l_size, list_begin( nl ), nl_size * sizeof(
OBJECT * ) );
@@ -124,7 +85,7 @@ LIST * list_push_back( LIST * head, OBJECT * value )
{
head = list_alloc( 1 );
}
else if ( ( ( size - 1 ) & size ) == 0 )
else
{
LIST * l = list_alloc( size + 1 );
memcpy( l, head, sizeof( LIST ) + size * sizeof( OBJECT * ) );
@@ -368,16 +329,6 @@ LIST * list_unique( LIST * sorted_list )
void list_done()
{
for ( int32_t i = 0; i < int32_t(sizeof( freelist ) / sizeof( freelist[ 0 ] )); ++i )
{
LIST * l = freelist[ i ];
while ( l )
{
LIST * const tmp = l;
l = l->impl.next;
BJAM_FREE( tmp );
}
}
}