corelib/tests/alloc-pool.cc

332 lines
7.3 KiB
C++

#include <ebcl/Alloc.hh>
#include <ebcl/Pointers.hh>
#include <cppunit/extensions/HelperMacros.h>
using namespace ebcl;
class AllocPoolTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( AllocPoolTest );
CPPUNIT_TEST( testUnused );
CPPUNIT_TEST( testAllocPartial );
CPPUNIT_TEST( testAllocFull );
CPPUNIT_TEST( testAllocNewList );
CPPUNIT_TEST( testFreePartialToFree );
CPPUNIT_TEST( testFreePartialToPartial );
CPPUNIT_TEST( testFreeFullToPartial );
CPPUNIT_TEST( testFreeLists );
CPPUNIT_TEST( testFreeFragmented );
CPPUNIT_TEST( testFreeMaxLists );
CPPUNIT_TEST( testReallocation );
CPPUNIT_TEST_SUITE_END( );
public:
void setUp( ) override;
void testUnused( );
void testAllocPartial( );
void testAllocFull( );
void testAllocNewList( );
void testFreePartialToFree( );
void testFreePartialToPartial( );
void testFreeFullToPartial( );
void testFreeLists( );
void testFreeFragmented( );
void testFreeMaxLists( );
void testReallocation( );
};
CPPUNIT_TEST_SUITE_REGISTRATION( AllocPoolTest );
/*----------------------------------------------------------------------------*/
namespace {
class T_Test_
{
public:
static size_t counters[ 256 ];
uint8_t index;
T_Test_( ) = delete;
T_Test_( const uint8_t v ) noexcept
: index( v )
{ counters[ index ] ++; }
T_Test_( T_Test_ const& other ) noexcept
: index( other.index )
{ counters[ index ] ++; }
T_Test_( T_Test_&& other ) noexcept
: index( other.index )
{ counters[ index ] ++; }
~T_Test_( )
{ counters[ index ] --; }
void* operator new( size_t count ) noexcept;
void operator delete( void* object ) noexcept;
static size_t total( ) noexcept
{
size_t sum = 0;
for ( auto i = 0 ; i < 255 ; i ++ ) {
sum += counters[ i ];
}
return sum;
}
};
M_CLASS_POINTERS( Test_ );
size_t T_Test_::counters[ 256 ];
static constexpr size_t PerList_ = 15;
static constexpr size_t MaxFreeLists_ = 4;
static constexpr size_t MFLObjects_ = PerList_ * MaxFreeLists_;
using T_Pool_ = T_PoolAllocator<
sizeof( T_Test_ ) , alignof( T_Test_ ) ,
PerList_ , MaxFreeLists_ >;
static T_OwnPtr< T_Pool_ > Pool_;
void InitPool_( )
{
Pool_ = NewOwned< T_Pool_ >( );
}
void KillPool_( )
{
Pool_.clear( );
}
void* T_Test_::operator new(
const size_t count ) noexcept
{
assert( Pool_ );
return Pool_->allocate( count );
}
void T_Test_::operator delete(
void* object ) noexcept
{
assert( Pool_ );
Pool_->free( object );
}
}
#define M_CHECK_LISTS_( T , F , U ) \
do { \
CPPUNIT_ASSERT_EQUAL( size_t( T ) , Pool_->countFreeLists( ) ); \
CPPUNIT_ASSERT_EQUAL( size_t( F ) , Pool_->countPartialLists( ) ); \
CPPUNIT_ASSERT_EQUAL( size_t( U ) , Pool_->countFullLists( ) ); \
} while ( 0 )
#define M_CHECK_USAGE_( T , F , U ) \
do { \
size_t _t_ , _f_ , _u_; \
Pool_->getUsage( _t_ , _f_ , _u_ ); \
CPPUNIT_ASSERT_EQUAL( size_t( T ) , _t_ ); \
CPPUNIT_ASSERT_EQUAL( size_t( F ) , _f_ ); \
CPPUNIT_ASSERT_EQUAL( size_t( U ) , _u_ ); \
} while ( 0 )
#define M_CHECK_COUNT_( N ) \
CPPUNIT_ASSERT_EQUAL( size_t( N ) , T_Test_::total( ) )
void AllocPoolTest::setUp( )
{
memset( T_Test_::counters , 0 , sizeof( T_Test_::counters ) );
}
/*----------------------------------------------------------------------------*/
void AllocPoolTest::testUnused( )
{
InitPool_( );
M_CHECK_LISTS_( 1 , 0 , 0 );
M_CHECK_USAGE_( PerList_ , PerList_ , 0 );
KillPool_( );
M_CHECK_COUNT_( 0 );
}
/*----------------------------------------------------------------------------*/
void AllocPoolTest::testAllocPartial( )
{
InitPool_( );
{
OP_Test_ test( NewOwned< T_Test_ >( 0 ) );
M_CHECK_COUNT_( 1 );
M_CHECK_LISTS_( 0 , 1 , 0 );
M_CHECK_USAGE_( PerList_ , PerList_ - 1 , 1 );
}
KillPool_( );
M_CHECK_COUNT_( 0 );
}
void AllocPoolTest::testAllocFull( )
{
InitPool_( );
{
OP_Test_ test[ PerList_ ];
for ( auto i = 0u ; i < PerList_ ; i ++ ) {
test[ i ] = NewOwned< T_Test_ >( i );
}
M_CHECK_COUNT_( PerList_ );
M_CHECK_LISTS_( 0 , 0 , 1 );
M_CHECK_USAGE_( PerList_ , 0 , PerList_ );
}
KillPool_( );
M_CHECK_COUNT_( 0 );
}
void AllocPoolTest::testAllocNewList( )
{
InitPool_( );
{
OP_Test_ test[ PerList_ + 1 ];
for ( auto i = 0u ; i <= PerList_ ; i ++ ) {
test[ i ] = NewOwned< T_Test_ >( i );
}
M_CHECK_COUNT_( PerList_ + 1 );
M_CHECK_LISTS_( 0 , 1 , 1 );
M_CHECK_USAGE_( PerList_ * 2 , PerList_ - 1 , PerList_ + 1 );
}
KillPool_( );
M_CHECK_COUNT_( 0 );
}
/*----------------------------------------------------------------------------*/
void AllocPoolTest::testFreePartialToFree( )
{
InitPool_( );
{
OP_Test_ obj( NewOwned< T_Test_ >( 0 ) );
obj.clear( );
M_CHECK_COUNT_( 0 );
M_CHECK_LISTS_( 1 , 0 , 0 );
M_CHECK_USAGE_( PerList_ , PerList_ , 0 );
}
KillPool_( );
}
void AllocPoolTest::testFreePartialToPartial( )
{
InitPool_( );
{
OP_Test_ persist( NewOwned< T_Test_ >( 0 ) );
OP_Test_ test( NewOwned< T_Test_ >( 1 ) );
test.clear( );
M_CHECK_COUNT_( 1 );
M_CHECK_LISTS_( 0 , 1 , 0 );
M_CHECK_USAGE_( PerList_ , PerList_ - 1 , 1 );
}
KillPool_( );
}
void AllocPoolTest::testFreeFullToPartial( )
{
InitPool_( );
{
OP_Test_ objs[ PerList_ ];
for ( auto i = 0u ; i < PerList_ ; i ++ ) {
objs[ i ] = NewOwned< T_Test_ >( i );
}
objs[ PerList_ - 1 ].clear( );
M_CHECK_COUNT_( PerList_ - 1 );
M_CHECK_LISTS_( 0 , 1 , 0 );
M_CHECK_USAGE_( PerList_ , 1 , PerList_ - 1 );
}
KillPool_( );
}
/*----------------------------------------------------------------------------*/
void AllocPoolTest::testFreeLists( )
{
InitPool_( );
{
OP_Test_ obj[ MFLObjects_ ];
for ( auto i = 0u ; i < MFLObjects_ ; i ++ ) {
obj[ i ] = NewOwned< T_Test_ >( i );
}
for ( auto i = 0u ; i < MFLObjects_ ; i ++ ) {
obj[ i ].clear( );
}
M_CHECK_COUNT_( 0 );
M_CHECK_LISTS_( MaxFreeLists_ , 0 , 0 );
M_CHECK_USAGE_( MFLObjects_ , MFLObjects_ , 0 );
}
KillPool_( );
}
void AllocPoolTest::testFreeFragmented( )
{
InitPool_( );
{
OP_Test_ obj[ MFLObjects_ ];
for ( auto i = 0u ; i < MFLObjects_ ; i ++ ) {
obj[ i ] = NewOwned< T_Test_ >( i );
}
for ( auto i = 0u ; i < MaxFreeLists_ ; i ++ ) {
obj[ i * PerList_ ].clear( );
}
M_CHECK_COUNT_( MFLObjects_ - MaxFreeLists_ );
M_CHECK_LISTS_( 0 , MaxFreeLists_ , 0 );
M_CHECK_USAGE_( MFLObjects_ , MaxFreeLists_ , MFLObjects_ - MaxFreeLists_ );
}
KillPool_( );
}
void AllocPoolTest::testFreeMaxLists( )
{
InitPool_( );
{
OP_Test_ obj[ MFLObjects_ + PerList_ ];
for ( auto i = 0u ; i < MFLObjects_ + PerList_ ; i ++ ) {
obj[ i ] = NewOwned< T_Test_ >( i );
}
for ( auto i = 0u ; i < MFLObjects_ + PerList_ ; i ++ ) {
obj[ i ].clear( );
}
M_CHECK_COUNT_( 0 );
M_CHECK_LISTS_( MaxFreeLists_ , 0 , 0 );
M_CHECK_USAGE_( MFLObjects_ , MFLObjects_ , 0 );
}
KillPool_( );
}
/*----------------------------------------------------------------------------*/
void AllocPoolTest::testReallocation( )
{
InitPool_( );
{
OP_Test_ obj[ PerList_ ];
T_Test_* ptr[ PerList_ ];
for ( auto i = 0u ; i < PerList_ ; i ++ ) {
obj[ i ] = NewOwned< T_Test_ >( i );
ptr[ i ] = obj[ i ].get( );
}
for ( auto i = 1u ; i < PerList_ ; i += 2 ) {
obj[ i ].clear( );
}
for ( auto i = 1u ; i < PerList_ ; i += 2 ) {
obj[ i ] = NewOwned< T_Test_ >( i );
CPPUNIT_ASSERT( obj[ i ].get( ) == ptr[ i ] );
}
M_CHECK_LISTS_( 0 , 0 , 1 );
M_CHECK_USAGE_( PerList_ , 0 , PerList_ );
}
KillPool_( );
}