tests/unit/map2/map_insfind_int.h

   1 //$$CDS-header$$
   2
   3 #include "map2/map_type.h"
   4 #include "cppunit/thread.h"
   5
   6 #include <cds/os/topology.h>
   7 #include <vector>
   8
   9 namespace map2 {
  10
  11 #define TEST_CASE(TAG, X)  void X();
  12
  13     class Map_InsFind_int: public CppUnitMini::TestCase
  14     {
  15     public:
  16         size_t c_nThreadCount = 8;     // thread count
  17         size_t c_nMapSize = 5000;      // map size (count of searching item)
  18         size_t c_nMaxLoadFactor = 8;   // maximum load factor
  19         bool   c_bPrintGCState = true;
  20
  21         size_t c_nCuckooInitialSize = 1024;// initial size for CuckooMap
  22         size_t c_nCuckooProbesetSize = 16; // CuckooMap probeset size (only for list-based probeset)
  23         size_t c_nCuckooProbesetThreshold = 0; // CUckooMap probeset threshold (o - use default)
  24
  25         size_t c_nMultiLevelMap_HeadBits = 10;
  26         size_t c_nMultiLevelMap_ArrayBits = 4;
  27
  28         size_t  c_nLoadFactor = 2;  // current load factor
  29
  30     private:
  31         typedef size_t  key_type;
  32         typedef size_t  value_type;
  33
  34         template <typename Iterator, typename Map>
  35         static bool check_result( Iterator const& it, Map const& map )
  36         {
  37             return it != map.end();
  38         }
  39         template <typename Map>
  40         static bool check_result( bool b, Map const& )
  41         {
  42             return b;
  43         }
  44
  45         template <class Map>
  46         class Inserter: public CppUnitMini::TestThread
  47         {
  48             Map&     m_Map;
  49             std::vector<size_t> m_arrVal;
  50
  51             virtual Inserter *    clone()
  52             {
  53                 return new Inserter( *this );
  54             }
  55
  56             void make_array()
  57             {
  58                 size_t const nThreadCount = getTest().c_nThreadCount;
  59                 size_t const nSize = getTest().c_nMapSize / nThreadCount + 1;
  60                 m_arrVal.resize( nSize );
  61                 size_t nItem = m_nThreadNo;
  62                 for ( size_t i = 0; i < nSize; nItem += nThreadCount, ++i )
  63                     m_arrVal[i] = nItem;
  64                 shuffle( m_arrVal.begin(), m_arrVal.end() );
  65             }
  66         public:
  67             size_t  m_nInsertSuccess;
  68             size_t  m_nInsertFailed;
  69             size_t  m_nFindSuccess;
  70             size_t  m_nFindFail;
  71
  72         public:
  73             Inserter( CppUnitMini::ThreadPool& pool, Map& rMap )
  74                 : CppUnitMini::TestThread( pool )
  75                 , m_Map( rMap )
  76             {}
  77             Inserter( Inserter& src )
  78                 : CppUnitMini::TestThread( src )
  79                 , m_Map( src.m_Map )
  80             {}
  81
  82             Map_InsFind_int&  getTest()
  83             {
  84                 return reinterpret_cast<Map_InsFind_int&>( m_Pool.m_Test );
  85             }
  86
  87             virtual void init()
  88             {
  89                 cds::threading::Manager::attachThread();
  90                 make_array();
  91             }
  92             virtual void fini() { cds::threading::Manager::detachThread()   ; }
  93
  94             virtual void test()
  95             {
  96                 Map& rMap = m_Map;
  97
  98                 m_nInsertSuccess =
  99                     m_nInsertFailed =
 100                     m_nFindSuccess =
 101                     m_nFindFail = 0;
 102
 103                 size_t const nArrSize = m_arrVal.size();
 104                 for ( size_t i = 0; i < nArrSize; ++i ) {
 105                     size_t const nItem = m_arrVal[i];
 106                     if ( check_result( rMap.insert( nItem, nItem * 8 ), rMap ))
 107                         ++m_nInsertSuccess;
 108                     else
 109                         ++m_nInsertFailed;
 110
 111                     for ( size_t k = 0; k <= i; ++k ) {
 112                         if ( check_result( rMap.contains( m_arrVal[k] ), rMap ))
 113                             ++m_nFindSuccess;
 114                         else
 115                             ++m_nFindFail;
 116                     }
 117                 }
 118             }
 119         };
 120
 121     protected:
 122
 123         template <class Map>
 124         void do_test( Map& testMap )
 125         {
 126             typedef Inserter<Map>       InserterThread;
 127             cds::OS::Timer    timer;
 128
 129             CppUnitMini::ThreadPool pool( *this );
 130             pool.add( new InserterThread( pool, testMap ), c_nThreadCount );
 131             pool.run();
 132             CPPUNIT_MSG( "   Duration=" << pool.avgDuration() );
 133
 134             size_t nInsertSuccess = 0;
 135             size_t nInsertFailed = 0;
 136             size_t nFindSuccess = 0;
 137             size_t nFindFailed = 0;
 138             for ( CppUnitMini::ThreadPool::iterator it = pool.begin(); it != pool.end(); ++it ) {
 139                 InserterThread * pThread = static_cast<InserterThread *>( *it );
 140
 141                 nInsertSuccess += pThread->m_nInsertSuccess;
 142                 nInsertFailed += pThread->m_nInsertFailed;
 143                 nFindSuccess += pThread->m_nFindSuccess;
 144                 nFindFailed += pThread->m_nFindFail;
 145             }
 146
 147             CPPUNIT_MSG( "    Totals: Ins succ=" << nInsertSuccess << " fail=" << nInsertFailed << "\n"
 148                       << "           Find succ=" << nFindSuccess << " fail=" << nFindFailed
 149             );
 150
 151             CPPUNIT_CHECK( nInsertFailed == 0 );
 152             CPPUNIT_CHECK( nFindFailed == 0 );
 153
 154             check_before_cleanup( testMap );
 155
 156             testMap.clear();
 157             additional_check( testMap );
 158             print_stat( testMap );
 159             additional_cleanup( testMap );
 160         }
 161
 162         template <class Map>
 163         void run_test()
 164         {
 165             static_assert( (!std::is_same< typename Map::item_counter, cds::atomicity::empty_item_counter >::value),
 166                 "Empty item counter is not suitable for this test");
 167
 168             CPPUNIT_MSG( "Thread count: " << c_nThreadCount
 169                 << " map size=" << c_nMapSize
 170                 );
 171
 172             if ( Map::c_bLoadFactorDepended ) {
 173                 for ( c_nLoadFactor = 1; c_nLoadFactor <= c_nMaxLoadFactor; c_nLoadFactor *= 2 ) {
 174                     CPPUNIT_MSG( "Load factor=" << c_nLoadFactor );
 175                     Map  testMap( *this );
 176                     do_test( testMap );
 177                     if ( c_bPrintGCState )
 178                         print_gc_state();
 179                 }
 180             }
 181             else {
 182                 Map testMap( *this );
 183                 do_test( testMap );
 184                 if ( c_bPrintGCState )
 185                     print_gc_state();
 186             }
 187         }
 188
 189         void setUpParams( const CppUnitMini::TestCfg& cfg );
 190
 191 #   include "map2/map_defs.h"
 192         CDSUNIT_DECLARE_MichaelMap
 193         CDSUNIT_DECLARE_MichaelMap_nogc
 194         CDSUNIT_DECLARE_SplitList
 195         CDSUNIT_DECLARE_SplitList_nogc
 196         CDSUNIT_DECLARE_SkipListMap
 197         CDSUNIT_DECLARE_SkipListMap_nogc
 198         CDSUNIT_DECLARE_EllenBinTreeMap
 199         CDSUNIT_DECLARE_BronsonAVLTreeMap
 200         CDSUNIT_DECLARE_MultiLevelHashMap_fixed
 201         CDSUNIT_DECLARE_MultiLevelHashMap_city
 202         CDSUNIT_DECLARE_StripedMap
 203         CDSUNIT_DECLARE_RefinableMap
 204         CDSUNIT_DECLARE_CuckooMap
 205         CDSUNIT_DECLARE_StdMap
 206         CDSUNIT_DECLARE_StdMap_NoLock
 207
 208         CPPUNIT_TEST_SUITE(Map_InsFind_int)
 209             CDSUNIT_TEST_MichaelMap
 210             CDSUNIT_TEST_MichaelMap_nogc
 211             CDSUNIT_TEST_SplitList
 212             CDSUNIT_TEST_SplitList_nogc
 213             CDSUNIT_TEST_SkipListMap
 214             CDSUNIT_TEST_SkipListMap_nogc
 215             CDSUNIT_TEST_EllenBinTreeMap
 216             CDSUNIT_TEST_BronsonAVLTreeMap
 217             CDSUNIT_TEST_MultiLevelHashMap_fixed
 218             CDSUNIT_TEST_MultiLevelHashMap_city
 219             CDSUNIT_TEST_CuckooMap
 220             CDSUNIT_TEST_StripedMap
 221             CDSUNIT_TEST_RefinableMap
 222             CDSUNIT_TEST_StdMap
 223             CDSUNIT_TEST_StdMap_NoLock
 224         CPPUNIT_TEST_SUITE_END();
 225     };
 226 } // namespace map2