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