test/unit/intrusive-set/intrusive_michael_lazy_dhp.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 "test_intrusive_set_hp.h"
  32
  33 #include <cds/intrusive/lazy_list_dhp.h>
  34 #include <cds/intrusive/michael_set.h>
  35
  36 #include <mutex>
  37
  38 namespace {
  39     namespace ci = cds::intrusive;
  40     typedef cds::gc::DHP gc_type;
  41
  42     class IntrusiveMichaelLazySet_DHP : public cds_test::intrusive_set_hp
  43     {
  44     protected:
  45         typedef cds_test::intrusive_set_hp base_class;
  46
  47     protected:
  48         typedef typename base_class::base_int_item< ci::lazy_list::node<gc_type>>   base_item_type;
  49         typedef typename base_class::base_int_item< ci::lazy_list::node<gc_type, std::mutex>>   base_mutex_item_type;
  50         typedef typename base_class::member_int_item< ci::lazy_list::node<gc_type>> member_item_type;
  51         typedef typename base_class::member_int_item< ci::lazy_list::node<gc_type, std::mutex>> member_mutex_item_type;
  52
  53         void SetUp()
  54         {
  55             struct list_traits : public ci::lazy_list::traits
  56             {
  57                 typedef ci::lazy_list::base_hook< ci::opt::gc<gc_type>> hook;
  58             };
  59             typedef ci::LazyList< gc_type, base_item_type, list_traits > list_type;
  60             typedef ci::MichaelHashSet< gc_type, list_type >   set_type;
  61
  62             cds::gc::dhp::smr::construct( set_type::c_nHazardPtrCount );
  63             cds::threading::Manager::attachThread();
  64         }
  65
  66         void TearDown()
  67         {
  68             cds::threading::Manager::detachThread();
  69             cds::gc::dhp::smr::destruct();
  70         }
  71     };
  72
  73
  74     TEST_F( IntrusiveMichaelLazySet_DHP, base_cmp )
  75     {
  76         typedef ci::LazyList< gc_type
  77             , base_item_type
  78             ,ci::lazy_list::make_traits<
  79                 ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type > > >
  80                 ,ci::opt::compare< cmp<base_item_type> >
  81                 ,ci::opt::disposer< mock_disposer >
  82                 ,ci::opt::back_off< cds::backoff::pause >
  83             >::type
  84         > bucket_type;
  85
  86         typedef ci::MichaelHashSet< gc_type, bucket_type,
  87             ci::michael_set::make_traits<
  88                 ci::opt::hash< hash_int >
  89             >::type
  90         > set_type;
  91
  92         set_type s( kSize, 2 );
  93         test( s );
  94     }
  95
  96     TEST_F( IntrusiveMichaelLazySet_DHP, base_less )
  97     {
  98         typedef ci::LazyList< gc_type
  99             , base_item_type
 100             ,ci::lazy_list::make_traits<
 101                 ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< gc_type >>>
 102                 ,ci::opt::less< less<base_item_type> >
 103                 ,ci::opt::disposer< mock_disposer >
 104             >::type
 105         > bucket_type;
 106
 107         typedef ci::MichaelHashSet< gc_type, bucket_type,
 108             ci::michael_set::make_traits<
 109                 ci::opt::hash< hash_int >
 110             >::type
 111         > set_type;
 112
 113         set_type s( kSize, 2 );
 114         test( s );
 115     }
 116
 117     TEST_F( IntrusiveMichaelLazySet_DHP, base_cmpmix )
 118     {
 119         struct list_traits : public ci::lazy_list::traits
 120         {
 121             typedef ci::lazy_list::base_hook< ci::opt::gc<gc_type>> hook;
 122             typedef base_class::less<base_item_type> less;
 123             typedef cmp<base_item_type> compare;
 124             typedef mock_disposer disposer;
 125         };
 126         typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type;
 127
 128         struct set_traits : public ci::michael_set::traits
 129         {
 130             typedef hash_int hash;
 131             typedef simple_item_counter item_counter;
 132         };
 133         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 134
 135         set_type s( kSize, 2 );
 136         test( s );
 137     }
 138
 139     TEST_F( IntrusiveMichaelLazySet_DHP, base_mutex )
 140     {
 141         struct list_traits : public ci::lazy_list::traits
 142         {
 143             typedef ci::lazy_list::base_hook< ci::opt::gc<gc_type>, ci::opt::lock_type<std::mutex>> hook;
 144             typedef base_class::less<base_mutex_item_type> less;
 145             typedef cmp<base_mutex_item_type> compare;
 146             typedef mock_disposer disposer;
 147         };
 148         typedef ci::LazyList< gc_type, base_mutex_item_type, list_traits > bucket_type;
 149
 150         struct set_traits : public ci::michael_set::traits
 151         {
 152             typedef hash_int hash;
 153             typedef simple_item_counter item_counter;
 154         };
 155         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 156
 157         set_type s( kSize, 2 );
 158         test( s );
 159     }
 160
 161     TEST_F( IntrusiveMichaelLazySet_DHP, base_stat )
 162     {
 163         struct list_traits: public ci::lazy_list::traits
 164         {
 165             typedef ci::lazy_list::base_hook< ci::opt::gc<gc_type>> hook;
 166             typedef base_class::less<base_item_type> less;
 167             typedef mock_disposer disposer;
 168             typedef ci::lazy_list::stat<> stat;
 169         };
 170         typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type;
 171
 172         struct set_traits: public ci::michael_set::traits
 173         {
 174             typedef hash_int hash;
 175             typedef simple_item_counter item_counter;
 176         };
 177         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 178
 179         set_type s( kSize, 2 );
 180         test( s );
 181         EXPECT_GE( s.statistics().m_nInsertSuccess, 0u );
 182     }
 183
 184     TEST_F( IntrusiveMichaelLazySet_DHP, base_wrapped_stat )
 185     {
 186         struct list_traits: public ci::lazy_list::traits
 187         {
 188             typedef ci::lazy_list::base_hook< ci::opt::gc<gc_type>> hook;
 189             typedef base_class::less<base_item_type> less;
 190             typedef mock_disposer disposer;
 191             typedef ci::lazy_list::wrapped_stat<> stat;
 192         };
 193         typedef ci::LazyList< gc_type, base_item_type, list_traits > bucket_type;
 194
 195         struct set_traits: public ci::michael_set::traits
 196         {
 197             typedef hash_int hash;
 198             typedef simple_item_counter item_counter;
 199         };
 200         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 201
 202         set_type s( kSize, 2 );
 203         test( s );
 204         EXPECT_GE( s.statistics().m_nInsertSuccess, 0u );
 205     }
 206
 207     TEST_F( IntrusiveMichaelLazySet_DHP, member_cmp )
 208     {
 209         typedef ci::LazyList< gc_type
 210             ,member_item_type
 211             ,ci::lazy_list::make_traits<
 212                 ci::opt::hook< ci::lazy_list::member_hook<
 213                     offsetof( member_item_type, hMember ),
 214                     ci::opt::gc<gc_type>
 215                 > >
 216                 ,ci::opt::compare< cmp<member_item_type> >
 217                 ,ci::opt::disposer< mock_disposer >
 218             >::type
 219         >    bucket_type;
 220
 221         typedef ci::MichaelHashSet< gc_type, bucket_type,
 222             ci::michael_set::make_traits<
 223                 ci::opt::hash< hash_int >
 224             >::type
 225         > set_type;
 226
 227         set_type s( kSize, 2 );
 228         test( s );
 229     }
 230
 231     TEST_F( IntrusiveMichaelLazySet_DHP, member_less )
 232     {
 233         typedef ci::LazyList< gc_type
 234             , member_item_type
 235             ,ci::lazy_list::make_traits<
 236                 ci::opt::hook< ci::lazy_list::member_hook<
 237                     offsetof( member_item_type, hMember ),
 238                     ci::opt::gc<gc_type>
 239                 > >
 240                 ,ci::opt::less< less<member_item_type> >
 241                 ,ci::opt::disposer< mock_disposer >
 242             >::type
 243         > bucket_type;
 244
 245         typedef ci::MichaelHashSet< gc_type, bucket_type,
 246             ci::michael_set::make_traits<
 247                 ci::opt::hash< hash_int >
 248             >::type
 249         > set_type;
 250
 251         set_type s( kSize, 2 );
 252         test( s );
 253     }
 254
 255     TEST_F( IntrusiveMichaelLazySet_DHP, member_cmpmix )
 256     {
 257         struct list_traits : public ci::lazy_list::traits
 258         {
 259             typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc<gc_type>> hook;
 260             typedef base_class::less<member_item_type> less;
 261             typedef cmp<member_item_type> compare;
 262             typedef mock_disposer disposer;
 263         };
 264         typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type;
 265
 266         struct set_traits : public ci::michael_set::traits
 267         {
 268             typedef hash_int hash;
 269             typedef simple_item_counter item_counter;
 270         };
 271         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 272
 273         set_type s( kSize, 2 );
 274         test( s );
 275     }
 276
 277     TEST_F( IntrusiveMichaelLazySet_DHP, member_mutex )
 278     {
 279         struct list_traits : public ci::lazy_list::traits
 280         {
 281             typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc<gc_type>, ci::opt::lock_type<std::mutex>> hook;
 282             typedef base_class::less<member_mutex_item_type> less;
 283             typedef cmp<member_mutex_item_type> compare;
 284             typedef mock_disposer disposer;
 285         };
 286         typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type;
 287
 288         struct set_traits : public ci::michael_set::traits
 289         {
 290             typedef hash_int hash;
 291             typedef simple_item_counter item_counter;
 292         };
 293         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 294
 295         set_type s( kSize, 2 );
 296         test( s );
 297     }
 298
 299     TEST_F( IntrusiveMichaelLazySet_DHP, member_stat )
 300     {
 301         struct list_traits: public ci::lazy_list::traits
 302         {
 303             typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc<gc_type>> hook;
 304             typedef cmp<member_item_type> compare;
 305             typedef mock_disposer disposer;
 306             typedef ci::lazy_list::stat<> stat;
 307         };
 308         typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type;
 309
 310         struct set_traits: public ci::michael_set::traits
 311         {
 312             typedef hash_int hash;
 313             typedef simple_item_counter item_counter;
 314         };
 315         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 316
 317         set_type s( kSize, 2 );
 318         test( s );
 319         EXPECT_GE( s.statistics().m_nInsertSuccess, 0u );
 320     }
 321
 322     TEST_F( IntrusiveMichaelLazySet_DHP, member_wrapped_stat )
 323     {
 324         struct list_traits: public ci::lazy_list::traits
 325         {
 326             typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc<gc_type>> hook;
 327             typedef cmp<member_item_type> compare;
 328             typedef mock_disposer disposer;
 329             typedef ci::lazy_list::wrapped_stat<> stat;
 330         };
 331         typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type;
 332
 333         struct set_traits: public ci::michael_set::traits
 334         {
 335             typedef hash_int hash;
 336             typedef simple_item_counter item_counter;
 337         };
 338         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 339
 340         set_type s( kSize, 2 );
 341         test( s );
 342         EXPECT_GE( s.statistics().m_nInsertSuccess, 0u );
 343     }
 344
 345 } // namespace