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