tests/unit/map2/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-2016
   5
   6     Source code repo: http://github.com/khizmax/libcds/
   7     Download: http://sourceforge.net/projects/libcds/files/
   8
   9     Redistribution and use in source and binary forms, with or without
  10     modification, are permitted provided that the following conditions are met:
  11
  12     * Redistributions of source code must retain the above copyright notice, this
  13       list of conditions and the following disclaimer.
  14
  15     * Redistributions in binary form must reproduce the above copyright notice,
  16       this list of conditions and the following disclaimer in the documentation
  17       and/or other materials provided with the distribution.
  18
  19     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  23     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  26     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 #ifndef CDSUNIT_MAP_TYPE_SPLIT_LIST_H
  32 #define CDSUNIT_MAP_TYPE_SPLIT_LIST_H
  33
  34 #include "map2/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/split_list_map.h>
  47 #include <cds/container/split_list_map_rcu.h>
  48 #include <cds/container/split_list_map_nogc.h>
  49
  50 #include "print_split_list_stat.h"
  51
  52 namespace map2 {
  53
  54     template <class GC, typename Key, typename T, typename Traits = cc::split_list::traits >
  55     class SplitListMap : public cc::SplitListMap< GC, Key, T, Traits >
  56     {
  57         typedef cc::SplitListMap< GC, Key, T, Traits > base_class;
  58     public:
  59         template <typename Config>
  60         SplitListMap( Config const& cfg)
  61             : base_class( cfg.c_nMapSize, cfg.c_nLoadFactor )
  62         {}
  63
  64         // for testing
  65         static CDS_CONSTEXPR bool const c_bExtractSupported = true;
  66         static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
  67         static CDS_CONSTEXPR bool const c_bEraseExactKey = false;
  68     };
  69
  70     template <typename Key, typename T, typename Traits >
  71     class SplitListMap< cds::gc::nogc, Key, T, Traits> : public cc::SplitListMap< cds::gc::nogc, Key, T, Traits >
  72     {
  73         typedef cc::SplitListMap< cds::gc::nogc, Key, T, Traits > base_class;
  74     public:
  75         template <typename Config>
  76         SplitListMap( Config const& cfg)
  77             : base_class( cfg.c_nMapSize, cfg.c_nLoadFactor )
  78         {}
  79
  80         template <typename K>
  81         bool insert( K const& key )
  82         {
  83             return base_class::insert( key ) != base_class::end();
  84         }
  85
  86         template <typename K, typename V>
  87         bool insert( K const& key, V const& val )
  88         {
  89             return base_class::insert( key, val ) != base_class::end();
  90         }
  91
  92         template <typename K, typename Func>
  93         bool insert_with( K const& key, Func func )
  94         {
  95             return base_class::insert_with( key, func ) != base_class::end();
  96         }
  97
  98         template <typename K>
  99         bool find( K const& key )
 100         {
 101             return base_class::find( key ) != base_class::end();
 102         }
 103
 104         void clear()
 105         {}
 106
 107         // for testing
 108         static CDS_CONSTEXPR bool const c_bExtractSupported = true;
 109         static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
 110     };
 111
 112     struct tag_SplitListMap;
 113
 114     template <typename Key, typename Value>
 115     struct map_type< tag_SplitListMap, Key, Value >: public map_type_base< Key, Value >
 116     {
 117         typedef map_type_base< Key, Value > base_class;
 118         typedef typename base_class::compare    compare;
 119         typedef typename base_class::less       less;
 120         typedef typename base_class::equal_to   equal_to;
 121         typedef typename base_class::key_hash   key_hash;
 122         typedef typename base_class::hash       hash;
 123
 124
 125         // ***************************************************************************
 126         // SplitListMap based on MichaelList
 127         struct traits_SplitList_Michael_dyn_cmp: public cc::split_list::make_traits<
 128                 cc::split_list::ordered_list<cc::michael_list_tag>
 129                 ,co::hash< hash >
 130                 ,cc::split_list::ordered_list_traits<
 131                     typename cc::michael_list::make_traits<
 132                         co::compare< compare >
 133                     >::type
 134                 >
 135             >::type
 136         {};
 137         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_HP_dyn_cmp;
 138         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_DHP_dyn_cmp;
 139         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_NOGC_dyn_cmp;
 140         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPI_dyn_cmp;
 141         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPB_dyn_cmp;
 142         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPT_dyn_cmp;
 143 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 144         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHB_dyn_cmp;
 145         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHT_dyn_cmp;
 146 #endif
 147
 148         struct traits_SplitList_Michael_dyn_cmp_stat : public traits_SplitList_Michael_dyn_cmp
 149         {
 150             typedef cc::split_list::stat<> stat;
 151         };
 152         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_HP_dyn_cmp_stat;
 153         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_DHP_dyn_cmp_stat;
 154         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_cmp_stat> SplitList_Michael_NOGC_dyn_cmp_stat;
 155         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPI_dyn_cmp_stat;
 156         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPB_dyn_cmp_stat;
 157         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPT_dyn_cmp_stat;
 158 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 159         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHB_dyn_cmp_stat;
 160         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHT_dyn_cmp_stat;
 161 #endif
 162
 163         struct traits_SplitList_Michael_dyn_cmp_seqcst: public cc::split_list::make_traits<
 164                 cc::split_list::ordered_list<cc::michael_list_tag>
 165                 ,co::hash< hash >
 166                 ,co::memory_model< co::v::sequential_consistent >
 167                 ,cc::split_list::ordered_list_traits<
 168                     typename cc::michael_list::make_traits<
 169                         co::compare< compare >
 170                         ,co::memory_model< co::v::sequential_consistent >
 171                     >::type
 172                 >
 173             >::type
 174         {};
 175         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_HP_dyn_cmp_seqcst;
 176         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_DHP_dyn_cmp_seqcst;
 177         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst> SplitList_Michael_NOGC_dyn_cmp_seqcst;
 178         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPI_dyn_cmp_seqcst;
 179         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPB_dyn_cmp_seqcst;
 180         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPT_dyn_cmp_seqcst;
 181 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 182         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHB_dyn_cmp_seqcst;
 183         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHT_dyn_cmp_seqcst;
 184 #endif
 185
 186         struct traits_SplitList_Michael_st_cmp: public cc::split_list::make_traits<
 187                 cc::split_list::ordered_list<cc::michael_list_tag>
 188                 ,cc::split_list::dynamic_bucket_table< false >
 189                 ,co::hash< hash >
 190                 ,cc::split_list::ordered_list_traits<
 191                     typename cc::michael_list::make_traits<
 192                         co::compare< compare >
 193                     >::type
 194                 >
 195             >::type
 196         {};
 197         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_HP_st_cmp;
 198         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_DHP_st_cmp;
 199         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_cmp> SplitList_Michael_NOGC_st_cmp;
 200         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPI_st_cmp;
 201         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPB_st_cmp;
 202         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPT_st_cmp;
 203 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 204         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHB_st_cmp;
 205         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHT_st_cmp;
 206 #endif
 207
 208         struct traits_SplitList_Michael_st_cmp_seqcst: public cc::split_list::make_traits<
 209                 cc::split_list::ordered_list<cc::michael_list_tag>
 210                 ,co::hash< hash >
 211                 ,cc::split_list::dynamic_bucket_table< false >
 212                 ,co::memory_model< co::v::sequential_consistent >
 213                 ,cc::split_list::ordered_list_traits<
 214                     typename cc::michael_list::make_traits<
 215                         co::compare< compare >
 216                         ,co::memory_model< co::v::sequential_consistent >
 217                     >::type
 218                 >
 219             >::type
 220         {};
 221         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_HP_st_cmp_seqcst;
 222         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_DHP_st_cmp_seqcst;
 223         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_NOGC_st_cmp_seqcst;
 224         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_GPI_st_cmp_seqcst;
 225         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_GPB_st_cmp_seqcst;
 226         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_GPT_st_cmp_seqcst;
 227 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 228         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_SHB_st_cmp_seqcst;
 229         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_SHT_st_cmp_seqcst;
 230 #endif
 231
 232         //HP + less
 233         struct traits_SplitList_Michael_dyn_less: public cc::split_list::make_traits<
 234                 cc::split_list::ordered_list<cc::michael_list_tag>
 235                 ,co::hash< hash >
 236                 ,cc::split_list::ordered_list_traits<
 237                     typename cc::michael_list::make_traits<
 238                         co::less< less >
 239                     >::type
 240                 >
 241             >::type
 242         {};
 243         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_HP_dyn_less;
 244         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_DHP_dyn_less;
 245         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_less> SplitList_Michael_NOGC_dyn_less;
 246         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPI_dyn_less;
 247         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPB_dyn_less;
 248         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPT_dyn_less;
 249 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 250         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHB_dyn_less;
 251         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHT_dyn_less;
 252 #endif
 253
 254
 255         struct traits_SplitList_Michael_dyn_less_seqcst: public cc::split_list::make_traits<
 256                 cc::split_list::ordered_list<cc::michael_list_tag>
 257                 ,co::hash< hash >
 258                 ,co::memory_model< co::v::sequential_consistent >
 259                 ,cc::split_list::ordered_list_traits<
 260                     typename cc::michael_list::make_traits<
 261                         co::less< less >
 262                         ,co::memory_model< co::v::sequential_consistent >
 263                     >::type
 264                 >
 265             >::type
 266         {};
 267         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_HP_dyn_less_seqcst;
 268         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_DHP_dyn_less_seqcst;
 269         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_less_seqcst> SplitList_Michael_NOGC_dyn_less_seqcst;
 270         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPI_dyn_less_seqcst;
 271         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPB_dyn_less_seqcst;
 272         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPT_dyn_less_seqcst;
 273 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 274         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHB_dyn_less_seqcst;
 275         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHT_dyn_less_seqcst;
 276 #endif
 277
 278         struct traits_SplitList_Michael_st_less: public cc::split_list::make_traits<
 279                 cc::split_list::ordered_list<cc::michael_list_tag>
 280                 ,cc::split_list::dynamic_bucket_table< false >
 281                 ,co::hash< hash >
 282                 ,cc::split_list::ordered_list_traits<
 283                     typename cc::michael_list::make_traits<
 284                         co::less< less >
 285                     >::type
 286                 >
 287             >::type
 288         {};
 289         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_HP_st_less;
 290         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_DHP_st_less;
 291         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_less> SplitList_Michael_NOGC_st_less;
 292         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPI_st_less;
 293         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPB_st_less;
 294         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPT_st_less;
 295 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 296         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHB_st_less;
 297         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHT_st_less;
 298 #endif
 299
 300         struct traits_SplitList_Michael_st_less_stat : traits_SplitList_Michael_st_less
 301         {
 302             typedef cc::split_list::stat<> stat;
 303         };
 304         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_HP_st_less_stat;
 305         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_DHP_st_less_stat;
 306         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_less_stat> SplitList_Michael_NOGC_st_less_stat;
 307         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPI_st_less_stat;
 308         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPB_st_less_stat;
 309         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPT_st_less_stat;
 310 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 311         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHB_st_less_stat;
 312         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHT_st_less_stat;
 313 #endif
 314
 315
 316         class traits_SplitList_Michael_st_less_seqcst: public cc::split_list::make_traits<
 317                 cc::split_list::ordered_list<cc::michael_list_tag>
 318                 ,co::hash< hash >
 319                 ,cc::split_list::dynamic_bucket_table< false >
 320                 ,co::memory_model< co::v::sequential_consistent >
 321                 ,cc::split_list::ordered_list_traits<
 322                     typename cc::michael_list::make_traits<
 323                         co::less< less >
 324                         ,co::memory_model< co::v::sequential_consistent >
 325                     >::type
 326                 >
 327             >::type
 328         {};
 329         typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_HP_st_less_seqcst;
 330         typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_DHP_st_less_seqcst;
 331         typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_less_seqcst> SplitList_Michael_NOGC_st_less_seqcst;
 332         typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPI_st_less_seqcst;
 333         typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPB_st_less_seqcst;
 334         typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPT_st_less_seqcst;
 335 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 336         typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHB_st_less_seqcst;
 337         typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHT_st_less_seqcst;
 338 #endif
 339
 340
 341         // ***************************************************************************
 342         // SplitListMap based on LazyKVList
 343
 344         struct SplitList_Lazy_dyn_cmp :
 345             public cc::split_list::make_traits<
 346                 cc::split_list::ordered_list<cc::lazy_list_tag>
 347                 ,co::hash< hash >
 348                 ,cc::split_list::ordered_list_traits<
 349                     typename cc::lazy_list::make_traits<
 350                         co::compare< compare >
 351                     >::type
 352                 >
 353             >::type
 354         {};
 355         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_HP_dyn_cmp;
 356         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_DHP_dyn_cmp;
 357         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_cmp> SplitList_Lazy_NOGC_dyn_cmp;
 358         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPI_dyn_cmp;
 359         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPB_dyn_cmp;
 360         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPT_dyn_cmp;
 361 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 362         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp;
 363         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp;
 364 #endif
 365
 366         struct SplitList_Lazy_dyn_cmp_stat : public SplitList_Lazy_dyn_cmp
 367         {
 368             typedef cc::split_list::stat<> stat;
 369         };
 370         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_HP_dyn_cmp_stat;
 371         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_DHP_dyn_cmp_stat;
 372         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_cmp_stat> SplitList_Lazy_NOGC_dyn_cmp_stat;
 373         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPI_dyn_cmp_stat;
 374         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPB_dyn_cmp_stat;
 375         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPT_dyn_cmp_stat;
 376 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 377         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_SHB_dyn_cmp_stat;
 378         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_SHT_dyn_cmp_stat;
 379 #endif
 380
 381         struct SplitList_Lazy_dyn_cmp_seqcst :
 382             public cc::split_list::make_traits<
 383                 cc::split_list::ordered_list<cc::lazy_list_tag>
 384                 ,co::hash< hash >
 385                 ,co::memory_model< co::v::sequential_consistent >
 386                 ,cc::split_list::ordered_list_traits<
 387                     typename cc::lazy_list::make_traits<
 388                         co::compare< compare >
 389                         ,co::memory_model< co::v::sequential_consistent >
 390                     >::type
 391                 >
 392             >::type
 393         {};
 394         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_HP_dyn_cmp_seqcst;
 395         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_DHP_dyn_cmp_seqcst;
 396         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_cmp_seqcst> SplitList_Lazy_NOGC_dyn_cmp_seqcst;
 397         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPI_dyn_cmp_seqcst;
 398         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPB_dyn_cmp_seqcst;
 399         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPT_dyn_cmp_seqcst;
 400 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 401         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHB_dyn_cmp_seqcst;
 402         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHT_dyn_cmp_seqcst;
 403 #endif
 404
 405         struct SplitList_Lazy_st_cmp :
 406             public cc::split_list::make_traits<
 407                 cc::split_list::ordered_list<cc::lazy_list_tag>
 408                 ,cc::split_list::dynamic_bucket_table< false >
 409                 ,co::hash< hash >
 410                 ,cc::split_list::ordered_list_traits<
 411                     typename cc::lazy_list::make_traits<
 412                         co::compare< compare >
 413                     >::type
 414                 >
 415             >::type
 416         {};
 417         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_HP_st_cmp;
 418         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_DHP_st_cmp;
 419         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_cmp> SplitList_Lazy_NOGC_st_cmp;
 420         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPI_st_cmp;
 421         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPB_st_cmp;
 422         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPT_st_cmp;
 423 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 424         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHB_st_cmp;
 425         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHT_st_cmp;
 426 #endif
 427
 428
 429         struct SplitList_Lazy_st_cmp_seqcst :
 430             public cc::split_list::make_traits<
 431                 cc::split_list::ordered_list<cc::lazy_list_tag>
 432                 ,co::hash< hash >
 433                 ,cc::split_list::dynamic_bucket_table< false >
 434                 ,co::memory_model< co::v::sequential_consistent >
 435                 ,cc::split_list::ordered_list_traits<
 436                     typename cc::lazy_list::make_traits<
 437                         co::compare< compare >
 438                         ,co::memory_model< co::v::sequential_consistent >
 439                     >::type
 440                 >
 441             >::type
 442         {};
 443         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_HP_st_cmp_seqcst;
 444         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_DHP_st_cmp_seqcst;
 445         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_NOGC_st_cmp_seqcst;
 446         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_GPI_st_cmp_seqcst;
 447         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_GPB_st_cmp_seqcst;
 448         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_GPT_st_cmp_seqcst;
 449 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 450         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_SHB_st_cmp_seqcst;
 451         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_SHT_st_cmp_seqcst;
 452 #endif
 453
 454
 455         struct SplitList_Lazy_dyn_less :
 456             public cc::split_list::make_traits<
 457                 cc::split_list::ordered_list<cc::lazy_list_tag>
 458                 ,co::hash< hash >
 459                 ,cc::split_list::ordered_list_traits<
 460                     typename cc::lazy_list::make_traits<
 461                         co::less< less >
 462                     >::type
 463                 >
 464             >::type
 465         {};
 466         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_HP_dyn_less;
 467         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_DHP_dyn_less;
 468         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_less> SplitList_Lazy_NOGC_dyn_less;
 469         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPI_dyn_less;
 470         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPB_dyn_less;
 471         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPT_dyn_less;
 472 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 473         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHB_dyn_less;
 474         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHT_dyn_less;
 475 #endif
 476
 477         struct SplitList_Lazy_dyn_less_seqcst:
 478             public cc::split_list::make_traits<
 479                 cc::split_list::ordered_list<cc::lazy_list_tag>
 480                 ,co::hash< hash >
 481                 ,co::memory_model< co::v::sequential_consistent >
 482                 ,cc::split_list::ordered_list_traits<
 483                     typename cc::lazy_list::make_traits<
 484                         co::less< less >
 485                         ,co::memory_model< co::v::sequential_consistent >
 486                     >::type
 487                 >
 488             >::type
 489         {};
 490         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_HP_dyn_less_seqcst;
 491         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_DHP_dyn_less_seqcst;
 492         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_less_seqcst> SplitList_Lazy_NOGC_dyn_less_seqcst;
 493         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPI_dyn_less_seqcst;
 494         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPB_dyn_less_seqcst;
 495         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPT_dyn_less_seqcst;
 496 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 497         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHB_dyn_less_seqcst;
 498         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHT_dyn_less_seqcst;
 499 #endif
 500
 501         struct SplitList_Lazy_st_less :
 502             public cc::split_list::make_traits<
 503                 cc::split_list::ordered_list<cc::lazy_list_tag>
 504                 ,cc::split_list::dynamic_bucket_table< false >
 505                 ,co::hash< hash >
 506                 ,cc::split_list::ordered_list_traits<
 507                     typename cc::lazy_list::make_traits<
 508                         co::less< less >
 509                     >::type
 510                 >
 511             >::type
 512         {};
 513         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_HP_st_less;
 514         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_DHP_st_less;
 515         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_less> SplitList_Lazy_NOGC_st_less;
 516         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPI_st_less;
 517         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPB_st_less;
 518         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPT_st_less;
 519 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 520         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHB_st_less;
 521         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHT_st_less;
 522 #endif
 523
 524         struct SplitList_Lazy_st_less_stat : public SplitList_Lazy_st_less
 525         {
 526             typedef cc::split_list::stat<> stat;
 527         };
 528         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_HP_st_less_stat;
 529         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_DHP_st_less_stat;
 530         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_less_stat> SplitList_Lazy_NOGC_st_less_stat;
 531         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPI_st_less_stat;
 532         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPB_st_less_stat;
 533         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPT_st_less_stat;
 534 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 535         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHB_st_less_stat;
 536         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHT_st_less_stat;
 537 #endif
 538
 539         struct SplitList_Lazy_st_less_seqcst :
 540             public cc::split_list::make_traits<
 541                 cc::split_list::ordered_list<cc::lazy_list_tag>
 542                 ,co::hash< hash >
 543                 ,cc::split_list::dynamic_bucket_table< false >
 544                 ,co::memory_model< co::v::sequential_consistent >
 545                 ,cc::split_list::ordered_list_traits<
 546                     typename cc::lazy_list::make_traits<
 547                         co::less< less >
 548                         ,co::memory_model< co::v::sequential_consistent >
 549                     >::type
 550                 >
 551             >::type
 552         {};
 553         typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_HP_st_less_seqcst;
 554         typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_DHP_st_less_seqcst;
 555         typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_less_seqcst> SplitList_Lazy_NOGC_st_less_seqcst;
 556         typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPI_st_less_seqcst;
 557         typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPB_st_less_seqcst;
 558         typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPT_st_less_seqcst;
 559 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 560         typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHB_st_less_seqcst;
 561         typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHT_st_less_seqcst;
 562 #endif
 563     };
 564
 565     template <typename GC, typename K, typename T, typename Traits >
 566     static inline void print_stat( SplitListMap< GC, K, T, Traits > const& m )
 567     {
 568         CPPUNIT_MSG( m.statistics() );
 569     }
 570
 571 }   // namespace map2
 572
 573 #endif // ifndef CDSUNIT_MAP_TYPE_SPLIT_LIST_H