mirror of
https://github.com/greg7mdp/parallel-hashmap.git
synced 2026-08-29 08:34:39 +08:00
Replace custom CompressedTuple with std::tuple.
This commit is contained in:
greg7mdp
Vendored
-3
@@ -107,9 +107,6 @@ if (PHMAP_BUILD_TESTS)
|
||||
enable_testing()
|
||||
|
||||
## ---------------- regular hash maps ----------------------------
|
||||
phmap_cc_test(NAME compressed_tuple SRCS "tests/compressed_tuple_test.cc"
|
||||
DEPS ${PHMAP_GTEST_LIBS})
|
||||
|
||||
phmap_cc_test(NAME container_memory SRCS "tests/container_memory_test.cc"
|
||||
DEPS ${PHMAP_GTEST_LIBS})
|
||||
|
||||
|
||||
Vendored
+8
-12
@@ -1861,7 +1861,7 @@ namespace priv {
|
||||
void swap(btree &x);
|
||||
|
||||
const key_compare &key_comp() const noexcept {
|
||||
return root_.template get<0>();
|
||||
return std::get<0>(root_);
|
||||
}
|
||||
template <typename K, typename LK>
|
||||
bool compare_keys(const K &x, const LK &y) const {
|
||||
@@ -1954,10 +1954,10 @@ namespace priv {
|
||||
|
||||
private:
|
||||
// Internal accessor routines.
|
||||
node_type *root() { return root_.template get<2>(); }
|
||||
const node_type *root() const { return root_.template get<2>(); }
|
||||
node_type *&mutable_root() noexcept { return root_.template get<2>(); }
|
||||
key_compare *mutable_key_comp() noexcept { return &root_.template get<0>(); }
|
||||
node_type *root() { return std::get<2>(root_); }
|
||||
const node_type *root() const { return std::get<2>(root_); }
|
||||
node_type *&mutable_root() noexcept { return std::get<2>(root_); }
|
||||
key_compare *mutable_key_comp() noexcept { return &std::get<0>(root_); }
|
||||
|
||||
// The leftmost node is stored as the parent of the root node.
|
||||
node_type *leftmost() { return root()->parent(); }
|
||||
@@ -1965,10 +1965,10 @@ namespace priv {
|
||||
|
||||
// Allocator routines.
|
||||
allocator_type *mutable_allocator() noexcept {
|
||||
return &root_.template get<1>();
|
||||
return &std::get<1>(root_);
|
||||
}
|
||||
const allocator_type &allocator() const noexcept {
|
||||
return root_.template get<1>();
|
||||
return std::get<1>(root_);
|
||||
}
|
||||
|
||||
// Allocates a correctly aligned node of at least size bytes using the
|
||||
@@ -2110,11 +2110,7 @@ namespace priv {
|
||||
}
|
||||
|
||||
private:
|
||||
// We use compressed tuple in order to save space because key_compare and
|
||||
// allocator_type are usually empty.
|
||||
phmap::priv::CompressedTuple<key_compare, allocator_type,
|
||||
node_type *>
|
||||
root_;
|
||||
std::tuple<key_compare, allocator_type, node_type *> root_;
|
||||
|
||||
// A pointer to the rightmost node. Note that the leftmost node is stored as
|
||||
// the root's parent.
|
||||
|
||||
Vendored
+9
-10
@@ -2281,7 +2281,7 @@ private:
|
||||
growth_left() = CapacityToGrowth(capacity) - size_;
|
||||
}
|
||||
|
||||
size_t& growth_left() { return settings_.template get<0>(); }
|
||||
size_t& growth_left() { return std::get<0>(settings_); }
|
||||
|
||||
template <size_t N,
|
||||
template <class, class, class, class> class RefSet,
|
||||
@@ -2309,13 +2309,13 @@ private:
|
||||
// small tables.
|
||||
bool is_small() const { return capacity_ < Group::kWidth - 1; }
|
||||
|
||||
hasher& hash_ref() { return settings_.template get<1>(); }
|
||||
const hasher& hash_ref() const { return settings_.template get<1>(); }
|
||||
key_equal& eq_ref() { return settings_.template get<2>(); }
|
||||
const key_equal& eq_ref() const { return settings_.template get<2>(); }
|
||||
allocator_type& alloc_ref() { return settings_.template get<3>(); }
|
||||
hasher& hash_ref() { return std::get<1>(settings_); }
|
||||
const hasher& hash_ref() const { return std::get<1>(settings_); }
|
||||
key_equal& eq_ref() { return std::get<2>(settings_); }
|
||||
const key_equal& eq_ref() const { return std::get<2>(settings_); }
|
||||
allocator_type& alloc_ref() { return std::get<3>(settings_); }
|
||||
const allocator_type& alloc_ref() const {
|
||||
return settings_.template get<3>();
|
||||
return std::get<3>(settings_);
|
||||
}
|
||||
|
||||
// TODO(alkis): Investigate removing some of these fields:
|
||||
@@ -2326,9 +2326,8 @@ private:
|
||||
size_t size_ = 0; // number of full slots
|
||||
size_t capacity_ = 0; // total number of slots
|
||||
HashtablezInfoHandle infoz_;
|
||||
phmap::priv::CompressedTuple<size_t /* growth_left */, hasher,
|
||||
key_equal, allocator_type>
|
||||
settings_{0, hasher{}, key_equal{}, allocator_type{}};
|
||||
std::tuple<size_t /* growth_left */, hasher, key_equal, allocator_type>
|
||||
settings_{0, hasher{}, key_equal{}, allocator_type{}};
|
||||
};
|
||||
|
||||
|
||||
|
||||
Vendored
-174
@@ -4127,180 +4127,6 @@ public:
|
||||
: internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
|
||||
};
|
||||
|
||||
} // namespace priv
|
||||
} // namespace phmap
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// compressed_tuple.h
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// We need to mark these classes with this declspec to ensure that
|
||||
// CompressedTuple happens.
|
||||
#define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC __declspec(empty_bases)
|
||||
#else // _MSC_VER
|
||||
#define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
|
||||
#endif // _MSC_VER
|
||||
|
||||
namespace phmap {
|
||||
namespace priv {
|
||||
|
||||
template <typename... Ts>
|
||||
class CompressedTuple;
|
||||
|
||||
namespace internal_compressed_tuple {
|
||||
|
||||
template <typename D, size_t I>
|
||||
struct Elem;
|
||||
template <typename... B, size_t I>
|
||||
struct Elem<CompressedTuple<B...>, I>
|
||||
: std::tuple_element<I, std::tuple<B...>> {};
|
||||
template <typename D, size_t I>
|
||||
using ElemT = typename Elem<D, I>::type;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Use the __is_final intrinsic if available. Where it's not available, classes
|
||||
// declared with the 'final' specifier cannot be used as CompressedTuple
|
||||
// elements.
|
||||
// TODO(sbenza): Replace this with std::is_final in C++14.
|
||||
// ---------------------------------------------------------------------------
|
||||
template <typename T>
|
||||
constexpr bool IsFinal() {
|
||||
#if defined(__clang__) || defined(__GNUC__)
|
||||
return __is_final(T);
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr bool ShouldUseBase() {
|
||||
#ifdef __INTEL_COMPILER
|
||||
// avoid crash in Intel compiler
|
||||
// assertion failed at: "shared/cfe/edgcpfe/lower_init.c", line 7013
|
||||
return false;
|
||||
#else
|
||||
return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>();
|
||||
#endif
|
||||
}
|
||||
|
||||
// The storage class provides two specializations:
|
||||
// - For empty classes, it stores T as a base class.
|
||||
// - For everything else, it stores T as a member.
|
||||
// ------------------------------------------------
|
||||
template <typename D, size_t I, bool = ShouldUseBase<ElemT<D, I>>()>
|
||||
struct Storage
|
||||
{
|
||||
using T = ElemT<D, I>;
|
||||
T value;
|
||||
constexpr Storage() = default;
|
||||
explicit constexpr Storage(T&& v) : value(phmap::forward<T>(v)) {}
|
||||
constexpr const T& get() const& { return value; }
|
||||
T& get() & { return value; }
|
||||
constexpr const T&& get() const&& { return phmap::move(*this).value; }
|
||||
T&& get() && { return std::move(*this).value; }
|
||||
};
|
||||
|
||||
template <typename D, size_t I>
|
||||
struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<D, I, true>
|
||||
: ElemT<D, I>
|
||||
{
|
||||
using T = internal_compressed_tuple::ElemT<D, I>;
|
||||
constexpr Storage() = default;
|
||||
explicit constexpr Storage(T&& v) : T(phmap::forward<T>(v)) {}
|
||||
constexpr const T& get() const& { return *this; }
|
||||
T& get() & { return *this; }
|
||||
constexpr const T&& get() const&& { return phmap::move(*this); }
|
||||
T&& get() && { return std::move(*this); }
|
||||
};
|
||||
|
||||
template <typename D, typename I>
|
||||
struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
|
||||
|
||||
template <typename... Ts, size_t... I>
|
||||
struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
|
||||
CompressedTupleImpl<CompressedTuple<Ts...>, phmap::index_sequence<I...>>
|
||||
// We use the dummy identity function through std::integral_constant to
|
||||
// convince MSVC of accepting and expanding I in that context. Without it
|
||||
// you would get:
|
||||
// error C3548: 'I': parameter pack cannot be used in this context
|
||||
: Storage<CompressedTuple<Ts...>,
|
||||
std::integral_constant<size_t, I>::value>...
|
||||
{
|
||||
constexpr CompressedTupleImpl() = default;
|
||||
explicit constexpr CompressedTupleImpl(Ts&&... args)
|
||||
: Storage<CompressedTuple<Ts...>, I>(phmap::forward<Ts>(args))... {}
|
||||
};
|
||||
|
||||
} // namespace internal_compressed_tuple
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helper class to perform the Empty Base Class Optimization.
|
||||
// Ts can contain classes and non-classes, empty or not. For the ones that
|
||||
// are empty classes, we perform the CompressedTuple. If all types in Ts are
|
||||
// empty classes, then CompressedTuple<Ts...> is itself an empty class.
|
||||
//
|
||||
// To access the members, use member .get<N>() function.
|
||||
//
|
||||
// Eg:
|
||||
// phmap::priv::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
|
||||
// t3);
|
||||
// assert(value.get<0>() == 7);
|
||||
// T1& t1 = value.get<1>();
|
||||
// const T2& t2 = value.get<2>();
|
||||
// ...
|
||||
//
|
||||
// https://en.cppreference.com/w/cpp/language/ebo
|
||||
// ---------------------------------------------------------------------------
|
||||
template <typename... Ts>
|
||||
class PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
|
||||
: private internal_compressed_tuple::CompressedTupleImpl<
|
||||
CompressedTuple<Ts...>, phmap::index_sequence_for<Ts...>>
|
||||
{
|
||||
private:
|
||||
template <int I>
|
||||
using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
|
||||
|
||||
public:
|
||||
constexpr CompressedTuple() = default;
|
||||
explicit constexpr CompressedTuple(Ts... base)
|
||||
: CompressedTuple::CompressedTupleImpl(phmap::forward<Ts>(base)...) {}
|
||||
|
||||
template <int I>
|
||||
ElemT<I>& get() & {
|
||||
return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
|
||||
}
|
||||
|
||||
template <int I>
|
||||
constexpr const ElemT<I>& get() const& {
|
||||
return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
|
||||
}
|
||||
|
||||
template <int I>
|
||||
ElemT<I>&& get() && {
|
||||
return std::move(*this)
|
||||
.internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
|
||||
}
|
||||
|
||||
template <int I>
|
||||
constexpr const ElemT<I>&& get() const&& {
|
||||
return phmap::move(*this)
|
||||
.internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
|
||||
}
|
||||
};
|
||||
|
||||
// Explicit specialization for a zero-element tuple
|
||||
// (needed to avoid ambiguous overloads for the default constructor).
|
||||
// ---------------------------------------------------------------------------
|
||||
template <>
|
||||
class PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
|
||||
|
||||
} // namespace priv
|
||||
} // namespace phmap
|
||||
|
||||
|
||||
namespace phmap {
|
||||
namespace priv {
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(push)
|
||||
|
||||
@@ -1,201 +0,0 @@
|
||||
// Copyright 2018 The Abseil Authors.
|
||||
//
|
||||
// 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 "parallel_hashmap/phmap.h"
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace phmap {
|
||||
namespace priv {
|
||||
namespace {
|
||||
|
||||
enum class CallType { kConstRef, kConstMove };
|
||||
|
||||
template <int>
|
||||
struct Empty {
|
||||
constexpr CallType value() const& { return CallType::kConstRef; }
|
||||
constexpr CallType value() const&& { return CallType::kConstMove; }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct NotEmpty {
|
||||
T value;
|
||||
};
|
||||
|
||||
template <typename T, typename U>
|
||||
struct TwoValues {
|
||||
T value1;
|
||||
U value2;
|
||||
};
|
||||
|
||||
TEST(CompressedTupleTest, Sizeof) {
|
||||
EXPECT_EQ(sizeof(int), sizeof(CompressedTuple<int>));
|
||||
EXPECT_EQ(sizeof(int), sizeof(CompressedTuple<int, Empty<0>>));
|
||||
EXPECT_EQ(sizeof(int), sizeof(CompressedTuple<int, Empty<0>, Empty<1>>));
|
||||
EXPECT_EQ(sizeof(int),
|
||||
sizeof(CompressedTuple<int, Empty<0>, Empty<1>, Empty<2>>));
|
||||
|
||||
EXPECT_EQ(sizeof(TwoValues<int, double>),
|
||||
sizeof(CompressedTuple<int, NotEmpty<double>>));
|
||||
EXPECT_EQ(sizeof(TwoValues<int, double>),
|
||||
sizeof(CompressedTuple<int, Empty<0>, NotEmpty<double>>));
|
||||
EXPECT_EQ(sizeof(TwoValues<int, double>),
|
||||
sizeof(CompressedTuple<int, Empty<0>, NotEmpty<double>, Empty<1>>));
|
||||
}
|
||||
|
||||
TEST(CompressedTupleTest, Access) {
|
||||
struct S {
|
||||
std::string x;
|
||||
};
|
||||
CompressedTuple<int, Empty<0>, S> x(7, {}, S{"ABC"});
|
||||
EXPECT_EQ(sizeof(x), sizeof(TwoValues<int, S>));
|
||||
EXPECT_EQ(7, x.get<0>());
|
||||
EXPECT_EQ("ABC", x.get<2>().x);
|
||||
}
|
||||
|
||||
TEST(CompressedTupleTest, NonClasses) {
|
||||
CompressedTuple<int, const char*> x(7, "ABC");
|
||||
EXPECT_EQ(7, x.get<0>());
|
||||
EXPECT_STREQ("ABC", x.get<1>());
|
||||
}
|
||||
|
||||
TEST(CompressedTupleTest, MixClassAndNonClass) {
|
||||
CompressedTuple<int, const char*, Empty<0>, NotEmpty<double>> x(7, "ABC", {},
|
||||
{1.25});
|
||||
struct Mock {
|
||||
int v;
|
||||
const char* p;
|
||||
double d;
|
||||
};
|
||||
EXPECT_EQ(sizeof(x), sizeof(Mock));
|
||||
EXPECT_EQ(7, x.get<0>());
|
||||
EXPECT_STREQ("ABC", x.get<1>());
|
||||
EXPECT_EQ(1.25, x.get<3>().value);
|
||||
}
|
||||
|
||||
TEST(CompressedTupleTest, Nested) {
|
||||
CompressedTuple<int, CompressedTuple<int>,
|
||||
CompressedTuple<int, CompressedTuple<int>>>
|
||||
x(1, CompressedTuple<int>(2),
|
||||
CompressedTuple<int, CompressedTuple<int>>(3, CompressedTuple<int>(4)));
|
||||
EXPECT_EQ(1, x.get<0>());
|
||||
EXPECT_EQ(2, x.get<1>().get<0>());
|
||||
EXPECT_EQ(3, x.get<2>().get<0>());
|
||||
EXPECT_EQ(4, x.get<2>().get<1>().get<0>());
|
||||
|
||||
CompressedTuple<Empty<0>, Empty<0>,
|
||||
CompressedTuple<Empty<0>, CompressedTuple<Empty<0>>>>
|
||||
y;
|
||||
std::set<Empty<0>*> empties{&y.get<0>(), &y.get<1>(), &y.get<2>().get<0>(),
|
||||
&y.get<2>().get<1>().get<0>()};
|
||||
#ifdef _MSC_VER
|
||||
// MSVC has a bug where many instances of the same base class are layed out in
|
||||
// the same address when using __declspec(empty_bases).
|
||||
// This will be fixed in a future version of MSVC.
|
||||
int expected = 1;
|
||||
#else
|
||||
int expected = 4;
|
||||
#endif
|
||||
EXPECT_EQ(expected, sizeof(y));
|
||||
EXPECT_EQ(expected, empties.size());
|
||||
EXPECT_EQ(sizeof(y), sizeof(Empty<0>) * empties.size());
|
||||
|
||||
EXPECT_EQ(4 * sizeof(char),
|
||||
sizeof(CompressedTuple<CompressedTuple<char, char>,
|
||||
CompressedTuple<char, char>>));
|
||||
EXPECT_TRUE(
|
||||
(std::is_empty<CompressedTuple<CompressedTuple<Empty<0>>,
|
||||
CompressedTuple<Empty<1>>>>::value));
|
||||
}
|
||||
|
||||
TEST(CompressedTupleTest, Reference) {
|
||||
int i = 7;
|
||||
std::string s = "Very long std::string that goes in the heap";
|
||||
CompressedTuple<int, int&, std::string, std::string&> x(i, i, s, s);
|
||||
|
||||
// Sanity check. We should have not moved from `s`
|
||||
EXPECT_EQ(s, "Very long std::string that goes in the heap");
|
||||
|
||||
EXPECT_EQ(x.get<0>(), x.get<1>());
|
||||
EXPECT_NE(&x.get<0>(), &x.get<1>());
|
||||
EXPECT_EQ(&x.get<1>(), &i);
|
||||
|
||||
EXPECT_EQ(x.get<2>(), x.get<3>());
|
||||
EXPECT_NE(&x.get<2>(), &x.get<3>());
|
||||
EXPECT_EQ(&x.get<3>(), &s);
|
||||
}
|
||||
|
||||
TEST(CompressedTupleTest, NoElements) {
|
||||
CompressedTuple<> x;
|
||||
static_cast<void>(x); // Silence -Wunused-variable.
|
||||
EXPECT_TRUE(std::is_empty<CompressedTuple<>>::value);
|
||||
}
|
||||
|
||||
TEST(CompressedTupleTest, MoveOnlyElements) {
|
||||
CompressedTuple<std::unique_ptr<std::string>> str_tup(
|
||||
phmap::make_unique<std::string>("str"));
|
||||
|
||||
CompressedTuple<CompressedTuple<std::unique_ptr<std::string>>,
|
||||
std::unique_ptr<int>>
|
||||
x(std::move(str_tup), phmap::make_unique<int>(5));
|
||||
|
||||
EXPECT_EQ(*x.get<0>().get<0>(), "str");
|
||||
EXPECT_EQ(*x.get<1>(), 5);
|
||||
|
||||
std::unique_ptr<std::string> x0 = std::move(x.get<0>()).get<0>();
|
||||
std::unique_ptr<int> x1 = std::move(x).get<1>();
|
||||
|
||||
EXPECT_EQ(*x0, "str");
|
||||
EXPECT_EQ(*x1, 5);
|
||||
}
|
||||
|
||||
TEST(CompressedTupleTest, Constexpr) {
|
||||
constexpr CompressedTuple<int, double, CompressedTuple<int>, Empty<0>> x(
|
||||
7, 1.25, CompressedTuple<int>(5), {});
|
||||
constexpr int x0 = x.get<0>();
|
||||
constexpr double x1 = x.get<1>();
|
||||
constexpr int x2 = x.get<2>().get<0>();
|
||||
constexpr CallType x3 = x.get<3>().value();
|
||||
|
||||
EXPECT_EQ(x0, 7);
|
||||
EXPECT_EQ(x1, 1.25);
|
||||
EXPECT_EQ(x2, 5);
|
||||
EXPECT_EQ(x3, CallType::kConstRef);
|
||||
|
||||
#if defined(__clang__)
|
||||
// An apparent bug in earlier versions of gcc claims these are ambiguous.
|
||||
constexpr int x2m = std::move(x.get<2>()).get<0>();
|
||||
constexpr CallType x3m = std::move(x).get<3>().value();
|
||||
EXPECT_EQ(x2m, 5);
|
||||
EXPECT_EQ(x3m, CallType::kConstMove);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined(__clang__) || defined(__GNUC__)
|
||||
TEST(CompressedTupleTest, EmptyFinalClass) {
|
||||
struct S final {
|
||||
int f() const { return 5; }
|
||||
};
|
||||
CompressedTuple<S> x;
|
||||
EXPECT_EQ(x.get<0>().f(), 5);
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
} // namespace priv
|
||||
} // namespace phmap
|
||||
Reference in New Issue
Block a user