flat_hash_set test passing

parallel_hashmap/phmap_utils.h

@@ -34,7 +34,212 @@
 // limitations under the License.
 // ---------------------------------------------------------------------------
 
+//#include <cstddef>
+#include <functional>
+#define PHMAP_HASH_CLASS std::hash
 
+namespace phmap
+{
+
+template <class T>  T phmap_min(T a, T b) { return a < b  ? a : b; }
+template <class T>  T phmap_max(T a, T b) { return a >= b ? a : b; }
+
+template <class T>
+struct Hash
+{
+    inline size_t operator()(const T &__v) const noexcept
+    {
+        PHMAP_HASH_CLASS<T> hasher;
+        return hasher(__v);
+    }
+};
+
+template <class T>
+struct Hash<T *>
+{
+    static size_t spp_log2 (size_t val) noexcept
+    {
+        size_t res = 0;
+        while (val > 1)
+        {
+            val >>= 1;
+            res++;
+        }
+        return res;
+    }
+
+    inline size_t operator()(const T *__v) const noexcept
+    {
+        static const size_t shift = 3; // spp_log2(1 + sizeof(T)); // T might be incomplete!
+        const uintptr_t i = (const uintptr_t)__v;
+        return static_cast<size_t>(i >> shift);
+    }
+};
+
+// from http://burtleburtle.net/bob/hash/integer.html
+// fast and efficient for power of two table sizes where we always
+// consider the last bits.
+// ---------------------------------------------------------------
+inline size_t spp_mix_32(uint32_t a)
+{
+    a = a ^ (a >> 4);
+    a = (a ^ 0xdeadbeef) + (a << 5);
+    a = a ^ (a >> 11);
+    return static_cast<size_t>(a);
+}
+
+// More thorough scrambling as described in
+// https://gist.github.com/badboy/6267743
+// ----------------------------------------
+inline size_t spp_mix_64(uint64_t a)
+{
+    a = (~a) + (a << 21); // a = (a << 21) - a - 1;
+    a = a ^ (a >> 24);
+    a = (a + (a << 3)) + (a << 8); // a * 265
+    a = a ^ (a >> 14);
+    a = (a + (a << 2)) + (a << 4); // a * 21
+    a = a ^ (a >> 28);
+    a = a + (a << 31);
+    return static_cast<size_t>(a);
+}
+
+template<class ArgumentType, class ResultType>
+struct spp_unary_function
+{
+    typedef ArgumentType argument_type;
+    typedef ResultType result_type;
+};
+
+template <>
+struct Hash<bool> : public spp_unary_function<bool, size_t>
+{
+    inline size_t operator()(bool __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<char> : public spp_unary_function<char, size_t>
+{
+    inline size_t operator()(char __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<signed char> : public spp_unary_function<signed char, size_t>
+{
+    inline size_t operator()(signed char __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<unsigned char> : public spp_unary_function<unsigned char, size_t>
+{
+    inline size_t operator()(unsigned char __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<wchar_t> : public spp_unary_function<wchar_t, size_t>
+{
+    inline size_t operator()(wchar_t __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<int16_t> : public spp_unary_function<int16_t, size_t>
+{
+    inline size_t operator()(int16_t __v) const noexcept
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct Hash<uint16_t> : public spp_unary_function<uint16_t, size_t>
+{
+    inline size_t operator()(uint16_t __v) const noexcept
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct Hash<int32_t> : public spp_unary_function<int32_t, size_t>
+{
+    inline size_t operator()(int32_t __v) const noexcept
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct Hash<uint32_t> : public spp_unary_function<uint32_t, size_t>
+{
+    inline size_t operator()(uint32_t __v) const noexcept
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct Hash<int64_t> : public spp_unary_function<int64_t, size_t>
+{
+    inline size_t operator()(int64_t __v) const noexcept
+    { return spp_mix_64(static_cast<uint64_t>(__v)); }
+};
+
+template <>
+struct Hash<uint64_t> : public spp_unary_function<uint64_t, size_t>
+{
+    inline size_t operator()(uint64_t __v) const noexcept
+    { return spp_mix_64(static_cast<uint64_t>(__v)); }
+};
+
+template <>
+struct Hash<float> : public spp_unary_function<float, size_t>
+{
+    inline size_t operator()(float __v) const noexcept
+    {
+        // -0.0 and 0.0 should return same hash
+        uint32_t *as_int = reinterpret_cast<uint32_t *>(&__v);
+        return (__v == 0) ? static_cast<size_t>(0) : spp_mix_32(*as_int);
+    }
+};
+
+template <>
+struct Hash<double> : public spp_unary_function<double, size_t>
+{
+    inline size_t operator()(double __v) const noexcept
+    {
+        // -0.0 and 0.0 should return same hash
+        uint64_t *as_int = reinterpret_cast<uint64_t *>(&__v);
+        return (__v == 0) ? static_cast<size_t>(0) : spp_mix_64(*as_int);
+    }
+};
+
+template <class T, int sz> struct Combiner
+{
+    inline void operator()(T& seed, T value);
+};
+
+template <class T> struct Combiner<T, 4>
+{
+    inline void  operator()(T& seed, T value)
+    {
+        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+    }
+};
+
+template <class T> struct Combiner<T, 8>
+{
+    inline void  operator()(T& seed, T value)
+    {
+        seed ^= value + T(0xc6a4a7935bd1e995) + (seed << 6) + (seed >> 2);
+    }
+};
+
+template <class T>
+inline void hash_combine(std::size_t& seed, T const& v)
+{
+    spp_::Hash<T> hasher;
+    Combiner<std::size_t, sizeof(std::size_t)> combiner;
+
+    combiner(seed, hasher(v));
+}
+
+}
 
 
 #endif // phmap_utils_h_guard_