test/stress/map/insdel_string/map_insdel_string.cpp

   1 /*
   2     This file is a part of libcds - Concurrent Data Structures library
   3
   4     (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017
   5
   6     Source code repo: http://github.com/khizmax/libcds/
   7     Download: http://sourceforge.net/projects/libcds/files/
   8
   9     Redistribution and use in source and binary forms, with or without
  10     modification, are permitted provided that the following conditions are met:
  11
  12     * Redistributions of source code must retain the above copyright notice, this
  13       list of conditions and the following disclaimer.
  14
  15     * Redistributions in binary form must reproduce the above copyright notice,
  16       this list of conditions and the following disclaimer in the documentation
  17       and/or other materials provided with the distribution.
  18
  19     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  23     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  26     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 #include "map_insdel_string.h"
  32 #include <cds_test/hash_func.h>
  33
  34 namespace map {
  35
  36     size_t Map_InsDel_string::s_nMapSize = 1000000;      // map size
  37     size_t Map_InsDel_string::s_nInsertThreadCount = 4;  // count of insertion thread
  38     size_t Map_InsDel_string::s_nDeleteThreadCount = 4;  // count of deletion thread
  39     size_t Map_InsDel_string::s_nThreadPassCount = 4;    // pass count for each thread
  40     size_t Map_InsDel_string::s_nMaxLoadFactor = 8;      // maximum load factor
  41
  42     size_t Map_InsDel_string::s_nCuckooInitialSize = 1024;// initial size for CuckooSet
  43     size_t Map_InsDel_string::s_nCuckooProbesetSize = 16; // CuckooSet probeset size (only for list-based probeset)
  44     size_t Map_InsDel_string::s_nCuckooProbesetThreshold = 0; // CuckooSet probeset threshold (0 - use default)
  45
  46     size_t Map_InsDel_string::s_nFeldmanMap_HeadBits = 10;
  47     size_t Map_InsDel_string::s_nFeldmanMap_ArrayBits = 4;
  48
  49     size_t Map_InsDel_string::s_nLoadFactor = 1;
  50     std::vector<std::string> Map_InsDel_string::s_arrKeys;
  51
  52     void Map_InsDel_string::setup_test_case()
  53     {
  54         cds_test::config const& cfg = get_config( "map_insdel_string" );
  55
  56         s_nMapSize = cfg.get_size_t( "MapSize", s_nMapSize );
  57         if ( s_nMapSize < 1000 )
  58             s_nMapSize = 1000;
  59
  60         s_nInsertThreadCount = cfg.get_size_t( "InsertThreadCount", s_nInsertThreadCount );
  61         if ( s_nInsertThreadCount == 0 )
  62             s_nInsertThreadCount = 2;
  63
  64         s_nDeleteThreadCount = cfg.get_size_t( "DeleteThreadCount", s_nDeleteThreadCount );
  65         if ( s_nDeleteThreadCount == 0 )
  66             s_nDeleteThreadCount = 2;
  67
  68         s_nThreadPassCount = cfg.get_size_t( "ThreadPassCount", s_nThreadPassCount );
  69         if ( s_nThreadPassCount == 0 )
  70             s_nThreadPassCount = 4;
  71
  72         s_nMaxLoadFactor = cfg.get_size_t( "MaxLoadFactor", s_nMaxLoadFactor );
  73         if ( s_nMaxLoadFactor == 0 )
  74             s_nMaxLoadFactor = 1;
  75
  76         s_nCuckooInitialSize = cfg.get_size_t( "CuckooInitialSize", s_nCuckooInitialSize );
  77         if ( s_nCuckooInitialSize < 256 )
  78             s_nCuckooInitialSize = 256;
  79
  80         s_nCuckooProbesetSize = cfg.get_size_t( "CuckooProbesetSize", s_nCuckooProbesetSize );
  81         if ( s_nCuckooProbesetSize < 8 )
  82             s_nCuckooProbesetSize = 8;
  83
  84         s_nCuckooProbesetThreshold = cfg.get_size_t( "CuckooProbesetThreshold", s_nCuckooProbesetThreshold );
  85
  86         s_nFeldmanMap_HeadBits = cfg.get_size_t( "FeldmanMapHeadBits", s_nFeldmanMap_HeadBits );
  87         if ( s_nFeldmanMap_HeadBits == 0 )
  88             s_nFeldmanMap_HeadBits = 2;
  89
  90         s_nFeldmanMap_ArrayBits = cfg.get_size_t( "FeldmanMapArrayBits", s_nFeldmanMap_ArrayBits );
  91         if ( s_nFeldmanMap_ArrayBits == 0 )
  92             s_nFeldmanMap_ArrayBits = 2;
  93     }
  94
  95     void Map_InsDel_string::SetUpTestCase()
  96     {
  97         setup_test_case();
  98
  99         s_arrKeys.clear();
 100         s_arrKeys.reserve( s_nMapSize );
 101         std::vector<std::string> dict = load_dictionary();
 102         for ( size_t i = 0; i < s_nMapSize; ++i )
 103             s_arrKeys.push_back( std::move( dict.at(i)));
 104     }
 105
 106     void Map_InsDel_string::TearDownTestCase()
 107     {
 108         s_arrKeys.clear();
 109     }
 110
 111     std::vector<size_t> Map_InsDel_string::get_load_factors()
 112     {
 113         cds_test::config const& cfg = get_config( "map_insdel_string" );
 114
 115         s_nMaxLoadFactor = cfg.get_size_t( "MaxLoadFactor", s_nMaxLoadFactor );
 116         if ( s_nMaxLoadFactor == 0 )
 117             s_nMaxLoadFactor = 1;
 118
 119         std::vector<size_t> lf;
 120         for ( size_t n = 1; n <= s_nMaxLoadFactor; n *= 2 )
 121             lf.push_back( n );
 122
 123         return lf;
 124     }
 125
 126     template <typename Hash>
 127     void Map_InsDel_string::fill_string_array()
 128     {
 129         typedef Hash hasher;
 130         typedef typename hasher::result_type hash_type;
 131
 132         std::map<hash_type, size_t> mapHash;
 133         s_arrKeys.clear();
 134         std::vector<std::string> dict = load_dictionary();
 135
 136         size_t nSize = dict.size();
 137         if ( nSize > s_nMapSize )
 138             nSize = s_nMapSize;
 139         s_arrKeys.reserve( nSize );
 140
 141         size_t nDiffHash = 0;
 142         hasher h;
 143         for ( size_t i = 0; i < dict.size(); ++i ) {
 144             hash_type hash = h( dict.at( i ));
 145             if ( mapHash.insert( std::make_pair( hash, i )).second ) {
 146                 if ( ++nDiffHash >= nSize )
 147                     break;
 148                 s_arrKeys.push_back( std::move( dict.at( i )));
 149             }
 150         }
 151         s_nMapSize = dict.size();
 152     }
 153
 154     void Map_InsDel_string_stdhash::SetUpTestCase()
 155     {
 156         setup_test_case();
 157         fill_string_array<std::hash<std::string>>();
 158     }
 159
 160 #if CDS_BUILD_BITS == 64
 161     void Map_InsDel_string_city32::SetUpTestCase()
 162     {
 163         setup_test_case();
 164         fill_string_array<cds_test::city32>();
 165     }
 166
 167     void Map_InsDel_string_city64::SetUpTestCase()
 168     {
 169         setup_test_case();
 170         fill_string_array<cds_test::city64>();
 171     }
 172
 173     void Map_InsDel_string_city128::SetUpTestCase()
 174     {
 175         setup_test_case();
 176         fill_string_array<cds_test::city128>();
 177     }
 178
 179 #endif
 180
 181 #ifdef CDSTEST_GTEST_INSTANTIATE_TEST_CASE_P_HAS_4TH_ARG
 182     static std::string get_test_parameter_name( testing::TestParamInfo<size_t> const& p )
 183     {
 184         return std::to_string( p.param );
 185     }
 186     INSTANTIATE_TEST_CASE_P( a, Map_InsDel_string_LF, ::testing::ValuesIn( Map_InsDel_string::get_load_factors() ), get_test_parameter_name );
 187 #else
 188     INSTANTIATE_TEST_CASE_P( a, Map_InsDel_string_LF, ::testing::ValuesIn( Map_InsDel_string::get_load_factors() ) );
 189 #endif
 190
 191 } // namespace map