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