test/stress/sequential/sequential-set/set_type_split_list.h

   1 /*
   2     This file is a part of libcds - Concurrent Data Structures library
   3
   4     (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017
   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 #ifndef CDSUNIT_SET_TYPE_SPLIT_LIST_H
  32 #define CDSUNIT_SET_TYPE_SPLIT_LIST_H
  33
  34 #include "set_type.h"
  35
  36 #include <cds/container/michael_list_hp.h>
  37 #include <cds/container/michael_list_dhp.h>
  38 #include <cds/container/michael_list_rcu.h>
  39 #include <cds/container/lazy_list_hp.h>
  40 #include <cds/container/lazy_list_dhp.h>
  41 #include <cds/container/lazy_list_rcu.h>
  42 #include <cds/container/iterable_list_hp.h>
  43 #include <cds/container/iterable_list_dhp.h>
  44
  45 #include <cds/container/split_list_set.h>
  46 #include <cds/container/split_list_set_rcu.h>
  47
  48 #include <cds_test/stat_splitlist_out.h>
  49 #include <cds_test/stat_michael_list_out.h>
  50 #include <cds_test/stat_lazy_list_out.h>
  51 #include <cds_test/stat_iterable_list_out.h>
  52
  53 namespace set {
  54
  55     template <typename GC, typename T, typename Traits = cc::split_list::traits>
  56     class SplitListSet : public cc::SplitListSet< GC, T, Traits >
  57     {
  58         typedef cc::SplitListSet< GC, T, Traits > base_class;
  59     public:
  60         template <typename Config>
  61         SplitListSet( Config const& cfg )
  62             : base_class( cfg.s_nSetSize, cfg.s_nLoadFactor )
  63         {}
  64
  65         template <typename Iterator>
  66         typename std::enable_if< std::is_same< Iterator, typename base_class::iterator>::value, Iterator>::type
  67         get_begin()
  68         {
  69             return base_class::begin();
  70         }
  71
  72         template <typename Iterator>
  73         typename std::enable_if< std::is_same< Iterator, typename base_class::iterator>::value, Iterator>::type
  74         get_end()
  75         {
  76             return base_class::end();
  77         }
  78
  79         // for testing
  80         static CDS_CONSTEXPR bool const c_bExtractSupported = true;
  81         static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
  82         static CDS_CONSTEXPR bool const c_bEraseExactKey = false;
  83     };
  84
  85     struct tag_SplitListSet;
  86
  87     template <typename Key, typename Val>
  88     struct set_type< tag_SplitListSet, Key, Val >: public set_type_base< Key, Val >
  89     {
  90         typedef set_type_base< Key, Val > base_class;
  91         typedef typename base_class::key_val key_val;
  92         typedef typename base_class::compare compare;
  93         typedef typename base_class::less less;
  94         typedef typename base_class::hash hash;
  95
  96         // ***************************************************************************
  97         // SplitListSet based on MichaelList
  98
  99         struct traits_SplitList_Michael_dyn_cmp :
 100             public cc::split_list::make_traits<
 101                 cc::split_list::ordered_list<cc::michael_list_tag>
 102                 ,co::hash< hash >
 103                 ,co::item_counter<cds::atomicity::cache_friendly_item_counter >
 104                 ,cc::split_list::ordered_list_traits<
 105                     typename cc::michael_list::make_traits<
 106                         co::compare< compare >
 107                     >::type
 108                 >
 109             >::type
 110         {};
 111         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_HP_dyn_cmp;
 112         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_DHP_dyn_cmp;
 113         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPI_dyn_cmp;
 114         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPB_dyn_cmp;
 115         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPT_dyn_cmp;
 116 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 117         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHB_dyn_cmp;
 118 #endif
 119
 120         struct traits_SplitList_Michael_dyn_cmp_swar: public traits_SplitList_Michael_dyn_cmp
 121         {
 122             typedef cds::algo::bit_reversal::swar bit_reversal;
 123         };
 124         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_swar > SplitList_Michael_HP_dyn_cmp_swar;
 125         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_swar > SplitList_Michael_DHP_dyn_cmp_swar;
 126         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_swar > SplitList_Michael_RCU_GPI_dyn_cmp_swar;
 127         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_swar > SplitList_Michael_RCU_GPB_dyn_cmp_swar;
 128         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_swar > SplitList_Michael_RCU_GPT_dyn_cmp_swar;
 129 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 130         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_swar > SplitList_Michael_RCU_SHB_dyn_cmp_swar;
 131 #endif
 132
 133         struct traits_SplitList_Michael_dyn_cmp_stat :
 134             public cc::split_list::make_traits<
 135                 cc::split_list::ordered_list<cc::michael_list_tag>
 136                 ,co::hash< hash >
 137                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 138                 ,co::stat< cc::split_list::stat<> >
 139                 ,cc::split_list::ordered_list_traits<
 140                     typename cc::michael_list::make_traits<
 141                         co::compare< compare >
 142                         ,co::stat< cc::michael_list::stat<>>
 143                     >::type
 144                 >
 145             >::type
 146         {};
 147         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_HP_dyn_cmp_stat;
 148         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_DHP_dyn_cmp_stat;
 149         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPI_dyn_cmp_stat;
 150         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPB_dyn_cmp_stat;
 151         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPT_dyn_cmp_stat;
 152 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 153         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHB_dyn_cmp_stat;
 154 #endif
 155
 156         struct traits_SplitList_Michael_dyn_cmp_seqcst :
 157             public cc::split_list::make_traits<
 158                 cc::split_list::ordered_list<cc::michael_list_tag>
 159                 ,co::hash< hash >
 160                 ,co::item_counter<cds::atomicity::cache_friendly_item_counter >
 161                 ,co::memory_model< co::v::sequential_consistent >
 162                 ,cc::split_list::ordered_list_traits<
 163                     typename cc::michael_list::make_traits<
 164                         co::compare< compare >
 165                         ,co::memory_model< co::v::sequential_consistent >
 166                     >::type
 167                 >
 168             >::type
 169         {};
 170         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_HP_dyn_cmp_seqcst;
 171         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_DHP_dyn_cmp_seqcst;
 172         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPI_dyn_cmp_seqcst;
 173         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPB_dyn_cmp_seqcst;
 174         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPT_dyn_cmp_seqcst;
 175 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 176         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHB_dyn_cmp_seqcst;
 177 #endif
 178
 179         struct traits_SplitList_Michael_st_cmp :
 180             public cc::split_list::make_traits<
 181                 cc::split_list::ordered_list<cc::michael_list_tag>
 182                 ,cc::split_list::dynamic_bucket_table< false >
 183                 ,co::hash< hash >
 184                 ,co::item_counter<cds::atomicity::cache_friendly_item_counter >
 185                 ,cc::split_list::ordered_list_traits<
 186                     typename cc::michael_list::make_traits<
 187                         co::compare< compare >
 188                     >::type
 189                 >
 190             >::type
 191         {};
 192         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_HP_st_cmp;
 193         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_DHP_st_cmp;
 194         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPI_st_cmp;
 195         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPB_st_cmp;
 196         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPT_st_cmp;
 197 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 198         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHB_st_cmp;
 199 #endif
 200
 201         //HP + less
 202         struct traits_SplitList_Michael_dyn_less :
 203             public cc::split_list::make_traits<
 204                 cc::split_list::ordered_list<cc::michael_list_tag>
 205                 ,co::hash< hash >
 206                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 207                 ,cc::split_list::ordered_list_traits<
 208                     typename cc::michael_list::make_traits<
 209                         co::less< less >
 210                     >::type
 211                 >
 212             >::type
 213         {};
 214         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_HP_dyn_less;
 215         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_DHP_dyn_less;
 216         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPI_dyn_less;
 217         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPB_dyn_less;
 218         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPT_dyn_less;
 219 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 220         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHB_dyn_less;
 221 #endif
 222
 223         struct traits_SplitList_Michael_st_less :
 224             public cc::split_list::make_traits<
 225                 cc::split_list::ordered_list<cc::michael_list_tag>
 226                 ,cc::split_list::dynamic_bucket_table< false >
 227                 ,co::hash< hash >
 228                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 229                 ,cc::split_list::ordered_list_traits<
 230                     typename cc::michael_list::make_traits<
 231                         co::less< less >
 232                     >::type
 233                 >
 234             >::type
 235         {};
 236         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Michael_st_less > SplitList_Michael_HP_st_less;
 237         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_DHP_st_less;
 238         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPI_st_less;
 239         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPB_st_less;
 240         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPT_st_less;
 241 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 242         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHB_st_less;
 243 #endif
 244
 245         struct traits_SplitList_Michael_st_less_stat :
 246             public cc::split_list::make_traits<
 247                 cc::split_list::ordered_list<cc::michael_list_tag>
 248                 ,cc::split_list::dynamic_bucket_table< false >
 249                 ,co::hash< hash >
 250                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 251                 ,co::stat< cc::split_list::stat<>>
 252                 ,cc::split_list::ordered_list_traits<
 253                     typename cc::michael_list::make_traits<
 254                         co::less< less >
 255                         ,co::stat< cc::michael_list::stat<>>
 256                     >::type
 257                 >
 258             >::type
 259         {};
 260         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_HP_st_less_stat;
 261         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_DHP_st_less_stat;
 262         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPI_st_less_stat;
 263         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPB_st_less_stat;
 264         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPT_st_less_stat;
 265 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 266         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHB_st_less_stat;
 267 #endif
 268
 269         // ***************************************************************************
 270         // SplitListSet based on LazyList
 271
 272         struct traits_SplitList_Lazy_dyn_cmp :
 273             public cc::split_list::make_traits<
 274                 cc::split_list::ordered_list<cc::lazy_list_tag>
 275                 ,co::hash< hash >
 276                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 277                 ,cc::split_list::ordered_list_traits<
 278                     typename cc::lazy_list::make_traits<
 279                         co::compare< compare >
 280                     >::type
 281                 >
 282             >::type
 283         {};
 284         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_HP_dyn_cmp;
 285         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_DHP_dyn_cmp;
 286         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPI_dyn_cmp;
 287         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPB_dyn_cmp;
 288         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPT_dyn_cmp;
 289 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 290         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp;
 291 #endif
 292
 293         struct traits_SplitList_Lazy_dyn_cmp_stat : public traits_SplitList_Lazy_dyn_cmp
 294         {
 295             typedef cc::split_list::stat<> stat;
 296             typedef typename cc::lazy_list::make_traits<
 297                 co::compare< compare >
 298                 , co::stat< cc::lazy_list::stat<>>
 299             >::type ordered_list_traits;
 300         };
 301         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_HP_dyn_cmp_stat;
 302         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_DHP_dyn_cmp_stat;
 303         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPI_dyn_cmp_stat;
 304         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPB_dyn_cmp_stat;
 305         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPT_dyn_cmp_stat;
 306 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 307         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp_stat;
 308 #endif
 309
 310         struct traits_SplitList_Lazy_dyn_cmp_seqcst :
 311             public cc::split_list::make_traits<
 312                 cc::split_list::ordered_list<cc::lazy_list_tag>
 313                 ,co::hash< hash >
 314                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 315                 ,co::memory_model< co::v::sequential_consistent >
 316                 ,cc::split_list::ordered_list_traits<
 317                     typename cc::lazy_list::make_traits<
 318                         co::compare< compare >
 319                         ,co::memory_model< co::v::sequential_consistent >
 320                     >::type
 321                 >
 322             >::type
 323         {};
 324         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_HP_dyn_cmp_seqcst;
 325         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_DHP_dyn_cmp_seqcst;
 326         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPI_dyn_cmp_seqcst;
 327         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPB_dyn_cmp_seqcst;
 328         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPT_dyn_cmp_seqcst;
 329 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 330         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHB_dyn_cmp_seqcst;
 331 #endif
 332
 333         struct traits_SplitList_Lazy_st_cmp :
 334             public cc::split_list::make_traits<
 335                 cc::split_list::ordered_list<cc::lazy_list_tag>
 336                 ,cc::split_list::dynamic_bucket_table< false >
 337                 ,co::hash< hash >
 338                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 339                 ,cc::split_list::ordered_list_traits<
 340                     typename cc::lazy_list::make_traits<
 341                         co::compare< compare >
 342                     >::type
 343                 >
 344             >::type
 345         {};
 346         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_HP_st_cmp;
 347         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_DHP_st_cmp;
 348         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPI_st_cmp;
 349         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPB_st_cmp;
 350         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPT_st_cmp;
 351 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 352         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHB_st_cmp;
 353 #endif
 354
 355         struct traits_SplitList_Lazy_dyn_less :
 356             public cc::split_list::make_traits<
 357                 cc::split_list::ordered_list<cc::lazy_list_tag>
 358                 ,co::hash< hash >
 359                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 360                 ,cc::split_list::ordered_list_traits<
 361                     typename cc::lazy_list::make_traits<
 362                         co::less< less >
 363                     >::type
 364                 >
 365             >::type
 366         {};
 367         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_HP_dyn_less;
 368         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_DHP_dyn_less;
 369         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPI_dyn_less;
 370         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPB_dyn_less;
 371         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPT_dyn_less;
 372 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 373         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHB_dyn_less;
 374 #endif
 375
 376         struct traits_SplitList_Lazy_st_less :
 377             public cc::split_list::make_traits<
 378                 cc::split_list::ordered_list<cc::lazy_list_tag>
 379                 ,cc::split_list::dynamic_bucket_table< false >
 380                 ,co::hash< hash >
 381                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 382                 ,cc::split_list::ordered_list_traits<
 383                     typename cc::lazy_list::make_traits<
 384                         co::less< less >
 385                     >::type
 386                 >
 387             >::type
 388         {};
 389         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_HP_st_less;
 390         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_DHP_st_less;
 391         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPI_st_less;
 392         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPB_st_less;
 393         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPT_st_less;
 394 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 395         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHB_st_less;
 396 #endif
 397
 398         struct traits_SplitList_Lazy_st_less_stat : public traits_SplitList_Lazy_st_less
 399         {
 400             typedef cc::split_list::stat<> stat;
 401             typedef typename cc::lazy_list::make_traits<
 402                 co::less< less >
 403                 , co::stat< cc::lazy_list::stat<>>
 404             >::type ordered_list_traits;
 405         };
 406         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_HP_st_less_stat;
 407         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_DHP_st_less_stat;
 408         typedef SplitListSet< rcu_gpi, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPI_st_less_stat;
 409         typedef SplitListSet< rcu_gpb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPB_st_less_stat;
 410         typedef SplitListSet< rcu_gpt, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPT_st_less_stat;
 411 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 412         typedef SplitListSet< rcu_shb, key_val, traits_SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHB_st_less_stat;
 413 #endif
 414
 415         // ***************************************************************************
 416         // SplitListSet based on IterableList
 417
 418         struct traits_SplitList_Iterable_dyn_cmp :
 419             public cc::split_list::make_traits<
 420                 cc::split_list::ordered_list<cc::iterable_list_tag>
 421                 ,co::hash< hash >
 422                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 423                 ,cc::split_list::ordered_list_traits<
 424                     typename cc::iterable_list::make_traits<
 425                         co::compare< compare >
 426                     >::type
 427                 >
 428             >::type
 429         {};
 430         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Iterable_dyn_cmp > SplitList_Iterable_HP_dyn_cmp;
 431         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Iterable_dyn_cmp > SplitList_Iterable_DHP_dyn_cmp;
 432
 433         struct traits_SplitList_Iterable_dyn_cmp_stat:
 434             public cc::split_list::make_traits<
 435                 cc::split_list::ordered_list<cc::iterable_list_tag>
 436                 ,co::hash< hash >
 437                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 438                 ,co::stat< cc::split_list::stat<> >
 439                 ,cc::split_list::ordered_list_traits<
 440                     typename cc::iterable_list::make_traits<
 441                         co::compare< compare >
 442                         ,co::stat< cc::iterable_list::stat<>>
 443                     >::type
 444                 >
 445             >::type
 446         {};
 447         typedef SplitListSet< cds::gc::HP, key_val, traits_SplitList_Iterable_dyn_cmp_stat > SplitList_Iterable_HP_dyn_cmp_stat;
 448         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Iterable_dyn_cmp_stat > SplitList_Iterable_DHP_dyn_cmp_stat;
 449
 450         struct traits_SplitList_Iterable_dyn_cmp_seqcst :
 451             public cc::split_list::make_traits<
 452                 cc::split_list::ordered_list<cc::iterable_list_tag>
 453                 ,co::hash< hash >
 454                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 455                 ,co::memory_model< co::v::sequential_consistent >
 456                 ,cc::split_list::ordered_list_traits<
 457                     typename cc::iterable_list::make_traits<
 458                         co::compare< compare >
 459                         ,co::memory_model< co::v::sequential_consistent >
 460                     >::type
 461                 >
 462             >::type
 463         {};
 464         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Iterable_dyn_cmp_seqcst > SplitList_Iterable_HP_dyn_cmp_seqcst;
 465         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Iterable_dyn_cmp_seqcst > SplitList_Iterable_DHP_dyn_cmp_seqcst;
 466
 467         struct traits_SplitList_Iterable_st_cmp :
 468             public cc::split_list::make_traits<
 469                 cc::split_list::ordered_list<cc::iterable_list_tag>
 470                 ,cc::split_list::dynamic_bucket_table< false >
 471                 ,co::hash< hash >
 472                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 473                 ,cc::split_list::ordered_list_traits<
 474                     typename cc::iterable_list::make_traits<
 475                         co::compare< compare >
 476                     >::type
 477                 >
 478             >::type
 479         {};
 480         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Iterable_st_cmp > SplitList_Iterable_HP_st_cmp;
 481         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Iterable_st_cmp > SplitList_Iterable_DHP_st_cmp;
 482
 483         //HP + less
 484         struct traits_SplitList_Iterable_dyn_less :
 485             public cc::split_list::make_traits<
 486                 cc::split_list::ordered_list<cc::iterable_list_tag>
 487                 ,co::hash< hash >
 488                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 489                 ,cc::split_list::ordered_list_traits<
 490                     typename cc::iterable_list::make_traits<
 491                         co::less< less >
 492                     >::type
 493                 >
 494             >::type
 495         {};
 496         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Iterable_dyn_less > SplitList_Iterable_HP_dyn_less;
 497         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Iterable_dyn_less > SplitList_Iterable_DHP_dyn_less;
 498
 499         struct traits_SplitList_Iterable_st_less :
 500             public cc::split_list::make_traits<
 501                 cc::split_list::ordered_list<cc::iterable_list_tag>
 502                 ,cc::split_list::dynamic_bucket_table< false >
 503                 ,co::hash< hash >
 504                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 505                 ,cc::split_list::ordered_list_traits<
 506                     typename cc::iterable_list::make_traits<
 507                         co::less< less >
 508                     >::type
 509                 >
 510             >::type
 511         {};
 512         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Iterable_st_less > SplitList_Iterable_HP_st_less;
 513         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Iterable_st_less > SplitList_Iterable_DHP_st_less;
 514
 515         struct traits_SplitList_Iterable_st_less_stat :
 516             public cc::split_list::make_traits<
 517                 cc::split_list::ordered_list<cc::iterable_list_tag>
 518                 ,cc::split_list::dynamic_bucket_table< false >
 519                 ,co::hash< hash >
 520                 , co::item_counter<cds::atomicity::cache_friendly_item_counter >
 521                 ,co::stat< cc::split_list::stat<>>
 522                 ,cc::split_list::ordered_list_traits<
 523                     typename cc::iterable_list::make_traits<
 524                         co::less< less >
 525                         ,co::stat< cc::iterable_list::stat<>>
 526                     >::type
 527                 >
 528             >::type
 529         {};
 530         typedef SplitListSet< cds::gc::HP,  key_val, traits_SplitList_Iterable_st_less_stat > SplitList_Iterable_HP_st_less_stat;
 531         typedef SplitListSet< cds::gc::DHP, key_val, traits_SplitList_Iterable_st_less_stat > SplitList_Iterable_DHP_st_less_stat;
 532
 533     };
 534
 535     template <typename GC, typename T, typename Traits>
 536     static inline void print_stat( cds_test::property_stream& o, SplitListSet<GC, T, Traits> const& s )
 537     {
 538         o << s.statistics()
 539           << cds_test::stat_prefix( "list_stat" )
 540           << s.list_statistics()
 541           << cds_test::stat_prefix( "" );
 542     }
 543
 544 } // namespace set
 545
 546
 547 #define CDSSTRESS_SplitListSet_case( fixture, test_case, splitlist_set_type, key_type, value_type ) \
 548     TEST_P( fixture, splitlist_set_type ) \
 549     { \
 550         typedef set::set_type< tag_SplitListSet, key_type, value_type >::splitlist_set_type set_type; \
 551         test_case<set_type>(); \
 552     }
 553
 554
 555 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 556
 557 #if defined(CDS_STRESS_TEST_LEVEL) && CDS_STRESS_TEST_LEVEL > 1
 558 #   define CDSSTRESS_SplitListSet_SHRCU_2( fixture, test_case, key_type, value_type ) \
 559
 560 #else
 561 #   define CDSSTRESS_SplitListSet_SHRCU_2( fixture, test_case, key_type, value_type )
 562 #endif
 563
 564 #if defined(CDS_STRESS_TEST_LEVEL) && CDS_STRESS_TEST_LEVEL == 1
 565 #   define CDSSTRESS_SplitListSet_SHRCU_1( fixture, test_case, key_type, value_type ) \
 566         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_SHT_dyn_cmp,         key_type, value_type ) \
 567         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_SHB_st_cmp,          key_type, value_type ) \
 568         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_SHB_dyn_less,        key_type, value_type ) \
 569         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_SHB_st_less,         key_type, value_type ) \
 570         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_SHT_dyn_cmp,            key_type, value_type ) \
 571         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_SHT_st_cmp,             key_type, value_type ) \
 572         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_SHB_dyn_less,           key_type, value_type ) \
 573         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_SHT_st_less,            key_type, value_type ) \
 574
 575 #else
 576 #   define CDSSTRESS_SplitListSet_SHRCU_1( fixture, test_case, key_type, value_type )
 577 #endif
 578
 579
 580 #   define CDSSTRESS_SplitListSet_SHRCU( fixture, test_case, key_type, value_type ) \
 581         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_SHB_dyn_cmp,         key_type, value_type ) \
 582         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_SHT_st_cmp,          key_type, value_type ) \
 583         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_SHT_dyn_less,        key_type, value_type ) \
 584         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_SHT_st_less,         key_type, value_type ) \
 585         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_SHB_dyn_cmp,            key_type, value_type ) \
 586         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_SHB_st_cmp,             key_type, value_type ) \
 587         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_SHT_dyn_less,           key_type, value_type ) \
 588         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_SHB_st_less,            key_type, value_type ) \
 589         CDSSTRESS_SplitListSet_SHRCU_1( fixture, test_case, key_type, value_type ) \
 590         CDSSTRESS_SplitListSet_SHRCU_2( fixture, test_case, key_type, value_type ) \
 591
 592 #else
 593 #   define CDSSTRESS_SplitListSet_SHRCU( fixture, test_case, key_type, value_type )
 594 #endif
 595
 596 #if defined(CDS_STRESS_TEST_LEVEL) && CDS_STRESS_TEST_LEVEL > 1
 597 #   define CDSSTRESS_SplitListSet_HP_2( fixture, test_case, key_type, value_type ) \
 598
 599 #   define CDSSTRESS_SplitListSet_RCU_2( fixture, test_case, key_type, value_type ) \
 600
 601 #else
 602 #   define CDSSTRESS_SplitListSet_HP_2( fixture, test_case, key_type, value_type )
 603 #   define CDSSTRESS_SplitListSet_RCU_2( fixture, test_case, key_type, value_type )
 604 #endif
 605
 606 #if defined(CDS_STRESS_TEST_LEVEL) && CDS_STRESS_TEST_LEVEL == 1
 607 #   define CDSSTRESS_SplitListSet_HP_1( fixture, test_case, key_type, value_type ) \
 608         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_DHP_dyn_cmp,             key_type, value_type ) \
 609         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_DHP_dyn_cmp_swar,        key_type, value_type ) \
 610         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_HP_st_cmp,               key_type, value_type ) \
 611         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_DHP_dyn_less,            key_type, value_type ) \
 612         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_HP_st_less,              key_type, value_type ) \
 613         \
 614         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_DHP_dyn_cmp,                key_type, value_type ) \
 615         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_DHP_st_cmp,                 key_type, value_type ) \
 616         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_HP_dyn_less,                key_type, value_type ) \
 617         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_DHP_st_less,                key_type, value_type ) \
 618
 619 #   define CDSSTRESS_SplitListSet_RCU_1( fixture, test_case, key_type, value_type ) \
 620         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPT_dyn_cmp_swar,    key_type, value_type ) \
 621         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPI_st_cmp,          key_type, value_type ) \
 622         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPT_st_cmp,          key_type, value_type ) \
 623         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPB_dyn_less,        key_type, value_type ) \
 624         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPI_st_less,         key_type, value_type ) \
 625         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPT_st_less,         key_type, value_type ) \
 626         \
 627         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPB_dyn_cmp,            key_type, value_type ) \
 628         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPB_st_cmp,             key_type, value_type ) \
 629         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPI_dyn_less,           key_type, value_type ) \
 630         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPT_dyn_less,           key_type, value_type ) \
 631         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPB_st_less,            key_type, value_type ) \
 632         \
 633         CDSSTRESS_SplitListSet_SHRCU( fixture, test_case, key_type, value_type )
 634
 635
 636 #else
 637 #   define CDSSTRESS_SplitListSet_HP_1( fixture, test_case, key_type, value_type )
 638 #   define CDSSTRESS_SplitListSet_RCU_1( fixture, test_case, key_type, value_type )
 639 #endif
 640
 641 #define CDSSTRESS_SplitListSet_HP( fixture, test_case, key_type, value_type ) \
 642     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_HP_dyn_cmp,              key_type, value_type ) \
 643     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_HP_dyn_cmp_swar,         key_type, value_type ) \
 644     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_DHP_st_cmp,              key_type, value_type ) \
 645     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_HP_dyn_less,             key_type, value_type ) \
 646     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_DHP_st_less,             key_type, value_type ) \
 647     \
 648     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_HP_dyn_cmp,                 key_type, value_type ) \
 649     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_HP_st_cmp,                  key_type, value_type ) \
 650     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_DHP_dyn_less,               key_type, value_type ) \
 651     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_HP_st_less,                 key_type, value_type ) \
 652     CDSSTRESS_SplitListSet_HP_1( fixture, test_case, key_type, value_type ) \
 653     CDSSTRESS_SplitListSet_HP_2( fixture, test_case, key_type, value_type ) \
 654
 655 #define CDSSTRESS_SplitListSet_RCU( fixture, test_case, key_type, value_type ) \
 656     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPI_dyn_cmp,         key_type, value_type ) \
 657     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPB_dyn_cmp,         key_type, value_type ) \
 658     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPB_dyn_cmp_swar,    key_type, value_type ) \
 659     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPT_dyn_cmp,         key_type, value_type ) \
 660     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPB_st_cmp,          key_type, value_type ) \
 661     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPI_dyn_less,        key_type, value_type ) \
 662     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPT_dyn_less,        key_type, value_type ) \
 663     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Michael_RCU_GPB_st_less,         key_type, value_type ) \
 664     \
 665     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPI_dyn_cmp,            key_type, value_type ) \
 666     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPT_dyn_cmp,            key_type, value_type ) \
 667     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPI_st_cmp,             key_type, value_type ) \
 668     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPT_st_cmp,             key_type, value_type ) \
 669     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPB_dyn_less,           key_type, value_type ) \
 670     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPI_st_less,            key_type, value_type ) \
 671     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Lazy_RCU_GPT_st_less,            key_type, value_type ) \
 672     CDSSTRESS_SplitListSet_RCU_1( fixture, test_case, key_type, value_type ) \
 673     CDSSTRESS_SplitListSet_RCU_2( fixture, test_case, key_type, value_type ) \
 674
 675 #define CDSSTRESS_SplitListSet( fixture, test_case, key_type, value_type ) \
 676     CDSSTRESS_SplitListSet_HP( fixture, test_case, key_type, value_type ) \
 677     CDSSTRESS_SplitListSet_RCU( fixture, test_case, key_type, value_type ) \
 678
 679 #if defined(CDS_STRESS_TEST_LEVEL) && CDS_STRESS_TEST_LEVEL > 0
 680 #   define CDSSTRESS_SplitListIterableSet_1( fixture, test_case, key_type, value_type ) \
 681         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Iterable_DHP_dyn_cmp,             key_type, value_type ) \
 682         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Iterable_HP_st_cmp,               key_type, value_type ) \
 683         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Iterable_DHP_dyn_less,            key_type, value_type ) \
 684         CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Iterable_HP_st_less,              key_type, value_type ) \
 685
 686 #else
 687 #   define CDSSTRESS_SplitListIterableSet_1( fixture, test_case, key_type, value_type )
 688 #endif
 689
 690 #define CDSSTRESS_SplitListIterableSet( fixture, test_case, key_type, value_type ) \
 691     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Iterable_HP_dyn_cmp,              key_type, value_type ) \
 692     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Iterable_DHP_st_cmp,              key_type, value_type ) \
 693     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Iterable_HP_dyn_less,             key_type, value_type ) \
 694     CDSSTRESS_SplitListSet_case( fixture, test_case, SplitList_Iterable_DHP_st_less,             key_type, value_type ) \
 695     CDSSTRESS_SplitListIterableSet_1( fixture, test_case, key_type, value_type )
 696
 697 #endif // #ifndef CDSUNIT_SET_TYPE_SPLIT_LIST_H