tests/test-hdr/set/hdr_intrusive_feldman_hashset_rcu_gpt.cpp

   1 //$$CDS-header$$
   2
   3 #include "set/hdr_intrusive_feldman_hashset.h"
   4 #include <cds/urcu/general_threaded.h>
   5 #include <cds/intrusive/feldman_hashset_rcu.h>
   6 #include "unit/print_feldman_hashset_stat.h"
   7
   8 namespace set {
   9     namespace {
  10         typedef cds::urcu::gc<cds::urcu::general_threaded<>> rcu_type;
  11     } // namespace
  12
  13     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_nohash()
  14     {
  15         typedef size_t key_type;
  16
  17         struct traits : public ci::feldman_hashset::traits
  18         {
  19             typedef get_key<key_type> hash_accessor;
  20             typedef item_disposer disposer;
  21         };
  22         typedef ci::FeldmanHashSet< rcu_type, Item<key_type>, traits > set_type;
  23         static_assert(std::is_same< typename set_type::hash_type, size_t>::value, "set::hash_type != size_t!!!");
  24         test_rcu<set_type, nohash<key_type>>(4, 2);
  25
  26         typedef ci::FeldmanHashSet<
  27             rcu_type,
  28             Item<key_type>,
  29             typename ci::feldman_hashset::make_traits<
  30                 ci::feldman_hashset::hash_accessor< get_key<key_type>>
  31                 , ci::opt::disposer< item_disposer >
  32             >::type
  33         > set_type2;
  34         test_rcu<set_type2, nohash<key_type>>(4, 2);
  35     }
  36
  37     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_stdhash()
  38     {
  39         typedef size_t hash_type;
  40
  41         struct traits: public ci::feldman_hashset::traits
  42         {
  43             typedef get_hash<hash_type> hash_accessor;
  44             typedef item_disposer disposer;
  45         };
  46         typedef ci::FeldmanHashSet< rcu_type, Item<hash_type>, traits > set_type;
  47         static_assert(std::is_same< typename set_type::hash_type, size_t>::value, "set::hash_type != size_t!!!" );
  48         test_rcu<set_type, std::hash<hash_type>>(4, 2);
  49
  50         typedef ci::FeldmanHashSet<
  51             rcu_type,
  52             Item<hash_type>,
  53             typename ci::feldman_hashset::make_traits<
  54                 ci::feldman_hashset::hash_accessor< get_hash<hash_type>>
  55                 , ci::opt::disposer< item_disposer >
  56             >::type
  57         > set_type2;
  58         test_rcu<set_type2, std::hash<hash_type>>(4, 2);
  59     }
  60
  61     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_hash128()
  62     {
  63         typedef hash128 hash_type;
  64
  65         struct traits: public ci::feldman_hashset::traits
  66         {
  67             typedef get_hash<hash_type> hash_accessor;
  68             typedef item_disposer disposer;
  69             typedef hash128::less less;
  70         };
  71         typedef ci::FeldmanHashSet< rcu_type, Item<hash_type>, traits > set_type;
  72         static_assert(std::is_same< typename set_type::hash_type, hash_type>::value, "set::hash_type != hash128!!!" );
  73         test_rcu<set_type, hash128::make>(4, 2);
  74
  75         typedef ci::FeldmanHashSet<
  76             rcu_type,
  77             Item<hash_type>,
  78             typename ci::feldman_hashset::make_traits<
  79                 ci::feldman_hashset::hash_accessor< get_hash<hash_type>>
  80                 , ci::opt::disposer< item_disposer >
  81                 , ci::opt::less< hash_type::less >
  82             >::type
  83         > set_type2;
  84         test_rcu<set_type2, hash128::make>(4, 2);
  85     }
  86
  87     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_nohash_stat()
  88     {
  89         typedef size_t key_type;
  90
  91         struct traits : public ci::feldman_hashset::traits
  92         {
  93             typedef get_key<key_type> hash_accessor;
  94             typedef item_disposer disposer;
  95             typedef ci::feldman_hashset::stat<> stat;
  96         };
  97         typedef ci::FeldmanHashSet< rcu_type, Item<key_type>, traits > set_type;
  98         static_assert(std::is_same< typename set_type::hash_type, size_t>::value, "set::hash_type != size_t!!!");
  99         test_rcu<set_type, nohash<key_type>>(4, 2);
 100
 101         typedef ci::FeldmanHashSet<
 102             rcu_type,
 103             Item<key_type>,
 104             typename ci::feldman_hashset::make_traits<
 105             ci::feldman_hashset::hash_accessor< get_key<key_type>>
 106             , ci::opt::disposer< item_disposer >
 107             , co::stat< ci::feldman_hashset::stat<>>
 108             >::type
 109         > set_type2;
 110         test_rcu<set_type2, nohash<key_type>>(4, 2);
 111     }
 112
 113     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_stdhash_stat()
 114     {
 115         typedef size_t hash_type;
 116
 117         struct traits: public ci::feldman_hashset::traits
 118         {
 119             typedef get_hash<hash_type> hash_accessor;
 120             typedef item_disposer disposer;
 121             typedef ci::feldman_hashset::stat<> stat;
 122         };
 123         typedef ci::FeldmanHashSet< rcu_type, Item<hash_type>, traits > set_type;
 124         static_assert(std::is_same< typename set_type::hash_type, size_t>::value, "set::hash_type != size_t!!!" );
 125         test_rcu<set_type, std::hash<hash_type>>(4, 2);
 126
 127         typedef ci::FeldmanHashSet<
 128             rcu_type,
 129             Item<hash_type>,
 130             typename ci::feldman_hashset::make_traits<
 131                 ci::feldman_hashset::hash_accessor< get_hash<hash_type>>
 132                 , ci::opt::disposer< item_disposer >
 133                 ,co::stat< ci::feldman_hashset::stat<>>
 134             >::type
 135         > set_type2;
 136         test_rcu<set_type2, std::hash<hash_type>>(4, 2);
 137     }
 138
 139     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_hash128_stat()
 140     {
 141         typedef hash128 hash_type;
 142
 143         struct traits: public ci::feldman_hashset::traits
 144         {
 145             typedef get_hash<hash_type> hash_accessor;
 146             typedef item_disposer disposer;
 147             typedef hash128::cmp  compare;
 148             typedef ci::feldman_hashset::stat<> stat;
 149         };
 150         typedef ci::FeldmanHashSet< rcu_type, Item<hash_type>, traits > set_type;
 151         static_assert(std::is_same< typename set_type::hash_type, hash_type>::value, "set::hash_type != hash_type!!!" );
 152         test_rcu<set_type, hash_type::make>(4, 2);
 153
 154         typedef ci::FeldmanHashSet<
 155             rcu_type,
 156             Item<hash_type>,
 157             typename ci::feldman_hashset::make_traits<
 158                 ci::feldman_hashset::hash_accessor< get_hash<hash_type>>
 159                 , ci::opt::disposer< item_disposer >
 160                 ,co::stat< ci::feldman_hashset::stat<>>
 161                 ,co::compare< hash128::cmp >
 162             >::type
 163         > set_type2;
 164         test_rcu<set_type2, hash_type::make>(4, 2);
 165     }
 166
 167     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_nohash_5_3()
 168     {
 169         typedef size_t key_type;
 170
 171         struct traits : public ci::feldman_hashset::traits
 172         {
 173             typedef get_key<key_type> hash_accessor;
 174             typedef item_disposer disposer;
 175         };
 176         typedef ci::FeldmanHashSet< rcu_type, Item<key_type>, traits > set_type;
 177         static_assert(std::is_same< typename set_type::hash_type, size_t>::value, "set::hash_type != size_t!!!");
 178         test_rcu<set_type, nohash<key_type>>(5, 3);
 179
 180         typedef ci::FeldmanHashSet<
 181             rcu_type,
 182             Item<key_type>,
 183             typename ci::feldman_hashset::make_traits<
 184             ci::feldman_hashset::hash_accessor< get_key<key_type>>
 185             , ci::opt::disposer< item_disposer >
 186             >::type
 187         > set_type2;
 188         test_rcu<set_type2, nohash<key_type>>(5, 3);
 189     }
 190
 191     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_stdhash_5_3()
 192     {
 193         typedef size_t hash_type;
 194
 195         struct traits: public ci::feldman_hashset::traits
 196         {
 197             typedef get_hash<hash_type> hash_accessor;
 198             typedef item_disposer disposer;
 199         };
 200         typedef ci::FeldmanHashSet< rcu_type, Item<hash_type>, traits > set_type;
 201         static_assert(std::is_same< typename set_type::hash_type, size_t>::value, "set::hash_type != size_t!!!" );
 202         test_rcu<set_type, std::hash<hash_type>>(5, 3);
 203
 204         typedef ci::FeldmanHashSet<
 205             rcu_type,
 206             Item<hash_type>,
 207             typename ci::feldman_hashset::make_traits<
 208                 ci::feldman_hashset::hash_accessor< get_hash<hash_type>>
 209                 , ci::opt::disposer< item_disposer >
 210             >::type
 211         > set_type2;
 212         test_rcu<set_type2, std::hash<hash_type>>(5, 3);
 213     }
 214
 215     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_hash128_4_3()
 216     {
 217         typedef hash128 hash_type;
 218
 219         struct traits: public ci::feldman_hashset::traits
 220         {
 221             typedef get_hash<hash_type> hash_accessor;
 222             typedef item_disposer disposer;
 223             typedef co::v::sequential_consistent memory_model;
 224         };
 225         typedef ci::FeldmanHashSet< rcu_type, Item<hash_type>, traits > set_type;
 226         static_assert(std::is_same< typename set_type::hash_type, hash_type>::value, "set::hash_type != hash_type!!!" );
 227         test_rcu<set_type, hash128::make >(4, 3);
 228
 229         typedef ci::FeldmanHashSet<
 230             rcu_type,
 231             Item<hash_type>,
 232             typename ci::feldman_hashset::make_traits<
 233                 ci::feldman_hashset::hash_accessor< get_hash<hash_type>>
 234                 , ci::opt::disposer< item_disposer >
 235                 ,co::memory_model< co::v::sequential_consistent >
 236             >::type
 237         > set_type2;
 238         test_rcu<set_type2, hash128::make >(4, 3);
 239     }
 240
 241     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_nohash_5_3_stat()
 242     {
 243         typedef size_t key_type;
 244
 245         struct traits: public ci::feldman_hashset::traits
 246         {
 247             typedef get_key<key_type> hash_accessor;
 248             typedef item_disposer disposer;
 249             typedef ci::feldman_hashset::stat<> stat;
 250         };
 251         typedef ci::FeldmanHashSet< rcu_type, Item<key_type>, traits > set_type;
 252         static_assert(std::is_same< typename set_type::hash_type, size_t>::value, "set::hash_type != size_t!!!" );
 253         test_rcu<set_type, nohash<key_type>>(5, 3);
 254
 255         typedef ci::FeldmanHashSet<
 256             rcu_type,
 257             Item<key_type>,
 258             typename ci::feldman_hashset::make_traits<
 259                 ci::feldman_hashset::hash_accessor< get_key<key_type>>
 260                 , ci::opt::disposer< item_disposer >
 261                 ,co::stat< ci::feldman_hashset::stat<>>
 262             >::type
 263         > set_type2;
 264         test_rcu<set_type2, nohash<key_type>>(5, 3);
 265     }
 266
 267     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_stdhash_5_3_stat()
 268     {
 269         typedef size_t hash_type;
 270
 271         struct traits: public ci::feldman_hashset::traits
 272         {
 273             typedef get_hash<hash_type> hash_accessor;
 274             typedef item_disposer disposer;
 275             typedef ci::feldman_hashset::stat<> stat;
 276         };
 277         typedef ci::FeldmanHashSet< rcu_type, Item<hash_type>, traits > set_type;
 278         static_assert(std::is_same< typename set_type::hash_type, size_t>::value, "set::hash_type != size_t!!!" );
 279         test_rcu<set_type, std::hash<hash_type>>(5, 3);
 280
 281         typedef ci::FeldmanHashSet<
 282             rcu_type,
 283             Item<hash_type>,
 284             typename ci::feldman_hashset::make_traits<
 285                 ci::feldman_hashset::hash_accessor< get_hash<hash_type>>
 286                 , ci::opt::disposer< item_disposer >
 287                 ,co::stat< ci::feldman_hashset::stat<>>
 288             >::type
 289         > set_type2;
 290         test_rcu<set_type2, std::hash<hash_type>>(5, 3);
 291     }
 292
 293     void IntrusiveFeldmanHashSetHdrTest::rcu_gpt_hash128_4_3_stat()
 294     {
 295         typedef hash128 hash_type;
 296
 297         struct traits: public ci::feldman_hashset::traits
 298         {
 299             typedef get_hash<hash_type> hash_accessor;
 300             typedef item_disposer disposer;
 301             typedef ci::feldman_hashset::stat<> stat;
 302             typedef hash128::less less;
 303             typedef hash128::cmp compare;
 304         };
 305         typedef ci::FeldmanHashSet< rcu_type, Item<hash_type>, traits > set_type;
 306         static_assert(std::is_same< typename set_type::hash_type, hash_type>::value, "set::hash_type != hash_type!!!" );
 307         test_rcu<set_type, hash_type::make>(4, 3);
 308
 309         typedef ci::FeldmanHashSet<
 310             rcu_type,
 311             Item<hash_type>,
 312             typename ci::feldman_hashset::make_traits<
 313                 ci::feldman_hashset::hash_accessor< get_hash<hash_type>>
 314                 , ci::opt::disposer< item_disposer >
 315                 , co::stat< ci::feldman_hashset::stat<>>
 316                 , co::less< hash_type::less >
 317                 , co::compare< hash128::cmp >
 318             >::type
 319         > set_type2;
 320         test_rcu<set_type2, hash_type::make>(4, 3);
 321     }
 322
 323 } // namespace set