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-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
  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::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount );
  63             cds::threading::Manager::attachThread();
  64         }
  65
  66         void TearDown()
  67         {
  68             cds::threading::Manager::detachThread();
  69             cds::gc::dhp::GarbageCollector::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
 162     TEST_F( IntrusiveMichaelLazySet_DHP, member_cmp )
 163     {
 164         typedef ci::LazyList< gc_type
 165             ,member_item_type
 166             ,ci::lazy_list::make_traits<
 167                 ci::opt::hook< ci::lazy_list::member_hook<
 168                     offsetof( member_item_type, hMember ),
 169                     ci::opt::gc<gc_type>
 170                 > >
 171                 ,ci::opt::compare< cmp<member_item_type> >
 172                 ,ci::opt::disposer< mock_disposer >
 173             >::type
 174         >    bucket_type;
 175
 176         typedef ci::MichaelHashSet< gc_type, bucket_type,
 177             ci::michael_set::make_traits<
 178                 ci::opt::hash< hash_int >
 179             >::type
 180         > set_type;
 181
 182         set_type s( kSize, 2 );
 183         test( s );
 184     }
 185
 186     TEST_F( IntrusiveMichaelLazySet_DHP, member_less )
 187     {
 188         typedef ci::LazyList< gc_type
 189             , member_item_type
 190             ,ci::lazy_list::make_traits<
 191                 ci::opt::hook< ci::lazy_list::member_hook<
 192                     offsetof( member_item_type, hMember ),
 193                     ci::opt::gc<gc_type>
 194                 > >
 195                 ,ci::opt::less< less<member_item_type> >
 196                 ,ci::opt::disposer< mock_disposer >
 197             >::type
 198         > bucket_type;
 199
 200         typedef ci::MichaelHashSet< gc_type, bucket_type,
 201             ci::michael_set::make_traits<
 202                 ci::opt::hash< hash_int >
 203             >::type
 204         > set_type;
 205
 206         set_type s( kSize, 2 );
 207         test( s );
 208     }
 209
 210     TEST_F( IntrusiveMichaelLazySet_DHP, member_cmpmix )
 211     {
 212         struct list_traits : public ci::lazy_list::traits
 213         {
 214             typedef ci::lazy_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc<gc_type>> hook;
 215             typedef base_class::less<member_item_type> less;
 216             typedef cmp<member_item_type> compare;
 217             typedef mock_disposer disposer;
 218         };
 219         typedef ci::LazyList< gc_type, member_item_type, list_traits > bucket_type;
 220
 221         struct set_traits : public ci::michael_set::traits
 222         {
 223             typedef hash_int hash;
 224             typedef simple_item_counter item_counter;
 225         };
 226         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 227
 228         set_type s( kSize, 2 );
 229         test( s );
 230     }
 231
 232     TEST_F( IntrusiveMichaelLazySet_DHP, member_mutex )
 233     {
 234         struct list_traits : public ci::lazy_list::traits
 235         {
 236             typedef ci::lazy_list::member_hook< offsetof( member_mutex_item_type, hMember ), ci::opt::gc<gc_type>, ci::opt::lock_type<std::mutex>> hook;
 237             typedef base_class::less<member_mutex_item_type> less;
 238             typedef cmp<member_mutex_item_type> compare;
 239             typedef mock_disposer disposer;
 240         };
 241         typedef ci::LazyList< gc_type, member_mutex_item_type, list_traits > bucket_type;
 242
 243         struct set_traits : public ci::michael_set::traits
 244         {
 245             typedef hash_int hash;
 246             typedef simple_item_counter item_counter;
 247         };
 248         typedef ci::MichaelHashSet< gc_type, bucket_type, set_traits > set_type;
 249
 250         set_type s( kSize, 2 );
 251         test( s );
 252     }
 253
 254 } // namespace