2017-11-01 20:14:23 +01:00
|
|
|
/******************************************************************************/
|
|
|
|
/* ALLOCATORS - INLINE CODE ***************************************************/
|
|
|
|
/******************************************************************************/
|
|
|
|
|
2017-11-01 21:44:54 +01:00
|
|
|
#ifndef _H_EBCL_INLINE_ALLOC
|
|
|
|
#define _H_EBCL_INLINE_ALLOC
|
|
|
|
#include <ebcl/Alloc.hh>
|
|
|
|
namespace ebcl {
|
2017-11-01 20:14:23 +01:00
|
|
|
|
|
|
|
|
|
|
|
/*= T_PoolHelper::T_List =====================================================*/
|
|
|
|
|
|
|
|
template< typename T , size_t P >
|
|
|
|
inline T_PoolHelper::T_List< T , P >::T_List(
|
|
|
|
T_List< T , P >*& n ) noexcept
|
|
|
|
: next( n ) , free( P )
|
|
|
|
{
|
|
|
|
for ( size_t i = 0 ; i < P ; i ++ ) {
|
|
|
|
storage[ i ].list = this;
|
|
|
|
}
|
|
|
|
for ( size_t i = 0 ; i < BitmapSize ; i ++ ) {
|
|
|
|
bitmap[ i ] = 0;
|
|
|
|
}
|
|
|
|
n = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template< typename T , size_t P >
|
|
|
|
inline T* T_PoolHelper::T_List< T , P >::findUnused( ) noexcept
|
|
|
|
{
|
|
|
|
size_t i = 0;
|
|
|
|
while ( bitmap[ i ] == 255 ) {
|
|
|
|
assert( i < BitmapSize );
|
|
|
|
i ++;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t j = 0;
|
|
|
|
while ( ( bitmap[ i ] & ( 1 << j ) ) != 0 ) {
|
|
|
|
j ++;
|
|
|
|
}
|
|
|
|
assert( i * 8 + j < P );
|
|
|
|
|
|
|
|
bitmap[ i ] = bitmap[ i ] | ( 1 << j );
|
|
|
|
free --;
|
|
|
|
return &storage[ i * 8 + j ];
|
|
|
|
}
|
|
|
|
|
|
|
|
template< typename T , size_t P >
|
|
|
|
inline size_t T_PoolHelper::T_List< T , P >::indexOf(
|
|
|
|
T const* const item ) noexcept
|
|
|
|
{
|
|
|
|
assert( item >= &storage[ 0 ] );
|
|
|
|
const size_t offset( ( (char*) item ) - ( (char*) &storage[ 0 ] ) );
|
|
|
|
assert( offset % sizeof( T ) == 0 );
|
|
|
|
const size_t index( offset / sizeof( T ) );
|
|
|
|
assert( index < P );
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
|
|
|
template< typename T , size_t P >
|
|
|
|
inline void T_PoolHelper::T_List< T , P >::destroy(
|
|
|
|
T_List< T , P >*& head ) noexcept
|
|
|
|
{
|
|
|
|
while ( head != nullptr ) {
|
|
|
|
T_Self* const n( head->next );
|
|
|
|
delete head;
|
|
|
|
head = n;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*= T_PoolHelper::T_Allocator ================================================*/
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
inline T_PoolHelper::T_Allocator< T , P , M >::T_Allocator( ) noexcept
|
|
|
|
: free_( nullptr ) , partial_( nullptr ) , full_( nullptr ) ,
|
|
|
|
nFree_( 1 )
|
|
|
|
{
|
|
|
|
new T_List_( free_ );
|
|
|
|
}
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
inline T_PoolHelper::T_Allocator< T , P , M >::~T_Allocator( )
|
|
|
|
{
|
|
|
|
T_List_::destroy( free_ );
|
|
|
|
T_List_::destroy( partial_ );
|
|
|
|
T_List_::destroy( full_ );
|
|
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
inline T* T_PoolHelper::T_Allocator< T , P , M >::allocate( ) noexcept
|
|
|
|
{
|
|
|
|
if ( partial_ == nullptr ) {
|
|
|
|
if ( free_ == nullptr ) {
|
|
|
|
new T_List_( partial_ );
|
|
|
|
} else {
|
|
|
|
assert( nFree_ > 0 );
|
|
|
|
partial_ = free_;
|
|
|
|
free_ = free_->next;
|
|
|
|
partial_->next = nullptr;
|
|
|
|
nFree_ --;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
T* const data( partial_->findUnused( ) );
|
|
|
|
if ( partial_->free == 0 ) {
|
|
|
|
T_List_* const nf( partial_ );
|
|
|
|
partial_ = nf->next;
|
|
|
|
nf->next = full_;
|
|
|
|
full_ = nf;
|
|
|
|
}
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
void T_PoolHelper::T_Allocator< T , P , M >::free(
|
|
|
|
T* const item ) noexcept
|
|
|
|
{
|
|
|
|
T_List_* const list( reinterpret_cast< T_List_* >( item->list ) );
|
|
|
|
const size_t index( list->indexOf( item ) );
|
|
|
|
|
|
|
|
list->bitmap[ index / 8 ] = list->bitmap[ index / 8 ] & ~( 1 << ( index & 7 ) );
|
|
|
|
list->free ++;
|
|
|
|
|
|
|
|
if ( list->free == 1 ) {
|
|
|
|
// Full list is now partial
|
|
|
|
moveList( list , full_ , partial_ );
|
|
|
|
} else if ( list->free == P ) {
|
|
|
|
// Partial list is now free
|
|
|
|
if ( nFree_ == M ) {
|
|
|
|
T_List_* p( nullptr );
|
|
|
|
moveList( list , partial_ , p );
|
|
|
|
delete list;
|
|
|
|
} else {
|
|
|
|
moveList( list , partial_ , free_ );
|
|
|
|
nFree_ ++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
size_t T_PoolHelper::T_Allocator< T , P , M >::countFreeLists( ) const noexcept
|
|
|
|
{
|
|
|
|
return nFree_;
|
|
|
|
}
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
size_t T_PoolHelper::T_Allocator< T , P , M >::countPartialLists( ) const noexcept
|
|
|
|
{
|
|
|
|
return countLists( partial_ );
|
|
|
|
}
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
size_t T_PoolHelper::T_Allocator< T , P , M >::countFullLists( ) const noexcept
|
|
|
|
{
|
|
|
|
return countLists( full_ );
|
|
|
|
}
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
void T_PoolHelper::T_Allocator< T , P , M >::getUsage(
|
|
|
|
size_t& total ,
|
|
|
|
size_t& free ,
|
|
|
|
size_t& used ) const noexcept
|
|
|
|
{
|
|
|
|
free = countFreeLists( ) * P;
|
|
|
|
used = countFullLists( ) * P;
|
|
|
|
total = free + used;
|
|
|
|
|
|
|
|
T_List_ const* p( partial_ );
|
|
|
|
while ( p != nullptr ) {
|
|
|
|
free += p->free;
|
|
|
|
used += P - p->free;
|
|
|
|
total += P;
|
|
|
|
p = p->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
void T_PoolHelper::T_Allocator< T , P , M >::moveList(
|
|
|
|
T_List_* const list ,
|
|
|
|
T_List_*& from ,
|
|
|
|
T_List_*& to ) noexcept
|
|
|
|
{
|
|
|
|
T_List_** ptr( &from );
|
|
|
|
while ( *ptr != list ) {
|
|
|
|
ptr = &( (*ptr)->next );
|
|
|
|
assert( *ptr != nullptr );
|
|
|
|
}
|
|
|
|
*ptr = list->next;
|
|
|
|
list->next = to;
|
|
|
|
to = list;
|
|
|
|
}
|
|
|
|
|
|
|
|
template< typename T , size_t P , size_t M >
|
|
|
|
size_t T_PoolHelper::T_Allocator< T , P , M >::countLists(
|
|
|
|
T_List_ const* head ) noexcept
|
|
|
|
{
|
|
|
|
size_t nLists( 0 );
|
|
|
|
while ( head != nullptr ) {
|
|
|
|
nLists ++;
|
|
|
|
head = head->next;
|
|
|
|
}
|
|
|
|
return nLists;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*= T_PoolAllocator ==========================================================*/
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
inline void* T_PoolAllocator< OS , OA , P , M >::allocate(
|
|
|
|
const size_t requested ) noexcept
|
|
|
|
{
|
|
|
|
#ifdef LW_CFG_NO_ALLOCATORS
|
|
|
|
return ::operator new( requested );
|
|
|
|
#else
|
|
|
|
assert( requested <= OS );
|
|
|
|
return reinterpret_cast< char* >( alloc_.allocate( ) );
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
void T_PoolAllocator< OS , OA , P , M >::free(
|
|
|
|
void* const item ) noexcept
|
|
|
|
{
|
|
|
|
#ifdef LW_CFG_NO_ALLOCATORS
|
|
|
|
::operator delete( item );
|
|
|
|
#else
|
|
|
|
alloc_.free( reinterpret_cast< T_Storage_* >( item ) );
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
size_t T_PoolAllocator< OS , OA , P , M >::countFreeLists( ) const noexcept
|
|
|
|
{
|
|
|
|
return alloc_.countFreeLists( );
|
|
|
|
}
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
size_t T_PoolAllocator< OS , OA , P , M >::countPartialLists( ) const noexcept
|
|
|
|
{
|
|
|
|
return alloc_.countPartialLists( );
|
|
|
|
}
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
size_t T_PoolAllocator< OS , OA , P , M >::countFullLists( ) const noexcept
|
|
|
|
{
|
|
|
|
return alloc_.countFullLists( );
|
|
|
|
}
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
void T_PoolAllocator< OS , OA , P , M >::getUsage(
|
|
|
|
size_t& total ,
|
|
|
|
size_t& free ,
|
|
|
|
size_t& used ) const noexcept
|
|
|
|
{
|
|
|
|
return alloc_.getUsage( total , free , used );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*= T_ThreadedPoolAllocator ==================================================*/
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
inline void* T_ThreadedPoolAllocator< OS , OA , P , M >::allocate(
|
|
|
|
const size_t requested ) noexcept
|
|
|
|
{
|
|
|
|
#ifdef LW_CFG_NO_ALLOCATORS
|
|
|
|
return ::operator new( requested );
|
|
|
|
#else
|
|
|
|
assert( requested <= OS );
|
|
|
|
|
|
|
|
T_Storage_* const alloc( ([this](){
|
|
|
|
T_Storage_* const fs( takeFromStack( ) );
|
|
|
|
return fs ? fs : alloc_.allocate( );
|
|
|
|
})() );
|
|
|
|
alloc->extra.pool = this;
|
|
|
|
return reinterpret_cast< char* >( alloc );
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
void T_ThreadedPoolAllocator< OS , OA , P , M >::free(
|
|
|
|
void* const item ) noexcept
|
|
|
|
{
|
|
|
|
#ifdef LW_CFG_NO_ALLOCATORS
|
|
|
|
::operator delete( item );
|
|
|
|
#else
|
|
|
|
T_Storage_* const storage( reinterpret_cast< T_Storage_* >( item ) );
|
|
|
|
if ( storage->extra.pool == this ) {
|
|
|
|
alloc_.free( storage );
|
|
|
|
} else {
|
|
|
|
storage->extra.pool->addToStack( storage );
|
|
|
|
}
|
|
|
|
|
|
|
|
T_Storage_* const fs( takeFromStack( ) );
|
|
|
|
if ( fs ) {
|
|
|
|
alloc_.free( fs );
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
size_t T_ThreadedPoolAllocator< OS , OA , P , M >::countFreeLists( ) const noexcept
|
|
|
|
{
|
|
|
|
return alloc_.countFreeLists( );
|
|
|
|
}
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
size_t T_ThreadedPoolAllocator< OS , OA , P , M >::countPartialLists( ) const noexcept
|
|
|
|
{
|
|
|
|
return alloc_.countPartialLists( );
|
|
|
|
}
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
size_t T_ThreadedPoolAllocator< OS , OA , P , M >::countFullLists( ) const noexcept
|
|
|
|
{
|
|
|
|
return alloc_.countFullLists( );
|
|
|
|
}
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
void T_ThreadedPoolAllocator< OS , OA , P , M >::getUsage(
|
|
|
|
size_t& total ,
|
|
|
|
size_t& free ,
|
|
|
|
size_t& used ) const noexcept
|
|
|
|
{
|
|
|
|
return alloc_.getUsage( total , free , used );
|
|
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
typename T_ThreadedPoolAllocator< OS , OA , P , M >::T_Storage_*
|
|
|
|
T_ThreadedPoolAllocator< OS , OA , P , M >::takeFromStack( ) noexcept
|
|
|
|
{
|
|
|
|
T_FreeHead_ o( freeHead_.load( std::memory_order_relaxed ) );
|
|
|
|
if ( o.head == nullptr ) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
T_FreeHead_ next;
|
|
|
|
do {
|
|
|
|
next.aba = o.aba + 1;
|
|
|
|
next.head = o.head->extra.next;
|
|
|
|
} while ( !freeHead_.compare_exchange_weak( o , next ,
|
|
|
|
std::memory_order_acq_rel ,
|
|
|
|
std::memory_order_acquire ) );
|
|
|
|
return o.head;
|
|
|
|
}
|
|
|
|
|
|
|
|
template< size_t OS , size_t OA , size_t P , size_t M >
|
|
|
|
void T_ThreadedPoolAllocator< OS , OA , P , M >::addToStack(
|
|
|
|
T_Storage_* storage ) noexcept
|
|
|
|
{
|
|
|
|
assert( storage->extra.pool == this );
|
|
|
|
T_FreeHead_ o( freeHead_.load( std::memory_order_relaxed ) );
|
|
|
|
T_FreeHead_ r;
|
|
|
|
do {
|
|
|
|
storage->extra.next = o.head;
|
|
|
|
r.aba = o.aba + 1;
|
|
|
|
r.head = storage;
|
|
|
|
} while ( !freeHead_.compare_exchange_weak( o , r ,
|
|
|
|
std::memory_order_acq_rel ,
|
|
|
|
std::memory_order_acquire ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
2017-11-01 21:44:54 +01:00
|
|
|
#endif //_H_EBCL_INLINE_ALLOC
|