From 6c8b1660b4735b23c6d797ab98b68a0358bca39d Mon Sep 17 00:00:00 2001 From: syntheticpp Date: Wed, 2 Nov 2005 13:58:18 +0000 Subject: [PATCH] use new singleton lifetime policies git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@343 7ec92016-0320-0410-acc4-a06ded1c099a --- test/SmallObj/SmallSingleton.cpp | 263 ++++++++++++++++++++----------- 1 file changed, 172 insertions(+), 91 deletions(-) diff --git a/test/SmallObj/SmallSingleton.cpp b/test/SmallObj/SmallSingleton.cpp index 21d02c6..7ed2d96 100644 --- a/test/SmallObj/SmallSingleton.cpp +++ b/test/SmallObj/SmallSingleton.cpp @@ -1,6 +1,7 @@ //////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2005 Richard Sposato +// Copyright (c) 2005 Peter Kümmel // 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 @@ -17,30 +18,122 @@ #include "../../include/loki/Singleton.h" #include +// define DO_EXTRA_LOKI_TESTS in src/SmallObj.cpp to get +// a message when a SmallObject is created/deleted. using namespace std; +// ---------------------------------------------------------------------------- +// +// FollowIntoDeath policy +// // ---------------------------------------------------------------------------- typedef Loki::SmallValueObject< LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, LOKI_DEFAULT_CHUNK_SIZE, LOKI_MAX_SMALL_OBJECT_SIZE, - LOKI_DEFAULT_OBJECT_ALIGNMENT, Loki::SingletonWithLongevity > -LongLivedObject; + LOKI_DEFAULT_OBJECT_ALIGNMENT, + Loki::FollowIntoDeath::With::AsMasterLifetime // this is default +> +MasterObject; + +class FollowerSingleton : public MasterObject +{ +public: + + typedef Loki::SingletonHolder< FollowerSingleton, Loki::CreateUsingNew, + Loki::FollowIntoDeath::AfterMaster::IsDestroyed, + LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL > + MySmallSingleton; + + /// Returns reference to the singleton. + inline static FollowerSingleton & Instance( void ) + { + return MySmallSingleton::Instance(); + } + + FollowerSingleton( void ) + { + cout << "FollowerSingleton created" << endl; + } + ~FollowerSingleton( void ) + { + cout << "~FollowerSingleton" << endl; + } + void DoThat( void ) + { + cout << "FollowerSingleton::DoThat" << endl << endl; + } +private: + char m_stuff[ 16 ]; +}; -typedef Loki::SmallValueObject< LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, - LOKI_DEFAULT_CHUNK_SIZE, LOKI_MAX_SMALL_OBJECT_SIZE, - LOKI_DEFAULT_OBJECT_ALIGNMENT, Loki::NoDestroy > -ImmortalObject; // ---------------------------------------------------------------------------- +// +// DieOrder policy +// +// ---------------------------------------------------------------------------- + +typedef Loki::SmallValueObject< LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, + LOKI_DEFAULT_CHUNK_SIZE, LOKI_MAX_SMALL_OBJECT_SIZE, + LOKI_DEFAULT_OBJECT_ALIGNMENT, + Loki::DieOrder::Last +> +DieLastObject; + +class DieFirstSingleton : public DieLastObject +{ +public: + + typedef Loki::SingletonHolder< DieFirstSingleton, Loki::CreateUsingNew, + Loki::DieOrder::First, + LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL > + MySmallSingleton; + + /// Returns reference to the singleton. + inline static DieFirstSingleton & Instance( void ) + { + return MySmallSingleton::Instance(); + } + + DieFirstSingleton( void ) + { + cout << "DieFirstSingleton created" << endl; + } + ~DieFirstSingleton( void ) + { + cout << "~DieFirstSingleton" << endl; + } + void DoThat( void ) + { + cout << "DieFirstSingleton::DoThat" << endl << endl; + } +private: + char m_stuff[ 16 ]; +}; + + +// ---------------------------------------------------------------------------- +// +// SingletonWithLongevity policy +// +// ---------------------------------------------------------------------------- + +typedef Loki::SmallValueObject< LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, + LOKI_DEFAULT_CHUNK_SIZE, LOKI_MAX_SMALL_OBJECT_SIZE, + LOKI_DEFAULT_OBJECT_ALIGNMENT, + Loki::SingletonWithLongevity +> +LongLivedObject; class LongLivedSingleton : public LongLivedObject { public: typedef Loki::SingletonHolder< LongLivedSingleton, Loki::CreateUsingNew, - Loki::SingletonWithLongevity, LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL > + Loki::SingletonWithLongevity, + LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL > MySmallSingleton; /// Returns reference to the singleton. @@ -51,7 +144,7 @@ public: LongLivedSingleton( void ) { - cout << "LongLivedSingleton" << endl; + cout << "LongLivedSingleton created" << endl; } ~LongLivedSingleton( void ) { @@ -59,119 +152,107 @@ public: } void DoThat( void ) { - cout << "LongLivedSingleton::DoThat" << endl; + cout << "LongLivedSingleton::DoThat" << endl << endl; } private: char m_stuff[ 16 ]; }; -// ---------------------------------------------------------------------------- - inline unsigned int GetLongevity( LongLivedSingleton * ) { /// @note Must return a longevity level lower than the one in SmallObj.h. return 1; } -// ---------------------------------------------------------------------------- - -class ImmortalSingleton : public ImmortalObject -{ -public: - - typedef Loki::SingletonHolder< ImmortalSingleton, Loki::CreateUsingNew, - Loki::NoDestroy, LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL > - MySmallSingleton; - - /// Returns reference to the singleton. - inline static ImmortalSingleton & Instance( void ) - { - return MySmallSingleton::Instance(); - } - - ImmortalSingleton( void ) - { - cout << "ImmortalSingleton" << endl; - } - ~ImmortalSingleton( void ) - { - cout << "~ImmortalSingleton destructor should never get called!" << endl; - } - void DoThat( void ) - { - cout << "ImmortalSingleton::DoThat" << endl; - } -private: - char m_stuff[ 16 ]; -}; // ---------------------------------------------------------------------------- - -class MortalSingleton : public ImmortalObject -{ -public: - - typedef Loki::SingletonHolder< MortalSingleton, Loki::CreateUsingNew, - Loki::SingletonWithLongevity, LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL > - MySmallSingleton; - - /// Returns reference to the singleton. - inline static MortalSingleton & Instance( void ) - { - return MySmallSingleton::Instance(); - } - - MortalSingleton( void ) - { - cout << "MortalSingleton" << endl; - } - ~MortalSingleton( void ) - { - cout << "~MortalSingleton" << endl; - } - void DoThat( void ) - { - cout << "MortalSingleton::DoThat" << endl; - } -private: - char m_stuff[ 16 ]; -}; - +// +// detect memory leaks on MSVC Ide +// // ---------------------------------------------------------------------------- -inline unsigned int GetLongevity( MortalSingleton * ) +#ifdef _MSC_VER + +#include +#include + +void heap_debug() { - /// @note Must return a longevity level lower than the one in SmallObj.h. - return 1; + int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG ); + + // Turn on leak-checking bit + tmpFlag |= _CRTDBG_LEAK_CHECK_DF; + + //tmpFlag |= _CRTDBG_CHECK_MasterLWMasterYS_DF; + + // Turn off CRT block checking bit + tmpFlag &= ~_CRTDBG_CHECK_CRT_DF; + + // Set flag to the new value + _CrtSetDbgFlag( tmpFlag ); + } +#endif + +// ---------------------------------------------------------------------------- +// +// main +// // ---------------------------------------------------------------------------- int main() { - cout << "This program tests the three recommended combinations of singleton" << endl - << "lifetime policies for Loki's Small-Object Allocator and singleton" << endl - << "objects that are derived from SmallObject or SmallValueObject." << endl << endl - << "Those 3 recommended combinations are:" << endl - << "\t1. Both SmallObject and derived Singleton use NoDestroy policy." << endl - << "\t This is tested by the ImmortalSingleton class." << endl - << "\t2. Both use SingletonWithLongevity policy." << endl - << "\t This is tested by the LongLivedSingleton class." << endl - << "\t3. SmallObject has NoDestroy policy but the derived Singleton has" << endl - << "\t SingletonWithLongevity policy." << endl - << "\t This is tested by the MortalSingleton class." << endl << endl - << "If this program executes without crashing or asserting at exit time," << endl - << "then all 3 combinations work." << endl << endl; - MortalSingleton::Instance().DoThat(); + +#ifdef _MSC_VER + heap_debug(); +#endif + + cout << endl + << "This program tests the three recommended lifetime policies for Loki's " << endl + << "Small-Object Allocator and singleton objects that are derived " << endl + << "from SmallObject or SmallValueObject." << endl + << endl + << "Use one of the following lifetime policies" << endl + << "to manage the lifetime dependency:" << endl + << endl + << "1. FollowIntoDeath:" << endl + << " SmallObject has " << endl + << " FollowIntoDeath::With::AsMasterLiftime policy" << endl + << " and the derived Singleton has " << endl + << " FollowIntoDeath::After::IsDestroyed policy" << endl + << " This is tested by the FollowerSingleton class." << endl + << endl + << "2. DieOrder:" << endl + << " SmallObject has " << endl + << " DieOrder::Last policy " << endl + << " and the derived Singleton has " << endl + << " DieOrder::First" << endl + << " This is tested by the DieOrderSingleton class." << endl + << endl + << "3. Both SmallObject and derived Singleton use SingletonWithLongevity policy." << endl + << " This is tested by the LongLivedSingleton class." << endl + << endl << endl + << "If this program executes without crashing or asserting" << endl + << " at exit time, then all 3 policies work." << endl << endl; + + FollowerSingleton::Instance().DoThat(); + DieFirstSingleton::Instance().DoThat(); LongLivedSingleton::Instance().DoThat(); - ImmortalSingleton::Instance().DoThat(); + system("PAUSE"); + + cout << endl<< endl << "now leaving main" << endl << endl; + return 0; } // ---------------------------------------------------------------------------- // $Log$ +// Revision 1.4 2005/11/02 13:58:18 syntheticpp +// use new singleton lifetime policies +// // Revision 1.3 2005/10/30 14:03:23 syntheticpp // replace tabs space //