test/unit/list/intrusive_michael_hp.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_list_hp.h"
  32 #include <cds/intrusive/michael_list_hp.h>
  33
  34 namespace {
  35     namespace ci = cds::intrusive;
  36     typedef cds::gc::HP gc_type;
  37
  38     class IntrusiveMichaelList_HP : public cds_test::intrusive_list_hp
  39     {
  40     public:
  41         typedef cds_test::intrusive_list_hp::base_item< ci::michael_list::node< gc_type>> base_item;
  42         typedef cds_test::intrusive_list_hp::member_item< ci::michael_list::node< gc_type>> member_item;
  43
  44     protected:
  45         void SetUp()
  46         {
  47             struct traits: public ci::michael_list::traits
  48             {
  49                 typedef ci::michael_list::base_hook< cds::opt::gc< gc_type >> hook;
  50             };
  51             typedef ci::MichaelList< gc_type, base_item, traits > list_type;
  52
  53             // +1 - for guarded_ptr
  54             cds::gc::hp::GarbageCollector::Construct( list_type::c_nHazardPtrCount + 1, 1, 16 );
  55             cds::threading::Manager::attachThread();
  56         }
  57
  58         void TearDown()
  59         {
  60             cds::threading::Manager::detachThread();
  61             cds::gc::hp::GarbageCollector::Destruct( true );
  62         }
  63     };
  64
  65     TEST_F( IntrusiveMichaelList_HP, base_hook )
  66     {
  67         typedef ci::MichaelList< gc_type, base_item,
  68             typename ci::michael_list::make_traits<
  69                 ci::opt::hook< ci::michael_list::base_hook< cds::opt::gc< gc_type >>>
  70                 ,ci::opt::disposer< mock_disposer >
  71                 ,cds::opt::less< less< base_item >>
  72             >::type
  73        > list_type;
  74
  75        list_type l;
  76        test_common( l );
  77        test_ordered_iterator( l );
  78        test_hp( l );
  79     }
  80
  81     TEST_F( IntrusiveMichaelList_HP, base_hook_cmp )
  82     {
  83         typedef ci::MichaelList< gc_type, base_item,
  84             typename ci::michael_list::make_traits<
  85                 ci::opt::hook< ci::michael_list::base_hook< cds::opt::gc< gc_type >>>
  86                 , ci::opt::disposer< mock_disposer >
  87                 , cds::opt::compare< cmp< base_item >>
  88             >::type
  89         > list_type;
  90
  91         list_type l;
  92         test_common( l );
  93         test_ordered_iterator( l );
  94         test_hp( l );
  95     }
  96
  97     TEST_F( IntrusiveMichaelList_HP, base_hook_item_counting )
  98     {
  99         struct traits : public ci::michael_list::traits {
 100             typedef ci::michael_list::base_hook< cds::opt::gc< gc_type >> hook;
 101             typedef mock_disposer disposer;
 102             typedef cmp< base_item > compare;
 103             typedef intrusive_list_common::less< base_item > less;
 104             typedef cds::atomicity::item_counter item_counter;
 105         };
 106         typedef ci::MichaelList< gc_type, base_item, traits > list_type;
 107
 108         list_type l;
 109         test_common( l );
 110         test_ordered_iterator( l );
 111         test_hp( l );
 112     }
 113
 114     TEST_F( IntrusiveMichaelList_HP, base_hook_backoff )
 115     {
 116         struct traits : public ci::michael_list::traits {
 117             typedef ci::michael_list::base_hook< cds::opt::gc< gc_type >> hook;
 118             typedef mock_disposer disposer;
 119             typedef cmp< base_item > compare;
 120             typedef intrusive_list_common::less< base_item > less;
 121             typedef cds::atomicity::item_counter item_counter;
 122             typedef cds::backoff::pause back_off;
 123         };
 124         typedef ci::MichaelList< gc_type, base_item, traits > list_type;
 125
 126         list_type l;
 127         test_common( l );
 128         test_ordered_iterator( l );
 129         test_hp( l );
 130     }
 131
 132     TEST_F( IntrusiveMichaelList_HP, base_hook_seqcst )
 133     {
 134         struct traits : public ci::michael_list::traits {
 135             typedef ci::michael_list::base_hook< cds::opt::gc< gc_type >> hook;
 136             typedef mock_disposer disposer;
 137             typedef cmp< base_item > compare;
 138             typedef intrusive_list_common::less< base_item > less;
 139             typedef cds::atomicity::item_counter item_counter;
 140             typedef cds::opt::v::sequential_consistent memory_model;
 141         };
 142         typedef ci::MichaelList< gc_type, base_item, traits > list_type;
 143
 144         list_type l;
 145         test_common( l );
 146         test_ordered_iterator( l );
 147         test_hp( l );
 148     }
 149
 150     TEST_F( IntrusiveMichaelList_HP, member_hook )
 151     {
 152         typedef ci::MichaelList< gc_type, member_item,
 153             typename ci::michael_list::make_traits<
 154                 ci::opt::hook< ci::michael_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >>>
 155                 ,ci::opt::disposer< mock_disposer >
 156                 ,cds::opt::less< less< member_item >>
 157             >::type
 158        > list_type;
 159
 160        list_type l;
 161        test_common( l );
 162        test_ordered_iterator( l );
 163        test_hp( l );
 164     }
 165
 166     TEST_F( IntrusiveMichaelList_HP, member_hook_cmp )
 167     {
 168         typedef ci::MichaelList< gc_type, member_item,
 169             typename ci::michael_list::make_traits<
 170                 ci::opt::hook< ci::michael_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >>>
 171                 ,ci::opt::disposer< mock_disposer >
 172                 ,cds::opt::compare< cmp< member_item >>
 173             >::type
 174         > list_type;
 175
 176         list_type l;
 177         test_common( l );
 178         test_ordered_iterator( l );
 179         test_hp( l );
 180     }
 181
 182     TEST_F( IntrusiveMichaelList_HP, member_hook_item_counting )
 183     {
 184         struct traits : public ci::michael_list::traits {
 185             typedef ci::michael_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >> hook;
 186             typedef mock_disposer disposer;
 187             typedef cmp< member_item > compare;
 188             typedef intrusive_list_common::less< member_item > less;
 189             typedef cds::atomicity::item_counter item_counter;
 190         };
 191         typedef ci::MichaelList< gc_type, member_item, traits > list_type;
 192
 193         list_type l;
 194         test_common( l );
 195         test_ordered_iterator( l );
 196         test_hp( l );
 197     }
 198
 199     TEST_F( IntrusiveMichaelList_HP, member_hook_seqcst )
 200     {
 201         struct traits : public ci::michael_list::traits {
 202             typedef ci::michael_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >> hook;
 203             typedef mock_disposer disposer;
 204             typedef cmp< member_item > compare;
 205             typedef intrusive_list_common::less< member_item > less;
 206             typedef cds::atomicity::item_counter item_counter;
 207             typedef cds::opt::v::sequential_consistent memory_model;
 208         };
 209         typedef ci::MichaelList< gc_type, member_item, traits > list_type;
 210
 211         list_type l;
 212         test_common( l );
 213         test_ordered_iterator( l );
 214         test_hp( l );
 215     }
 216
 217     TEST_F( IntrusiveMichaelList_HP, member_hook_back_off )
 218     {
 219         struct traits : public ci::michael_list::traits {
 220             typedef ci::michael_list::member_hook< offsetof( member_item, hMember ), cds::opt::gc< gc_type >> hook;
 221             typedef mock_disposer disposer;
 222             typedef cmp< member_item > compare;
 223             typedef intrusive_list_common::less< member_item > less;
 224             typedef cds::atomicity::item_counter item_counter;
 225             typedef cds::backoff::empty back_off;
 226         };
 227         typedef ci::MichaelList< gc_type, member_item, traits > list_type;
 228
 229         list_type l;
 230         test_common( l );
 231         test_ordered_iterator( l );
 232         test_hp( l );
 233     }
 234
 235 } // namespace