0573fbc30036e0d35d14d20a93c9e658d8aa548c
[libcds.git] / test / stress / sequential / sequential-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             typedef cds::atomicity::cache_friendly_item_counter item_counter;
190         };
191
192         typedef FeldmanHashSet< cds::gc::HP,  key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_hp_stdhash;
193         typedef FeldmanHashSet< cds::gc::DHP, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_dhp_stdhash;
194         typedef FeldmanHashSet< rcu_gpi, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_rcu_gpi_stdhash;
195         typedef FeldmanHashSet< rcu_gpb, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_rcu_gpb_stdhash;
196         typedef FeldmanHashSet< rcu_gpt, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_rcu_gpt_stdhash;
197 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
198         typedef FeldmanHashSet< rcu_shb, key_val<std::hash<key_type>>, default_traits >    FeldmanHashSet_rcu_shb_stdhash;
199 #endif
200
201         struct traits_FeldmanHashSet_stat: public cc::feldman_hashset::make_traits<
202                 co::type_traits< default_traits >,
203                 co::stat< cc::feldman_hashset::stat<>>
204             >::type
205         {};
206
207         typedef FeldmanHashSet< cds::gc::HP,  key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_hp_stdhash_stat;
208         typedef FeldmanHashSet< cds::gc::DHP, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_dhp_stdhash_stat;
209         typedef FeldmanHashSet< rcu_gpi, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_rcu_gpi_stdhash_stat;
210         typedef FeldmanHashSet< rcu_gpb, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_rcu_gpb_stdhash_stat;
211         typedef FeldmanHashSet< rcu_gpt, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_rcu_gpt_stdhash_stat;
212 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
213         typedef FeldmanHashSet< rcu_shb, key_val<std::hash<key_type>>, traits_FeldmanHashSet_stat >    FeldmanHashSet_rcu_shb_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 #endif
230
231         struct traits_FeldmanHashSet_city64_stat : public traits_FeldmanHashSet_city64
232         {
233             typedef cc::feldman_hashset::stat<> stat;
234         };
235         typedef FeldmanHashSet< cds::gc::HP,  key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_hp_city64_stat;
236         typedef FeldmanHashSet< cds::gc::DHP, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_dhp_city64_stat;
237         typedef FeldmanHashSet< rcu_gpi, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_rcu_gpi_city64_stat;
238         typedef FeldmanHashSet< rcu_gpb, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_rcu_gpb_city64_stat;
239         typedef FeldmanHashSet< rcu_gpt, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_rcu_gpt_city64_stat;
240 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
241         typedef FeldmanHashSet< rcu_shb, key_val<::cds_test::city64>, traits_FeldmanHashSet_city64_stat >    FeldmanHashSet_rcu_shb_city64_stat;
242 #endif
243
244         struct traits_FeldmanHashSet_city128 : public default_traits
245         {
246             typedef ::cds_test::city128::less less;
247         };
248         typedef FeldmanHashSet< cds::gc::HP,  key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_hp_city128;
249         typedef FeldmanHashSet< cds::gc::DHP, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_dhp_city128;
250         typedef FeldmanHashSet< rcu_gpi, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_rcu_gpi_city128;
251         typedef FeldmanHashSet< rcu_gpb, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_rcu_gpb_city128;
252         typedef FeldmanHashSet< rcu_gpt, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_rcu_gpt_city128;
253 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
254         typedef FeldmanHashSet< rcu_shb, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128 >    FeldmanHashSet_rcu_shb_city128;
255 #endif
256
257         struct traits_FeldmanHashSet_city128_stat : public traits_FeldmanHashSet_city128
258         {
259             typedef cc::feldman_hashset::stat<> stat;
260         };
261         typedef FeldmanHashSet< cds::gc::HP,  key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_hp_city128_stat;
262         typedef FeldmanHashSet< cds::gc::DHP, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_dhp_city128_stat;
263         typedef FeldmanHashSet< rcu_gpi, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_rcu_gpi_city128_stat;
264         typedef FeldmanHashSet< rcu_gpb, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_rcu_gpb_city128_stat;
265         typedef FeldmanHashSet< rcu_gpt, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_rcu_gpt_city128_stat;
266 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
267         typedef FeldmanHashSet< rcu_shb, key_val<::cds_test::city128>, traits_FeldmanHashSet_city128_stat >    FeldmanHashSet_rcu_shb_city128_stat;
268 #endif
269
270 #endif // #if CDS_BUILD_BITS == 64
271
272
273         // for fixed-sized key
274         // No hash function is necessary
275
276         struct fixed_sized_key
277         {
278             typedef typename set_type_base< Key, Val >::key_type key_type;
279             struct key_val : public set_type_base< Key, Val >::key_val
280             {
281                 typedef typename set_type_base< Key, Val >::key_val base_class;
282
283                 explicit key_val(key_type const& k) : base_class(k) {}
284                 key_val(key_type const& k, value_type const& v) : base_class(k, v) {}
285
286                 template <typename K>
287                 explicit key_val(K const& k) : base_class(k) {}
288
289                 template <typename K, typename T>
290                 key_val(K const& k, T const& v) : base_class(k, v) {}
291
292                 // mock hasher
293                 struct hasher {
294                 template <typename Q>
295                     key_type operator()( Q const& k ) const
296                     {
297                         return key_type( k );
298                     }
299
300                     key_type const& operator()( key_val const& kv ) const
301                     {
302                         return kv.key;
303                     }
304
305                     key_type const& operator()( key_type const& k ) const
306                     {
307                         return k;
308                     }
309                 };
310             };
311
312             struct traits : public cc::feldman_hashset::traits
313             {
314                 struct hash_accessor {
315                     key_type const& operator()( key_val const& kv ) const
316                     {
317                         return kv.key;
318                     }
319
320                     key_type const& operator()( key_type const& k ) const
321                     {
322                         return k;
323                     }
324                 };
325
326                 typedef set::cmp<Key>   compare;
327                 typedef cds::atomicity::cache_friendly_item_counter item_counter;
328             };
329
330             struct traits_stat : public traits
331             {
332                 typedef cc::feldman_hashset::stat<> stat;
333             };
334         };
335
336         typedef FeldmanHashSet< cds::gc::HP, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >  FeldmanHashSet_hp_fixed;
337         typedef FeldmanHashSet< cds::gc::DHP, typename fixed_sized_key::key_val, typename fixed_sized_key::traits > FeldmanHashSet_dhp_fixed;
338         typedef FeldmanHashSet< rcu_gpi, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >    FeldmanHashSet_rcu_gpi_fixed;
339         typedef FeldmanHashSet< rcu_gpb, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >    FeldmanHashSet_rcu_gpb_fixed;
340         typedef FeldmanHashSet< rcu_gpt, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >    FeldmanHashSet_rcu_gpt_fixed;
341 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
342         typedef FeldmanHashSet< rcu_shb, typename fixed_sized_key::key_val, typename fixed_sized_key::traits >    FeldmanHashSet_rcu_shb_fixed;
343 #endif
344
345         typedef FeldmanHashSet< cds::gc::HP, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_hp_fixed_stat;
346         typedef FeldmanHashSet< cds::gc::DHP, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_dhp_fixed_stat;
347         typedef FeldmanHashSet< rcu_gpi, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_rcu_gpi_fixed_stat;
348         typedef FeldmanHashSet< rcu_gpb, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_rcu_gpb_fixed_stat;
349         typedef FeldmanHashSet< rcu_gpt, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_rcu_gpt_fixed_stat;
350 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
351         typedef FeldmanHashSet< rcu_shb, typename fixed_sized_key::key_val, typename fixed_sized_key::traits_stat >    FeldmanHashSet_rcu_shb_fixed_stat;
352 #endif
353
354     };
355
356     template <typename GC, typename T, typename Traits >
357     static inline void print_stat( cds_test::property_stream& o, FeldmanHashSet< GC, T, Traits > const& s )
358     {
359         std::vector< cds::intrusive::feldman_hashset::level_statistics > level_stat;
360         s.get_level_statistics( level_stat );
361
362         o << s.statistics()
363           << level_stat;
364     }
365 } // namespace set
366
367 #define CDSSTRESS_FeldmanHashSet_case( fixture, test_case, feldman_set_type, key_type, value_type ) \
368     TEST_F( fixture, feldman_set_type ) \
369     { \
370         typedef set::set_type< tag_FeldmanHashSet, key_type, value_type >::feldman_set_type set_type; \
371         test_case<set_type>(); \
372     }
373
374 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
375 #   define CDSSTRESS_FeldmanHashSet_fixed_SHRCU( fixture, test_case, key_type, value_type ) \
376         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_fixed,      key_type, value_type ) \
377
378 #   define CDSSTRESS_FeldmanHashSet_stdhash_SHRCU( fixture, test_case, key_type, value_type ) \
379         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_shb_stdhash,      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_city128,      key_type, value_type ) \
385
386 #   else
387 #       define CDSSTRESS_FeldmanHashSet_city_SHRCU( fixture, test_case, key_type, value_type )
388 #   endif
389
390 #else
391 #   define CDSSTRESS_FeldmanHashSet_fixed_SHRCU( fixture, test_case, key_type, value_type )
392 #   define CDSSTRESS_FeldmanHashSet_stdhash_SHRCU( fixture, test_case, key_type, value_type )
393 #   define CDSSTRESS_FeldmanHashSet_city_SHRCU( fixture, test_case, key_type, value_type )
394 #endif
395
396
397 #define CDSSTRESS_FeldmanHashSet_fixed_RCU( fixture, test_case, key_type, value_type ) \
398     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_fixed,        key_type, value_type ) \
399     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_fixed,        key_type, value_type ) \
400     //CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_fixed,        key_type, value_type ) \
401
402   //CDSSTRESS_FeldmanHashSet_fixed_SHRCU( fixture, test_case, key_type, value_type )
403
404 #define CDSSTRESS_FeldmanHashSet_fixed_HP( fixture, test_case, key_type, value_type ) \
405     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_fixed,             key_type, value_type ) \
406     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_fixed,            key_type, value_type ) \
407
408 #define CDSSTRESS_FeldmanHashSet_fixed( fixture, test_case, key_type, value_type ) \
409     CDSSTRESS_FeldmanHashSet_fixed_HP( fixture, test_case, key_type, value_type ) \
410     CDSSTRESS_FeldmanHashSet_fixed_RCU( fixture, test_case, key_type, value_type ) \
411
412 #define CDSSTRESS_FeldmanHashSet_stdhash_rcu_gpi( fixture, test_case, key_type, value_type ) \
413     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_stdhash,      key_type, value_type ) \
414
415 #define CDSSTRESS_FeldmanHashSet_stdhash_HP( fixture, test_case, key_type, value_type ) \
416     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_stdhash,           key_type, value_type ) \
417     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_stdhash,          key_type, value_type ) \
418
419 #define CDSSTRESS_FeldmanHashSet_stdhash_RCU( fixture, test_case, key_type, value_type ) \
420     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_stdhash,      key_type, value_type ) \
421     CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_stdhash,      key_type, value_type ) \
422
423     //CDSSTRESS_FeldmanHashSet_stdhash_SHRCU( fixture, test_case, key_type, value_type )
424
425 #define CDSSTRESS_FeldmanHashSet_stdhash( fixture, test_case, key_type, value_type ) \
426     CDSSTRESS_FeldmanHashSet_stdhash_HP( fixture, test_case, key_type, value_type ) \
427     CDSSTRESS_FeldmanHashSet_stdhash_RCU( fixture, test_case, key_type, value_type ) \
428
429 #if CDS_BUILD_BITS == 64
430 #   define CDSSTRESS_FeldmanHashSet_city_rcu_gpi( fixture, test_case, key_type, value_type ) \
431         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_city64,       key_type, value_type ) \
432         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpi_city128,      key_type, value_type ) \
433
434 #   define CDSSTRESS_FeldmanHashSet_city_HP( fixture, test_case, key_type, value_type ) \
435         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_city64,            key_type, value_type ) \
436         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_city64,           key_type, value_type ) \
437         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_hp_city128,           key_type, value_type ) \
438         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_dhp_city128,          key_type, value_type ) \
439
440 #   define CDSSTRESS_FeldmanHashSet_city_RCU( fixture, test_case, key_type, value_type ) \
441         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_city64,       key_type, value_type ) \
442         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_city64,       key_type, value_type ) \
443         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpb_city128,      key_type, value_type ) \
444         CDSSTRESS_FeldmanHashSet_case( fixture, test_case, FeldmanHashSet_rcu_gpt_city128,      key_type, value_type ) \
445
446         //CDSSTRESS_FeldmanHashSet_city_SHRCU( fixture, test_case, key_type, value_type )
447
448 #   define CDSSTRESS_FeldmanHashSet_city( fixture, test_case, key_type, value_type ) \
449         CDSSTRESS_FeldmanHashSet_city_HP( fixture, test_case, key_type, value_type ) \
450         CDSSTRESS_FeldmanHashSet_city_RCU( fixture, test_case, key_type, value_type ) \
451
452
453 #else
454 #   define CDSSTRESS_FeldmanHashSet_city_rcu_gpi( fixture, test_case, key_type, value_type )
455 #   define CDSSTRESS_FeldmanHashSet_city_HP( fixture, test_case, key_type, value_type )
456 #   define CDSSTRESS_FeldmanHashSet_city_RCU( fixture, test_case, key_type, value_type )
457 #   define CDSSTRESS_FeldmanHashSet_city( fixture, test_case, key_type, value_type )
458 #endif
459
460 #endif // #ifndef CDSUNIT_SET_TYPE_FELDMAN_HASHSET_H