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 CppUnitMini::TestCase Base;
  32         typedef size_t  key_type;
  33         typedef size_t  value_type;
  34
  35         template <typename Iterator, typename Map>
  36         static bool check_result( Iterator const& it, Map const& map )
  37         {
  38             return it != map.end();
  39         }
  40         template <typename Map>
  41         static bool check_result( bool b, Map const& )
  42         {
  43             return b;
  44         }
  45
  46         template <class Map>
  47         class Inserter: public CppUnitMini::TestThread
  48         {
  49             Map&     m_Map;
  50             std::vector<size_t> m_arrVal;
  51
  52             virtual Inserter *    clone()
  53             {
  54                 return new Inserter( *this );
  55             }
  56
  57             void make_array()
  58             {
  59                 size_t const nThreadCount = getTest().c_nThreadCount;
  60                 size_t const nSize = getTest().c_nMapSize / nThreadCount + 1;
  61                 m_arrVal.resize( nSize );
  62                 size_t nItem = m_nThreadNo;
  63                 for ( size_t i = 0; i < nSize; nItem += nThreadCount, ++i )
  64                     m_arrVal[i] = nItem;
  65                 shuffle( m_arrVal.begin(), m_arrVal.end() );
  66             }
  67         public:
  68             size_t  m_nInsertSuccess;
  69             size_t  m_nInsertFailed;
  70             size_t  m_nFindSuccess;
  71             size_t  m_nFindFail;
  72
  73         public:
  74             Inserter( CppUnitMini::ThreadPool& pool, Map& rMap )
  75                 : CppUnitMini::TestThread( pool )
  76                 , m_Map( rMap )
  77             {}
  78             Inserter( Inserter& src )
  79                 : CppUnitMini::TestThread( src )
  80                 , m_Map( src.m_Map )
  81             {}
  82
  83             Map_InsFind_int&  getTest()
  84             {
  85                 return reinterpret_cast<Map_InsFind_int&>( m_Pool.m_Test );
  86             }
  87
  88             virtual void init()
  89             {
  90                 cds::threading::Manager::attachThread();
  91                 make_array();
  92             }
  93             virtual void fini() { cds::threading::Manager::detachThread()   ; }
  94
  95             virtual void test()
  96             {
  97                 Map& rMap = m_Map;
  98
  99                 m_nInsertSuccess =
 100                     m_nInsertFailed =
 101                     m_nFindSuccess =
 102                     m_nFindFail = 0;
 103
 104                 size_t const nArrSize = m_arrVal.size();
 105                 for ( size_t i = 0; i < nArrSize; ++i ) {
 106                     size_t const nItem = m_arrVal[i];
 107                     if ( check_result( rMap.insert( nItem, nItem * 8 ), rMap ))
 108                         ++m_nInsertSuccess;
 109                     else
 110                         ++m_nInsertFailed;
 111
 112                     for ( size_t k = 0; k <= i; ++k ) {
 113                         if ( check_result( rMap.contains( m_arrVal[k] ), rMap ))
 114                             ++m_nFindSuccess;
 115                         else
 116                             ++m_nFindFail;
 117                     }
 118                 }
 119             }
 120         };
 121
 122     protected:
 123
 124         template <class Map>
 125         void do_test( Map& testMap )
 126         {
 127             typedef Inserter<Map>       InserterThread;
 128             cds::OS::Timer    timer;
 129
 130             CppUnitMini::ThreadPool pool( *this );
 131             pool.add( new InserterThread( pool, testMap ), c_nThreadCount );
 132             pool.run();
 133             CPPUNIT_MSG( "   Duration=" << pool.avgDuration() );
 134
 135             size_t nInsertSuccess = 0;
 136             size_t nInsertFailed = 0;
 137             size_t nFindSuccess = 0;
 138             size_t nFindFailed = 0;
 139             for ( CppUnitMini::ThreadPool::iterator it = pool.begin(); it != pool.end(); ++it ) {
 140                 InserterThread * pThread = static_cast<InserterThread *>( *it );
 141
 142                 nInsertSuccess += pThread->m_nInsertSuccess;
 143                 nInsertFailed += pThread->m_nInsertFailed;
 144                 nFindSuccess += pThread->m_nFindSuccess;
 145                 nFindFailed += pThread->m_nFindFail;
 146             }
 147
 148             CPPUNIT_MSG( "    Totals: Ins succ=" << nInsertSuccess << " fail=" << nInsertFailed << "\n"
 149                       << "           Find succ=" << nFindSuccess << " fail=" << nFindFailed
 150             );
 151
 152             CPPUNIT_CHECK( nInsertFailed == 0 );
 153             CPPUNIT_CHECK( nFindFailed == 0 );
 154
 155             check_before_cleanup( testMap );
 156
 157             testMap.clear();
 158             additional_check( testMap );
 159             print_stat( testMap );
 160             additional_cleanup( testMap );
 161         }
 162
 163         template <class Map>
 164         void run_test()
 165         {
 166             static_assert( (!std::is_same< typename Map::item_counter, cds::atomicity::empty_item_counter >::value),
 167                 "Empty item counter is not suitable for this test");
 168
 169             CPPUNIT_MSG( "Thread count: " << c_nThreadCount
 170                 << " map size=" << c_nMapSize
 171                 );
 172
 173             if ( Map::c_bLoadFactorDepended ) {
 174                 for ( c_nLoadFactor = 1; c_nLoadFactor <= c_nMaxLoadFactor; c_nLoadFactor *= 2 ) {
 175                     CPPUNIT_MSG( "Load factor=" << c_nLoadFactor );
 176                     Map  testMap( *this );
 177                     do_test( testMap );
 178                     if ( c_bPrintGCState )
 179                         print_gc_state();
 180                 }
 181             }
 182             else {
 183                 Map testMap( *this );
 184                 do_test( testMap );
 185                 if ( c_bPrintGCState )
 186                     print_gc_state();
 187             }
 188         }
 189
 190         void setUpParams( const CppUnitMini::TestCfg& cfg );
 191
 192 #   include "map2/map_defs.h"
 193         CDSUNIT_DECLARE_MichaelMap
 194         CDSUNIT_DECLARE_MichaelMap_nogc
 195         CDSUNIT_DECLARE_SplitList
 196         CDSUNIT_DECLARE_SplitList_nogc
 197         CDSUNIT_DECLARE_SkipListMap
 198         CDSUNIT_DECLARE_SkipListMap_nogc
 199         CDSUNIT_DECLARE_EllenBinTreeMap
 200         CDSUNIT_DECLARE_BronsonAVLTreeMap
 201         CDSUNIT_DECLARE_MultiLevelHashMap
 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
 218             CDSUNIT_TEST_CuckooMap
 219             CDSUNIT_TEST_StripedMap
 220             CDSUNIT_TEST_RefinableMap
 221             CDSUNIT_TEST_StdMap
 222             CDSUNIT_TEST_StdMap_NoLock
 223         CPPUNIT_TEST_SUITE_END();
 224     };
 225 } // namespace map2