test/unit/tree/intrusive_ellenbintree_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_tree_hp.h"
  32
  33 #include <cds/intrusive/ellen_bintree_hp.h>
  34 //#include <cds/memory/vyukov_queue_pool.h>
  35 //#include <cds/memory/pool_allocator.h>
  36
  37 namespace {
  38     namespace ci = cds::intrusive;
  39     typedef cds::gc::HP gc_type;
  40
  41     class IntrusiveEllenBinTree_HP : public cds_test::intrusive_tree_hp
  42     {
  43     protected:
  44         typedef cds_test::intrusive_tree_hp base_class;
  45
  46     protected:
  47         typedef base_class::key_type key_type;
  48
  49         typedef typename base_class::base_int_item< ci::ellen_bintree::node<gc_type>> base_item_type;
  50         typedef ci::ellen_bintree::internal_node< key_type, base_item_type >          internal_base_node;
  51         typedef ci::ellen_bintree::update_desc< base_item_type, internal_base_node >  update_base_desc;
  52
  53         typedef typename base_class::member_int_item< ci::ellen_bintree::node<gc_type>>  member_item_type;
  54         typedef ci::ellen_bintree::internal_node< key_type, member_item_type >           internal_member_node;
  55         typedef ci::ellen_bintree::update_desc< member_item_type, internal_member_node > update_member_desc;
  56
  57         void SetUp()
  58         {
  59             struct list_traits : public ci::ellen_bintree::traits
  60             {
  61                 typedef ci::ellen_bintree::base_hook< ci::opt::gc<gc_type>> hook;
  62             };
  63             typedef ci::EllenBinTree< gc_type, key_type, base_item_type > tree_type;
  64
  65             // +1 - for guarded_ptr
  66             cds::gc::hp::GarbageCollector::Construct( tree_type::c_nHazardPtrCount + 1, 1, 16 );
  67             cds::threading::Manager::attachThread();
  68         }
  69
  70         void TearDown()
  71         {
  72             cds::threading::Manager::detachThread();
  73             cds::gc::hp::GarbageCollector::Destruct( true );
  74         }
  75
  76         struct generic_traits: public ci::ellen_bintree::traits
  77         {
  78             typedef base_class::key_extractor key_extractor;
  79             typedef mock_disposer disposer;
  80         };
  81     };
  82
  83
  84     TEST_F( IntrusiveEllenBinTree_HP, base_cmp )
  85     {
  86         typedef ci::EllenBinTree< gc_type, key_type, base_item_type,
  87             ci::ellen_bintree::make_traits<
  88                 ci::opt::type_traits< generic_traits >
  89                 ,ci::opt::hook< ci::ellen_bintree::base_hook< ci::opt::gc< gc_type >>>
  90                 ,ci::opt::compare< cmp<base_item_type>>
  91             >::type
  92         > tree_type;
  93
  94         tree_type t;
  95         test( t );
  96     }
  97
  98     TEST_F( IntrusiveEllenBinTree_HP, base_less )
  99     {
 100         typedef ci::EllenBinTree< gc_type, key_type, base_item_type,
 101             ci::ellen_bintree::make_traits<
 102                 ci::opt::type_traits< generic_traits >
 103                 ,ci::opt::hook< ci::ellen_bintree::base_hook< ci::opt::gc< gc_type >>>
 104                 ,ci::opt::less< less<base_item_type>>
 105             >::type
 106         > tree_type;
 107
 108         tree_type t;
 109         test( t );
 110     }
 111
 112     TEST_F( IntrusiveEllenBinTree_HP, base_item_counter )
 113     {
 114         typedef ci::EllenBinTree< gc_type, key_type, base_item_type,
 115             ci::ellen_bintree::make_traits<
 116                 ci::opt::type_traits< generic_traits >
 117                 ,ci::opt::hook< ci::ellen_bintree::base_hook< ci::opt::gc< gc_type >>>
 118                 ,ci::opt::compare< cmp<base_item_type>>
 119                 ,ci::opt::item_counter< simple_item_counter >
 120             >::type
 121         > tree_type;
 122
 123         tree_type t;
 124         test( t );
 125     }
 126
 127     TEST_F( IntrusiveEllenBinTree_HP, base_backoff )
 128     {
 129         struct tree_traits: public generic_traits
 130         {
 131             typedef ci::ellen_bintree::base_hook< ci::opt::gc< gc_type >> hook;
 132             typedef cmp<base_item_type> compare;
 133             typedef base_class::less<base_item_type> less;
 134             typedef cds::atomicity::item_counter item_counter;
 135             typedef cds::backoff::yield back_off;
 136         };
 137
 138         typedef ci::EllenBinTree< gc_type, key_type, base_item_type, tree_traits > tree_type;
 139
 140         tree_type t;
 141         test( t );
 142     }
 143
 144     TEST_F( IntrusiveEllenBinTree_HP, base_seq_cst )
 145     {
 146         struct tree_traits: public generic_traits
 147         {
 148             typedef ci::ellen_bintree::base_hook< ci::opt::gc< gc_type >> hook;
 149             typedef cmp<base_item_type> compare;
 150             typedef base_class::less<base_item_type> less;
 151             typedef cds::atomicity::item_counter item_counter;
 152             typedef cds::backoff::pause back_off;
 153             typedef ci::opt::v::sequential_consistent memory_model;
 154         };
 155
 156         typedef ci::EllenBinTree< gc_type, key_type, base_item_type, tree_traits > tree_type;
 157
 158         tree_type t;
 159         test( t );
 160     }
 161
 162     // member hook
 163     TEST_F( IntrusiveEllenBinTree_HP, member_cmp )
 164     {
 165         typedef ci::EllenBinTree< gc_type, key_type, member_item_type,
 166             ci::ellen_bintree::make_traits<
 167                 ci::opt::type_traits< generic_traits >
 168                 ,ci::opt::hook< ci::ellen_bintree::member_hook< offsetof( member_item_type, hMember), ci::opt::gc< gc_type >>>
 169                 ,ci::opt::compare< cmp<member_item_type>>
 170             >::type
 171         > tree_type;
 172
 173         tree_type t;
 174         test( t );
 175     }
 176
 177     TEST_F( IntrusiveEllenBinTree_HP, member_less )
 178     {
 179         typedef ci::EllenBinTree< gc_type, key_type, member_item_type,
 180             ci::ellen_bintree::make_traits<
 181                 ci::opt::type_traits< generic_traits >
 182                 ,ci::opt::hook< ci::ellen_bintree::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >>>
 183                 ,ci::opt::less< less<member_item_type>>
 184             >::type
 185         > tree_type;
 186
 187         tree_type t;
 188         test( t );
 189     }
 190
 191     TEST_F( IntrusiveEllenBinTree_HP, member_item_counter )
 192     {
 193         typedef ci::EllenBinTree< gc_type, key_type, member_item_type,
 194             ci::ellen_bintree::make_traits<
 195                 ci::opt::type_traits< generic_traits >
 196                 ,ci::opt::hook< ci::ellen_bintree::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >>>
 197                 ,ci::opt::compare< cmp<member_item_type>>
 198                 ,ci::opt::item_counter< simple_item_counter >
 199             >::type
 200         > tree_type;
 201
 202         tree_type t;
 203         test( t );
 204     }
 205
 206     TEST_F( IntrusiveEllenBinTree_HP, member_backoff )
 207     {
 208         struct tree_traits: public generic_traits
 209         {
 210             typedef ci::ellen_bintree::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook;
 211             typedef cmp<member_item_type> compare;
 212             typedef base_class::less<member_item_type> less;
 213             typedef cds::atomicity::item_counter item_counter;
 214             typedef cds::backoff::yield back_off;
 215         };
 216
 217         typedef ci::EllenBinTree< gc_type, key_type, member_item_type, tree_traits > tree_type;
 218
 219         tree_type t;
 220         test( t );
 221     }
 222
 223     TEST_F( IntrusiveEllenBinTree_HP, member_seq_cst )
 224     {
 225         struct tree_traits: public generic_traits
 226         {
 227             typedef ci::ellen_bintree::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< gc_type >> hook;
 228             typedef cmp<member_item_type> compare;
 229             typedef base_class::less<member_item_type> less;
 230             typedef cds::atomicity::item_counter item_counter;
 231             typedef cds::backoff::pause back_off;
 232             typedef ci::opt::v::sequential_consistent memory_model;
 233         };
 234
 235         typedef ci::EllenBinTree< gc_type, key_type, member_item_type, tree_traits > tree_type;
 236
 237         tree_type t;
 238         test( t );
 239     }
 240
 241 } // namespace