test/stress/sequential/sequential-map/map_type.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_MAP_TYPE_H
  32 #define CDSUNIT_MAP_TYPE_H
  33
  34 #include <cds/urcu/general_instant.h>
  35 #include <cds/urcu/general_buffered.h>
  36 #include <cds/urcu/general_threaded.h>
  37 #include <cds/urcu/signal_buffered.h>
  38
  39 #include <cds/sync/spinlock.h>
  40 #include <cds/opt/hash.h>
  41 #include <boost/functional/hash/hash.hpp>
  42
  43 #include <cds_test/stress_test.h>
  44 #include <cds_test/check_size.h>
  45
  46 namespace map {
  47     namespace cc = cds::container;
  48     namespace co = cds::opt;
  49
  50     typedef cds::urcu::gc< cds::urcu::general_instant_stripped >   rcu_gpi;
  51     typedef cds::urcu::gc< cds::urcu::general_buffered_stripped >  rcu_gpb;
  52     typedef cds::urcu::gc< cds::urcu::general_threaded_stripped >  rcu_gpt;
  53 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
  54     typedef cds::urcu::gc< cds::urcu::signal_buffered_stripped >  rcu_shb;
  55 #endif
  56
  57     template <typename Key>
  58     struct less;
  59
  60     template <typename Key>
  61     struct cmp {
  62         int operator ()(Key const& k1, Key const& k2) const
  63         {
  64             if ( less<Key>( k1, k2 ))
  65                 return -1;
  66             return less<Key>( k2, k1 ) ? 1 : 0;
  67         }
  68     };
  69
  70     template <typename Key>
  71     struct hash;
  72
  73 #define CDSUNIT_INT_COMPARE(t)  template <> struct cmp<t> { int operator()( t k1, t k2 ) const { return (int)(k1 - k2); } }
  74     CDSUNIT_INT_COMPARE(char);
  75     CDSUNIT_INT_COMPARE(unsigned char);
  76     CDSUNIT_INT_COMPARE(int);
  77     CDSUNIT_INT_COMPARE(unsigned int);
  78     CDSUNIT_INT_COMPARE(long);
  79     CDSUNIT_INT_COMPARE(unsigned long);
  80     CDSUNIT_INT_COMPARE(long long);
  81     CDSUNIT_INT_COMPARE(unsigned long long);
  82 #undef CDSUNIT_INT_COMPARE
  83
  84 #define CDSUNIT_INT_LESS(t)  template <> struct less<t> { bool operator()( t k1, t k2 ) const { return k1 < k2; } }
  85     CDSUNIT_INT_LESS( char );
  86     CDSUNIT_INT_LESS( unsigned char );
  87     CDSUNIT_INT_LESS( int );
  88     CDSUNIT_INT_LESS( unsigned int );
  89     CDSUNIT_INT_LESS( long );
  90     CDSUNIT_INT_LESS( unsigned long );
  91     CDSUNIT_INT_LESS( long long );
  92     CDSUNIT_INT_LESS( unsigned long long );
  93 #undef CDSUNIT_INT_LESS
  94
  95     template <>
  96     struct cmp<std::string>
  97     {
  98         int operator()(std::string const& s1, std::string const& s2)
  99         {
 100             return s1.compare( s2 );
 101         }
 102         int operator()(std::string const& s1, char const * s2)
 103         {
 104             return s1.compare( s2 );
 105         }
 106         int operator()(char const * s1, std::string const& s2)
 107         {
 108             return -s2.compare( s1 );
 109         }
 110     };
 111
 112     template <>
 113     struct less<std::string>
 114     {
 115         bool operator ()( std::string const& k1, std::string const& k2 ) const
 116         {
 117             return cmp<std::string>()(k1, k2) < 0;
 118         }
 119         bool operator ()( std::string const& k1, char const* k2 ) const
 120         {
 121             return cmp<std::string>()(k1, k2) < 0;
 122         }
 123         bool operator ()( char const* k1, std::string const& k2 ) const
 124         {
 125             return cmp<std::string>()(k1, k2) < 0;
 126         }
 127     };
 128
 129     template <typename T>
 130     struct hash
 131     {
 132         typedef size_t result_type;
 133         typedef T      argument_type;
 134
 135         size_t operator()( T const& k ) const
 136         {
 137             return std::hash<size_t>()(k.nKey);
 138         }
 139
 140         size_t operator()( size_t k ) const
 141         {
 142             return std::hash<size_t>()(k);
 143         }
 144     };
 145
 146     template <>
 147     struct hash<size_t>
 148     {
 149         typedef size_t result_type;
 150         typedef size_t argument_type;
 151
 152         size_t operator()( size_t k ) const
 153         {
 154             return std::hash<size_t>()(k);
 155         }
 156     };
 157
 158     template <>
 159     struct hash<std::string>
 160     {
 161         typedef size_t result_type;
 162         typedef std::string argument_type;
 163
 164         size_t operator()( std::string const& k ) const
 165         {
 166             return std::hash<std::string>()(k);
 167         }
 168     };
 169
 170     // forward
 171     template <typename ImplSelector, typename Key, typename Value>
 172     struct map_type;
 173
 174     template <typename Key, typename Value>
 175     struct map_type_base
 176     {
 177         typedef map::hash<Key>    key_hash;
 178         typedef map::less<Key>    key_less;
 179         typedef cmp<Key>          key_compare;
 180
 181         struct equal_to {
 182             bool operator()( Key const& k1, Key const& k2 ) const
 183             {
 184                 return key_compare()( k1, k2 ) == 0;
 185             }
 186         };
 187
 188         struct hash2: public key_hash
 189         {
 190             size_t operator()( Key const& k ) const
 191             {
 192                 size_t h = key_hash::operator ()( k );
 193                 size_t seed = ~h;
 194                 seed ^= h + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 195                 return seed;
 196             }
 197             template <typename Q>
 198             size_t operator()( Q const& k ) const
 199             {
 200                 size_t h = key_hash::operator ()( k );
 201                 size_t seed = ~h;
 202                 seed ^= h + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 203                 return seed;
 204             }
 205         };
 206     };
 207
 208     struct empty_stat {};
 209     static inline cds_test::property_stream& operator <<( cds_test::property_stream& o, empty_stat const& )
 210     {
 211         return o;
 212     }
 213
 214     template <typename Map>
 215     static inline void print_stat( cds_test::property_stream& o, Map const& m )
 216     {
 217         o << m.statistics();
 218     }
 219
 220
 221     template <typename Map>
 222     static inline void check_before_cleanup( Map& /*m*/ )
 223     {}
 224
 225     template <typename Map>
 226     static inline void additional_cleanup( Map& /*m*/ )
 227     {}
 228
 229     template <typename Map>
 230     static inline void additional_check( Map& /*m*/ )
 231     {}
 232
 233 } // namespace map
 234
 235 #endif // ifndef CDSUNIT_MAP_TYPE_H