tests/test-hdr/set/hdr_intrusive_splitlist_set_hp_lazy.cpp

   1 //$$CDS-header$$
   2
   3 #include "set/hdr_intrusive_set.h"
   4 #include <cds/intrusive/lazy_list_hp.h>
   5 #include <cds/intrusive/split_list.h>
   6
   7 namespace set {
   8
   9     void IntrusiveHashSetHdrTest::split_dyn_HP_base_cmp_lazy()
  10     {
  11         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
  12         typedef ci::LazyList< cds::gc::HP
  13             ,item
  14             ,ci::lazy_list::make_traits<
  15                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::HP> > >
  16                 ,co::compare< cmp<item> >
  17                 ,ci::opt::disposer< faked_disposer >
  18                 ,ci::opt::back_off< cds::backoff::empty >
  19             >::type
  20         >    ord_list;
  21
  22         typedef ci::SplitListSet< cds::gc::HP, ord_list,
  23             ci::split_list::make_traits<
  24                 co::hash< hash_int >
  25                 ,ci::split_list::dynamic_bucket_table<true>
  26                 ,co::memory_model<co::v::relaxed_ordering>
  27             >::type
  28         > set;
  29         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
  30
  31         test_int<set>();
  32     }
  33
  34     void IntrusiveHashSetHdrTest::split_dyn_HP_base_less_lazy()
  35     {
  36         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
  37         typedef ci::LazyList< cds::gc::HP
  38             ,item
  39             ,ci::lazy_list::make_traits<
  40                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::HP> > >
  41                 ,co::less< less<item> >
  42                 ,ci::opt::disposer< faked_disposer >
  43             >::type
  44         >    ord_list;
  45
  46         typedef ci::SplitListSet< cds::gc::HP, ord_list,
  47             ci::split_list::make_traits<
  48                 co::hash< hash_int >
  49                 ,co::memory_model<co::v::sequential_consistent>
  50             >::type
  51         > set;
  52         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
  53
  54         test_int<set>();
  55     }
  56
  57     void IntrusiveHashSetHdrTest::split_dyn_HP_base_cmpmix_lazy()
  58     {
  59         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::HP> > > item;
  60         typedef ci::LazyList< cds::gc::HP
  61             ,item
  62             ,ci::lazy_list::make_traits<
  63                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::HP> > >
  64                 ,co::less< less<item> >
  65                 ,co::compare< cmp<item> >
  66                 ,ci::opt::disposer< faked_disposer >
  67             >::type
  68         >    ord_list;
  69
  70         typedef ci::SplitListSet< cds::gc::HP, ord_list,
  71             ci::split_list::make_traits<
  72                 co::hash< hash_int >
  73                 ,co::item_counter< simple_item_counter >
  74                 ,ci::split_list::dynamic_bucket_table<true>
  75             >::type
  76         > set;
  77         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
  78
  79         test_int<set>();
  80     }
  81
  82     void IntrusiveHashSetHdrTest::split_dyn_HP_base_cmpmix_stat_lazy()
  83     {
  84         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::HP> > > item;
  85         typedef ci::LazyList< cds::gc::HP
  86             ,item
  87             ,ci::lazy_list::make_traits<
  88                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::HP> > >
  89                 ,co::less< less<item> >
  90                 ,co::compare< cmp<item> >
  91                 ,ci::opt::disposer< faked_disposer >
  92             >::type
  93         >    ord_list;
  94
  95         typedef ci::SplitListSet< cds::gc::HP, ord_list,
  96             ci::split_list::make_traits<
  97                 co::hash< hash_int >
  98                 ,co::item_counter< simple_item_counter >
  99                 ,ci::split_list::dynamic_bucket_table<true>
 100                 ,co::stat< ci::split_list::stat<> >
 101             >::type
 102         > set;
 103         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 104
 105         test_int<set>();
 106     }
 107
 108     void IntrusiveHashSetHdrTest::split_dyn_HP_member_cmp_lazy()
 109     {
 110         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 111         typedef ci::LazyList< cds::gc::HP
 112             ,item
 113             ,ci::lazy_list::make_traits<
 114                 ci::opt::hook< ci::lazy_list::member_hook<
 115                     offsetof( item, hMember ),
 116                     co::gc<cds::gc::HP>
 117                 > >
 118                 ,co::compare< cmp<item> >
 119                 ,ci::opt::disposer< faked_disposer >
 120             >::type
 121         >    ord_list;
 122
 123         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 124             ci::split_list::make_traits<
 125                 co::hash< hash_int >
 126                 ,co::memory_model<co::v::relaxed_ordering>
 127             >::type
 128         > set;
 129         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 130
 131         test_int<set>();
 132     }
 133
 134     void IntrusiveHashSetHdrTest::split_dyn_HP_member_less_lazy()
 135     {
 136         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 137         typedef ci::LazyList< cds::gc::HP
 138             ,item
 139             ,ci::lazy_list::make_traits<
 140                 ci::opt::hook< ci::lazy_list::member_hook<
 141                     offsetof( item, hMember ),
 142                     co::gc<cds::gc::HP>
 143                 > >
 144                 ,co::less< less<item> >
 145                 ,ci::opt::disposer< faked_disposer >
 146             >::type
 147         >    ord_list;
 148
 149         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 150             ci::split_list::make_traits<
 151                 co::hash< hash_int >
 152                 ,co::memory_model<co::v::sequential_consistent>
 153             >::type
 154         > set;
 155         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 156
 157         test_int<set>();
 158     }
 159
 160     void IntrusiveHashSetHdrTest::split_dyn_HP_member_cmpmix_lazy()
 161     {
 162         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 163         typedef ci::LazyList< cds::gc::HP
 164             ,item
 165             ,ci::lazy_list::make_traits<
 166                 ci::opt::hook< ci::lazy_list::member_hook<
 167                     offsetof( item, hMember ),
 168                     co::gc<cds::gc::HP>
 169                 > >
 170                 ,co::compare< cmp<item> >
 171                 ,co::less< less<item> >
 172                 ,ci::opt::disposer< faked_disposer >
 173             >::type
 174         >    ord_list;
 175
 176         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 177             ci::split_list::make_traits<
 178                 co::hash< hash_int >
 179                 ,co::item_counter< simple_item_counter >
 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_HP_member_cmpmix_stat_lazy()
 188     {
 189         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 190         struct list_traits : public ci::lazy_list::traits
 191         {
 192             typedef ci::lazy_list::member_hook< offsetof( item, hMember ), co::gc<cds::gc::HP>> hook;
 193             typedef cmp<item> compare;
 194             typedef IntrusiveHashSetHdrTest::less<item> less;
 195             typedef faked_disposer disposer;
 196         };
 197         typedef ci::LazyList< cds::gc::HP, item, list_traits > ord_list;
 198
 199         struct set_traits : public ci::split_list::traits
 200         {
 201             typedef hash_int hash;
 202             typedef simple_item_counter item_counter;
 203             typedef ci::split_list::stat<> stat;
 204         };
 205         typedef ci::SplitListSet< cds::gc::HP, ord_list, set_traits > set;
 206
 207         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 208
 209         test_int<set>();
 210     }
 211
 212
 213     // Static bucket table
 214     void IntrusiveHashSetHdrTest::split_st_HP_base_cmp_lazy()
 215     {
 216         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 217         typedef ci::LazyList< cds::gc::HP
 218             ,item
 219             ,ci::lazy_list::make_traits<
 220                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::HP> > >
 221                 ,co::compare< cmp<item> >
 222                 ,ci::opt::disposer< faked_disposer >
 223             >::type
 224         >    ord_list;
 225
 226         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 227             ci::split_list::make_traits<
 228                 co::hash< hash_int >
 229                 ,ci::split_list::dynamic_bucket_table<false>
 230                 ,co::memory_model<co::v::relaxed_ordering>
 231             >::type
 232         > set;
 233         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 234
 235         test_int<set>();
 236     }
 237
 238     void IntrusiveHashSetHdrTest::split_st_HP_base_less_lazy()
 239     {
 240         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 241         typedef ci::LazyList< cds::gc::HP
 242             ,item
 243             ,ci::lazy_list::make_traits<
 244                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::HP> > >
 245                 ,co::less< less<item> >
 246                 ,ci::opt::disposer< faked_disposer >
 247             >::type
 248         >    ord_list;
 249
 250         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 251             ci::split_list::make_traits<
 252                 co::hash< hash_int >
 253                 ,ci::split_list::dynamic_bucket_table<false>
 254                 ,co::memory_model<co::v::sequential_consistent>
 255             >::type
 256         > set;
 257         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 258
 259         test_int<set>();
 260     }
 261
 262     void IntrusiveHashSetHdrTest::split_st_HP_base_cmpmix_lazy()
 263     {
 264         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::HP> > > item;
 265         typedef ci::LazyList< cds::gc::HP
 266             ,item
 267             ,ci::lazy_list::make_traits<
 268                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::HP> > >
 269                 ,co::less< less<item> >
 270                 ,co::compare< cmp<item> >
 271                 ,ci::opt::disposer< faked_disposer >
 272             >::type
 273         >    ord_list;
 274
 275         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 276             ci::split_list::make_traits<
 277                 co::hash< hash_int >
 278                 ,co::item_counter< simple_item_counter >
 279                 ,ci::split_list::dynamic_bucket_table<false>
 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_HP_base_cmpmix_stat_lazy()
 288     {
 289         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::HP> > > item;
 290         struct list_traits :
 291             public ci::lazy_list::make_traits<
 292                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::HP> > >
 293                 ,co::less< less<item> >
 294                 ,co::compare< cmp<item> >
 295                 ,ci::opt::disposer< faked_disposer >
 296             >::type
 297         {};
 298         typedef ci::LazyList< cds::gc::HP, item, list_traits > ord_list;
 299
 300         struct set_traits :
 301             public 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         {
 307             typedef ci::split_list::stat<> stat;
 308         };
 309         typedef ci::SplitListSet< cds::gc::HP, ord_list, set_traits > set;
 310
 311         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 312
 313         test_int<set>();
 314     }
 315
 316     void IntrusiveHashSetHdrTest::split_st_HP_member_cmp_lazy()
 317     {
 318         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 319         typedef ci::LazyList< cds::gc::HP
 320             ,item
 321             ,ci::lazy_list::make_traits<
 322                 ci::opt::hook< ci::lazy_list::member_hook<
 323                     offsetof( item, hMember ),
 324                     co::gc<cds::gc::HP>
 325                 > >
 326                 ,co::compare< cmp<item> >
 327                 ,ci::opt::disposer< faked_disposer >
 328             >::type
 329         >    ord_list;
 330
 331         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 332             ci::split_list::make_traits<
 333                 co::hash< hash_int >
 334                 ,ci::split_list::dynamic_bucket_table<false>
 335                 ,co::memory_model<co::v::relaxed_ordering>
 336             >::type
 337         > set;
 338         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 339
 340         test_int<set>();
 341     }
 342
 343     void IntrusiveHashSetHdrTest::split_st_HP_member_less_lazy()
 344     {
 345         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 346         typedef ci::LazyList< cds::gc::HP
 347             ,item
 348             ,ci::lazy_list::make_traits<
 349                 ci::opt::hook< ci::lazy_list::member_hook<
 350                     offsetof( item, hMember ),
 351                     co::gc<cds::gc::HP>
 352                 > >
 353                 ,co::less< less<item> >
 354                 ,ci::opt::disposer< faked_disposer >
 355             >::type
 356         >    ord_list;
 357
 358         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 359             ci::split_list::make_traits<
 360                 ci::split_list::dynamic_bucket_table<false>
 361                 ,co::hash< hash_int >
 362                 ,co::memory_model<co::v::sequential_consistent>
 363             >::type
 364         > set;
 365         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 366
 367         test_int<set>();
 368     }
 369
 370     void IntrusiveHashSetHdrTest::split_st_HP_member_cmpmix_lazy()
 371     {
 372         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 373         typedef ci::LazyList< cds::gc::HP
 374             ,item
 375             ,ci::lazy_list::make_traits<
 376                 ci::opt::hook< ci::lazy_list::member_hook<
 377                     offsetof( item, hMember ),
 378                     co::gc<cds::gc::HP>
 379                 > >
 380                 ,co::compare< cmp<item> >
 381                 ,co::less< less<item> >
 382                 ,ci::opt::disposer< faked_disposer >
 383             >::type
 384         >    ord_list;
 385
 386         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 387             ci::split_list::make_traits<
 388                 co::hash< hash_int >
 389                 ,co::item_counter< simple_item_counter >
 390                 ,ci::split_list::dynamic_bucket_table<false>
 391             >::type
 392         > set;
 393         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 394
 395         test_int<set>();
 396     }
 397
 398     void IntrusiveHashSetHdrTest::split_st_HP_member_cmpmix_stat_lazy()
 399     {
 400         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::HP> > > item;
 401         typedef ci::LazyList< cds::gc::HP
 402             ,item
 403             ,ci::lazy_list::make_traits<
 404                 ci::opt::hook< ci::lazy_list::member_hook<
 405                     offsetof( item, hMember ),
 406                     co::gc<cds::gc::HP>
 407                 > >
 408                 ,co::compare< cmp<item> >
 409                 ,co::less< less<item> >
 410                 ,ci::opt::disposer< faked_disposer >
 411             >::type
 412         >    ord_list;
 413
 414         typedef ci::SplitListSet< cds::gc::HP, ord_list,
 415             ci::split_list::make_traits<
 416                 co::hash< hash_int >
 417                 ,co::item_counter< simple_item_counter >
 418                 ,ci::split_list::dynamic_bucket_table<false>
 419                 ,co::stat< ci::split_list::stat<> >
 420             >::type
 421         > set;
 422
 423         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 424
 425         test_int<set>();
 426     }
 427
 428 } // namespace set