mirror of
https://github.com/greg7mdp/parallel-hashmap.git
synced 2026-08-29 16:40:39 +08:00
reorganize headers so that phmap_fwd_decl.h is more usable
This commit is contained in:
greg
@@ -19,7 +19,7 @@ This repository aims to provide an set of excellent hash map implementations, wi
|
||||
|
||||
- Supports **heterogeneous lookup**
|
||||
|
||||
- Easy to **forward declare**: just include `phmap_fwd_decl.h` in your header files to forward declare Parallel Hashmap containers. This header is only 111 lines including comments.
|
||||
- Easy to **forward declare**: just include `phmap_fwd_decl.h` in your header files to forward declare Parallel Hashmap containers.
|
||||
|
||||
- **Tested** on Windows (vs2015 & vs2017), linux (g++ 5, 6, 7, 8, clang++ 3.9, 4.0, 5.0) and MacOS (g++ and clang++) - click on travis and appveyor icons above for detailed test status.
|
||||
|
||||
|
||||
Vendored
+1
-237
@@ -51,6 +51,7 @@
|
||||
#include "phmap_bits.h"
|
||||
#include "phmap_base.h"
|
||||
#include "phmap_fwd_decl.h"
|
||||
#include "phmap_utils.h"
|
||||
|
||||
#if PHMAP_HAVE_STD_STRING_VIEW
|
||||
#include <string_view>
|
||||
@@ -58,243 +59,6 @@
|
||||
|
||||
namespace phmap {
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// ---------------------------------------------------------------
|
||||
template<int n>
|
||||
struct phmap_mix
|
||||
{
|
||||
inline size_t operator()(size_t) const;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct phmap_mix<4>
|
||||
{
|
||||
inline size_t operator()(size_t a) const
|
||||
{
|
||||
static constexpr uint64_t kmul = 0xcc9e2d51UL;
|
||||
// static constexpr uint64_t kmul = 0x3B9ACB93UL; // [greg] my own random prime
|
||||
uint64_t l = a * kmul;
|
||||
return static_cast<size_t>(l ^ (l >> 32));
|
||||
}
|
||||
};
|
||||
|
||||
#if defined(PHMAP_HAS_UMUL128)
|
||||
template<>
|
||||
struct phmap_mix<8>
|
||||
{
|
||||
// Very fast mixing (similar to Abseil)
|
||||
inline size_t operator()(size_t a) const
|
||||
{
|
||||
static constexpr uint64_t k = 0xde5fb9d2630458e9ULL;
|
||||
// static constexpr uint64_t k = 0x7C9D0BF0567102A5ULL; // [greg] my own random prime
|
||||
uint64_t h;
|
||||
uint64_t l = umul128(a, k, &h);
|
||||
return static_cast<size_t>(h + l);
|
||||
}
|
||||
};
|
||||
#else
|
||||
template<>
|
||||
struct phmap_mix<8>
|
||||
{
|
||||
inline size_t operator()(size_t a) const
|
||||
{
|
||||
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);
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
// --------------------------------------------
|
||||
template<int n>
|
||||
struct fold_if_needed
|
||||
{
|
||||
inline size_t operator()(uint64_t) const;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct fold_if_needed<4>
|
||||
{
|
||||
inline size_t operator()(uint64_t a) const
|
||||
{
|
||||
return static_cast<size_t>(a ^ (a >> 32));
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct fold_if_needed<8>
|
||||
{
|
||||
inline size_t operator()(uint64_t a) const
|
||||
{
|
||||
return static_cast<size_t>(a);
|
||||
}
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// see if class T has a hash_value() friend method
|
||||
// ---------------------------------------------------------------
|
||||
template<typename T>
|
||||
struct has_hash_value
|
||||
{
|
||||
private:
|
||||
typedef std::true_type yes;
|
||||
typedef std::false_type no;
|
||||
|
||||
template<typename U> static auto test(int) -> decltype(hash_value(std::declval<U&>()) == 1, yes());
|
||||
|
||||
template<typename> static no test(...);
|
||||
|
||||
public:
|
||||
static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// phmap::Hash
|
||||
// ---------------------------------------------------------------
|
||||
template <class T>
|
||||
struct Hash
|
||||
{
|
||||
template <class U, typename std::enable_if<has_hash_value<U>::value, int>::type = 0>
|
||||
size_t _hash(const T& val) const
|
||||
{
|
||||
return hash_value(val);
|
||||
}
|
||||
|
||||
template <class U, typename std::enable_if<!has_hash_value<U>::value, int>::type = 0>
|
||||
size_t _hash(const T& val) const
|
||||
{
|
||||
return std::hash<T>()(val);
|
||||
}
|
||||
|
||||
inline size_t operator()(const T& val) const
|
||||
{
|
||||
return _hash<T>(val);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct Hash<T *>
|
||||
{
|
||||
inline size_t operator()(const T *val) const noexcept
|
||||
{
|
||||
return static_cast<size_t>(reinterpret_cast<const uintptr_t>(val));
|
||||
}
|
||||
};
|
||||
|
||||
template<class ArgumentType, class ResultType>
|
||||
struct phmap_unary_function
|
||||
{
|
||||
typedef ArgumentType argument_type;
|
||||
typedef ResultType result_type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<bool> : public phmap_unary_function<bool, size_t>
|
||||
{
|
||||
inline size_t operator()(bool val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<char> : public phmap_unary_function<char, size_t>
|
||||
{
|
||||
inline size_t operator()(char val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<signed char> : public phmap_unary_function<signed char, size_t>
|
||||
{
|
||||
inline size_t operator()(signed char val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<unsigned char> : public phmap_unary_function<unsigned char, size_t>
|
||||
{
|
||||
inline size_t operator()(unsigned char val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<wchar_t> : public phmap_unary_function<wchar_t, size_t>
|
||||
{
|
||||
inline size_t operator()(wchar_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<int16_t> : public phmap_unary_function<int16_t, size_t>
|
||||
{
|
||||
inline size_t operator()(int16_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<uint16_t> : public phmap_unary_function<uint16_t, size_t>
|
||||
{
|
||||
inline size_t operator()(uint16_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<int32_t> : public phmap_unary_function<int32_t, size_t>
|
||||
{
|
||||
inline size_t operator()(int32_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<uint32_t> : public phmap_unary_function<uint32_t, size_t>
|
||||
{
|
||||
inline size_t operator()(uint32_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<int64_t> : public phmap_unary_function<int64_t, size_t>
|
||||
{
|
||||
inline size_t operator()(int64_t val) const noexcept
|
||||
{ return fold_if_needed<sizeof(size_t)>()(static_cast<uint64_t>(val)); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<uint64_t> : public phmap_unary_function<uint64_t, size_t>
|
||||
{
|
||||
inline size_t operator()(uint64_t val) const noexcept
|
||||
{ return fold_if_needed<sizeof(size_t)>()(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<float> : public phmap_unary_function<float, size_t>
|
||||
{
|
||||
inline size_t operator()(float val) const noexcept
|
||||
{
|
||||
// -0.0 and 0.0 should return same hash
|
||||
uint32_t *as_int = reinterpret_cast<uint32_t *>(&val);
|
||||
return (val == 0) ? static_cast<size_t>(0) :
|
||||
static_cast<size_t>(*as_int);
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<double> : public phmap_unary_function<double, size_t>
|
||||
{
|
||||
inline size_t operator()(double val) const noexcept
|
||||
{
|
||||
// -0.0 and 0.0 should return same hash
|
||||
uint64_t *as_int = reinterpret_cast<uint64_t *>(&val);
|
||||
return (val == 0) ? static_cast<size_t>(0) :
|
||||
fold_if_needed<sizeof(size_t)>()(*as_int);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
namespace container_internal {
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
Vendored
+5
@@ -11,10 +11,15 @@
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
|
||||
namespace phmap {
|
||||
|
||||
template <class T> struct Hash;
|
||||
template <class T> struct EqualTo;
|
||||
template <class T> using Allocator = typename std::allocator<T>;
|
||||
template<class T1, class T2> using Pair = typename std::pair<T1, T2>;
|
||||
|
||||
class NullMutex;
|
||||
|
||||
|
||||
Vendored
+240
-13
@@ -19,22 +19,249 @@
|
||||
// limitations under the License.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#if defined(__APPLE__)
|
||||
// forward declaration of std::hash does not work on mac. It is not really supposed
|
||||
// to work, I know, but it is nice to reduce the amount of headers included.
|
||||
#include <functional>
|
||||
#else
|
||||
#include <cstddef> // for size_t
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<class Key> struct hash;
|
||||
}
|
||||
#endif
|
||||
#include <cstdint>
|
||||
#include <functional>
|
||||
#include "phmap_bits.h"
|
||||
|
||||
namespace phmap
|
||||
{
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// ---------------------------------------------------------------
|
||||
template<int n>
|
||||
struct phmap_mix
|
||||
{
|
||||
inline size_t operator()(size_t) const;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct phmap_mix<4>
|
||||
{
|
||||
inline size_t operator()(size_t a) const
|
||||
{
|
||||
static constexpr uint64_t kmul = 0xcc9e2d51UL;
|
||||
// static constexpr uint64_t kmul = 0x3B9ACB93UL; // [greg] my own random prime
|
||||
uint64_t l = a * kmul;
|
||||
return static_cast<size_t>(l ^ (l >> 32));
|
||||
}
|
||||
};
|
||||
|
||||
#if defined(PHMAP_HAS_UMUL128)
|
||||
template<>
|
||||
struct phmap_mix<8>
|
||||
{
|
||||
// Very fast mixing (similar to Abseil)
|
||||
inline size_t operator()(size_t a) const
|
||||
{
|
||||
static constexpr uint64_t k = 0xde5fb9d2630458e9ULL;
|
||||
// static constexpr uint64_t k = 0x7C9D0BF0567102A5ULL; // [greg] my own random prime
|
||||
uint64_t h;
|
||||
uint64_t l = umul128(a, k, &h);
|
||||
return static_cast<size_t>(h + l);
|
||||
}
|
||||
};
|
||||
#else
|
||||
template<>
|
||||
struct phmap_mix<8>
|
||||
{
|
||||
inline size_t operator()(size_t a) const
|
||||
{
|
||||
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);
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
// --------------------------------------------
|
||||
template<int n>
|
||||
struct fold_if_needed
|
||||
{
|
||||
inline size_t operator()(uint64_t) const;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct fold_if_needed<4>
|
||||
{
|
||||
inline size_t operator()(uint64_t a) const
|
||||
{
|
||||
return static_cast<size_t>(a ^ (a >> 32));
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct fold_if_needed<8>
|
||||
{
|
||||
inline size_t operator()(uint64_t a) const
|
||||
{
|
||||
return static_cast<size_t>(a);
|
||||
}
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// see if class T has a hash_value() friend method
|
||||
// ---------------------------------------------------------------
|
||||
template<typename T>
|
||||
struct has_hash_value
|
||||
{
|
||||
private:
|
||||
typedef std::true_type yes;
|
||||
typedef std::false_type no;
|
||||
|
||||
template<typename U> static auto test(int) -> decltype(hash_value(std::declval<U&>()) == 1, yes());
|
||||
|
||||
template<typename> static no test(...);
|
||||
|
||||
public:
|
||||
static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
// phmap::Hash
|
||||
// ---------------------------------------------------------------
|
||||
template <class T>
|
||||
struct Hash
|
||||
{
|
||||
template <class U, typename std::enable_if<has_hash_value<U>::value, int>::type = 0>
|
||||
size_t _hash(const T& val) const
|
||||
{
|
||||
return hash_value(val);
|
||||
}
|
||||
|
||||
template <class U, typename std::enable_if<!has_hash_value<U>::value, int>::type = 0>
|
||||
size_t _hash(const T& val) const
|
||||
{
|
||||
return std::hash<T>()(val);
|
||||
}
|
||||
|
||||
inline size_t operator()(const T& val) const
|
||||
{
|
||||
return _hash<T>(val);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct Hash<T *>
|
||||
{
|
||||
inline size_t operator()(const T *val) const noexcept
|
||||
{
|
||||
return static_cast<size_t>(reinterpret_cast<const uintptr_t>(val));
|
||||
}
|
||||
};
|
||||
|
||||
template<class ArgumentType, class ResultType>
|
||||
struct phmap_unary_function
|
||||
{
|
||||
typedef ArgumentType argument_type;
|
||||
typedef ResultType result_type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<bool> : public phmap_unary_function<bool, size_t>
|
||||
{
|
||||
inline size_t operator()(bool val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<char> : public phmap_unary_function<char, size_t>
|
||||
{
|
||||
inline size_t operator()(char val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<signed char> : public phmap_unary_function<signed char, size_t>
|
||||
{
|
||||
inline size_t operator()(signed char val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<unsigned char> : public phmap_unary_function<unsigned char, size_t>
|
||||
{
|
||||
inline size_t operator()(unsigned char val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<wchar_t> : public phmap_unary_function<wchar_t, size_t>
|
||||
{
|
||||
inline size_t operator()(wchar_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<int16_t> : public phmap_unary_function<int16_t, size_t>
|
||||
{
|
||||
inline size_t operator()(int16_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<uint16_t> : public phmap_unary_function<uint16_t, size_t>
|
||||
{
|
||||
inline size_t operator()(uint16_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<int32_t> : public phmap_unary_function<int32_t, size_t>
|
||||
{
|
||||
inline size_t operator()(int32_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<uint32_t> : public phmap_unary_function<uint32_t, size_t>
|
||||
{
|
||||
inline size_t operator()(uint32_t val) const noexcept
|
||||
{ return static_cast<size_t>(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<int64_t> : public phmap_unary_function<int64_t, size_t>
|
||||
{
|
||||
inline size_t operator()(int64_t val) const noexcept
|
||||
{ return fold_if_needed<sizeof(size_t)>()(static_cast<uint64_t>(val)); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<uint64_t> : public phmap_unary_function<uint64_t, size_t>
|
||||
{
|
||||
inline size_t operator()(uint64_t val) const noexcept
|
||||
{ return fold_if_needed<sizeof(size_t)>()(val); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<float> : public phmap_unary_function<float, size_t>
|
||||
{
|
||||
inline size_t operator()(float val) const noexcept
|
||||
{
|
||||
// -0.0 and 0.0 should return same hash
|
||||
uint32_t *as_int = reinterpret_cast<uint32_t *>(&val);
|
||||
return (val == 0) ? static_cast<size_t>(0) :
|
||||
static_cast<size_t>(*as_int);
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Hash<double> : public phmap_unary_function<double, size_t>
|
||||
{
|
||||
inline size_t operator()(double val) const noexcept
|
||||
{
|
||||
// -0.0 and 0.0 should return same hash
|
||||
uint64_t *as_int = reinterpret_cast<uint64_t *>(&val);
|
||||
return (val == 0) ? static_cast<size_t>(0) :
|
||||
fold_if_needed<sizeof(size_t)>()(*as_int);
|
||||
}
|
||||
};
|
||||
|
||||
template <class H, int sz> struct Combiner
|
||||
{
|
||||
H operator()(H seed, size_t value);
|
||||
@@ -72,7 +299,7 @@ template <typename T, typename... Ts>
|
||||
H HashStateBase<H>::combine(H seed, const T& v, const Ts&... vs)
|
||||
{
|
||||
return HashStateBase<H>::combine(Combiner<H, sizeof(H)>()(
|
||||
seed, std::hash<T>()(v)), vs...);
|
||||
seed, phmap::Hash<T>()(v)), vs...);
|
||||
}
|
||||
|
||||
using HashState = HashStateBase<size_t>;
|
||||
|
||||
Reference in New Issue
Block a user