test/stress/set/set_type_feldman_hashset.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_FELDMAN_HASHSET_H
  32 #define CDSUNIT_SET_TYPE_FELDMAN_HASHSET_H
  33
  34 #include "set/set_type.h"
  35
  36 #include <cds/container/feldman_hashset_hp.h>
  37 #include <cds/container/feldman_hashset_dhp.h>
  38 #include <cds/container/feldman_hashset_rcu.h>
  39
  40 #include <cds_test/stat_feldman_hashset_out.h>
  41 #include <cds_test/hash_func.h>
  42
  43 namespace set {
  44
  45     template <class GC, typename T, typename Traits = cc::feldman_hashset::traits>
  46     class FeldmanHashSet : public cc::FeldmanHashSet< GC, T, Traits >
  47     {
  48         typedef cc::FeldmanHashSet< GC, T, Traits > base_class;
  49
  50         template <typename GC>
  51         struct get_extracted_ptr
  52         {
  53             typedef typename base_class::guarded_ptr extracted_ptr;
  54         };
  55
  56         template <typename RCU>
  57         struct get_extracted_ptr<cds::urcu::gc<RCU>>
  58         {
  59             typedef typename base_class::exempt_ptr extracted_ptr;
  60         };
  61
  62     public:
  63         typedef typename T::hasher hasher;
  64         typedef typename get_extracted_ptr<GC>::extracted_ptr extracted_ptr;
  65
  66         template <typename OtherTraits>
  67         struct rebind_traits {
  68             typedef FeldmanHashSet<GC, T, OtherTraits > result;
  69         };
  70
  71         template <class Config>
  72         FeldmanHashSet( Config const& cfg )
  73             : base_class( cfg.s_nFeldmanSet_HeadBits, cfg.s_nFeldmanSet_ArrayBits )
  74         {}
  75
  76         template <typename Q>
  77         bool erase( Q const& key )
  78         {
  79             return base_class::erase( hasher()( key ));
  80         }
  81
  82         template <typename Q, typename Func>
  83         bool erase( Q const& key, Func f )
  84         {
  85             return base_class::erase( hasher()( key ), f );
  86         }
  87
  88         template <typename Q>
  89         extracted_ptr extract(Q const& key)
  90         {
  91             return base_class::extract( hasher()(key));
  92         }
  93
  94         template <typename Q>
  95         bool contains( Q const& key )
  96         {
  97             return base_class::contains( hasher()(key));
  98         }
  99
 100         template <typename Iterator>
 101         typename std::enable_if< std::is_same< Iterator, typename base_class::iterator>::value, Iterator>::type
 102         get_begin()
 103         {
 104             return base_class::begin();
 105         }
 106
 107         template <typename Iterator>
 108         typename std::enable_if< std::is_same< Iterator, typename base_class::iterator>::value, Iterator>::type
 109         get_end()
 110         {
 111             return base_class::end();
 112         }
 113
 114         template <typename Iterator>
 115         typename std::enable_if< std::is_same< Iterator, typename base_class::reverse_iterator>::value, Iterator>::type
 116         get_begin()
 117         {
 118             return base_class::rbegin();
 119         }
 120
 121         template <typename Iterator>
 122         typename std::enable_if< std::is_same< Iterator, typename base_class::reverse_iterator>::value, Iterator>::type
 123         get_end()
 124         {
 125             return base_class::rend();
 126         }
 127
 128         // for testing
 129         static CDS_CONSTEXPR bool const c_bExtractSupported = true;
 130         static CDS_CONSTEXPR bool const c_bLoadFactorDepended = false;
 131         static CDS_CONSTEXPR bool const c_bEraseExactKey = true;
 132     };
 133
 134     struct tag_FeldmanHashSet;
 135
 136     template <typename Key, typename Val>
 137     struct set_type< tag_FeldmanHashSet, Key, Val >: public set_type_base< Key, Val >
 138     {
 139         typedef set_type_base< Key, Val > base_class;
 140         typedef typename base_class::compare compare;
 141         typedef typename base_class::less less;
 142         typedef typename base_class::hash hash;
 143         typedef typename base_class::key_type   key_type;
 144         typedef typename base_class::value_type value_type;
 145
 146         template <typename Hasher>
 147         struct hash_type
 148         {
 149             typedef Hasher hasher;
 150             typedef typename hasher::hash_type type;
 151         };
 152
 153         template <typename TH>
 154         struct hash_type<std::hash<TH>>
 155         {
 156             typedef std::hash<TH> hasher;
 157             typedef size_t type;
 158         };
 159
 160         template <typename Hasher>
 161         struct key_val: base_class::key_val
 162         {
 163             typedef typename base_class::key_val base;
 164             typedef Hasher hasher;
 165             typedef typename hash_type<hasher>::type hash_type;
 166
 167             hash_type hash;
 168
 169             explicit key_val( key_type const& k ): base(k), hash( hasher()( k )) {}
 170             key_val( key_type const& k, value_type const& v ): base(k, v), hash( hasher()( k )) {}
 171
 172             template <typename K>
 173             explicit key_val( K const& k ): base(k), hash( hasher()( k )) {}
 174
 175             template <typename K, typename T>
 176             key_val( K const& k, T const& v ): base(k, v), hash( hasher()( k )) {}
 177         };
 178
 179         struct default_traits : public cc::feldman_hashset::traits
 180         {
 181             struct hash_accessor {
 182                 template <typename Hasher>
 183                 typename key_val<Hasher>::hash_type const& operator()( key_val<Hasher> const& kv )
 184                 {
 185                     return kv.hash;
 186                 }
 187             };
 188         };
 189
 190         typedef FeldmanHashSet< cds::gc::HP,  key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_hp_stdhash;
 191         typedef FeldmanHashSet< cds::gc::DHP, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_dhp_stdhash;
 192         typedef FeldmanHashSet< rcu_gpi, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_rcu_gpi_stdhash;
 193         typedef FeldmanHashSet< rcu_gpb, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_rcu_gpb_stdhash;
 194         typedef FeldmanHashSet< rcu_gpt, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_rcu_gpt_stdhash;
 195 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 196         typedef FeldmanHashSet< rcu_shb, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_rcu_shb_stdhash;
 197         typedef FeldmanHashSet< rcu_sht, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_rcu_sht_stdhash;
 198 #endif
 199
 200         struct traits_FeldmanHashSet_stat: public cc::feldman_hashset::make_traits<
 201                 co::type_traits< default_traits >,
 202                 co::stat< cc::feldman_hashset::stat<>>
 203             >::type
 204         {};
 205
 206         typedef FeldmanHashSet< cds::gc::HP,  key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_hp_stdhash_stat;
 207         typedef FeldmanHashSet< cds::gc::DHP, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_dhp_stdhash_stat;
 208         typedef FeldmanHashSet< rcu_gpi, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_rcu_gpi_stdhash_stat;
 209         typedef FeldmanHashSet< rcu_gpb, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_rcu_gpb_stdhash_stat;
 210         typedef FeldmanHashSet< rcu_gpt, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_rcu_gpt_stdhash_stat;
 211 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 212         typedef FeldmanHashSet< rcu_shb, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_rcu_shb_stdhash_stat;
 213         typedef FeldmanHashSet< rcu_sht, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_rcu_sht_stdhash_stat;
 214 #endif
 215
 216         // CityHash
 217 #if CDS_BUILD_BITS == 64
 218         struct traits_FeldmanHashSet_city64 : public default_traits
 219         {
 220             typedef ::cds_test::city64::less less;
 221         };
 222         typedef FeldmanHashSet< cds::gc::HP,  key_val<::cds_test::city64>, traits_FeldmanHashSet_city64 >    FeldmanHashSet_hp_city64;
 223         typedef FeldmanHashSet< cds::gc::DHP, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64 >    FeldmanHashSet_dhp_city64;
 224         typedef FeldmanHashSet< rcu_gpi, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64 >    FeldmanHashSet_rcu_gpi_city64;
 225         typedef FeldmanHashSet< rcu_gpb, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64 >    FeldmanHashSet_rcu_gpb_city64;
 226         typedef FeldmanHashSet< rcu_gpt, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64 >    FeldmanHashSet_rcu_gpt_city64;
 227 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 228         typedef FeldmanHashSet< rcu_shb, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64 >    FeldmanHashSet_rcu_shb_city64;
 229         typedef FeldmanHashSet< rcu_sht, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64 >    FeldmanHashSet_rcu_sht_city64;
 230 #endif
 231
 232         struct traits_FeldmanHashSet_city64_stat : public traits_FeldmanHashSet_city64
 233         {
 234             typedef cc::feldman_hashset::stat<> stat;
 235         };
 236         typedef FeldmanHashSet< cds::gc::HP,  key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_hp_city64_stat;
 237         typedef FeldmanHashSet< cds::gc::DHP, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_dhp_city64_stat;
 238         typedef FeldmanHashSet< rcu_gpi, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_rcu_gpi_city64_stat;
 239         typedef FeldmanHashSet< rcu_gpb, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_rcu_gpb_city64_stat;
 240         typedef FeldmanHashSet< rcu_gpt, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_rcu_gpt_city64_stat;
 241 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 242         typedef FeldmanHashSet< rcu_shb, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_rcu_shb_city64_stat;
 243         typedef FeldmanHashSet< rcu_sht, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_rcu_sht_city64_stat;
 244 #endif
 245
 246         struct traits_FeldmanHashSet_city128 : public default_traits
 247         {
 248             typedef ::cds_test::city128::less less;
 249         };
 250         typedef FeldmanHashSet< cds::gc::HP,  key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_hp_city128;
 251         typedef FeldmanHashSet< cds::gc::DHP, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_dhp_city128;
 252         typedef FeldmanHashSet< rcu_gpi, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_rcu_gpi_city128;
 253         typedef FeldmanHashSet< rcu_gpb, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_rcu_gpb_city128;
 254         typedef FeldmanHashSet< rcu_gpt, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_rcu_gpt_city128;
 255 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 256         typedef FeldmanHashSet< rcu_shb, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_rcu_shb_city128;
 257         typedef FeldmanHashSet< rcu_sht, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_rcu_sht_city128;
 258 #endif
 259
 260         struct traits_FeldmanHashSet_city128_stat : public traits_FeldmanHashSet_city128
 261         {
 262             typedef cc::feldman_hashset::stat<> stat;
 263         };
 264         typedef FeldmanHashSet< cds::gc::HP,  key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_hp_city128_stat;
 265         typedef FeldmanHashSet< cds::gc::DHP, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_dhp_city128_stat;
 266         typedef FeldmanHashSet< rcu_gpi, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_rcu_gpi_city128_stat;
 267         typedef FeldmanHashSet< rcu_gpb, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_rcu_gpb_city128_stat;
 268         typedef FeldmanHashSet< rcu_gpt, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_rcu_gpt_city128_stat;
 269 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 270         typedef FeldmanHashSet< rcu_shb, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_rcu_shb_city128_stat;
 271         typedef FeldmanHashSet< rcu_sht, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_rcu_sht_city128_stat;
 272 #endif
 273
 274 #endif // #if CDS_BUILD_BITS == 64
 275
 276
 277         // for fixed-sized key
 278         // No hash function is necessary
 279
 280         struct fixed_sized_key
 281         {
 282             typedef typename set_type_base< Key, Val >::key_type key_type;
 283             struct key_val : public set_type_base< Key, Val >::key_val
 284             {
 285                 typedef typename set_type_base< Key, Val >::key_val base_class;
 286
 287                 explicit key_val(key_type const& k) : base_class(k) {}
 288                 key_val(key_type const& k, value_type const& v) : base_class(k, v) {}
 289
 290                 template <typename K>
 291                 explicit key_val(K const& k) : base_class(k) {}
 292
 293                 template <typename K, typename T>
 294                 key_val(K const& k, T const& v) : base_class(k, v) {}
 295
 296                 // mock hasher
 297                 struct hasher {
 298                 template <typename Q>
 299                     key_type operator()( Q const& k ) const
 300                     {
 301                         return key_type( k );
 302                     }
 303
 304                     key_type const& operator()( key_val const& kv ) const
 305                     {
 306                         return kv.key;
 307                     }
 308
 309                     key_type const& operator()( key_type const& k ) const
 310                     {
 311                         return k;
 312                     }
 313                 };
 314             };
 315
 316             struct traits : public cc::feldman_hashset::traits
 317             {
 318                 struct hash_accessor {
 319                     key_type const& operator()( key_val const& kv ) const
 320                     {
 321                         return kv.key;
 322                     }
 323
 324                     key_type const& operator()( key_type const& k ) const
 325                     {
 326                         return k;
 327                     }
 328                 };
 329
 330                 typedef set::cmp<Key>   compare;
 331             };
 332
 333             struct traits_stat : public traits
 334             {
 335                 typedef cc::feldman_hashset::stat<> stat;
 336             };
 337         };
 338
 339         typedef FeldmanHashSet< cds::gc::HP, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >  FeldmanHashSet_hp_fixed;
 340         typedef FeldmanHashSet< cds::gc::DHP, typename fixed_sized_key::key_val, typename fixed_sized_key::traits > FeldmanHashSet_dhp_fixed;
 341         typedef FeldmanHashSet< rcu_gpi, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >    FeldmanHashSet_rcu_gpi_fixed;
 342         typedef FeldmanHashSet< rcu_gpb, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >    FeldmanHashSet_rcu_gpb_fixed;
 343         typedef FeldmanHashSet< rcu_gpt, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >    FeldmanHashSet_rcu_gpt_fixed;
 344 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 345         typedef FeldmanHashSet< rcu_shb, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >    FeldmanHashSet_rcu_shb_fixed;
 346         typedef FeldmanHashSet< rcu_sht, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >    FeldmanHashSet_rcu_sht_fixed;
 347 #endif
 348
 349         typedef FeldmanHashSet< cds::gc::HP, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_hp_fixed_stat;
 350         typedef FeldmanHashSet< cds::gc::DHP, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_dhp_fixed_stat;
 351         typedef FeldmanHashSet< rcu_gpi, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_rcu_gpi_fixed_stat;
 352         typedef FeldmanHashSet< rcu_gpb, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_rcu_gpb_fixed_stat;
 353         typedef FeldmanHashSet< rcu_gpt, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_rcu_gpt_fixed_stat;
 354 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 355         typedef FeldmanHashSet< rcu_shb, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_rcu_shb_fixed_stat;
 356         typedef FeldmanHashSet< rcu_sht, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_rcu_sht_fixed_stat;
 357 #endif
 358
 359     };
 360
 361     template <typename GC, typename T, typename Traits >
 362     static inline void print_stat( cds_test::property_stream& o, FeldmanHashSet< GC, T, Traits > const& s )
 363     {
 364         std::vector< cds::intrusive::feldman_hashset::level_statistics > level_stat;
 365         s.get_level_statistics( level_stat );
 366
 367         o << s.statistics()
 368           << level_stat;
 369     }
 370 } // namespace set
 371
 372 #define CDSSTRESS_FeldmanHashSet_case( fixture, test_case, feldman_set_type, key_type, value_type ) \
 373     TEST_F( fixture, feldman_set_type ) \
 374     { \
 375         typedef set::set_type< tag_FeldmanHashSet, key_type, value_type >::feldman_set_type set_type; \
 376         test_case<set_type>(); \
 377     }
 378
 379 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 380 #   define CDSSTRESS_FeldmanHashSet_fixed_SHRCU( fixture, test_case, key_type, value_type ) \
 381         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_fixed,      key_type, value_type ) \
 382         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_sht_fixed,      key_type, value_type ) \
 383         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_fixed_stat, key_type, value_type ) \
 384         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_sht_fixed_stat, key_type, value_type )
 385
 386 #   define CDSSTRESS_FeldmanHashSet_stdhash_SHRCU( fixture, test_case, key_type, value_type ) \
 387         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_stdhash,      key_type, value_type ) \
 388         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_sht_stdhash,      key_type, value_type ) \
 389         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_stdhash_stat, key_type, value_type ) \
 390         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_sht_stdhash_stat, key_type, value_type )
 391
 392 #   if CDS_BUILD_BITS == 64
 393 #       define CDSSTRESS_FeldmanHashSet_city_SHRCU( fixture, test_case, key_type, value_type ) \
 394             CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_city64,       key_type, value_type ) \
 395             CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_sht_city64,       key_type, value_type ) \
 396             CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_city64_stat,  key_type, value_type ) \
 397             CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_sht_city64_stat,  key_type, value_type ) \
 398             CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_city128,      key_type, value_type ) \
 399             CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_sht_city128,      key_type, value_type ) \
 400             CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_city128_stat, key_type, value_type ) \
 401             CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_sht_city128_stat, key_type, value_type )
 402 #   else
 403 #       define CDSSTRESS_FeldmanHashSet_city_SHRCU( fixture, test_case, key_type, value_type )
 404 #   endif
 405
 406 #else
 407 #   define CDSSTRESS_FeldmanHashSet_fixed_SHRCU( fixture, test_case, key_type, value_type )
 408 #   define CDSSTRESS_FeldmanHashSet_stdhash_SHRCU( fixture, test_case, key_type, value_type )
 409 #   define CDSSTRESS_FeldmanHashSet_city_SHRCU( fixture, test_case, key_type, value_type )
 410 #endif
 411
 412
 413 #define CDSSTRESS_FeldmanHashSet_fixed_RCU( fixture, test_case, key_type, value_type ) \
 414     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_fixed,        key_type, value_type ) \
 415     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_fixed,        key_type, value_type ) \
 416     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_fixed,        key_type, value_type ) \
 417     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_fixed_stat,   key_type, value_type ) \
 418     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_fixed_stat,   key_type, value_type ) \
 419     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_fixed_stat,   key_type, value_type ) \
 420
 421     //CDSSTRESS_FeldmanHashSet_fixed_SHRCU( fixture, test_case, key_type, value_type ) \
 422
 423 #define CDSSTRESS_FeldmanHashSet_fixed_HP( fixture, test_case, key_type, value_type ) \
 424     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_fixed,             key_type, value_type ) \
 425     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_fixed,            key_type, value_type ) \
 426     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_fixed_stat,        key_type, value_type ) \
 427     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_fixed_stat,       key_type, value_type ) \
 428
 429 #define CDSSTRESS_FeldmanHashSet_fixed( fixture, test_case, key_type, value_type ) \
 430     CDSSTRESS_FeldmanHashSet_fixed_HP( fixture, test_case, key_type, value_type ) \
 431     CDSSTRESS_FeldmanHashSet_fixed_RCU( fixture, test_case, key_type, value_type ) \
 432
 433 #define CDSSTRESS_FeldmanHashSet_stdhash_rcu_gpi( fixture, test_case, key_type, value_type ) \
 434     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_stdhash,      key_type, value_type ) \
 435     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_stdhash_stat, key_type, value_type ) \
 436
 437 #define CDSSTRESS_FeldmanHashSet_stdhash_HP( fixture, test_case, key_type, value_type ) \
 438     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_stdhash,           key_type, value_type ) \
 439     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_stdhash,          key_type, value_type ) \
 440     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_stdhash_stat,      key_type, value_type ) \
 441     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_stdhash_stat,     key_type, value_type ) \
 442
 443 #define CDSSTRESS_FeldmanHashSet_stdhash_RCU( fixture, test_case, key_type, value_type ) \
 444     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_stdhash,      key_type, value_type ) \
 445     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_stdhash,      key_type, value_type ) \
 446     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_stdhash_stat, key_type, value_type ) \
 447     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_stdhash_stat, key_type, value_type ) \
 448
 449     //CDSSTRESS_FeldmanHashSet_stdhash_SHRCU( fixture, test_case, key_type, value_type )
 450
 451 #define CDSSTRESS_FeldmanHashSet_stdhash( fixture, test_case, key_type, value_type ) \
 452     CDSSTRESS_FeldmanHashSet_stdhash_HP( fixture, test_case, key_type, value_type ) \
 453     CDSSTRESS_FeldmanHashSet_stdhash_RCU( fixture, test_case, key_type, value_type ) \
 454
 455 #if CDS_BUILD_BITS == 64
 456 #   define CDSSTRESS_FeldmanHashSet_city_rcu_gpi( fixture, test_case, key_type, value_type ) \
 457         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_city64,       key_type, value_type ) \
 458         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_city64_stat,  key_type, value_type ) \
 459         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_city128,      key_type, value_type ) \
 460         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_city128_stat, key_type, value_type ) \
 461
 462 #   define CDSSTRESS_FeldmanHashSet_city_HP( fixture, test_case, key_type, value_type ) \
 463         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_city64,            key_type, value_type ) \
 464         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_city64,           key_type, value_type ) \
 465         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_city64_stat,       key_type, value_type ) \
 466         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_city64_stat,      key_type, value_type ) \
 467         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_city128,           key_type, value_type ) \
 468         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_city128,          key_type, value_type ) \
 469         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_city128_stat,      key_type, value_type ) \
 470         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_city128_stat,     key_type, value_type ) \
 471
 472 #   define CDSSTRESS_FeldmanHashSet_city_RCU( fixture, test_case, key_type, value_type ) \
 473         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_city64,       key_type, value_type ) \
 474         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_city64,       key_type, value_type ) \
 475         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_city64_stat,  key_type, value_type ) \
 476         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_city64_stat,  key_type, value_type ) \
 477         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_city128,      key_type, value_type ) \
 478         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_city128,      key_type, value_type ) \
 479         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_city128_stat, key_type, value_type ) \
 480         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_city128_stat, key_type, value_type ) \
 481
 482         //CDSSTRESS_FeldmanHashSet_city_SHRCU( fixture, test_case, key_type, value_type )
 483
 484 #   define CDSSTRESS_FeldmanHashSet_city( fixture, test_case, key_type, value_type ) \
 485         CDSSTRESS_FeldmanHashSet_city_HP( fixture, test_case, key_type, value_type ) \
 486         CDSSTRESS_FeldmanHashSet_city_RCU( fixture, test_case, key_type, value_type ) \
 487
 488
 489 #else
 490 #   define CDSSTRESS_FeldmanHashSet_city_rcu_gpi( fixture, test_case, key_type, value_type )
 491 #   define CDSSTRESS_FeldmanHashSet_city_HP( fixture, test_case, key_type, value_type )
 492 #   define CDSSTRESS_FeldmanHashSet_city_RCU( fixture, test_case, key_type, value_type )
 493 #   define CDSSTRESS_FeldmanHashSet_city( fixture, test_case, key_type, value_type )
 494 #endif
 495
 496 #endif // #ifndef CDSUNIT_SET_TYPE_FELDMAN_HASHSET_H