mirror of
https://github.com/greg7mdp/parallel-hashmap.git
synced 2026-08-30 00:50:38 +08:00
sunkaicheng
502 lines
13 KiB
C++
Vendored
502 lines
13 KiB
C++
Vendored
#if !defined(phmap_utils_h_guard_)
|
|
#define phmap_utils_h_guard_
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
|
|
//
|
|
// minimal header providing phmap::HashState
|
|
//
|
|
// use as: phmap::HashState().combine(0, _first_name, _last_name, _age);
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include "phmap_bits.h"
|
|
#include "phmap_base.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(U::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 U::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);
|
|
};
|
|
|
|
template <class H> struct Combiner<H, 4>
|
|
{
|
|
H operator()(H seed, size_t value)
|
|
{
|
|
return seed ^ (value + 0x9e3779b9 + (seed << 6) + (seed >> 2));
|
|
}
|
|
};
|
|
|
|
template <class H> struct Combiner<H, 8>
|
|
{
|
|
H operator()(H seed, size_t value)
|
|
{
|
|
return seed ^ (value + size_t(0xc6a4a7935bd1e995) + (seed << 6) + (seed >> 2));
|
|
}
|
|
};
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
template <typename H>
|
|
class HashStateBase {
|
|
public:
|
|
template <typename T, typename... Ts>
|
|
static H combine(H state, const T& value, const Ts&... values);
|
|
|
|
static H combine(H state) { return state; }
|
|
};
|
|
|
|
template <typename H>
|
|
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, phmap::Hash<T>()(v)), vs...);
|
|
}
|
|
|
|
using HashState = HashStateBase<size_t>;
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#define CHECK_FILE(f) { \
|
|
if (!f.is_open()) { \
|
|
std::cerr << "File is not open!" << std::endl; \
|
|
return false; \
|
|
} \
|
|
}
|
|
|
|
template<typename Archive>
|
|
class ArchiveGuard {
|
|
public:
|
|
ArchiveGuard(Archive* ar): ar_(ar) {};
|
|
~ArchiveGuard() {
|
|
if (ar_) {
|
|
ar_->finish();
|
|
}
|
|
}
|
|
private:
|
|
Archive* ar_;
|
|
};
|
|
|
|
class BinaryOutputArchive {
|
|
public:
|
|
using Guard = ArchiveGuard<BinaryOutputArchive>;
|
|
|
|
BinaryOutputArchive(const std::string& file_path) {
|
|
ofs_.open(file_path.c_str(), std::ios_base::binary);
|
|
}
|
|
|
|
virtual ~BinaryOutputArchive() {
|
|
finish();
|
|
}
|
|
|
|
bool dump(char* p, size_t sz) {
|
|
CHECK_FILE(ofs_);
|
|
ofs_.write(p, sz);
|
|
return true;
|
|
}
|
|
|
|
template<typename V>
|
|
typename std::enable_if<std::is_arithmetic<V>::value, bool>::type
|
|
dump(const V& v) {
|
|
CHECK_FILE(ofs_);
|
|
ofs_.write(reinterpret_cast<char*>(const_cast<V*>(&v)), sizeof(V));
|
|
return true;
|
|
}
|
|
|
|
template<typename V>
|
|
typename std::enable_if<std::is_same<std::string, typename std::remove_cv<V>::type>::value, bool>::type
|
|
dump(const V& v) {
|
|
CHECK_FILE(ofs_);
|
|
uint32_t sz = v.length();
|
|
ofs_.write(reinterpret_cast<char*>(&sz), sizeof(sz));
|
|
ofs_.write(const_cast<char*>(v.data()), sz);
|
|
return true;
|
|
}
|
|
|
|
template<typename V>
|
|
typename std::enable_if<type_traits_internal::PairTrait<V>::value
|
|
&& type_traits_internal::IsStringOrArithmeticType<V>::value, bool>::type
|
|
dump(const V& v) {
|
|
return dump<typename type_traits_internal::PairTrait<V>::first_type>(v.first)
|
|
&& dump<typename type_traits_internal::PairTrait<V>::second_type>(v.second);
|
|
}
|
|
|
|
void finish() {
|
|
if (ofs_.is_open()) {
|
|
ofs_.close();
|
|
}
|
|
}
|
|
private:
|
|
std::ofstream ofs_;
|
|
};
|
|
|
|
|
|
class BinaryInputArchive {
|
|
public:
|
|
using Guard = ArchiveGuard<BinaryInputArchive>;
|
|
|
|
BinaryInputArchive(const std::string& file_path) {
|
|
ifs_.open(file_path.c_str(), std::ios_base::binary);
|
|
}
|
|
|
|
virtual ~BinaryInputArchive() {
|
|
finish();
|
|
}
|
|
|
|
bool load(char* p, size_t sz) {
|
|
CHECK_FILE(ifs_);
|
|
ifs_.read(p, sz);
|
|
return true;
|
|
}
|
|
|
|
template<typename V>
|
|
typename std::enable_if<std::is_arithmetic<V>::value, bool>::type
|
|
load(V* v) {
|
|
CHECK_FILE(ifs_);
|
|
ifs_.read(reinterpret_cast<char*>(v), sizeof(V));
|
|
return true;
|
|
}
|
|
|
|
template<typename V>
|
|
typename std::enable_if<std::is_same<std::string, typename std::remove_cv<V>::type>::value, bool>::type
|
|
load(V* v) {
|
|
CHECK_FILE(ifs_);
|
|
uint32_t sz = 0;
|
|
ifs_.read(reinterpret_cast<char*>(&sz), sizeof(sz));
|
|
const_cast<std::string*>(v)->resize(sz);
|
|
ifs_.read(const_cast<char*>(v->data()), sz);
|
|
return true;
|
|
}
|
|
|
|
template<typename V>
|
|
typename std::enable_if<type_traits_internal::PairTrait<V>::value
|
|
&& type_traits_internal::IsStringOrArithmeticType<V>::value, bool>::type
|
|
load(V* v) {
|
|
using first_type = typename type_traits_internal::PairTrait<V>::first_type;
|
|
using second_type = typename type_traits_internal::PairTrait<V>::second_type;
|
|
return load<first_type>(const_cast<first_type*>(&v->first))
|
|
&& load<second_type>(const_cast<second_type*>(&v->second));
|
|
}
|
|
|
|
void finish() {
|
|
if (ifs_.is_open()) {
|
|
ifs_.close();
|
|
}
|
|
}
|
|
private:
|
|
std::ifstream ifs_;
|
|
};
|
|
|
|
template<typename T = BinaryOutputArchive>
|
|
class OutputArchiveWrapper {
|
|
public:
|
|
using SubArchive = T;
|
|
OutputArchiveWrapper(const std::string& dir): dir_(dir) {
|
|
}
|
|
|
|
virtual ~OutputArchiveWrapper() {
|
|
|
|
}
|
|
|
|
bool dump_meta(size_t subcnt) {
|
|
auto ar = std::make_shared<SubArchive>(dir_ + "/meta.dump");
|
|
typename SubArchive::Guard guard(ar.get());
|
|
ar->dump(subcnt);
|
|
return true;
|
|
}
|
|
|
|
std::shared_ptr<SubArchive> create_archive(size_t i) {
|
|
std::string file_path = dir_ + "/sub_" + std::to_string(i) + ".dump";
|
|
return std::make_shared<SubArchive>(file_path);
|
|
}
|
|
private:
|
|
std::string dir_;
|
|
};
|
|
|
|
template<typename T = BinaryInputArchive>
|
|
class InputArchiveWrapper {
|
|
public:
|
|
using SubArchive = T;
|
|
InputArchiveWrapper(const std::string& dir): dir_(dir) {
|
|
}
|
|
|
|
virtual ~InputArchiveWrapper() {
|
|
|
|
}
|
|
|
|
size_t load_meta() {
|
|
size_t subcnt = 0;
|
|
auto ar = std::make_shared<SubArchive>(dir_ + "/meta.dump");
|
|
typename SubArchive::Guard guard(ar.get());
|
|
ar->load(&subcnt);
|
|
return subcnt;
|
|
}
|
|
|
|
std::shared_ptr<SubArchive> create_archive(size_t i) {
|
|
std::string file_path = dir_ + "/sub_" + std::to_string(i) + ".dump";
|
|
return std::make_shared<SubArchive>(file_path);
|
|
}
|
|
private:
|
|
std::string dir_;
|
|
};
|
|
|
|
} // namespace phmap
|
|
|
|
|
|
#endif // phmap_utils_h_guard_
|