tests/test-hdr/set/hdr_intrusive_cuckoo_refinable_set.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_cuckoo_set.h"
  32 #include <cds/intrusive/cuckoo_set.h>
  33
  34 #include "set/intrusive_cuckoo_set_common.h"
  35 #include "../unit/print_cuckoo_stat.h"
  36
  37 namespace set {
  38
  39     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_equal()
  40     {
  41         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
  42         typedef ci::CuckooSet< item_type
  43             ,ci::cuckoo::make_traits<
  44                 co::hash< std::tuple< hash1, hash2 > >
  45                 ,co::mutex_policy< ci::cuckoo::refinable<> >
  46                 ,co::equal_to< equal_to<item_type> >
  47             >::type
  48         > set_type;
  49
  50         test_cuckoo<set_type>();
  51     }
  52
  53     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_equal()
  54     {
  55         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > >  item_type;
  56
  57         typedef ci::CuckooSet< item_type
  58             ,ci::cuckoo::make_traits<
  59                 ci::opt::hook< ci::cuckoo::base_hook<
  60                     ci::cuckoo::probeset_type< item_type::probeset_type >
  61                 > >
  62                 ,co::hash< std::tuple< hash1, hash2 > >
  63                 ,co::equal_to< equal_to<item_type> >
  64                 ,co::mutex_policy< ci::cuckoo::refinable<> >
  65             >::type
  66         > set_type;
  67
  68         test_cuckoo<set_type>();
  69     }
  70
  71     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_cmp()
  72     {
  73         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
  74
  75         typedef ci::CuckooSet< item_type
  76             ,ci::cuckoo::make_traits<
  77                 ci::opt::hook< ci::cuckoo::base_hook<
  78                     ci::cuckoo::probeset_type< item_type::probeset_type >
  79                 > >
  80                 ,co::mutex_policy< ci::cuckoo::refinable<> >
  81                 ,co::hash< std::tuple< hash1, hash2 > >
  82                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
  83             >::type
  84         > set_type;
  85
  86         test_cuckoo<set_type>();
  87     }
  88
  89     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmp()
  90     {
  91         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > >  item_type;
  92
  93         typedef ci::CuckooSet< item_type
  94             ,ci::cuckoo::make_traits<
  95                 ci::opt::hook< ci::cuckoo::base_hook<
  96                     ci::cuckoo::probeset_type< item_type::probeset_type >
  97                 > >
  98                 ,co::mutex_policy< ci::cuckoo::refinable<> >
  99                 ,co::hash< std::tuple< hash1, hash2 > >
 100                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 101             >::type
 102         > set_type;
 103
 104         test_cuckoo<set_type>();
 105     }
 106
 107     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_less()
 108     {
 109         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
 110
 111         typedef ci::CuckooSet< item_type
 112             ,ci::cuckoo::make_traits<
 113                 ci::opt::hook< ci::cuckoo::base_hook<
 114                     ci::cuckoo::probeset_type< item_type::probeset_type >
 115                 > >
 116                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 117                 ,co::hash< std::tuple< hash1, hash2 > >
 118                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 119             >::type
 120         > set_type;
 121
 122         test_cuckoo<set_type>();
 123     }
 124
 125     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_less()
 126     {
 127         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > >  item_type;
 128
 129         typedef ci::CuckooSet< item_type
 130             ,ci::cuckoo::make_traits<
 131                 ci::opt::hook< ci::cuckoo::base_hook<
 132                     ci::cuckoo::probeset_type< item_type::probeset_type >
 133                 > >
 134                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 135                 ,co::hash< std::tuple< hash1, hash2 > >
 136                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 137             >::type
 138         > set_type;
 139
 140         test_cuckoo<set_type>();
 141     }
 142
 143     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_cmpmix()
 144     {
 145         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
 146
 147         typedef ci::CuckooSet< item_type
 148             ,ci::cuckoo::make_traits<
 149                 ci::opt::hook< ci::cuckoo::base_hook<
 150                     ci::cuckoo::probeset_type< item_type::probeset_type >
 151                 > >
 152                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 153                 ,co::hash< std::tuple< hash1, hash2 > >
 154                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 155                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 156             >::type
 157         > set_type;
 158
 159         test_cuckoo<set_type>();
 160     }
 161
 162     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmpmix()
 163     {
 164         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 0 > >  item_type;
 165
 166         typedef ci::CuckooSet< item_type
 167             ,ci::cuckoo::make_traits<
 168                 ci::opt::hook< ci::cuckoo::base_hook<
 169                     ci::cuckoo::probeset_type< item_type::probeset_type >
 170                 > >
 171                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 172                 ,co::hash< std::tuple< hash1, hash2 > >
 173                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 174                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 175             >::type
 176         > set_type;
 177
 178         test_cuckoo<set_type>();
 179     }
 180
 181     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmpmix_stat()
 182     {
 183         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 0 > >  item_type;
 184
 185         typedef ci::CuckooSet< item_type
 186             ,ci::cuckoo::make_traits<
 187                 ci::opt::hook< ci::cuckoo::base_hook<
 188                     ci::cuckoo::probeset_type< item_type::probeset_type >
 189                 > >
 190                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 191                 ,co::hash< std::tuple< hash1, hash2 > >
 192                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 193                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 194                 ,co::stat< ci::cuckoo::stat >
 195             >::type
 196         > set_type;
 197
 198         unsigned int nProbesetSize = set_type::node_type::probeset_size ? set_type::node_type::probeset_size : 4;
 199         set_type s( 256, nProbesetSize, nProbesetSize / 2 );
 200         test_with( s );
 201         CPPUNIT_MSG( s.statistics() << s.mutex_policy_statistics() );
 202     }
 203
 204
 205     // base hook, store hash
 206     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_equal_storehash()
 207     {
 208         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 2 > >  item_type;
 209         typedef ci::CuckooSet< item_type
 210             ,ci::cuckoo::make_traits<
 211                 ci::opt::hook< ci::cuckoo::base_hook<
 212                     ci::cuckoo::probeset_type< item_type::probeset_type >
 213                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 214                 > >
 215                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 216                 ,co::hash< std::tuple< hash1, hash2 > >
 217                 ,co::equal_to< equal_to<item_type> >
 218             >::type
 219         > set_type;
 220
 221         test_cuckoo<set_type>();
 222     }
 223
 224     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_equal_storehash()
 225     {
 226         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > >  item_type;
 227
 228         typedef ci::CuckooSet< item_type
 229             ,ci::cuckoo::make_traits<
 230                 ci::opt::hook< ci::cuckoo::base_hook<
 231                     ci::cuckoo::probeset_type< item_type::probeset_type >
 232                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 233                 > >
 234                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 235                 ,co::hash< std::tuple< hash1, hash2 > >
 236                 ,co::equal_to< equal_to<item_type> >
 237             >::type
 238         > set_type;
 239
 240         test_cuckoo<set_type>();
 241     }
 242
 243     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_cmp_storehash()
 244     {
 245         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 2 > >  item_type;
 246
 247         typedef ci::CuckooSet< item_type
 248             ,ci::cuckoo::make_traits<
 249                 ci::opt::hook< ci::cuckoo::base_hook<
 250                     ci::cuckoo::probeset_type< item_type::probeset_type >
 251                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 252                 > >
 253                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 254                 ,co::hash< std::tuple< hash1, hash2 > >
 255                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 256             >::type
 257         > set_type;
 258
 259         test_cuckoo<set_type>();
 260     }
 261
 262     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmp_storehash()
 263     {
 264         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > >  item_type;
 265
 266         typedef ci::CuckooSet< item_type
 267             ,ci::cuckoo::make_traits<
 268                 ci::opt::hook< ci::cuckoo::base_hook<
 269                     ci::cuckoo::probeset_type< item_type::probeset_type >
 270                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 271                 > >
 272                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 273                 ,co::hash< std::tuple< hash1, hash2 > >
 274                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 275             >::type
 276         > set_type;
 277
 278         test_cuckoo<set_type>();
 279     }
 280
 281     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_less_storehash()
 282     {
 283         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 2 > >  item_type;
 284
 285         typedef ci::CuckooSet< item_type
 286             ,ci::cuckoo::make_traits<
 287                 ci::opt::hook< ci::cuckoo::base_hook<
 288                     ci::cuckoo::probeset_type< item_type::probeset_type >
 289                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 290                 > >
 291                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 292                 ,co::hash< std::tuple< hash1, hash2 > >
 293                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 294             >::type
 295         > set_type;
 296
 297         test_cuckoo<set_type>();
 298     }
 299
 300     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_less_storehash()
 301     {
 302         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > >  item_type;
 303
 304         typedef ci::CuckooSet< item_type
 305             ,ci::cuckoo::make_traits<
 306                 ci::opt::hook< ci::cuckoo::base_hook<
 307                     ci::cuckoo::probeset_type< item_type::probeset_type >
 308                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 309                 > >
 310                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 311                 ,co::hash< std::tuple< hash1, hash2 > >
 312                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 313             >::type
 314         > set_type;
 315
 316         test_cuckoo<set_type>();
 317     }
 318
 319     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_basehook_sort_cmpmix_storehash()
 320     {
 321         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::list, 2 > >  item_type;
 322
 323         typedef ci::CuckooSet< item_type
 324             ,ci::cuckoo::make_traits<
 325                 ci::opt::hook< ci::cuckoo::base_hook<
 326                     ci::cuckoo::probeset_type< item_type::probeset_type >
 327                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 328                 > >
 329                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 330                 ,co::hash< std::tuple< hash1, hash2 > >
 331                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 332                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 333             >::type
 334         > set_type;
 335
 336         test_cuckoo<set_type>();
 337     }
 338
 339     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_basehook_sort_cmpmix_storehash()
 340     {
 341         typedef IntrusiveCuckooSetHdrTest::base_item< ci::cuckoo::node< ci::cuckoo::vector<8>, 2 > >  item_type;
 342
 343         typedef ci::CuckooSet< item_type
 344             ,ci::cuckoo::make_traits<
 345                 ci::opt::hook< ci::cuckoo::base_hook<
 346                     ci::cuckoo::probeset_type< item_type::probeset_type >
 347                     ,ci::cuckoo::store_hash< item_type::hash_array_size >
 348                 > >
 349                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 350                 ,co::hash< std::tuple< hash1, hash2 > >
 351                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 352                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 353             >::type
 354         > set_type;
 355
 356         test_cuckoo<set_type>();
 357     }
 358
 359
 360     // Member hook
 361     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_equal()
 362     {
 363         typedef IntrusiveCuckooSetHdrTest::member_item< ci::cuckoo::node< ci::cuckoo::list, 0 > >  item_type;
 364         typedef ci::CuckooSet< item_type
 365             ,ci::cuckoo::make_traits<
 366                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember)> >
 367                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 368                 ,co::hash< std::tuple< hash1, hash2 > >
 369                 ,co::equal_to< equal_to<item_type> >
 370             >::type
 371         > set_type;
 372
 373         test_cuckoo<set_type>();
 374     }
 375
 376     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_equal()
 377     {
 378         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > node_type;
 379         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 380
 381         typedef ci::CuckooSet< item_type
 382             ,ci::cuckoo::make_traits<
 383                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 384                     ci::cuckoo::probeset_type< node_type::probeset_type >
 385                 > >
 386                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 387                 ,co::hash< std::tuple< hash1, hash2 > >
 388                 ,co::equal_to< equal_to<item_type> >
 389             >::type
 390         > set_type;
 391
 392         test_cuckoo<set_type>();
 393     }
 394
 395     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_cmp()
 396     {
 397         typedef ci::cuckoo::node< ci::cuckoo::list, 0 > node_type;
 398         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 399
 400         typedef ci::CuckooSet< item_type
 401             ,ci::cuckoo::make_traits<
 402                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 403                     ci::cuckoo::probeset_type< node_type::probeset_type >
 404                 > >
 405                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 406                 ,co::hash< std::tuple< hash1, hash2 > >
 407                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 408             >::type
 409         > set_type;
 410
 411         test_cuckoo<set_type>();
 412     }
 413
 414     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_cmp()
 415     {
 416         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > node_type;
 417         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 418
 419         typedef ci::CuckooSet< item_type
 420             ,ci::cuckoo::make_traits<
 421                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 422                     ci::cuckoo::probeset_type< node_type::probeset_type >
 423                 > >
 424                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 425                 ,co::hash< std::tuple< hash1, hash2 > >
 426                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 427             >::type
 428         > set_type;
 429
 430         test_cuckoo<set_type>();
 431     }
 432
 433     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_less()
 434     {
 435         typedef ci::cuckoo::node< ci::cuckoo::list, 0 > node_type;
 436         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 437
 438         typedef ci::CuckooSet< item_type
 439             ,ci::cuckoo::make_traits<
 440                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 441                     ci::cuckoo::probeset_type< node_type::probeset_type >
 442                 > >
 443                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 444                 ,co::hash< std::tuple< hash1, hash2 > >
 445                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 446             >::type
 447         > set_type;
 448
 449         test_cuckoo<set_type>();
 450     }
 451
 452     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_less()
 453     {
 454         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 0 > node_type;
 455         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 456
 457         typedef ci::CuckooSet< item_type
 458             ,ci::cuckoo::make_traits<
 459                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 460                     ci::cuckoo::probeset_type< node_type::probeset_type >
 461                 > >
 462                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 463                 ,co::hash< std::tuple< hash1, hash2 > >
 464                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 465             >::type
 466         > set_type;
 467
 468         test_cuckoo<set_type>();
 469     }
 470
 471     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_cmpmix()
 472     {
 473         typedef ci::cuckoo::node< ci::cuckoo::list, 0 > node_type;
 474         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 475
 476         typedef ci::CuckooSet< item_type
 477             ,ci::cuckoo::make_traits<
 478                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 479                     ci::cuckoo::probeset_type< node_type::probeset_type >
 480                 > >
 481                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 482                 ,co::hash< std::tuple< hash1, hash2 > >
 483                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 484                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 485             >::type
 486         > set_type;
 487
 488         test_cuckoo<set_type>();
 489     }
 490
 491     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_cmpmix()
 492     {
 493         typedef ci::cuckoo::node< ci::cuckoo::vector<8>, 0 > node_type;
 494         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 495
 496         typedef ci::CuckooSet< item_type
 497             ,ci::cuckoo::make_traits<
 498                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 499                     ci::cuckoo::probeset_type< node_type::probeset_type >
 500                 > >
 501                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 502                 ,co::hash< std::tuple< hash1, hash2 > >
 503                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 504                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 505             >::type
 506         > set_type;
 507
 508         test_cuckoo<set_type>();
 509     }
 510
 511
 512     // member hook, store hash
 513     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_equal_storehash()
 514     {
 515         typedef ci::cuckoo::node< ci::cuckoo::list, 2 > node_type;
 516         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 517         typedef ci::CuckooSet< item_type
 518             ,ci::cuckoo::make_traits<
 519                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 520                     ci::cuckoo::probeset_type< node_type::probeset_type >
 521                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 522                 > >
 523                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 524                 ,co::hash< std::tuple< hash1, hash2 > >
 525                 ,co::equal_to< equal_to<item_type> >
 526             >::type
 527         > set_type;
 528
 529         test_cuckoo<set_type>();
 530     }
 531
 532     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_equal_storehash()
 533     {
 534         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > node_type;
 535         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 536
 537         typedef ci::CuckooSet< item_type
 538             ,ci::cuckoo::make_traits<
 539                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 540                     ci::cuckoo::probeset_type< node_type::probeset_type >
 541                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 542                 > >
 543                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 544                 ,co::hash< std::tuple< hash1, hash2 > >
 545                 ,co::equal_to< equal_to<item_type> >
 546             >::type
 547         > set_type;
 548
 549         test_cuckoo<set_type>();
 550     }
 551
 552     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_cmp_storehash()
 553     {
 554         typedef ci::cuckoo::node< ci::cuckoo::list, 2 > node_type;
 555         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 556
 557         typedef ci::CuckooSet< item_type
 558             ,ci::cuckoo::make_traits<
 559                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 560                     ci::cuckoo::probeset_type< node_type::probeset_type >
 561                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 562                 > >
 563                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 564                 ,co::hash< std::tuple< hash1, hash2 > >
 565                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 566             >::type
 567         > set_type;
 568
 569         test_cuckoo<set_type>();
 570     }
 571
 572     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_cmp_storehash()
 573     {
 574         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > node_type;
 575         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 576
 577         typedef ci::CuckooSet< item_type
 578             ,ci::cuckoo::make_traits<
 579                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 580                     ci::cuckoo::probeset_type< node_type::probeset_type >
 581                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 582                 > >
 583                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 584                 ,co::hash< std::tuple< hash1, hash2 > >
 585                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 586             >::type
 587         > set_type;
 588
 589         test_cuckoo<set_type>();
 590     }
 591
 592     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_less_storehash()
 593     {
 594         typedef ci::cuckoo::node< ci::cuckoo::list, 2 > node_type;
 595         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 596
 597         typedef ci::CuckooSet< item_type
 598             ,ci::cuckoo::make_traits<
 599                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 600                     ci::cuckoo::probeset_type< node_type::probeset_type >
 601                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 602                 > >
 603                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 604                 ,co::hash< std::tuple< hash1, hash2 > >
 605                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 606             >::type
 607         > set_type;
 608
 609         test_cuckoo<set_type>();
 610     }
 611
 612     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_less_storehash()
 613     {
 614         typedef ci::cuckoo::node< ci::cuckoo::vector<4>, 2 > node_type;
 615         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 616
 617         typedef ci::CuckooSet< item_type
 618             ,ci::cuckoo::make_traits<
 619                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 620                     ci::cuckoo::probeset_type< node_type::probeset_type >
 621                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 622                 > >
 623                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 624                 ,co::hash< std::tuple< hash1, hash2 > >
 625                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 626             >::type
 627         > set_type;
 628
 629         test_cuckoo<set_type>();
 630     }
 631
 632     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_list_memberhook_sort_cmpmix_storehash()
 633     {
 634         typedef ci::cuckoo::node< ci::cuckoo::list, 2 > node_type;
 635         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 636
 637         typedef ci::CuckooSet< item_type
 638             ,ci::cuckoo::make_traits<
 639                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 640                     ci::cuckoo::probeset_type< node_type::probeset_type >
 641                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 642                 > >
 643                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 644                 ,co::hash< std::tuple< hash1, hash2 > >
 645                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 646                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 647             >::type
 648         > set_type;
 649
 650         test_cuckoo<set_type>();
 651     }
 652
 653     void IntrusiveCuckooSetHdrTest::Cuckoo_refinable_vector_memberhook_sort_cmpmix_storehash()
 654     {
 655         typedef ci::cuckoo::node< ci::cuckoo::vector<8>, 2 > node_type;
 656         typedef IntrusiveCuckooSetHdrTest::member_item< node_type >  item_type;
 657
 658         typedef ci::CuckooSet< item_type
 659             ,ci::cuckoo::make_traits<
 660                 ci::opt::hook< ci::cuckoo::member_hook< offsetof(item_type, hMember),
 661                     ci::cuckoo::probeset_type< node_type::probeset_type >
 662                     ,ci::cuckoo::store_hash< node_type::hash_array_size >
 663                 > >
 664                 ,co::mutex_policy< ci::cuckoo::refinable<> >
 665                 ,co::hash< std::tuple< hash1, hash2 > >
 666                 ,co::less< IntrusiveCuckooSetHdrTest::less<item_type> >
 667                 ,co::compare< IntrusiveCuckooSetHdrTest::cmp<item_type> >
 668             >::type
 669         > set_type;
 670
 671         test_cuckoo<set_type>();
 672     }
 673
 674 }   // namespace set