tests/test-hdr/set/hdr_intrusive_splitlist_set_nogc_lazy.cpp

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