c74e851a38
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@1044 7ec92016-0320-0410-acc4-a06ded1c099a
920 lines
26 KiB
C++
920 lines
26 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Part of LevelMutex test program for The Loki Library
|
|
// Copyright (c) 2008, 2009 Richard Sposato
|
|
// The copyright on this file is protected under the terms of the MIT license.
|
|
//
|
|
// Permission to use, copy, modify, distribute and sell this software for any
|
|
// purpose is hereby granted without fee, provided that the above copyright
|
|
// notice appear in all copies and that both that copyright notice and this
|
|
// permission notice appear in supporting documentation.
|
|
//
|
|
// The author makes no representations about the suitability of this software
|
|
// for any purpose. It is provided "as is" without express or implied warranty.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// $Id$
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#include "Thing.hpp"
|
|
|
|
#include <assert.h>
|
|
#if !defined( _MSC_VER )
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <algorithm>
|
|
#include <functional>
|
|
|
|
#include <SafeFormat.h>
|
|
#include <LockingPtr.h>
|
|
|
|
using namespace ::Loki;
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
typedef ::Loki::LockingPtr< Thing, volatile SleepMutex > SingleThingLocker;
|
|
|
|
typedef ::Loki::LockingPtr< const Thing, volatile SleepMutex > ConstSingleThingLocker;
|
|
|
|
typedef ::Loki::LockingPtr< LevelThing, volatile SleepMutex > LevelThingLocker;
|
|
|
|
typedef ::Loki::LockingPtr< const LevelThing, volatile SleepMutex > ConstLevelThingLocker;
|
|
|
|
typedef ::Loki::LockingPtr< SomeThing, volatile SleepMutex > SomeThingLocker;
|
|
|
|
typedef ::Loki::LockingPtr< const SomeThing, volatile SleepMutex > ConstSomeThingLocker;
|
|
|
|
volatile Thing * Thing::s_thing = NULL;
|
|
|
|
Thing::ThingPool Thing::s_pool;
|
|
|
|
LevelThing::LevelThingPool LevelThing::s_pool;
|
|
|
|
TestResults * TestResults::s_instance = NULL;
|
|
|
|
MultiLevelPool::MultiThingPool MultiLevelPool::s_pool;
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
ExceptionTossingMutex::ExceptionTossingMutex( unsigned int level ) :
|
|
#if defined( _MSC_VER )
|
|
SleepLevelMutex( level ),
|
|
#else
|
|
SleepLevelMutex( level ),
|
|
#endif
|
|
m_policy( ExceptionTossingMutex::Never )
|
|
{
|
|
assert( NULL != this );
|
|
#if defined( _MSC_VER )
|
|
SetWakable( false );
|
|
#endif
|
|
SetSleepTime( 5 );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
ExceptionTossingMutex::~ExceptionTossingMutex( void )
|
|
{
|
|
assert( NULL != this );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
MutexErrors::Type ExceptionTossingMutex::Lock( void ) volatile
|
|
{
|
|
if ( m_policy != ExceptionTossingMutex::Never )
|
|
{
|
|
bool toss = ( m_policy == ExceptionTossingMutex::Always );
|
|
if ( !toss )
|
|
{
|
|
const unsigned int number = ( ::rand() % 16 );
|
|
toss = ( 0 == number );
|
|
}
|
|
if ( toss )
|
|
{
|
|
throw MutexException( "Just a test exception from DoLock.",
|
|
GetLevel(), ::Loki::MutexErrors::OtherError );
|
|
}
|
|
}
|
|
return SleepLevelMutex::Lock();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
MutexErrors::Type ExceptionTossingMutex::TryLock( void ) volatile
|
|
{
|
|
if ( m_policy != ExceptionTossingMutex::Never )
|
|
{
|
|
bool toss = ( m_policy == ExceptionTossingMutex::Always );
|
|
if ( !toss )
|
|
{
|
|
const unsigned int number = ( ::rand() % 16 );
|
|
toss = ( 0 == number );
|
|
}
|
|
if ( toss )
|
|
{
|
|
throw MutexException( "Just a test exception from DoLock.",
|
|
GetLevel(), ::Loki::MutexErrors::OtherError );
|
|
}
|
|
}
|
|
return SleepLevelMutex::TryLock();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
MutexErrors::Type ExceptionTossingMutex::Unlock( void ) volatile
|
|
{
|
|
if ( m_policy != ExceptionTossingMutex::Never )
|
|
{
|
|
bool toss = ( m_policy == ExceptionTossingMutex::Always );
|
|
if ( !toss )
|
|
{
|
|
const unsigned int number = ( ::rand() % 16 );
|
|
toss = ( 0 == number );
|
|
}
|
|
if ( toss )
|
|
{
|
|
throw MutexException( "Just a test exception from DoLock.",
|
|
GetLevel(), ::Loki::MutexErrors::OtherError );
|
|
}
|
|
}
|
|
return SleepLevelMutex::Unlock();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool TestResults::Create( unsigned int threadCount )
|
|
{
|
|
if ( NULL != s_instance )
|
|
return true;
|
|
s_instance = new TestResults( threadCount );
|
|
return ( NULL != s_instance );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void TestResults::Destroy( void )
|
|
{
|
|
delete s_instance;
|
|
s_instance = NULL;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
TestResults::TestResults( unsigned int threadCount ) :
|
|
m_results()
|
|
{
|
|
assert( NULL != this );
|
|
Reset( threadCount );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
TestResults::~TestResults( void )
|
|
{
|
|
assert( NULL != this );
|
|
assert( this == s_instance );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void TestResults::Reset( unsigned int threadCount )
|
|
{
|
|
assert( NULL != this );
|
|
TestResult result;
|
|
result.m_total = 0;
|
|
result.m_fails = 0;
|
|
m_results.clear();
|
|
m_results.resize( threadCount, result );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void TestResults::SetResult( unsigned int threadIndex, unsigned int total,
|
|
unsigned int fails )
|
|
{
|
|
assert( NULL != this );
|
|
assert( this == s_instance );
|
|
|
|
if ( threadIndex <= m_results.size() )
|
|
{
|
|
m_results[ threadIndex ].m_total = total;
|
|
m_results[ threadIndex ].m_fails = fails;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void TestResults::OutputResults( void )
|
|
{
|
|
assert( NULL != this );
|
|
assert( this == s_instance );
|
|
|
|
bool passed = true;
|
|
const unsigned int count = m_results.size();
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
Printf( "Thread: %d \t total: %d \t fails: %d\n" )( ii )
|
|
( m_results[ ii ].m_total )
|
|
( m_results[ ii ].m_fails );
|
|
if ( m_results[ ii ].m_fails != 0 )
|
|
passed = false;
|
|
m_results[ ii ].m_total = 0;
|
|
m_results[ ii ].m_fails = 0;
|
|
}
|
|
const char * message = ( passed ) ? "Passed!" : "FAILED!";
|
|
Printf( "Value Test Result: %s\n" )( message );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
TestResults::TestResult::TestResult( void ) :
|
|
m_total( 0 ),
|
|
m_fails( 0 )
|
|
{
|
|
assert( NULL != this );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
TestResults::TestResult::TestResult( const TestResult & that ) :
|
|
m_total( that.m_total ),
|
|
m_fails( that.m_fails )
|
|
{
|
|
assert( NULL != this );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
TestResults::TestResult::~TestResult( void )
|
|
{
|
|
assert( NULL != this );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void GoToSleep( unsigned int milliSeconds )
|
|
{
|
|
#if defined( _MSC_VER )
|
|
::SleepEx( milliSeconds, true );
|
|
#elif ( __GNUC__ )
|
|
unsigned int microseconds = milliSeconds * 1000;
|
|
if ( 0 == microseconds )
|
|
microseconds = 1;
|
|
::usleep( microseconds );
|
|
#else
|
|
#error "Find out if your compiler supports a sleep command and add it here."
|
|
#endif
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void Thing::Init( unsigned int value )
|
|
{
|
|
if ( NULL != s_thing )
|
|
return;
|
|
s_thing = new Thing( value );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void Thing::Destroy( void )
|
|
{
|
|
if ( NULL == s_thing )
|
|
return;
|
|
delete s_thing;
|
|
s_thing = NULL;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
volatile Thing * Thing::GetFromPool( unsigned int index )
|
|
{
|
|
if ( s_pool.size() <= index )
|
|
return NULL;
|
|
volatile Thing * thing = s_pool[ index ];
|
|
return thing;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
unsigned int Thing::GetPoolSize( void )
|
|
{
|
|
return s_pool.size();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool Thing::MakePool( unsigned int count )
|
|
{
|
|
if ( ( 0 == count ) || ( 100 < count ) )
|
|
return false;
|
|
|
|
DestroyPool();
|
|
s_pool.reserve( count );
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
volatile Thing * thing = new Thing( ii );
|
|
s_pool.push_back( thing );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void Thing::DestroyPool( void )
|
|
{
|
|
const unsigned int count = s_pool.size();
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
volatile Thing * thing = s_pool[ ii ];
|
|
delete thing;
|
|
}
|
|
s_pool.clear();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
Thing::Thing( unsigned int value ) :
|
|
m_mutex( 10 ),
|
|
m_value( value )
|
|
{
|
|
assert( NULL != this );
|
|
#if defined( _MSC_VER )
|
|
m_mutex.GetMutexPolicy().SetWakable( false );
|
|
#endif
|
|
m_mutex.GetMutexPolicy().SetSleepTime( 5 );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
Thing::~Thing( void )
|
|
{
|
|
assert( NULL != this );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void Thing::Print( unsigned int value, unsigned int index, unsigned int startSize ) const volatile
|
|
{
|
|
assert( NULL != this );
|
|
MutexLocker locker( m_mutex );
|
|
assert( m_mutex.IsLockedByCurrentThread() );
|
|
// volatile SleepMutex & mutex = const_cast< volatile SleepMutex & >( m_mutex );
|
|
// ConstSingleThingLocker pSafeThis( *this, mutex );
|
|
const Thing * pSafeThis = const_cast< const Thing * >( this );
|
|
pSafeThis->Print( value, index, startSize );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void Thing::Print( unsigned int value, unsigned int index, unsigned int startSize ) const
|
|
{
|
|
assert( NULL != this );
|
|
switch ( startSize )
|
|
{
|
|
default:
|
|
case 16: ::GoToSleep( 3 ); Printf("%d: %d: ----------------\n")( value )( index );
|
|
case 15: ::GoToSleep( 3 ); Printf("%d: %d: ---------------\n")( value )( index );
|
|
case 14: ::GoToSleep( 3 ); Printf("%d: %d: --------------\n")( value )( index );
|
|
case 13: ::GoToSleep( 3 ); Printf("%d: %d: -------------\n")( value )( index );
|
|
case 12: ::GoToSleep( 3 ); Printf("%d: %d: ------------\n")( value )( index );
|
|
case 11: ::GoToSleep( 3 ); Printf("%d: %d: -----------\n")( value )( index );
|
|
case 10: ::GoToSleep( 3 ); Printf("%d: %d: ----------\n")( value )( index );
|
|
case 9: ::GoToSleep( 3 ); Printf("%d: %d: ---------\n")( value )( index );
|
|
case 8: ::GoToSleep( 3 ); Printf("%d: %d: --------\n")( value )( index );
|
|
case 7: ::GoToSleep( 3 ); Printf("%d: %d: -------\n")( value )( index );
|
|
case 6: ::GoToSleep( 3 ); Printf("%d: %d: ------\n")( value )( index );
|
|
case 5: ::GoToSleep( 3 ); Printf("%d: %d: -----\n")( value )( index );
|
|
case 4: ::GoToSleep( 3 ); Printf("%d: %d: ----\n")( value )( index );
|
|
case 3: ::GoToSleep( 3 ); Printf("%d: %d: ---\n")( value )( index );
|
|
case 2: ::GoToSleep( 3 ); Printf("%d: %d: --\n")( value )( index );
|
|
case 1: ::GoToSleep( 3 ); Printf("%d: %d: -\n")( value )( index );
|
|
case 0: ::GoToSleep( 3 ); Printf("%d: %d: \n")( value )( index );
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void Thing::SetValue( unsigned int value ) volatile
|
|
{
|
|
assert( NULL != this );
|
|
SingleThingLocker pSafeThis( *this, m_mutex );
|
|
pSafeThis->m_value = value;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
volatile LevelThing * LevelThing::GetFromPool( unsigned int index )
|
|
{
|
|
if ( s_pool.size() <= index )
|
|
return NULL;
|
|
volatile LevelThing * thing = s_pool[ index ];
|
|
return thing;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool LevelThing::MakePool( unsigned int count )
|
|
{
|
|
s_pool.clear();
|
|
s_pool.reserve( count );
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
volatile LevelThing * thing = new LevelThing( ii * 10, ii );
|
|
s_pool.push_back( thing );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void LevelThing::DestroyPool( void )
|
|
{
|
|
const unsigned int count = s_pool.size();
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
volatile LevelThing * thing = s_pool[ ii ];
|
|
delete thing;
|
|
}
|
|
s_pool.clear();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
LevelThing::LevelThing( unsigned int level, unsigned int place ) :
|
|
m_mutex( level ),
|
|
m_place( place ),
|
|
m_value( 0 )
|
|
{
|
|
assert( NULL != this );
|
|
#if defined( _MSC_VER )
|
|
m_mutex.GetMutexPolicy().SetWakable( false );
|
|
#endif
|
|
m_mutex.GetMutexPolicy().SetSleepTime( 5 );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
LevelThing::~LevelThing( void )
|
|
{
|
|
assert( NULL != this );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
LevelThing::MyUnlocker LevelThing::LockHierarchy( void ) volatile
|
|
{
|
|
assert( NULL != this );
|
|
for ( signed ii = m_place; 0 <= ii; --ii )
|
|
{
|
|
volatile LevelThing * thing = s_pool[ ii ];
|
|
assert( NULL != thing );
|
|
const MutexErrors::Type result = thing->m_mutex.Lock();
|
|
if ( MutexErrors::Success != result )
|
|
break;
|
|
}
|
|
|
|
MyUnlocker unlocker( this );
|
|
return unlocker;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void LevelThing::UnlockHierarchy( void ) volatile
|
|
{
|
|
assert( NULL != this );
|
|
try
|
|
{
|
|
for ( unsigned ii = 0; ii <= m_place; ++ii )
|
|
{
|
|
volatile LevelThing * thing = s_pool[ ii ];
|
|
assert( NULL != thing );
|
|
thing->m_mutex.Unlock();
|
|
}
|
|
}
|
|
catch ( ... )
|
|
{
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void LevelThing::SetValue( unsigned int value ) volatile
|
|
{
|
|
assert( NULL != this );
|
|
MutexLocker locker( m_mutex, !m_mutex.IsLockedByCurrentThread() );
|
|
(void)locker;
|
|
m_value = value;
|
|
if ( 0 == m_place )
|
|
return;
|
|
|
|
volatile LevelThing * thing = s_pool[ m_place - 1 ];
|
|
assert( NULL != thing );
|
|
thing->SetValue( value );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void LevelThing::SetValue( unsigned int value )
|
|
{
|
|
assert( NULL != this );
|
|
m_value = value;
|
|
if ( 0 == m_place )
|
|
return;
|
|
|
|
LevelThing * thing = const_cast< LevelThing * >( s_pool[ m_place - 1 ] );
|
|
assert( NULL != thing );
|
|
thing->SetValue( value );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool LevelThing::DoValuesMatch( unsigned int value ) const volatile
|
|
{
|
|
assert( NULL != this );
|
|
{
|
|
MutexLocker locker( m_mutex, !m_mutex.IsLockedByCurrentThread() );
|
|
(void)locker;
|
|
if ( m_value != value )
|
|
return false;
|
|
}
|
|
if ( 0 == m_place )
|
|
return true;
|
|
|
|
const volatile LevelThing * thing = s_pool[ m_place - 1 ];
|
|
assert( NULL != thing );
|
|
return thing->DoValuesMatch( value );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool LevelThing::DoValuesMatch( unsigned int value ) const
|
|
{
|
|
assert( NULL != this );
|
|
if ( m_value != value )
|
|
return false;
|
|
if ( 0 == m_place )
|
|
return true;
|
|
|
|
const LevelThing * thing = const_cast< LevelThing * >( s_pool[ m_place - 1 ] );
|
|
assert( NULL != thing );
|
|
return thing->DoValuesMatch( value );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
SomeThing::SomeThing( unsigned int level, unsigned int place ) :
|
|
m_mutex( level ),
|
|
m_place( place ),
|
|
m_level( level ),
|
|
m_value( 0 )
|
|
{
|
|
assert( NULL != this );
|
|
#if defined( _MSC_VER )
|
|
m_mutex.GetMutexPolicy().SetWakable( false );
|
|
#endif
|
|
m_mutex.GetMutexPolicy().SetSleepTime( 5 );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
SomeThing::~SomeThing( void )
|
|
{
|
|
assert( NULL != this );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void SomeThing::SetValue( unsigned int value ) volatile
|
|
{
|
|
assert( NULL != this );
|
|
SomeThingLocker pSafeThis( *this, m_mutex );
|
|
pSafeThis->m_value = value;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void SomeThing::SetValue( unsigned int value )
|
|
{
|
|
assert( NULL != this );
|
|
m_value = value;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
ManyThingsPool::ManyThingsPool( unsigned int level, unsigned int count ) :
|
|
m_pool()
|
|
{
|
|
assert( NULL != this );
|
|
m_pool.reserve( count );
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
volatile SomeThing * thing = new SomeThing( level, ii );
|
|
m_pool.push_back( thing );
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
ManyThingsPool::~ManyThingsPool( void )
|
|
{
|
|
assert( NULL != this );
|
|
const unsigned int count = m_pool.size();
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
volatile SomeThing * thing = m_pool[ ii ];
|
|
delete thing;
|
|
}
|
|
m_pool.clear();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
unsigned int ManyThingsPool::GetCount( void ) const
|
|
{
|
|
assert( NULL != this );
|
|
const unsigned int count = m_pool.size();
|
|
return count;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
volatile SomeThing * ManyThingsPool::GetFromPool( unsigned int index )
|
|
{
|
|
assert( NULL != this );
|
|
ManyThingsPool * pThis = const_cast< ManyThingsPool * >( this );
|
|
if ( pThis->m_pool.size() <= index )
|
|
return NULL;
|
|
volatile SomeThing * thing = pThis->m_pool[ index ];
|
|
assert( NULL != thing );
|
|
return thing;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void MultiLevelPool::MakePool( unsigned int count, unsigned int thingCount )
|
|
{
|
|
s_pool.clear();
|
|
s_pool.reserve( count );
|
|
unsigned int level = 100;
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
const unsigned int newCount = ( ::rand() % thingCount ) + 4;
|
|
ManyThingsPool * pool = new ManyThingsPool( ii + level, newCount );
|
|
s_pool.push_back( pool );
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void MultiLevelPool::DestroyPool( void )
|
|
{
|
|
const unsigned int count = s_pool.size();
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
ManyThingsPool * pool = s_pool[ ii ];
|
|
delete pool;
|
|
}
|
|
s_pool.clear();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
unsigned int MultiLevelPool::GetCount( void )
|
|
{
|
|
const unsigned int count = s_pool.size();
|
|
return count;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
ManyThingsPool * MultiLevelPool::GetFromPool( unsigned int index )
|
|
{
|
|
if ( s_pool.size() <= index )
|
|
return NULL;
|
|
ManyThingsPool * pool = s_pool[ index ];
|
|
assert( NULL != pool );
|
|
return pool;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void CheckForMatchingValues( unsigned int & failCount, unsigned int & testCount,
|
|
unsigned int value, const SomeThingPool & pool )
|
|
{
|
|
const unsigned int count = pool.size();
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
SomeThing * thing = const_cast< SomeThing * >( pool[ ii ] );
|
|
assert( NULL != thing );
|
|
testCount++;
|
|
if ( value != thing->GetValue() )
|
|
failCount++;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void CheckForMatchingValues( unsigned int & failCount, unsigned int & testCount,
|
|
unsigned int value, const SomeThingPool & pool, bool locked )
|
|
{
|
|
if ( !locked )
|
|
{
|
|
CheckForMatchingValues( failCount, testCount, value, pool );
|
|
return;
|
|
}
|
|
|
|
const unsigned int count = pool.size();
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
volatile SomeThing * thing = pool[ ii ];
|
|
assert( NULL != thing );
|
|
assert( thing->GetMutex().IsLockedByCurrentThread() );
|
|
testCount++;
|
|
if ( value != thing->GetValue() )
|
|
failCount++;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void MakePool( SomeThingPool & target )
|
|
{
|
|
SomeThingPool temp;
|
|
bool useThis = false;
|
|
unsigned int count2 = 0;
|
|
unsigned int r = 0;
|
|
bool first = true;
|
|
const unsigned int count1 = MultiLevelPool::GetCount();
|
|
|
|
for ( unsigned int index1 = 0; index1 < count1; ++index1 )
|
|
{
|
|
r = ( ::rand() % 4 );
|
|
useThis = ( 0 == index1 ) || ( r != 0 );
|
|
if ( !useThis )
|
|
continue;
|
|
|
|
ManyThingsPool * pool = MultiLevelPool::GetFromPool( index1 );
|
|
assert( NULL != pool );
|
|
count2 = pool->GetCount();
|
|
first = true;
|
|
|
|
for ( unsigned int index2 = 0; index2 < count2; ++index2 )
|
|
{
|
|
r = ( ::rand() % 4 );
|
|
useThis = ( 0 == index1 ) || ( r != 0 );
|
|
if ( !useThis )
|
|
continue;
|
|
volatile SomeThing * thing = pool->GetFromPool( index2 );
|
|
assert( NULL != thing );
|
|
temp.push_back( thing );
|
|
|
|
if ( first )
|
|
{
|
|
// The containers at most levels will have multiple mutexes,
|
|
// but some levels will have just a single mutex.
|
|
r = ( ::rand() % 4 );
|
|
if ( r != 0 )
|
|
break;
|
|
}
|
|
first = false;
|
|
}
|
|
}
|
|
|
|
temp.swap( target );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/// @struct SomeThingComparator Binary-functor for comparing 2 SomeThing's.
|
|
struct SomeThingComparator : std::binary_function< volatile SomeThing *, volatile SomeThing *, bool >
|
|
{
|
|
/// Returns true if left string < right string.
|
|
inline bool operator ()( volatile SomeThing * lhs, volatile SomeThing * rhs ) const
|
|
{
|
|
return ( lhs->GetLevel() < rhs->GetLevel() );
|
|
}
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void SortByLevel( SomeThingPool & pool )
|
|
{
|
|
const unsigned int count = pool.size();
|
|
assert( 0 != count );
|
|
SomeThingComparator comparator;
|
|
::std::sort( pool.begin(), pool.end(), comparator );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void LockThese( SomeThingPool & pool )
|
|
{
|
|
|
|
const unsigned int count = pool.size();
|
|
assert( 0 != count );
|
|
SortByLevel( pool );
|
|
|
|
volatile SomeThing * thing = pool[ count - 1 ];
|
|
assert( NULL != thing );
|
|
unsigned int level = thing->GetLevel();
|
|
LevelMutexInfo::MutexContainer mutexes;
|
|
MutexErrors::Type result = MutexErrors::Success;
|
|
signed int ii = count - 1;
|
|
|
|
for ( ; 0 <= ii; --ii )
|
|
{
|
|
thing = pool[ ii ];
|
|
assert( NULL != thing );
|
|
if ( level != thing->GetLevel() )
|
|
{
|
|
assert( mutexes.size() != 0 );
|
|
result = LevelMutexInfo::MultiLock( mutexes );
|
|
assert( result == MutexErrors::Success );
|
|
mutexes.clear();
|
|
level = thing->GetLevel();
|
|
}
|
|
mutexes.push_back( &thing->GetMutex() );
|
|
}
|
|
|
|
assert( mutexes.size() != 0 );
|
|
result = LevelMutexInfo::MultiLock( mutexes );
|
|
assert( result == MutexErrors::Success );
|
|
|
|
for ( ii = count - 1; 0 <= ii; --ii )
|
|
{
|
|
thing = pool[ ii ];
|
|
assert( NULL != thing );
|
|
assert( thing->GetMutex().IsLockedByCurrentThread() );
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void UnlockThese( SomeThingPool & pool )
|
|
{
|
|
|
|
const unsigned int count = pool.size();
|
|
assert( 0 != count );
|
|
SortByLevel( pool );
|
|
|
|
volatile SomeThing * thing = pool[ 0 ];
|
|
assert( NULL != thing );
|
|
unsigned int level = thing->GetLevel();
|
|
LevelMutexInfo::MutexContainer mutexes;
|
|
MutexErrors::Type result = MutexErrors::Success;
|
|
unsigned int ii = 0;
|
|
|
|
for ( ii = 0; ii < count; ++ii )
|
|
{
|
|
thing = pool[ ii ];
|
|
assert( NULL != thing );
|
|
if ( level != thing->GetLevel() )
|
|
{
|
|
assert( mutexes.size() != 0 );
|
|
result = LevelMutexInfo::MultiUnlock( mutexes );
|
|
assert( result == MutexErrors::Success );
|
|
mutexes.clear();
|
|
level = thing->GetLevel();
|
|
}
|
|
mutexes.push_back( &thing->GetMutex() );
|
|
}
|
|
|
|
assert( mutexes.size() != 0 );
|
|
result = LevelMutexInfo::MultiUnlock( mutexes );
|
|
assert( result == MutexErrors::Success );
|
|
|
|
for ( ii = 0; ii < count; ++ii )
|
|
{
|
|
thing = pool[ ii ];
|
|
assert( NULL != thing );
|
|
assert( !thing->GetMutex().IsLockedByCurrentThread() );
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
unsigned int CountLockedByThisThread( const SomeThingPool & pool )
|
|
{
|
|
const unsigned int count = pool.size();
|
|
unsigned int locked = 0;
|
|
|
|
for ( unsigned int ii = 0; ii < count; ++ii )
|
|
{
|
|
const volatile SomeThing * thing = pool[ ii ];
|
|
assert( NULL != thing );
|
|
if ( thing->GetMutex().IsLockedByCurrentThread() )
|
|
locked++;
|
|
}
|
|
|
|
return locked;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|