tests/unit/map2/map_delodd.h

   1 //$$CDS-header$$
   2
   3 #include "cppunit/thread.h"
   4 #include "map2/map_type.h"
   5 #include <cds/os/topology.h>
   6
   7 namespace map2 {
   8
   9 #   define TEST_MAP(IMPL, C, X)         void C::X() { test<map_type<IMPL, key_type, value_type>::X >(); }
  10 #   define TEST_MAP_EXTRACT(IMPL, C, X) void C::X() { test_extract<map_type<IMPL, key_type, value_type>::X >(); }
  11 #   define TEST_MAP_NOLF(IMPL, C, X)    void C::X() { test_nolf<map_type<IMPL, key_type, value_type>::X >(); }
  12 #   define TEST_MAP_NOLF_EXTRACT(IMPL, C, X) void C::X() { test_nolf_extract<map_type<IMPL, key_type, value_type>::X >(); }
  13
  14     namespace {
  15         struct key_thread
  16         {
  17             size_t  nKey;
  18             size_t  nThread;
  19
  20             key_thread( size_t key, size_t threadNo )
  21                 : nKey( key )
  22                 , nThread( threadNo )
  23             {}
  24
  25             key_thread()
  26             {}
  27         };
  28
  29         //typedef MapTypes<key_thread, size_t>::key_val     key_value_pair;
  30     }
  31
  32     template <>
  33     struct cmp<key_thread> {
  34         int operator ()(key_thread const& k1, key_thread const& k2) const
  35         {
  36             if ( k1.nKey < k2.nKey )
  37                 return -1;
  38             if ( k1.nKey > k2.nKey )
  39                 return 1;
  40             if ( k1.nThread < k2.nThread )
  41                 return -1;
  42             if ( k1.nThread > k2.nThread )
  43                 return 1;
  44             return 0;
  45         }
  46         int operator ()(key_thread const& k1, size_t k2) const
  47         {
  48             if ( k1.nKey < k2 )
  49                 return -1;
  50             if ( k1.nKey > k2 )
  51                 return 1;
  52             return 0;
  53         }
  54         int operator ()(size_t k1, key_thread const& k2) const
  55         {
  56             if ( k1 < k2.nKey )
  57                 return -1;
  58             if ( k1 > k2.nKey )
  59                 return 1;
  60             return 0;
  61         }
  62     };
  63
  64 } // namespace map2
  65
  66 namespace std {
  67     template <>
  68     struct less<map2::key_thread>
  69     {
  70         bool operator()(map2::key_thread const& k1, map2::key_thread const& k2) const
  71         {
  72             if ( k1.nKey <= k2.nKey )
  73                 return k1.nKey < k2.nKey || k1.nThread < k2.nThread;
  74             return false;
  75         }
  76     };
  77
  78     template <>
  79     struct hash<map2::key_thread>
  80     {
  81         typedef size_t              result_type;
  82         typedef map2::key_thread    argument_type;
  83
  84         size_t operator()( map2::key_thread const& k ) const
  85         {
  86             return std::hash<size_t>()(k.nKey);
  87         }
  88         size_t operator()( size_t k ) const
  89         {
  90             return std::hash<size_t>()(k);
  91         }
  92     };
  93 } // namespace std
  94
  95 namespace boost {
  96     inline size_t hash_value( map2::key_thread const& k )
  97     {
  98         return std::hash<size_t>()( k.nKey );
  99     }
 100
 101     template <>
 102     struct hash<map2::key_thread>
 103     {
 104         typedef size_t              result_type;
 105         typedef map2::key_thread    argument_type;
 106
 107         size_t operator()(map2::key_thread const& k) const
 108         {
 109             return boost::hash<size_t>()( k.nKey );
 110         }
 111         size_t operator()(size_t k) const
 112         {
 113             return boost::hash<size_t>()( k );
 114         }
 115     };
 116 } // namespace boost
 117
 118 namespace map2 {
 119
 120     class Map_DelOdd: public CppUnitMini::TestCase
 121     {
 122         static size_t  c_nMapSize;          // max map size
 123         static size_t  c_nInsThreadCount;   // insert thread count
 124         static size_t  c_nDelThreadCount;   // delete thread count
 125         static size_t  c_nExtractThreadCount;  // extract thread count
 126         static size_t  c_nMaxLoadFactor;    // maximum load factor
 127         static bool    c_bPrintGCState;
 128
 129         std::vector<size_t>     m_arrInsert;
 130         std::vector<size_t>     m_arrRemove;
 131
 132     protected:
 133         typedef CppUnitMini::TestCase Base;
 134
 135         typedef key_thread  key_type;
 136         typedef size_t      value_type;
 137         typedef std::pair<key_type const, value_type> pair_type;
 138
 139         atomics::atomic<size_t>      m_nInsThreadCount;
 140
 141         // Inserts keys from [0..N)
 142         template <class Map>
 143         class InsertThread: public CppUnitMini::TestThread
 144         {
 145             Map&     m_Map;
 146
 147             virtual InsertThread *    clone()
 148             {
 149                 return new InsertThread( *this );
 150             }
 151
 152             struct ensure_func
 153             {
 154                 template <typename Q>
 155                 void operator()( bool /*bNew*/, Q const& )
 156                 {}
 157                 template <typename Q, typename V>
 158                 void operator()( bool /*bNew*/, Q const&, V& )
 159                 {}
 160             };
 161         public:
 162             size_t  m_nInsertSuccess;
 163             size_t  m_nInsertFailed;
 164
 165         public:
 166             InsertThread( CppUnitMini::ThreadPool& pool, Map& rMap )
 167                 : CppUnitMini::TestThread( pool )
 168                 , m_Map( rMap )
 169             {}
 170             InsertThread( InsertThread& src )
 171                 : CppUnitMini::TestThread( src )
 172                 , m_Map( src.m_Map )
 173             {}
 174
 175             Map_DelOdd&  getTest()
 176             {
 177                 return reinterpret_cast<Map_DelOdd&>( m_Pool.m_Test );
 178             }
 179
 180             virtual void init() { cds::threading::Manager::attachThread()   ; }
 181             virtual void fini() { cds::threading::Manager::detachThread()   ; }
 182
 183             virtual void test()
 184             {
 185                 Map& rMap = m_Map;
 186
 187                 m_nInsertSuccess =
 188                     m_nInsertFailed = 0;
 189
 190                 std::vector<size_t>& arrData = getTest().m_arrInsert;
 191                 for ( size_t i = 0; i < arrData.size(); ++i ) {
 192                     if ( rMap.insert( key_type( arrData[i], m_nThreadNo )))
 193                         ++m_nInsertSuccess;
 194                     else
 195                         ++m_nInsertFailed;
 196                 }
 197
 198                 ensure_func f;
 199                 for ( size_t i = arrData.size() - 1; i > 0; --i ) {
 200                     if ( arrData[i] & 1 ) {
 201                         rMap.ensure( key_type( arrData[i], m_nThreadNo ), f );
 202                     }
 203                 }
 204
 205                 getTest().m_nInsThreadCount.fetch_sub( 1, atomics::memory_order_acquire );
 206             }
 207         };
 208
 209         struct key_equal {
 210             bool operator()( key_type const& k1, key_type const& k2 ) const
 211             {
 212                 return k1.nKey == k2.nKey;
 213             }
 214             bool operator()( size_t k1, key_type const& k2 ) const
 215             {
 216                 return k1 == k2.nKey;
 217             }
 218             bool operator()( key_type const& k1, size_t k2 ) const
 219             {
 220                 return k1.nKey == k2;
 221             }
 222         };
 223
 224         struct key_less {
 225             bool operator()( key_type const& k1, key_type const& k2 ) const
 226             {
 227                 return k1.nKey < k2.nKey;
 228             }
 229             bool operator()( size_t k1, key_type const& k2 ) const
 230             {
 231                 return k1 < k2.nKey;
 232             }
 233             bool operator()( key_type const& k1, size_t k2 ) const
 234             {
 235                 return k1.nKey < k2;
 236             }
 237
 238             typedef key_equal equal_to;
 239         };
 240
 241         // Deletes odd keys from [0..N)
 242         template <class Map>
 243         class DeleteThread: public CppUnitMini::TestThread
 244         {
 245             Map&     m_Map;
 246
 247             virtual DeleteThread *    clone()
 248             {
 249                 return new DeleteThread( *this );
 250             }
 251         public:
 252             size_t  m_nDeleteSuccess;
 253             size_t  m_nDeleteFailed;
 254
 255         public:
 256             DeleteThread( CppUnitMini::ThreadPool& pool, Map& rMap )
 257                 : CppUnitMini::TestThread( pool )
 258                 , m_Map( rMap )
 259             {}
 260             DeleteThread( DeleteThread& src )
 261                 : CppUnitMini::TestThread( src )
 262                 , m_Map( src.m_Map )
 263             {}
 264
 265             Map_DelOdd&  getTest()
 266             {
 267                 return reinterpret_cast<Map_DelOdd&>( m_Pool.m_Test );
 268             }
 269
 270             virtual void init() { cds::threading::Manager::attachThread()   ; }
 271             virtual void fini() { cds::threading::Manager::detachThread()   ; }
 272
 273             virtual void test()
 274             {
 275                 Map& rMap = m_Map;
 276
 277                 m_nDeleteSuccess =
 278                     m_nDeleteFailed = 0;
 279
 280                 for ( size_t pass = 0; pass < 2; pass++ ) {
 281                     std::vector<size_t>& arrData = getTest().m_arrRemove;
 282                     if ( m_nThreadNo & 1 ) {
 283                         for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
 284                             for ( size_t i = 0; i < arrData.size(); ++i ) {
 285                                 if ( arrData[i] & 1 ) {
 286                                     if ( rMap.erase_with( arrData[i], key_less() ))
 287                                         ++m_nDeleteSuccess;
 288                                     else
 289                                         ++m_nDeleteFailed;
 290                                 }
 291                             }
 292                             if ( getTest().m_nInsThreadCount.load( atomics::memory_order_acquire ) == 0 )
 293                                 break;
 294                         }
 295                     }
 296                     else {
 297                         for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
 298                             for ( size_t i = arrData.size() - 1; i > 0; --i ) {
 299                                 if ( arrData[i] & 1 ) {
 300                                     if ( rMap.erase_with( arrData[i], key_less() ))
 301                                         ++m_nDeleteSuccess;
 302                                     else
 303                                         ++m_nDeleteFailed;
 304                                 }
 305                             }
 306                             if ( getTest().m_nInsThreadCount.load( atomics::memory_order_acquire ) == 0 )
 307                                 break;
 308                         }
 309                     }
 310                 }
 311             }
 312         };
 313
 314         // Deletes odd keys from [0..N)
 315         template <class GC, class Map >
 316         class ExtractThread: public CppUnitMini::TestThread
 317         {
 318             Map&     m_Map;
 319
 320             virtual ExtractThread *    clone()
 321             {
 322                 return new ExtractThread( *this );
 323             }
 324         public:
 325             size_t  m_nDeleteSuccess;
 326             size_t  m_nDeleteFailed;
 327
 328         public:
 329             ExtractThread( CppUnitMini::ThreadPool& pool, Map& rMap )
 330                 : CppUnitMini::TestThread( pool )
 331                 , m_Map( rMap )
 332             {}
 333             ExtractThread( ExtractThread& src )
 334                 : CppUnitMini::TestThread( src )
 335                 , m_Map( src.m_Map )
 336             {}
 337
 338             Map_DelOdd&  getTest()
 339             {
 340                 return reinterpret_cast<Map_DelOdd&>( m_Pool.m_Test );
 341             }
 342
 343             virtual void init() { cds::threading::Manager::attachThread()   ; }
 344             virtual void fini() { cds::threading::Manager::detachThread()   ; }
 345
 346             virtual void test()
 347             {
 348                 Map& rMap = m_Map;
 349
 350                 m_nDeleteSuccess =
 351                     m_nDeleteFailed = 0;
 352
 353                 typename Map::guarded_ptr gp;
 354
 355                 for ( size_t pass = 0; pass < 2; ++pass ) {
 356                     std::vector<size_t>& arrData = getTest().m_arrRemove;
 357                     if ( m_nThreadNo & 1 ) {
 358                         for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
 359                             for ( size_t i = 0; i < arrData.size(); ++i ) {
 360                                 if ( arrData[i] & 1 ) {
 361                                     gp = rMap.extract_with( arrData[i], key_less());
 362                                     if ( gp )
 363                                         ++m_nDeleteSuccess;
 364                                     else
 365                                         ++m_nDeleteFailed;
 366                                     gp.release();
 367                                 }
 368                             }
 369                             if ( getTest().m_nInsThreadCount.load( atomics::memory_order_acquire ) == 0 )
 370                                 break;
 371                         }
 372                     }
 373                     else {
 374                         for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
 375                             for ( size_t i = arrData.size() - 1; i > 0; --i ) {
 376                                 if ( arrData[i] & 1 ) {
 377                                     gp = rMap.extract_with( arrData[i], key_less());
 378                                     if ( gp )
 379                                         ++m_nDeleteSuccess;
 380                                     else
 381                                         ++m_nDeleteFailed;
 382                                     gp.release();
 383                                 }
 384                             }
 385                             if ( getTest().m_nInsThreadCount.load( atomics::memory_order_acquire ) == 0 )
 386                                 break;
 387                         }
 388                     }
 389                 }
 390             }
 391         };
 392
 393         template <class RCU, class Map >
 394         class ExtractThread< cds::urcu::gc<RCU>, Map > : public CppUnitMini::TestThread
 395         {
 396             Map&     m_Map;
 397
 398             virtual ExtractThread *    clone()
 399             {
 400                 return new ExtractThread( *this );
 401             }
 402         public:
 403             size_t  m_nDeleteSuccess;
 404             size_t  m_nDeleteFailed;
 405
 406         public:
 407             ExtractThread( CppUnitMini::ThreadPool& pool, Map& rMap )
 408                 : CppUnitMini::TestThread( pool )
 409                 , m_Map( rMap )
 410             {}
 411             ExtractThread( ExtractThread& src )
 412                 : CppUnitMini::TestThread( src )
 413                 , m_Map( src.m_Map )
 414             {}
 415
 416             Map_DelOdd&  getTest()
 417             {
 418                 return reinterpret_cast<Map_DelOdd&>( m_Pool.m_Test );
 419             }
 420
 421             virtual void init() { cds::threading::Manager::attachThread()   ; }
 422             virtual void fini() { cds::threading::Manager::detachThread()   ; }
 423
 424             virtual void test()
 425             {
 426                 Map& rMap = m_Map;
 427
 428                 m_nDeleteSuccess =
 429                     m_nDeleteFailed = 0;
 430
 431                 typename Map::exempt_ptr xp;
 432
 433                 std::vector<size_t>& arrData = getTest().m_arrRemove;
 434                 if ( m_nThreadNo & 1 ) {
 435                     for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
 436                         for ( size_t i = 0; i < arrData.size(); ++i ) {
 437                             if ( arrData[i] & 1 ) {
 438                                 if ( Map::c_bExtractLockExternal ) {
 439                                     {
 440                                         typename Map::rcu_lock l;
 441                                         xp = rMap.extract_with( arrData[i], key_less() );
 442                                         if ( xp )
 443                                             ++m_nDeleteSuccess;
 444                                         else
 445                                             ++m_nDeleteFailed;
 446                                     }
 447                                 }
 448                                 else {
 449                                     xp = rMap.extract_with( arrData[i], key_less() );
 450                                     if ( xp )
 451                                         ++m_nDeleteSuccess;
 452                                     else
 453                                         ++m_nDeleteFailed;
 454                                 }
 455                                 xp.release();
 456                             }
 457                         }
 458                         if ( getTest().m_nInsThreadCount.load( atomics::memory_order_acquire ) == 0 )
 459                             break;
 460                     }
 461                 }
 462                 else {
 463                     for ( size_t k = 0; k < c_nInsThreadCount; ++k ) {
 464                         for ( size_t i = arrData.size() - 1; i > 0; --i ) {
 465                             if ( arrData[i] & 1 ) {
 466                                 if ( Map::c_bExtractLockExternal ) {
 467                                     {
 468                                         typename Map::rcu_lock l;
 469                                         xp = rMap.extract_with( arrData[i], key_less() );
 470                                         if ( xp )
 471                                             ++m_nDeleteSuccess;
 472                                         else
 473                                             ++m_nDeleteFailed;
 474                                     }
 475                                 }
 476                                 else {
 477                                     xp = rMap.extract_with( arrData[i], key_less() );
 478                                     if ( xp )
 479                                         ++m_nDeleteSuccess;
 480                                     else
 481                                         ++m_nDeleteFailed;
 482                                 }
 483                                 xp.release();
 484                             }
 485                         }
 486                         if ( getTest().m_nInsThreadCount.load( atomics::memory_order_acquire ) == 0 )
 487                             break;
 488                     }
 489                 }
 490             }
 491         };
 492
 493     protected:
 494         template <class Map>
 495         void do_test( size_t nLoadFactor )
 496         {
 497             Map  testMap( c_nMapSize, nLoadFactor );
 498             do_test_with( testMap );
 499         }
 500
 501         template <class Map>
 502         void do_test_extract( size_t nLoadFactor )
 503         {
 504             Map  testMap( c_nMapSize, nLoadFactor );
 505             do_test_extract_with( testMap );
 506         }
 507
 508         template <class Map>
 509         void do_test_with( Map& testMap )
 510         {
 511             typedef InsertThread<Map> insert_thread;
 512             typedef DeleteThread<Map> delete_thread;
 513
 514             m_nInsThreadCount.store( c_nInsThreadCount, atomics::memory_order_release );
 515
 516             CppUnitMini::ThreadPool pool( *this );
 517             pool.add( new insert_thread( pool, testMap ), c_nInsThreadCount );
 518             pool.add( new delete_thread( pool, testMap ), c_nDelThreadCount ? c_nDelThreadCount : cds::OS::topology::processor_count());
 519             pool.run();
 520             CPPUNIT_MSG( "   Duration=" << pool.avgDuration() );
 521
 522             size_t nInsertSuccess = 0;
 523             size_t nInsertFailed = 0;
 524             size_t nDeleteSuccess = 0;
 525             size_t nDeleteFailed = 0;
 526             for ( CppUnitMini::ThreadPool::iterator it = pool.begin(); it != pool.end(); ++it ) {
 527                 insert_thread * pThread = dynamic_cast<insert_thread *>( *it );
 528                 if ( pThread ) {
 529                     nInsertSuccess += pThread->m_nInsertSuccess;
 530                     nInsertFailed += pThread->m_nInsertFailed;
 531                 }
 532                 else {
 533                     delete_thread * p = static_cast<delete_thread *>( *it );
 534                     nDeleteSuccess += p->m_nDeleteSuccess;
 535                     nDeleteFailed += p->m_nDeleteFailed;
 536                 }
 537             }
 538
 539             CPPUNIT_MSG( "  Totals (success/failed): \n\t"
 540                 << "      Insert=" << nInsertSuccess << '/' << nInsertFailed << "\n\t"
 541                 << "      Delete=" << nDeleteSuccess << '/' << nDeleteFailed << "\n\t"
 542                 );
 543             CPPUNIT_CHECK( nInsertSuccess == c_nMapSize * c_nInsThreadCount );
 544             CPPUNIT_CHECK( nInsertFailed == 0 );
 545
 546             analyze( testMap );
 547         }
 548
 549         template <class Map>
 550         void do_test_extract_with( Map& testMap )
 551         {
 552             typedef InsertThread<Map> insert_thread;
 553             typedef DeleteThread<Map> delete_thread;
 554             typedef ExtractThread< typename Map::gc, Map > extract_thread;
 555
 556             m_nInsThreadCount.store( c_nInsThreadCount, atomics::memory_order_release );
 557
 558             CppUnitMini::ThreadPool pool( *this );
 559             pool.add( new insert_thread( pool, testMap ), c_nInsThreadCount );
 560             if ( c_nDelThreadCount )
 561                 pool.add( new delete_thread( pool, testMap ), c_nDelThreadCount );
 562             if ( c_nExtractThreadCount )
 563                 pool.add( new extract_thread( pool, testMap ), c_nExtractThreadCount );
 564             pool.run();
 565             CPPUNIT_MSG( "   Duration=" << pool.avgDuration() );
 566
 567             size_t nInsertSuccess = 0;
 568             size_t nInsertFailed = 0;
 569             size_t nDeleteSuccess = 0;
 570             size_t nDeleteFailed = 0;
 571             size_t nExtractSuccess = 0;
 572             size_t nExtractFailed = 0;
 573             for ( CppUnitMini::ThreadPool::iterator it = pool.begin(); it != pool.end(); ++it ) {
 574                 insert_thread * pThread = dynamic_cast<insert_thread *>( *it );
 575                 if ( pThread ) {
 576                     nInsertSuccess += pThread->m_nInsertSuccess;
 577                     nInsertFailed += pThread->m_nInsertFailed;
 578                 }
 579                 else {
 580                     delete_thread * p = dynamic_cast<delete_thread *>( *it );
 581                     if ( p ) {
 582                         nDeleteSuccess += p->m_nDeleteSuccess;
 583                         nDeleteFailed += p->m_nDeleteFailed;
 584                     }
 585                     else {
 586                         extract_thread * pExtract = dynamic_cast<extract_thread *>( *it );
 587                         assert( pExtract );
 588                         nExtractSuccess += pExtract->m_nDeleteSuccess;
 589                         nExtractFailed += pExtract->m_nDeleteFailed;
 590                     }
 591                 }
 592             }
 593
 594             CPPUNIT_MSG( "  Totals (success/failed): \n\t"
 595                 << "      Insert=" << nInsertSuccess << '/' << nInsertFailed << "\n\t"
 596                 << "      Delete=" << nDeleteSuccess << '/' << nDeleteFailed << "\n\t"
 597                 << "      Extract=" << nExtractSuccess << '/' << nExtractFailed << "\n\t"
 598                 );
 599             CPPUNIT_CHECK( nInsertSuccess == c_nMapSize * c_nInsThreadCount );
 600             CPPUNIT_CHECK( nInsertFailed == 0 );
 601
 602             analyze( testMap );
 603         }
 604
 605         template <class Map>
 606         void analyze( Map& testMap )
 607         {
 608             cds::OS::Timer    timer;
 609
 610             // All even keys must be in the map
 611             {
 612                 size_t nErrorCount = 0;
 613                 CPPUNIT_MSG( "  Check even keys..." );
 614                 for ( size_t n = 0; n < c_nMapSize; n +=2 ) {
 615                     for ( size_t i = 0; i < c_nInsThreadCount; ++i ) {
 616                         if ( !testMap.find( key_type(n, i) ) ) {
 617                             if ( ++nErrorCount < 10 ) {
 618                                 CPPUNIT_MSG( "key " << n << "-" << i << " is not found!");
 619                             }
 620                         }
 621                     }
 622                 }
 623                 CPPUNIT_CHECK_EX( nErrorCount == 0, "Totals: " << nErrorCount << " keys is not found");
 624             }
 625
 626             check_before_cleanup( testMap );
 627
 628             CPPUNIT_MSG( "  Clear map (single-threaded)..." );
 629             timer.reset();
 630             testMap.clear();
 631             CPPUNIT_MSG( "   Duration=" << timer.duration() );
 632             CPPUNIT_CHECK_EX( testMap.empty(), ((long long) testMap.size()) );
 633
 634             additional_check( testMap );
 635             print_stat( testMap );
 636
 637             additional_cleanup( testMap );
 638         }
 639
 640         template <class Map>
 641         void test()
 642         {
 643             CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount
 644                 << " delete thread count=" << c_nDelThreadCount
 645                 << " set size=" << c_nMapSize
 646                 );
 647
 648             for ( size_t nLoadFactor = 1; nLoadFactor <= c_nMaxLoadFactor; nLoadFactor *= 2 ) {
 649                 CPPUNIT_MSG( "Load factor=" << nLoadFactor );
 650                 do_test<Map>( nLoadFactor );
 651                 if ( c_bPrintGCState )
 652                     print_gc_state();
 653             }
 654         }
 655
 656         template <class Map>
 657         void test_extract()
 658         {
 659             CPPUNIT_MSG( "Thread count: insert=" << c_nInsThreadCount
 660                 << ", delete=" << c_nDelThreadCount
 661                 << ", extract=" << c_nExtractThreadCount
 662                 << "; set size=" << c_nMapSize
 663                 );
 664
 665             for ( size_t nLoadFactor = 1; nLoadFactor <= c_nMaxLoadFactor; nLoadFactor *= 2 ) {
 666                 CPPUNIT_MSG( "Load factor=" << nLoadFactor );
 667                 do_test_extract<Map>( nLoadFactor );
 668                 if ( c_bPrintGCState )
 669                     print_gc_state();
 670             }
 671         }
 672
 673         template <class Map>
 674         void test_nolf()
 675         {
 676             CPPUNIT_MSG( "Insert thread count=" << c_nInsThreadCount
 677                 << " delete thread count=" << c_nDelThreadCount
 678                 << " set size=" << c_nMapSize
 679                 );
 680
 681             Map s;
 682             do_test_with( s );
 683             if ( c_bPrintGCState )
 684                 print_gc_state();
 685         }
 686
 687         template <class Map>
 688         void test_nolf_extract()
 689         {
 690             CPPUNIT_MSG( "Thread count: insert=" << c_nInsThreadCount
 691                 << ", delete=" << c_nDelThreadCount
 692                 << ", extract=" << c_nExtractThreadCount
 693                 << "; set size=" << c_nMapSize
 694                 );
 695
 696             Map s;
 697             do_test_extract_with( s );
 698             if ( c_bPrintGCState )
 699                 print_gc_state();
 700         }
 701
 702         void setUpParams( const CppUnitMini::TestCfg& cfg );
 703
 704         void run_MichaelMap(const char *in_name, bool invert = false);
 705         void run_SplitList(const char *in_name, bool invert = false);
 706         //void run_StripedMap(const char *in_name, bool invert = false);
 707         //void run_RefinableMap(const char *in_name, bool invert = false);
 708         void run_CuckooMap(const char *in_name, bool invert = false);
 709         void run_SkipListMap(const char *in_name, bool invert = false);
 710         void run_EllenBinTreeMap(const char *in_name, bool invert = false);
 711         void run_BronsonAVLTreeMap(const char *in_name, bool invert = false);
 712         //void run_StdMap(const char *in_name, bool invert = false);
 713
 714         virtual void myRun(const char *in_name, bool invert = false);
 715
 716 #   include "map2/map_defs.h"
 717         CDSUNIT_DECLARE_MichaelMap
 718         CDSUNIT_DECLARE_SplitList
 719         //CDSUNIT_DECLARE_StripedMap
 720         //CDSUNIT_DECLARE_RefinableMap
 721         CDSUNIT_DECLARE_CuckooMap
 722         CDSUNIT_DECLARE_SkipListMap
 723         CDSUNIT_DECLARE_EllenBinTreeMap
 724         CDSUNIT_DECLARE_BronsonAVLTreeMap
 725         //CDSUNIT_DECLARE_StdMap
 726     };
 727 } // namespace map2