test/unit/map/test_split_lazy_rcu.h

   1 /*
   2     This file is a part of libcds - Concurrent Data Structures library
   3
   4     (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
   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 #ifndef CDSUNIT_MAP_TEST_SPLIT_LIST_LAZY_RCU_H
  31 #define CDSUNIT_MAP_TEST_SPLIT_LIST_LAZY_RCU_H
  32
  33 #include "test_map_rcu.h"
  34 #include <cds/container/lazy_list_rcu.h>
  35 #include <cds/container/split_list_map_rcu.h>
  36
  37 namespace cc = cds::container;
  38
  39 template <class RCU>
  40 class SplitListLazyMap: public cds_test::container_map_rcu
  41 {
  42     typedef cds_test::container_map_rcu base_class;
  43 public:
  44     typedef cds::urcu::gc<RCU> rcu_type;
  45
  46 protected:
  47     void SetUp()
  48     {
  49         RCU::Construct();
  50         cds::threading::Manager::attachThread();
  51     }
  52
  53     void TearDown()
  54     {
  55         cds::threading::Manager::detachThread();
  56         RCU::Destruct();
  57     }
  58 };
  59
  60 TYPED_TEST_CASE_P( SplitListLazyMap );
  61
  62 //TYPED_TEST_P( SplitListLazyMap, compare )
  63 TYPED_TEST_P( SplitListLazyMap, compare )
  64 {
  65     typedef typename TestFixture::rcu_type   rcu_type;
  66     typedef typename TestFixture::key_type   key_type;
  67     typedef typename TestFixture::value_type value_type;
  68     typedef typename TestFixture::hash1      hash1;
  69
  70     typedef cc::SplitListMap< rcu_type, key_type, value_type,
  71         typename cc::split_list::make_traits<
  72             cc::split_list::ordered_list< cc::lazy_list_tag >
  73             , cds::opt::hash< hash1 >
  74             , cc::split_list::ordered_list_traits<
  75                 typename cc::lazy_list::make_traits<
  76                     cds::opt::compare< typename TestFixture::cmp >
  77                 >::type
  78             >
  79         >::type
  80     > map_type;
  81
  82     map_type m( TestFixture::kSize, 2 );
  83     this->test( m );
  84 }
  85
  86 TYPED_TEST_P( SplitListLazyMap, less )
  87 {
  88     typedef typename TestFixture::rcu_type   rcu_type;
  89     typedef typename TestFixture::key_type   key_type;
  90     typedef typename TestFixture::value_type value_type;
  91     typedef typename TestFixture::hash1      hash1;
  92
  93     typedef cc::SplitListMap< rcu_type, key_type, value_type,
  94         typename cc::split_list::make_traits<
  95             cc::split_list::ordered_list< cc::lazy_list_tag >
  96             , cds::opt::hash< hash1 >
  97             , cc::split_list::ordered_list_traits<
  98                 typename cc::lazy_list::make_traits<
  99                     cds::opt::less< typename TestFixture::less >
 100                 >::type
 101             >
 102         >::type
 103     > map_type;
 104
 105     map_type m( TestFixture::kSize, 4 );
 106     this->test( m );
 107 }
 108
 109 TYPED_TEST_P( SplitListLazyMap, cmpmix )
 110 {
 111     typedef typename TestFixture::rcu_type   rcu_type;
 112     typedef typename TestFixture::key_type   key_type;
 113     typedef typename TestFixture::value_type value_type;
 114     typedef typename TestFixture::hash1      hash1;
 115
 116     typedef cc::SplitListMap< rcu_type, key_type, value_type,
 117         typename cc::split_list::make_traits<
 118             cc::split_list::ordered_list< cc::lazy_list_tag >
 119             , cds::opt::hash< hash1 >
 120             , cc::split_list::ordered_list_traits<
 121                 typename cc::lazy_list::make_traits<
 122                     cds::opt::less< typename TestFixture::less >
 123                     , cds::opt::compare< typename TestFixture::cmp >
 124                 >::type
 125             >
 126         >::type
 127     > map_type;
 128
 129     map_type m( TestFixture::kSize, 2 );
 130     this->test( m );
 131 }
 132
 133 TYPED_TEST_P( SplitListLazyMap, item_counting )
 134 {
 135     typedef typename TestFixture::rcu_type   rcu_type;
 136     typedef typename TestFixture::key_type   key_type;
 137     typedef typename TestFixture::value_type value_type;
 138     typedef typename TestFixture::hash1      hash1;
 139
 140     struct map_traits: public cc::split_list::traits
 141     {
 142         typedef cc::lazy_list_tag ordered_list;
 143         typedef hash1 hash;
 144         typedef cds::atomicity::item_counter item_counter;
 145
 146         struct ordered_list_traits: public cc::lazy_list::traits
 147         {
 148             typedef typename TestFixture::cmp compare;
 149             typedef typename TestFixture::less less;
 150             typedef cds::backoff::empty back_off;
 151         };
 152     };
 153     typedef cc::SplitListMap< rcu_type, key_type, value_type, map_traits > map_type;
 154
 155     map_type m( TestFixture::kSize, 1 );
 156     this->test( m );
 157 }
 158
 159 TYPED_TEST_P( SplitListLazyMap, stat )
 160 {
 161     typedef typename TestFixture::rcu_type   rcu_type;
 162     typedef typename TestFixture::key_type   key_type;
 163     typedef typename TestFixture::value_type value_type;
 164     typedef typename TestFixture::hash1      hash1;
 165
 166     struct map_traits: public cc::split_list::traits
 167     {
 168         typedef cc::lazy_list_tag ordered_list;
 169         typedef hash1 hash;
 170         typedef cds::atomicity::item_counter item_counter;
 171         typedef cc::split_list::stat<> stat;
 172
 173         struct ordered_list_traits: public cc::lazy_list::traits
 174         {
 175             typedef typename TestFixture::less less;
 176             typedef cds::opt::v::sequential_consistent memory_model;
 177         };
 178     };
 179     typedef cc::SplitListMap< rcu_type, key_type, value_type, map_traits > map_type;
 180
 181     map_type m( TestFixture::kSize, 3 );
 182     this->test( m );
 183 }
 184
 185 TYPED_TEST_P( SplitListLazyMap, back_off )
 186 {
 187     typedef typename TestFixture::rcu_type   rcu_type;
 188     typedef typename TestFixture::key_type   key_type;
 189     typedef typename TestFixture::value_type value_type;
 190     typedef typename TestFixture::hash1      hash1;
 191
 192     struct map_traits: public cc::split_list::traits
 193     {
 194         typedef cc::lazy_list_tag ordered_list;
 195         typedef hash1 hash;
 196         typedef cds::atomicity::item_counter item_counter;
 197         typedef cds::backoff::yield back_off;
 198         typedef cds::opt::v::sequential_consistent memory_model;
 199
 200         struct ordered_list_traits: public cc::lazy_list::traits
 201         {
 202             typedef typename TestFixture::cmp compare;
 203             typedef cds::backoff::pause back_off;
 204         };
 205     };
 206     typedef cc::SplitListMap< rcu_type, key_type, value_type, map_traits > map_type;
 207
 208     map_type m( TestFixture::kSize, 2 );
 209     this->test( m );
 210 }
 211
 212 TYPED_TEST_P( SplitListLazyMap, mutex )
 213 {
 214     typedef typename TestFixture::rcu_type   rcu_type;
 215     typedef typename TestFixture::key_type   key_type;
 216     typedef typename TestFixture::value_type value_type;
 217     typedef typename TestFixture::hash1      hash1;
 218
 219     struct map_traits: public cc::split_list::traits
 220     {
 221         typedef cc::lazy_list_tag ordered_list;
 222         typedef hash1 hash;
 223         typedef cds::atomicity::item_counter item_counter;
 224         typedef cds::backoff::yield back_off;
 225         typedef cds::opt::v::sequential_consistent memory_model;
 226
 227         struct ordered_list_traits: public cc::lazy_list::traits
 228         {
 229             typedef typename TestFixture::cmp compare;
 230             typedef cds::backoff::pause back_off;
 231             typedef std::mutex lock_type;
 232         };
 233     };
 234     typedef cc::SplitListMap< rcu_type, key_type, value_type, map_traits > map_type;
 235
 236     map_type m( TestFixture::kSize, 2 );
 237     this->test( m );
 238 }
 239
 240 namespace {
 241     struct set_static_traits: public cc::split_list::traits
 242     {
 243         static bool const dynamic_bucket_table = false;
 244     };
 245 }
 246
 247 TYPED_TEST_P( SplitListLazyMap, static_bucket_table )
 248 {
 249     typedef typename TestFixture::rcu_type   rcu_type;
 250     typedef typename TestFixture::key_type   key_type;
 251     typedef typename TestFixture::value_type value_type;
 252     typedef typename TestFixture::hash1      hash1;
 253
 254     struct map_traits: public set_static_traits
 255     {
 256         typedef cc::lazy_list_tag ordered_list;
 257         typedef hash1 hash;
 258         typedef cds::atomicity::item_counter item_counter;
 259
 260         struct ordered_list_traits: public cc::lazy_list::traits
 261         {
 262             typedef typename TestFixture::cmp compare;
 263             typedef cds::backoff::pause back_off;
 264         };
 265     };
 266     typedef cc::SplitListMap< rcu_type, key_type, value_type, map_traits > map_type;
 267
 268     map_type m( TestFixture::kSize, 4 );
 269     this->test( m );
 270 }
 271
 272 REGISTER_TYPED_TEST_CASE_P( SplitListLazyMap,
 273     compare, less, cmpmix, item_counting, stat, back_off, mutex, static_bucket_table
 274 );
 275
 276
 277 #endif // CDSUNIT_MAP_TEST_SPLIT_LIST_LAZY_RCU_H
 278