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