tests/unit/map2/map_delodd.h

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