tests/test-hdr/set/hdr_intrusive_splitlist_set_dhp_lazy.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 "set/hdr_intrusive_set.h"
  32 #include <cds/intrusive/lazy_list_dhp.h>
  33 #include <cds/intrusive/split_list.h>
  34
  35 namespace set {
  36
  37     void IntrusiveHashSetHdrTest::split_dyn_DHP_base_cmp_lazy()
  38     {
  39         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
  40         typedef ci::LazyList< cds::gc::DHP
  41             ,item
  42             ,ci::lazy_list::make_traits<
  43                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
  44                 ,co::compare< cmp<item> >
  45                 ,ci::opt::disposer< faked_disposer >
  46             >::type
  47         >    ord_list;
  48
  49         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
  50             ci::split_list::make_traits<
  51                 co::hash< hash_int >
  52                 ,ci::split_list::dynamic_bucket_table<true>
  53                 ,co::memory_model<co::v::relaxed_ordering>
  54             >::type
  55         > set;
  56         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
  57
  58         test_int<set>();
  59     }
  60
  61     void IntrusiveHashSetHdrTest::split_dyn_DHP_base_less_lazy()
  62     {
  63         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
  64         typedef ci::LazyList< cds::gc::DHP
  65             ,item
  66             ,ci::lazy_list::make_traits<
  67                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
  68                 ,co::less< less<item> >
  69                 ,ci::opt::disposer< faked_disposer >
  70             >::type
  71         >    ord_list;
  72
  73         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
  74             ci::split_list::make_traits<
  75                 co::hash< hash_int >
  76                 ,co::memory_model<co::v::sequential_consistent>
  77             >::type
  78         > set;
  79         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
  80
  81         test_int<set>();
  82     }
  83
  84     void IntrusiveHashSetHdrTest::split_dyn_DHP_base_cmpmix_lazy()
  85     {
  86         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::DHP> > > item;
  87         typedef ci::LazyList< cds::gc::DHP
  88             ,item
  89             ,ci::lazy_list::make_traits<
  90                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
  91                 ,co::less< less<item> >
  92                 ,co::compare< cmp<item> >
  93                 ,ci::opt::disposer< faked_disposer >
  94             >::type
  95         >    ord_list;
  96
  97         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
  98             ci::split_list::make_traits<
  99                 co::hash< hash_int >
 100                 ,co::item_counter< simple_item_counter >
 101                 ,ci::split_list::dynamic_bucket_table<true>
 102             >::type
 103         > set;
 104         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 105
 106         test_int<set>();
 107     }
 108
 109     void IntrusiveHashSetHdrTest::split_dyn_DHP_base_cmpmix_stat_lazy()
 110     {
 111         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::DHP> > > item;
 112         typedef ci::LazyList< cds::gc::DHP
 113             ,item
 114             ,ci::lazy_list::make_traits<
 115                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
 116                 ,co::less< less<item> >
 117                 ,co::compare< cmp<item> >
 118                 ,ci::opt::disposer< faked_disposer >
 119             >::type
 120         >    ord_list;
 121
 122         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 123             ci::split_list::make_traits<
 124                 co::hash< hash_int >
 125                 ,co::item_counter< simple_item_counter >
 126                 ,ci::split_list::dynamic_bucket_table<true>
 127                 ,co::stat< ci::split_list::stat<> >
 128             >::type
 129         > set;
 130         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 131
 132         test_int<set>();
 133     }
 134
 135     void IntrusiveHashSetHdrTest::split_dyn_DHP_member_cmp_lazy()
 136     {
 137         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 138         typedef ci::LazyList< cds::gc::DHP
 139             ,item
 140             ,ci::lazy_list::make_traits<
 141                 ci::opt::hook< ci::lazy_list::member_hook<
 142                     offsetof( item, hMember ),
 143                     co::gc<cds::gc::DHP>
 144                 > >
 145                 ,co::compare< cmp<item> >
 146                 ,ci::opt::disposer< faked_disposer >
 147             >::type
 148         >    ord_list;
 149
 150         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 151             ci::split_list::make_traits<
 152                 co::hash< hash_int >
 153                 ,co::memory_model<co::v::relaxed_ordering>
 154             >::type
 155         > set;
 156         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 157
 158         test_int<set>();
 159     }
 160
 161     void IntrusiveHashSetHdrTest::split_dyn_DHP_member_less_lazy()
 162     {
 163         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 164         typedef ci::LazyList< cds::gc::DHP
 165             ,item
 166             ,ci::lazy_list::make_traits<
 167                 ci::opt::hook< ci::lazy_list::member_hook<
 168                     offsetof( item, hMember ),
 169                     co::gc<cds::gc::DHP>
 170                 > >
 171                 ,co::less< less<item> >
 172                 ,ci::opt::disposer< faked_disposer >
 173             >::type
 174         >    ord_list;
 175
 176         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 177             ci::split_list::make_traits<
 178                 co::hash< hash_int >
 179                 ,co::memory_model<co::v::sequential_consistent>
 180             >::type
 181         > set;
 182         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 183
 184         test_int<set>();
 185     }
 186
 187     void IntrusiveHashSetHdrTest::split_dyn_DHP_member_cmpmix_lazy()
 188     {
 189         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 190         typedef ci::LazyList< cds::gc::DHP
 191             ,item
 192             ,ci::lazy_list::make_traits<
 193                 ci::opt::hook< ci::lazy_list::member_hook<
 194                     offsetof( item, hMember ),
 195                     co::gc<cds::gc::DHP>
 196                 > >
 197                 ,co::compare< cmp<item> >
 198                 ,co::less< less<item> >
 199                 ,ci::opt::disposer< faked_disposer >
 200             >::type
 201         >    ord_list;
 202
 203         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 204             ci::split_list::make_traits<
 205                 co::hash< hash_int >
 206                 ,co::item_counter< simple_item_counter >
 207             >::type
 208         > set;
 209         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 210
 211         test_int<set>();
 212     }
 213
 214     void IntrusiveHashSetHdrTest::split_dyn_DHP_member_cmpmix_stat_lazy()
 215     {
 216         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 217         struct list_traits : public ci::lazy_list::traits
 218         {
 219             typedef ci::lazy_list::member_hook< offsetof( item, hMember ), co::gc<cds::gc::DHP>> hook;
 220             typedef cmp<item> compare;
 221             typedef IntrusiveHashSetHdrTest::less<item> less;
 222             typedef faked_disposer disposer;
 223         };
 224         typedef ci::LazyList< cds::gc::DHP, item, list_traits > ord_list;
 225
 226         struct set_traits : public ci::split_list::traits {
 227             typedef hash_int hash;
 228             typedef simple_item_counter item_counter;
 229             typedef ci::split_list::stat<> stat;
 230         };
 231         typedef ci::SplitListSet< cds::gc::DHP, ord_list, set_traits > set;
 232
 233         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 234
 235         test_int<set>();
 236     }
 237
 238     // Static bucket table
 239     void IntrusiveHashSetHdrTest::split_st_DHP_base_cmp_lazy()
 240     {
 241         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 242         typedef ci::LazyList< cds::gc::DHP
 243             ,item
 244             ,ci::lazy_list::make_traits<
 245                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
 246                 ,co::compare< cmp<item> >
 247                 ,ci::opt::disposer< faked_disposer >
 248             >::type
 249         >    ord_list;
 250
 251         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 252             ci::split_list::make_traits<
 253                 co::hash< hash_int >
 254                 ,ci::split_list::dynamic_bucket_table<false>
 255                 ,co::memory_model<co::v::relaxed_ordering>
 256             >::type
 257         > set;
 258         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 259
 260         test_int<set>();
 261     }
 262
 263     void IntrusiveHashSetHdrTest::split_st_DHP_base_less_lazy()
 264     {
 265         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 266         typedef ci::LazyList< cds::gc::DHP
 267             ,item
 268             ,ci::lazy_list::make_traits<
 269                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
 270                 ,co::less< less<item> >
 271                 ,ci::opt::disposer< faked_disposer >
 272             >::type
 273         >    ord_list;
 274
 275         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 276             ci::split_list::make_traits<
 277                 co::hash< hash_int >
 278                 ,ci::split_list::dynamic_bucket_table<false>
 279                 ,co::memory_model<co::v::sequential_consistent>
 280             >::type
 281         > set;
 282         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 283
 284         test_int<set>();
 285     }
 286
 287     void IntrusiveHashSetHdrTest::split_st_DHP_base_cmpmix_lazy()
 288     {
 289         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::DHP> > > item;
 290         typedef ci::LazyList< cds::gc::DHP
 291             ,item
 292             ,ci::lazy_list::make_traits<
 293                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
 294                 ,co::less< less<item> >
 295                 ,co::compare< cmp<item> >
 296                 ,ci::opt::disposer< faked_disposer >
 297             >::type
 298         >    ord_list;
 299
 300         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 301             ci::split_list::make_traits<
 302                 co::hash< hash_int >
 303                 ,co::item_counter< simple_item_counter >
 304                 ,ci::split_list::dynamic_bucket_table<false>
 305             >::type
 306         > set;
 307         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 308
 309         test_int<set>();
 310     }
 311
 312     void IntrusiveHashSetHdrTest::split_st_DHP_base_cmpmix_stat_lazy()
 313     {
 314         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::DHP> > > item;
 315         typedef ci::LazyList< cds::gc::DHP
 316             ,item
 317             ,ci::lazy_list::make_traits<
 318                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
 319                 ,co::less< less<item> >
 320                 ,co::compare< cmp<item> >
 321                 ,ci::opt::disposer< faked_disposer >
 322             >::type
 323         >    ord_list;
 324
 325         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 326             ci::split_list::make_traits<
 327                 co::hash< hash_int >
 328                 ,co::item_counter< simple_item_counter >
 329                 ,ci::split_list::dynamic_bucket_table<false>
 330                 ,co::stat< ci::split_list::stat<> >
 331             >::type
 332         > set;
 333         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 334
 335         test_int<set>();
 336     }
 337
 338     void IntrusiveHashSetHdrTest::split_st_DHP_member_cmp_lazy()
 339     {
 340         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 341         typedef ci::LazyList< cds::gc::DHP
 342             ,item
 343             ,ci::lazy_list::make_traits<
 344                 ci::opt::hook< ci::lazy_list::member_hook<
 345                     offsetof( item, hMember ),
 346                     co::gc<cds::gc::DHP>
 347                 > >
 348                 ,co::compare< cmp<item> >
 349                 ,ci::opt::disposer< faked_disposer >
 350             >::type
 351         >    ord_list;
 352
 353         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 354             ci::split_list::make_traits<
 355                 co::hash< hash_int >
 356                 ,ci::split_list::dynamic_bucket_table<false>
 357                 ,co::memory_model<co::v::relaxed_ordering>
 358             >::type
 359         > set;
 360         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 361
 362         test_int<set>();
 363     }
 364
 365     void IntrusiveHashSetHdrTest::split_st_DHP_member_less_lazy()
 366     {
 367         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 368         typedef ci::LazyList< cds::gc::DHP
 369             ,item
 370             ,ci::lazy_list::make_traits<
 371                 ci::opt::hook< ci::lazy_list::member_hook<
 372                     offsetof( item, hMember ),
 373                     co::gc<cds::gc::DHP>
 374                 > >
 375                 ,co::less< less<item> >
 376                 ,ci::opt::disposer< faked_disposer >
 377             >::type
 378         >    ord_list;
 379
 380         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 381             ci::split_list::make_traits<
 382                 ci::split_list::dynamic_bucket_table<false>
 383                 ,co::hash< hash_int >
 384                 ,co::memory_model<co::v::sequential_consistent>
 385             >::type
 386         > set;
 387         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 388
 389         test_int<set>();
 390     }
 391
 392     void IntrusiveHashSetHdrTest::split_st_DHP_member_cmpmix_lazy()
 393     {
 394         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 395         typedef ci::LazyList< cds::gc::DHP
 396             ,item
 397             ,ci::lazy_list::make_traits<
 398                 ci::opt::hook< ci::lazy_list::member_hook<
 399                     offsetof( item, hMember ),
 400                     co::gc<cds::gc::DHP>
 401                 > >
 402                 ,co::compare< cmp<item> >
 403                 ,co::less< less<item> >
 404                 ,ci::opt::disposer< faked_disposer >
 405             >::type
 406         >    ord_list;
 407
 408         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 409             ci::split_list::make_traits<
 410                 co::hash< hash_int >
 411                 ,co::item_counter< simple_item_counter >
 412                 ,ci::split_list::dynamic_bucket_table<false>
 413             >::type
 414         > set;
 415         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 416
 417         test_int<set>();
 418     }
 419
 420     void IntrusiveHashSetHdrTest::split_st_DHP_member_cmpmix_stat_lazy()
 421     {
 422         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 423         typedef ci::LazyList< cds::gc::DHP
 424             ,item
 425             ,ci::lazy_list::make_traits<
 426                 ci::opt::hook< ci::lazy_list::member_hook<
 427                     offsetof( item, hMember ),
 428                     co::gc<cds::gc::DHP>
 429                 > >
 430                 ,co::compare< cmp<item> >
 431                 ,co::less< less<item> >
 432                 ,ci::opt::disposer< faked_disposer >
 433             >::type
 434         >    ord_list;
 435
 436         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 437             ci::split_list::make_traits<
 438                 co::hash< hash_int >
 439                 ,co::item_counter< simple_item_counter >
 440                 ,ci::split_list::dynamic_bucket_table<false>
 441                 ,co::stat< ci::split_list::stat<> >
 442             >::type
 443         > set;
 444         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 445
 446         test_int<set>();
 447     }
 448
 449 } // namespace set