tests/test-hdr/set/hdr_intrusive_splitlist_set_dhp_lazy.cpp

   1 //$$CDS-header$$
   2
   3 #include "set/hdr_intrusive_set.h"
   4 #include <cds/intrusive/lazy_list_dhp.h>
   5 #include <cds/intrusive/split_list.h>
   6
   7 namespace set {
   8
   9     void IntrusiveHashSetHdrTest::split_dyn_DHP_base_cmp_lazy()
  10     {
  11         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
  12         typedef ci::LazyList< cds::gc::DHP
  13             ,item
  14             ,ci::lazy_list::make_traits<
  15                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
  16                 ,co::compare< cmp<item> >
  17                 ,ci::opt::disposer< faked_disposer >
  18             >::type
  19         >    ord_list;
  20
  21         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
  22             ci::split_list::make_traits<
  23                 co::hash< hash_int >
  24                 ,ci::split_list::dynamic_bucket_table<true>
  25                 ,co::memory_model<co::v::relaxed_ordering>
  26             >::type
  27         > set;
  28         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
  29
  30         test_int<set>();
  31     }
  32
  33     void IntrusiveHashSetHdrTest::split_dyn_DHP_base_less_lazy()
  34     {
  35         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
  36         typedef ci::LazyList< cds::gc::DHP
  37             ,item
  38             ,ci::lazy_list::make_traits<
  39                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
  40                 ,co::less< less<item> >
  41                 ,ci::opt::disposer< faked_disposer >
  42             >::type
  43         >    ord_list;
  44
  45         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
  46             ci::split_list::make_traits<
  47                 co::hash< hash_int >
  48                 ,co::memory_model<co::v::sequential_consistent>
  49             >::type
  50         > set;
  51         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
  52
  53         test_int<set>();
  54     }
  55
  56     void IntrusiveHashSetHdrTest::split_dyn_DHP_base_cmpmix_lazy()
  57     {
  58         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::DHP> > > item;
  59         typedef ci::LazyList< cds::gc::DHP
  60             ,item
  61             ,ci::lazy_list::make_traits<
  62                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
  63                 ,co::less< less<item> >
  64                 ,co::compare< cmp<item> >
  65                 ,ci::opt::disposer< faked_disposer >
  66             >::type
  67         >    ord_list;
  68
  69         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
  70             ci::split_list::make_traits<
  71                 co::hash< hash_int >
  72                 ,co::item_counter< simple_item_counter >
  73                 ,ci::split_list::dynamic_bucket_table<true>
  74             >::type
  75         > set;
  76         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
  77
  78         test_int<set>();
  79     }
  80
  81     void IntrusiveHashSetHdrTest::split_dyn_DHP_base_cmpmix_stat_lazy()
  82     {
  83         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::DHP> > > item;
  84         typedef ci::LazyList< cds::gc::DHP
  85             ,item
  86             ,ci::lazy_list::make_traits<
  87                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
  88                 ,co::less< less<item> >
  89                 ,co::compare< cmp<item> >
  90                 ,ci::opt::disposer< faked_disposer >
  91             >::type
  92         >    ord_list;
  93
  94         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
  95             ci::split_list::make_traits<
  96                 co::hash< hash_int >
  97                 ,co::item_counter< simple_item_counter >
  98                 ,ci::split_list::dynamic_bucket_table<true>
  99                 ,co::stat< ci::split_list::stat<> >
 100             >::type
 101         > set;
 102         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 103
 104         test_int<set>();
 105     }
 106
 107     void IntrusiveHashSetHdrTest::split_dyn_DHP_member_cmp_lazy()
 108     {
 109         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 110         typedef ci::LazyList< cds::gc::DHP
 111             ,item
 112             ,ci::lazy_list::make_traits<
 113                 ci::opt::hook< ci::lazy_list::member_hook<
 114                     offsetof( item, hMember ),
 115                     co::gc<cds::gc::DHP>
 116                 > >
 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::memory_model<co::v::relaxed_ordering>
 126             >::type
 127         > set;
 128         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 129
 130         test_int<set>();
 131     }
 132
 133     void IntrusiveHashSetHdrTest::split_dyn_DHP_member_less_lazy()
 134     {
 135         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 136         typedef ci::LazyList< cds::gc::DHP
 137             ,item
 138             ,ci::lazy_list::make_traits<
 139                 ci::opt::hook< ci::lazy_list::member_hook<
 140                     offsetof( item, hMember ),
 141                     co::gc<cds::gc::DHP>
 142                 > >
 143                 ,co::less< less<item> >
 144                 ,ci::opt::disposer< faked_disposer >
 145             >::type
 146         >    ord_list;
 147
 148         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 149             ci::split_list::make_traits<
 150                 co::hash< hash_int >
 151                 ,co::memory_model<co::v::sequential_consistent>
 152             >::type
 153         > set;
 154         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 155
 156         test_int<set>();
 157     }
 158
 159     void IntrusiveHashSetHdrTest::split_dyn_DHP_member_cmpmix_lazy()
 160     {
 161         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 162         typedef ci::LazyList< cds::gc::DHP
 163             ,item
 164             ,ci::lazy_list::make_traits<
 165                 ci::opt::hook< ci::lazy_list::member_hook<
 166                     offsetof( item, hMember ),
 167                     co::gc<cds::gc::DHP>
 168                 > >
 169                 ,co::compare< cmp<item> >
 170                 ,co::less< less<item> >
 171                 ,ci::opt::disposer< faked_disposer >
 172             >::type
 173         >    ord_list;
 174
 175         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 176             ci::split_list::make_traits<
 177                 co::hash< hash_int >
 178                 ,co::item_counter< simple_item_counter >
 179             >::type
 180         > set;
 181         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 182
 183         test_int<set>();
 184     }
 185
 186     void IntrusiveHashSetHdrTest::split_dyn_DHP_member_cmpmix_stat_lazy()
 187     {
 188         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 189         struct list_traits : public ci::lazy_list::traits
 190         {
 191             typedef ci::lazy_list::member_hook< offsetof( item, hMember ), co::gc<cds::gc::DHP>> hook;
 192             typedef cmp<item> compare;
 193             typedef IntrusiveHashSetHdrTest::less<item> less;
 194             typedef faked_disposer disposer;
 195         };
 196         typedef ci::LazyList< cds::gc::DHP, item, list_traits > ord_list;
 197
 198         struct set_traits : public ci::split_list::traits {
 199             typedef hash_int hash;
 200             typedef simple_item_counter item_counter;
 201             typedef ci::split_list::stat<> stat;
 202         };
 203         typedef ci::SplitListSet< cds::gc::DHP, ord_list, set_traits > set;
 204
 205         static_assert( set::traits::dynamic_bucket_table, "Set has static bucket table" );
 206
 207         test_int<set>();
 208     }
 209
 210     // Static bucket table
 211     void IntrusiveHashSetHdrTest::split_st_DHP_base_cmp_lazy()
 212     {
 213         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 214         typedef ci::LazyList< cds::gc::DHP
 215             ,item
 216             ,ci::lazy_list::make_traits<
 217                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
 218                 ,co::compare< cmp<item> >
 219                 ,ci::opt::disposer< faked_disposer >
 220             >::type
 221         >    ord_list;
 222
 223         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 224             ci::split_list::make_traits<
 225                 co::hash< hash_int >
 226                 ,ci::split_list::dynamic_bucket_table<false>
 227                 ,co::memory_model<co::v::relaxed_ordering>
 228             >::type
 229         > set;
 230         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 231
 232         test_int<set>();
 233     }
 234
 235     void IntrusiveHashSetHdrTest::split_st_DHP_base_less_lazy()
 236     {
 237         typedef base_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 238         typedef ci::LazyList< cds::gc::DHP
 239             ,item
 240             ,ci::lazy_list::make_traits<
 241                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
 242                 ,co::less< less<item> >
 243                 ,ci::opt::disposer< faked_disposer >
 244             >::type
 245         >    ord_list;
 246
 247         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 248             ci::split_list::make_traits<
 249                 co::hash< hash_int >
 250                 ,ci::split_list::dynamic_bucket_table<false>
 251                 ,co::memory_model<co::v::sequential_consistent>
 252             >::type
 253         > set;
 254         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 255
 256         test_int<set>();
 257     }
 258
 259     void IntrusiveHashSetHdrTest::split_st_DHP_base_cmpmix_lazy()
 260     {
 261         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::DHP> > > item;
 262         typedef ci::LazyList< cds::gc::DHP
 263             ,item
 264             ,ci::lazy_list::make_traits<
 265                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
 266                 ,co::less< less<item> >
 267                 ,co::compare< cmp<item> >
 268                 ,ci::opt::disposer< faked_disposer >
 269             >::type
 270         >    ord_list;
 271
 272         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 273             ci::split_list::make_traits<
 274                 co::hash< hash_int >
 275                 ,co::item_counter< simple_item_counter >
 276                 ,ci::split_list::dynamic_bucket_table<false>
 277             >::type
 278         > set;
 279         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 280
 281         test_int<set>();
 282     }
 283
 284     void IntrusiveHashSetHdrTest::split_st_DHP_base_cmpmix_stat_lazy()
 285     {
 286         typedef base_int_item< ci::split_list::node<ci::lazy_list::node<cds::gc::DHP> > > item;
 287         typedef ci::LazyList< cds::gc::DHP
 288             ,item
 289             ,ci::lazy_list::make_traits<
 290                 ci::opt::hook< ci::lazy_list::base_hook< co::gc<cds::gc::DHP> > >
 291                 ,co::less< less<item> >
 292                 ,co::compare< cmp<item> >
 293                 ,ci::opt::disposer< faked_disposer >
 294             >::type
 295         >    ord_list;
 296
 297         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 298             ci::split_list::make_traits<
 299                 co::hash< hash_int >
 300                 ,co::item_counter< simple_item_counter >
 301                 ,ci::split_list::dynamic_bucket_table<false>
 302                 ,co::stat< ci::split_list::stat<> >
 303             >::type
 304         > set;
 305         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 306
 307         test_int<set>();
 308     }
 309
 310     void IntrusiveHashSetHdrTest::split_st_DHP_member_cmp_lazy()
 311     {
 312         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 313         typedef ci::LazyList< cds::gc::DHP
 314             ,item
 315             ,ci::lazy_list::make_traits<
 316                 ci::opt::hook< ci::lazy_list::member_hook<
 317                     offsetof( item, hMember ),
 318                     co::gc<cds::gc::DHP>
 319                 > >
 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                 ,ci::split_list::dynamic_bucket_table<false>
 329                 ,co::memory_model<co::v::relaxed_ordering>
 330             >::type
 331         > set;
 332         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 333
 334         test_int<set>();
 335     }
 336
 337     void IntrusiveHashSetHdrTest::split_st_DHP_member_less_lazy()
 338     {
 339         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 340         typedef ci::LazyList< cds::gc::DHP
 341             ,item
 342             ,ci::lazy_list::make_traits<
 343                 ci::opt::hook< ci::lazy_list::member_hook<
 344                     offsetof( item, hMember ),
 345                     co::gc<cds::gc::DHP>
 346                 > >
 347                 ,co::less< less<item> >
 348                 ,ci::opt::disposer< faked_disposer >
 349             >::type
 350         >    ord_list;
 351
 352         typedef ci::SplitListSet< cds::gc::DHP, ord_list,
 353             ci::split_list::make_traits<
 354                 ci::split_list::dynamic_bucket_table<false>
 355                 ,co::hash< hash_int >
 356                 ,co::memory_model<co::v::sequential_consistent>
 357             >::type
 358         > set;
 359         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 360
 361         test_int<set>();
 362     }
 363
 364     void IntrusiveHashSetHdrTest::split_st_DHP_member_cmpmix_lazy()
 365     {
 366         typedef member_int_item< ci::split_list::node< ci::lazy_list::node<cds::gc::DHP> > > item;
 367         typedef ci::LazyList< cds::gc::DHP
 368             ,item
 369             ,ci::lazy_list::make_traits<
 370                 ci::opt::hook< ci::lazy_list::member_hook<
 371                     offsetof( item, hMember ),
 372                     co::gc<cds::gc::DHP>
 373                 > >
 374                 ,co::compare< cmp<item> >
 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                 co::hash< hash_int >
 383                 ,co::item_counter< simple_item_counter >
 384                 ,ci::split_list::dynamic_bucket_table<false>
 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_stat_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                 ,co::stat< ci::split_list::stat<> >
 414             >::type
 415         > set;
 416         static_assert( !set::traits::dynamic_bucket_table, "Set has dynamic bucket table" );
 417
 418         test_int<set>();
 419     }
 420
 421 } // namespace set