mirror of
https://github.com/trapexit/mergerfs.git
synced 2026-11-21 07:26:28 -05:00
Add support for FUSE passthrough
This commit is contained in:
parent
92312c8507
commit
e310d24615
412 changed files with 43707 additions and 17432 deletions
1055
src/boost/unordered/concurrent_flat_map.hpp
Normal file
1055
src/boost/unordered/concurrent_flat_map.hpp
Normal file
File diff suppressed because it is too large
Load diff
66
src/boost/unordered/concurrent_flat_map_fwd.hpp
Normal file
66
src/boost/unordered/concurrent_flat_map_fwd.hpp
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
/* Fast open-addressing concurrent hashmap.
|
||||
*
|
||||
* Copyright 2023 Christian Mazakas.
|
||||
* Copyright 2024 Braden Ganetsky.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_CONCURRENT_FLAT_MAP_FWD_HPP
|
||||
#define BOOST_UNORDERED_CONCURRENT_FLAT_MAP_FWD_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/container_hash/hash_fwd.hpp>
|
||||
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
|
||||
#include <memory_resource>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace unordered {
|
||||
|
||||
template <class Key, class T, class Hash = boost::hash<Key>,
|
||||
class Pred = std::equal_to<Key>,
|
||||
class Allocator = std::allocator<std::pair<Key const, T> > >
|
||||
class concurrent_flat_map;
|
||||
|
||||
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
|
||||
bool operator==(
|
||||
concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
|
||||
concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);
|
||||
|
||||
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
|
||||
bool operator!=(
|
||||
concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
|
||||
concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);
|
||||
|
||||
template <class Key, class T, class Hash, class Pred, class Alloc>
|
||||
void swap(concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
|
||||
concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y)
|
||||
noexcept(noexcept(x.swap(y)));
|
||||
|
||||
template <class K, class T, class H, class P, class A, class Predicate>
|
||||
typename concurrent_flat_map<K, T, H, P, A>::size_type erase_if(
|
||||
concurrent_flat_map<K, T, H, P, A>& c, Predicate pred);
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
|
||||
namespace pmr {
|
||||
template <class Key, class T, class Hash = boost::hash<Key>,
|
||||
class Pred = std::equal_to<Key> >
|
||||
using concurrent_flat_map = boost::unordered::concurrent_flat_map<Key, T,
|
||||
Hash, Pred, std::pmr::polymorphic_allocator<std::pair<Key const, T> > >;
|
||||
} // namespace pmr
|
||||
#endif
|
||||
|
||||
} // namespace unordered
|
||||
|
||||
using boost::unordered::concurrent_flat_map;
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UNORDERED_CONCURRENT_FLAT_MAP_HPP
|
||||
59
src/boost/unordered/detail/allocator_constructed.hpp
Normal file
59
src/boost/unordered/detail/allocator_constructed.hpp
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
/* Copyright 2024 Braden Ganetsky.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_ALLOCATOR_CONSTRUCTED_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_ALLOCATOR_CONSTRUCTED_HPP
|
||||
|
||||
#include <boost/core/allocator_traits.hpp>
|
||||
#include <boost/unordered/detail/opt_storage.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace unordered {
|
||||
namespace detail {
|
||||
|
||||
struct allocator_policy
|
||||
{
|
||||
template <class Allocator, class T, class... Args>
|
||||
static void construct(Allocator& a, T* p, Args&&... args)
|
||||
{
|
||||
boost::allocator_construct(a, p, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
template <class Allocator, class T>
|
||||
static void destroy(Allocator& a, T* p)
|
||||
{
|
||||
boost::allocator_destroy(a, p);
|
||||
}
|
||||
};
|
||||
|
||||
/* constructs a stack-based object with the given policy and allocator */
|
||||
template <class Allocator, class T, class Policy = allocator_policy>
|
||||
class allocator_constructed
|
||||
{
|
||||
opt_storage<T> storage;
|
||||
Allocator alloc;
|
||||
|
||||
public:
|
||||
template <class... Args>
|
||||
allocator_constructed(Allocator const& alloc_, Args&&... args)
|
||||
: alloc(alloc_)
|
||||
{
|
||||
Policy::construct(
|
||||
alloc, storage.address(), std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
~allocator_constructed() { Policy::destroy(alloc, storage.address()); }
|
||||
|
||||
T& value() { return *storage.address(); }
|
||||
};
|
||||
|
||||
} /* namespace detail */
|
||||
} /* namespace unordered */
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
71
src/boost/unordered/detail/archive_constructed.hpp
Normal file
71
src/boost/unordered/detail/archive_constructed.hpp
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
/* Copyright 2023 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_ARCHIVE_CONSTRUCTED_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_ARCHIVE_CONSTRUCTED_HPP
|
||||
|
||||
#include <boost/unordered/detail/opt_storage.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/core/no_exceptions_support.hpp>
|
||||
#include <boost/core/noncopyable.hpp>
|
||||
#include <boost/core/serialization.hpp>
|
||||
|
||||
namespace boost{
|
||||
namespace unordered{
|
||||
namespace detail{
|
||||
|
||||
/* constructs a stack-based object from a serialization archive */
|
||||
|
||||
template<typename T>
|
||||
struct archive_constructed:private noncopyable
|
||||
{
|
||||
template<class Archive>
|
||||
archive_constructed(const char* name,Archive& ar,unsigned int version)
|
||||
{
|
||||
core::load_construct_data_adl(ar,std::addressof(get()),version);
|
||||
BOOST_TRY{
|
||||
ar>>core::make_nvp(name,get());
|
||||
}
|
||||
BOOST_CATCH(...){
|
||||
get().~T();
|
||||
BOOST_RETHROW;
|
||||
}
|
||||
BOOST_CATCH_END
|
||||
}
|
||||
|
||||
~archive_constructed()
|
||||
{
|
||||
get().~T();
|
||||
}
|
||||
|
||||
#if defined(BOOST_GCC)&&(BOOST_GCC>=4*10000+6*100)
|
||||
#define BOOST_UNORDERED_IGNORE_WSTRICT_ALIASING
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_UNORDERED_IGNORE_WSTRICT_ALIASING)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
||||
#endif
|
||||
|
||||
T& get(){return *space.address();}
|
||||
|
||||
#if defined(BOOST_UNORDERED_IGNORE_WSTRICT_ALIASING)
|
||||
#pragma GCC diagnostic pop
|
||||
#undef BOOST_UNORDERED_IGNORE_WSTRICT_ALIASING
|
||||
#endif
|
||||
|
||||
private:
|
||||
opt_storage<T> space;
|
||||
};
|
||||
|
||||
} /* namespace detail */
|
||||
} /* namespace unordered */
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
27
src/boost/unordered/detail/bad_archive_exception.hpp
Normal file
27
src/boost/unordered/detail/bad_archive_exception.hpp
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
/* Copyright 2023 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_BAD_ARCHIVE_EXCEPTION_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_BAD_ARCHIVE_EXCEPTION_HPP
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
namespace boost{
|
||||
namespace unordered{
|
||||
namespace detail{
|
||||
|
||||
struct bad_archive_exception:std::runtime_error
|
||||
{
|
||||
bad_archive_exception():std::runtime_error("Invalid or corrupted archive"){}
|
||||
};
|
||||
|
||||
} /* namespace detail */
|
||||
} /* namespace unordered */
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
127
src/boost/unordered/detail/concurrent_static_asserts.hpp
Normal file
127
src/boost/unordered/detail/concurrent_static_asserts.hpp
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
/* Copyright 2023 Christian Mazakas.
|
||||
* Copyright 2023-2024 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_CONCURRENT_STATIC_ASSERTS_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_CONCURRENT_STATIC_ASSERTS_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/mp11/algorithm.hpp>
|
||||
#include <boost/mp11/list.hpp>
|
||||
#include <boost/unordered/detail/type_traits.hpp>
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F) \
|
||||
static_assert(boost::unordered::detail::is_invocable<F, value_type&>::value, \
|
||||
"The provided Callable must be invocable with value_type&");
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F) \
|
||||
static_assert( \
|
||||
boost::unordered::detail::is_invocable<F, value_type const&>::value, \
|
||||
"The provided Callable must be invocable with value_type const&");
|
||||
|
||||
#if BOOST_CXX_VERSION >= 202002L
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_EXEC_POLICY(P) \
|
||||
static_assert(!std::is_base_of<std::execution::parallel_unsequenced_policy, \
|
||||
ExecPolicy>::value, \
|
||||
"ExecPolicy must be sequenced."); \
|
||||
static_assert( \
|
||||
!std::is_base_of<std::execution::unsequenced_policy, ExecPolicy>::value, \
|
||||
"ExecPolicy must be sequenced.");
|
||||
|
||||
#else
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_EXEC_POLICY(P) \
|
||||
static_assert(!std::is_base_of<std::execution::parallel_unsequenced_policy, \
|
||||
ExecPolicy>::value, \
|
||||
"ExecPolicy must be sequenced.");
|
||||
#endif
|
||||
|
||||
#define BOOST_UNORDERED_DETAIL_COMMA ,
|
||||
|
||||
#define BOOST_UNORDERED_DETAIL_LAST_ARG(Arg, Args) \
|
||||
mp11::mp_back<mp11::mp_list<Arg BOOST_UNORDERED_DETAIL_COMMA Args> >
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_INVOCABLE(Arg, Args) \
|
||||
BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE( \
|
||||
BOOST_UNORDERED_DETAIL_LAST_ARG(Arg, Args))
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_CONST_INVOCABLE(Arg, Args) \
|
||||
BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE( \
|
||||
BOOST_UNORDERED_DETAIL_LAST_ARG(Arg, Args))
|
||||
|
||||
#define BOOST_UNORDERED_DETAIL_PENULTIMATE_ARG(Arg1, Arg2, Args) \
|
||||
mp11::mp_at_c<mp11::mp_list< \
|
||||
Arg1 BOOST_UNORDERED_DETAIL_COMMA Arg2 BOOST_UNORDERED_DETAIL_COMMA Args \
|
||||
>, \
|
||||
mp11::mp_size<mp11::mp_list< \
|
||||
Arg1 BOOST_UNORDERED_DETAIL_COMMA Arg2 BOOST_UNORDERED_DETAIL_COMMA Args \
|
||||
>>::value - 2>
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_PENULTIMATE_ARG_INVOCABLE( \
|
||||
Arg1, Arg2, Args) \
|
||||
BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE( \
|
||||
BOOST_UNORDERED_DETAIL_PENULTIMATE_ARG(Arg1, Arg2, Args))
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_PENULTIMATE_ARG_CONST_INVOCABLE( \
|
||||
Arg1, Arg2, Args) \
|
||||
BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE( \
|
||||
BOOST_UNORDERED_DETAIL_PENULTIMATE_ARG(Arg1, Arg2, Args))
|
||||
|
||||
namespace boost {
|
||||
namespace unordered {
|
||||
namespace detail {
|
||||
template <class...> struct is_invocable_helper : std::false_type
|
||||
{
|
||||
};
|
||||
|
||||
template <class F, class... Args>
|
||||
struct is_invocable_helper<
|
||||
void_t<decltype(std::declval<F>()(std::declval<Args>()...))>, F,
|
||||
Args...> : std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
template <class F, class... Args>
|
||||
using is_invocable = is_invocable_helper<void, F, Args...>;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
} // namespace unordered
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#if defined(BOOST_NO_CXX20_HDR_CONCEPTS)
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_FWD_ITERATOR(Iterator) \
|
||||
static_assert( \
|
||||
std::is_base_of< \
|
||||
std::forward_iterator_tag, \
|
||||
typename std::iterator_traits<Iterator>::iterator_category>::value, \
|
||||
"The provided iterator must be at least forward");
|
||||
#else
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_FWD_ITERATOR(Iterator) \
|
||||
static_assert(std::forward_iterator<Iterator>, \
|
||||
"The provided iterator must be at least forward");
|
||||
|
||||
#endif
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_KEY_COMPATIBLE_ITERATOR(Iterator) \
|
||||
static_assert( \
|
||||
std::is_same< \
|
||||
typename std::iterator_traits<Iterator>::value_type, \
|
||||
key_type>::value || \
|
||||
detail::are_transparent< \
|
||||
typename std::iterator_traits<Iterator>::value_type, \
|
||||
hasher, key_equal>::value, \
|
||||
"The provided iterator must dereference to a compatible key value");
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT_BULK_VISIT_ITERATOR(Iterator) \
|
||||
BOOST_UNORDERED_STATIC_ASSERT_FWD_ITERATOR(Iterator) \
|
||||
BOOST_UNORDERED_STATIC_ASSERT_KEY_COMPATIBLE_ITERATOR(Iterator)
|
||||
|
||||
#endif // BOOST_UNORDERED_DETAIL_CONCURRENT_STATIC_ASSERTS_HPP
|
||||
1993
src/boost/unordered/detail/foa/concurrent_table.hpp
Normal file
1993
src/boost/unordered/detail/foa/concurrent_table.hpp
Normal file
File diff suppressed because it is too large
Load diff
2404
src/boost/unordered/detail/foa/core.hpp
Normal file
2404
src/boost/unordered/detail/foa/core.hpp
Normal file
File diff suppressed because it is too large
Load diff
177
src/boost/unordered/detail/foa/cumulative_stats.hpp
Normal file
177
src/boost/unordered/detail/foa/cumulative_stats.hpp
Normal file
|
|
@ -0,0 +1,177 @@
|
|||
/* Copyright 2024 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_FOA_CUMULATIVE_STATS_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_FOA_CUMULATIVE_STATS_HPP
|
||||
|
||||
#include <array>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/mp11/tuple.hpp>
|
||||
#include <cmath>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_HAS_THREADS)
|
||||
#include <boost/unordered/detail/foa/rw_spinlock.hpp>
|
||||
#include <mutex>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
namespace unordered{
|
||||
namespace detail{
|
||||
namespace foa{
|
||||
|
||||
/* Cumulative one-pass calculation of the average, variance and deviation of
|
||||
* running sequences.
|
||||
*/
|
||||
|
||||
struct sequence_stats_data
|
||||
{
|
||||
double m=0.0;
|
||||
double m_prior=0.0;
|
||||
double s=0.0;
|
||||
};
|
||||
|
||||
struct welfords_algorithm /* 0-based */
|
||||
{
|
||||
template<typename T>
|
||||
int operator()(T&& x,sequence_stats_data& d)const noexcept
|
||||
{
|
||||
static_assert(
|
||||
noexcept(static_cast<double>(x)),
|
||||
"Argument conversion to double must not throw.");
|
||||
|
||||
d.m_prior=d.m;
|
||||
d.m+=(static_cast<double>(x)-d.m)/static_cast<double>(n);
|
||||
d.s+=(n!=1)*
|
||||
(static_cast<double>(x)-d.m_prior)*(static_cast<double>(x)-d.m);
|
||||
|
||||
return 0; /* mp11::tuple_transform requires that return type not be void */
|
||||
}
|
||||
|
||||
std::size_t n;
|
||||
};
|
||||
|
||||
struct sequence_stats_summary
|
||||
{
|
||||
double average;
|
||||
double variance;
|
||||
double deviation;
|
||||
};
|
||||
|
||||
/* Stats calculated jointly for N same-sized sequences to save the space
|
||||
* for count.
|
||||
*/
|
||||
|
||||
template<std::size_t N>
|
||||
class cumulative_stats
|
||||
{
|
||||
public:
|
||||
struct summary
|
||||
{
|
||||
std::size_t count;
|
||||
std::array<sequence_stats_summary,N> sequence_summary;
|
||||
};
|
||||
|
||||
void reset()noexcept{*this=cumulative_stats();}
|
||||
|
||||
template<typename... Ts>
|
||||
void add(Ts&&... xs)noexcept
|
||||
{
|
||||
static_assert(
|
||||
sizeof...(Ts)==N,"A sample must be provided for each sequence.");
|
||||
|
||||
if(BOOST_UNLIKELY(++n==0)){ /* wraparound */
|
||||
reset();
|
||||
n=1;
|
||||
}
|
||||
mp11::tuple_transform(
|
||||
welfords_algorithm{n},
|
||||
std::forward_as_tuple(std::forward<Ts>(xs)...),
|
||||
data);
|
||||
}
|
||||
|
||||
summary get_summary()const noexcept
|
||||
{
|
||||
summary res;
|
||||
res.count=n;
|
||||
for(std::size_t i=0;i<N;++i){
|
||||
double average=data[i].m,
|
||||
variance=n!=0?data[i].s/static_cast<double>(n):0.0, /* biased */
|
||||
deviation=std::sqrt(variance);
|
||||
res.sequence_summary[i]={average,variance,deviation};
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
private:
|
||||
std::size_t n=0;
|
||||
std::array<sequence_stats_data,N> data;
|
||||
};
|
||||
|
||||
#if defined(BOOST_HAS_THREADS)
|
||||
|
||||
template<std::size_t N>
|
||||
class concurrent_cumulative_stats:cumulative_stats<N>
|
||||
{
|
||||
using super=cumulative_stats<N>;
|
||||
using lock_guard=std::lock_guard<rw_spinlock>;
|
||||
|
||||
public:
|
||||
using summary=typename super::summary;
|
||||
|
||||
concurrent_cumulative_stats()noexcept:super{}{}
|
||||
concurrent_cumulative_stats(const concurrent_cumulative_stats& x)noexcept:
|
||||
concurrent_cumulative_stats{x,lock_guard{x.mut}}{}
|
||||
|
||||
concurrent_cumulative_stats&
|
||||
operator=(const concurrent_cumulative_stats& x)noexcept
|
||||
{
|
||||
auto x1=x;
|
||||
lock_guard lck{mut};
|
||||
static_cast<super&>(*this)=x1;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void reset()noexcept
|
||||
{
|
||||
lock_guard lck{mut};
|
||||
super::reset();
|
||||
}
|
||||
|
||||
template<typename... Ts>
|
||||
void add(Ts&&... xs)noexcept
|
||||
{
|
||||
lock_guard lck{mut};
|
||||
super::add(std::forward<Ts>(xs)...);
|
||||
}
|
||||
|
||||
summary get_summary()const noexcept
|
||||
{
|
||||
lock_guard lck{mut};
|
||||
return super::get_summary();
|
||||
}
|
||||
|
||||
private:
|
||||
concurrent_cumulative_stats(const super& x,lock_guard&&):super{x}{}
|
||||
|
||||
mutable rw_spinlock mut;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
template<std::size_t N>
|
||||
using concurrent_cumulative_stats=cumulative_stats<N>;
|
||||
|
||||
#endif
|
||||
|
||||
} /* namespace foa */
|
||||
} /* namespace detail */
|
||||
} /* namespace unordered */
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
94
src/boost/unordered/detail/foa/flat_map_types.hpp
Normal file
94
src/boost/unordered/detail/foa/flat_map_types.hpp
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
// Copyright (C) 2023 Christian Mazakas
|
||||
// Copyright (C) 2024 Braden Ganetsky
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_FOA_FLAT_MAP_TYPES_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_FOA_FLAT_MAP_TYPES_HPP
|
||||
|
||||
#include <boost/unordered/detail/foa/types_constructibility.hpp>
|
||||
|
||||
#include <boost/core/allocator_access.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace unordered {
|
||||
namespace detail {
|
||||
namespace foa {
|
||||
template <class Key, class T> struct flat_map_types
|
||||
{
|
||||
using key_type = Key;
|
||||
using mapped_type = T;
|
||||
using raw_key_type = typename std::remove_const<Key>::type;
|
||||
using raw_mapped_type = typename std::remove_const<T>::type;
|
||||
|
||||
using init_type = std::pair<raw_key_type, raw_mapped_type>;
|
||||
using moved_type = std::pair<raw_key_type&&, raw_mapped_type&&>;
|
||||
using value_type = std::pair<Key const, T>;
|
||||
|
||||
using element_type = value_type;
|
||||
|
||||
using types = flat_map_types<Key, T>;
|
||||
using constructibility_checker = map_types_constructibility<types>;
|
||||
|
||||
static value_type& value_from(element_type& x) { return x; }
|
||||
|
||||
template <class K, class V>
|
||||
static raw_key_type const& extract(std::pair<K, V> const& kv)
|
||||
{
|
||||
return kv.first;
|
||||
}
|
||||
|
||||
static moved_type move(init_type& x)
|
||||
{
|
||||
return {std::move(x.first), std::move(x.second)};
|
||||
}
|
||||
|
||||
static moved_type move(element_type& x)
|
||||
{
|
||||
// TODO: we probably need to launder here
|
||||
return {std::move(const_cast<raw_key_type&>(x.first)),
|
||||
std::move(const_cast<raw_mapped_type&>(x.second))};
|
||||
}
|
||||
|
||||
template <class A, class... Args>
|
||||
static void construct(A& al, init_type* p, Args&&... args)
|
||||
{
|
||||
constructibility_checker::check(al, p, std::forward<Args>(args)...);
|
||||
boost::allocator_construct(al, p, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
template <class A, class... Args>
|
||||
static void construct(A& al, value_type* p, Args&&... args)
|
||||
{
|
||||
constructibility_checker::check(al, p, std::forward<Args>(args)...);
|
||||
boost::allocator_construct(al, p, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
template <class A, class... Args>
|
||||
static void construct(A& al, key_type* p, Args&&... args)
|
||||
{
|
||||
constructibility_checker::check(al, p, std::forward<Args>(args)...);
|
||||
boost::allocator_construct(al, p, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
template <class A> static void destroy(A& al, init_type* p) noexcept
|
||||
{
|
||||
boost::allocator_destroy(al, p);
|
||||
}
|
||||
|
||||
template <class A> static void destroy(A& al, value_type* p) noexcept
|
||||
{
|
||||
boost::allocator_destroy(al, p);
|
||||
}
|
||||
|
||||
template <class A> static void destroy(A& al, key_type* p) noexcept
|
||||
{
|
||||
boost::allocator_destroy(al, p);
|
||||
}
|
||||
};
|
||||
} // namespace foa
|
||||
} // namespace detail
|
||||
} // namespace unordered
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UNORDERED_DETAIL_FOA_FLAT_MAP_TYPES_HPP
|
||||
35
src/boost/unordered/detail/foa/ignore_wshadow.hpp
Normal file
35
src/boost/unordered/detail/foa/ignore_wshadow.hpp
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
/* Copyright 2023 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_GCC)
|
||||
#if !defined(BOOST_UNORDERED_DETAIL_RESTORE_WSHADOW)
|
||||
/* GCC's -Wshadow triggers at scenarios like this:
|
||||
*
|
||||
* struct foo{};
|
||||
* template<typename Base>
|
||||
* struct derived:Base
|
||||
* {
|
||||
* void f(){int foo;}
|
||||
* };
|
||||
*
|
||||
* derived<foo>x;
|
||||
* x.f(); // declaration of "foo" in derived::f shadows base type "foo"
|
||||
*
|
||||
* This makes shadowing warnings unavoidable in general when a class template
|
||||
* derives from user-provided classes, as is the case with foa::table_core
|
||||
* deriving from empty_value.
|
||||
*/
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wshadow"
|
||||
#else
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#endif
|
||||
138
src/boost/unordered/detail/foa/reentrancy_check.hpp
Normal file
138
src/boost/unordered/detail/foa/reentrancy_check.hpp
Normal file
|
|
@ -0,0 +1,138 @@
|
|||
/* Copyright 2023 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_FOA_REENTRANCY_CHECK_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_FOA_REENTRANCY_CHECK_HPP
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <utility>
|
||||
|
||||
#if !defined(BOOST_UNORDERED_DISABLE_REENTRANCY_CHECK)&& \
|
||||
!defined(BOOST_ASSERT_IS_VOID)
|
||||
#define BOOST_UNORDERED_REENTRANCY_CHECK
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
namespace unordered{
|
||||
namespace detail{
|
||||
namespace foa{
|
||||
|
||||
#if defined(BOOST_UNORDERED_REENTRANCY_CHECK)
|
||||
|
||||
class entry_trace
|
||||
{
|
||||
public:
|
||||
entry_trace(const void* px_):px{px_}
|
||||
{
|
||||
if(px){
|
||||
BOOST_ASSERT_MSG(!find(px),"reentrancy not allowed");
|
||||
header()=this;
|
||||
}
|
||||
}
|
||||
|
||||
/* not used but VS in pre-C++17 mode needs to see it for RVO */
|
||||
entry_trace(const entry_trace&);
|
||||
|
||||
~entry_trace(){clear();}
|
||||
|
||||
void clear()
|
||||
{
|
||||
if(px){
|
||||
header()=next;
|
||||
px=nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
static entry_trace*& header()
|
||||
{
|
||||
thread_local entry_trace *pe=nullptr;
|
||||
return pe;
|
||||
}
|
||||
|
||||
static bool find(const void* px)
|
||||
{
|
||||
for(auto pe=header();pe;pe=pe->next){
|
||||
if(pe->px==px)return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
const void *px;
|
||||
entry_trace *next=header();
|
||||
};
|
||||
|
||||
template<typename LockGuard>
|
||||
struct reentrancy_checked
|
||||
{
|
||||
template<typename... Args>
|
||||
reentrancy_checked(const void* px,Args&&... args):
|
||||
tr{px},lck{std::forward<Args>(args)...}{}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
lck.unlock();
|
||||
tr.clear();
|
||||
}
|
||||
|
||||
entry_trace tr;
|
||||
LockGuard lck;
|
||||
};
|
||||
|
||||
template<typename LockGuard>
|
||||
struct reentrancy_bichecked
|
||||
{
|
||||
template<typename... Args>
|
||||
reentrancy_bichecked(const void* px,const void* py,Args&&... args):
|
||||
tr1{px},tr2{py!=px?py:nullptr},lck{std::forward<Args>(args)...}{}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
lck.unlock();
|
||||
tr2.clear();
|
||||
tr1.clear();
|
||||
}
|
||||
|
||||
entry_trace tr1,tr2;
|
||||
LockGuard lck;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
template<typename LockGuard>
|
||||
struct reentrancy_checked
|
||||
{
|
||||
template<typename... Args>
|
||||
reentrancy_checked(const void*,Args&&... args):
|
||||
lck{std::forward<Args>(args)...}{}
|
||||
|
||||
void unlock(){lck.unlock();}
|
||||
|
||||
LockGuard lck;
|
||||
};
|
||||
|
||||
template<typename LockGuard>
|
||||
struct reentrancy_bichecked
|
||||
{
|
||||
template<typename... Args>
|
||||
reentrancy_bichecked(const void*,const void*,Args&&... args):
|
||||
lck{std::forward<Args>(args)...}{}
|
||||
|
||||
void unlock(){lck.unlock();}
|
||||
|
||||
LockGuard lck;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
} /* namespace foa */
|
||||
} /* namespace detail */
|
||||
} /* namespace unordered */
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
11
src/boost/unordered/detail/foa/restore_wshadow.hpp
Normal file
11
src/boost/unordered/detail/foa/restore_wshadow.hpp
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
/* Copyright 2023 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#define BOOST_UNORDERED_DETAIL_RESTORE_WSHADOW
|
||||
#include <boost/unordered/detail/foa/ignore_wshadow.hpp>
|
||||
#undef BOOST_UNORDERED_DETAIL_RESTORE_WSHADOW
|
||||
179
src/boost/unordered/detail/foa/rw_spinlock.hpp
Normal file
179
src/boost/unordered/detail/foa/rw_spinlock.hpp
Normal file
|
|
@ -0,0 +1,179 @@
|
|||
#ifndef BOOST_UNORDERED_DETAIL_FOA_RW_SPINLOCK_HPP_INCLUDED
|
||||
#define BOOST_UNORDERED_DETAIL_FOA_RW_SPINLOCK_HPP_INCLUDED
|
||||
|
||||
// Copyright 2023 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
#include <boost/core/yield_primitives.hpp>
|
||||
#include <atomic>
|
||||
#include <cstdint>
|
||||
|
||||
namespace boost{
|
||||
namespace unordered{
|
||||
namespace detail{
|
||||
namespace foa{
|
||||
|
||||
class rw_spinlock
|
||||
{
|
||||
private:
|
||||
|
||||
// bit 31: locked exclusive
|
||||
// bit 30: writer pending
|
||||
// bit 29..0: reader lock count
|
||||
|
||||
static constexpr std::uint32_t locked_exclusive_mask = 1u << 31; // 0x8000'0000
|
||||
static constexpr std::uint32_t writer_pending_mask = 1u << 30; // 0x4000'0000
|
||||
static constexpr std::uint32_t reader_lock_count_mask = writer_pending_mask - 1; // 0x3FFF'FFFF
|
||||
|
||||
std::atomic<std::uint32_t> state_ = {};
|
||||
|
||||
private:
|
||||
|
||||
// Effects: Provides a hint to the implementation that the current thread
|
||||
// has been unable to make progress for k+1 iterations.
|
||||
|
||||
static void yield( unsigned k ) noexcept
|
||||
{
|
||||
unsigned const sleep_every = 1024; // see below
|
||||
|
||||
k %= sleep_every;
|
||||
|
||||
if( k < 5 )
|
||||
{
|
||||
// Intel recommendation from the Optimization Reference Manual
|
||||
// Exponentially increase number of PAUSE instructions each
|
||||
// iteration until reaching a maximum which is approximately
|
||||
// one timeslice long (2^4 == 16 in our case)
|
||||
|
||||
unsigned const pause_count = 1u << k;
|
||||
|
||||
for( unsigned i = 0; i < pause_count; ++i )
|
||||
{
|
||||
boost::core::sp_thread_pause();
|
||||
}
|
||||
}
|
||||
else if( k < sleep_every - 1 )
|
||||
{
|
||||
// Once the maximum number of PAUSE instructions is reached,
|
||||
// we switch to yielding the timeslice immediately
|
||||
|
||||
boost::core::sp_thread_yield();
|
||||
}
|
||||
else
|
||||
{
|
||||
// After `sleep_every` iterations of no progress, we sleep,
|
||||
// to avoid a deadlock if a lower priority thread has the lock
|
||||
|
||||
boost::core::sp_thread_sleep();
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
bool try_lock_shared() noexcept
|
||||
{
|
||||
std::uint32_t st = state_.load( std::memory_order_relaxed );
|
||||
|
||||
if( st >= reader_lock_count_mask )
|
||||
{
|
||||
// either bit 31 set, bit 30 set, or reader count is max
|
||||
return false;
|
||||
}
|
||||
|
||||
std::uint32_t newst = st + 1;
|
||||
return state_.compare_exchange_strong( st, newst, std::memory_order_acquire, std::memory_order_relaxed );
|
||||
}
|
||||
|
||||
void lock_shared() noexcept
|
||||
{
|
||||
for( unsigned k = 0; ; ++k )
|
||||
{
|
||||
std::uint32_t st = state_.load( std::memory_order_relaxed );
|
||||
|
||||
if( st < reader_lock_count_mask )
|
||||
{
|
||||
std::uint32_t newst = st + 1;
|
||||
if( state_.compare_exchange_weak( st, newst, std::memory_order_acquire, std::memory_order_relaxed ) ) return;
|
||||
}
|
||||
|
||||
yield( k );
|
||||
}
|
||||
}
|
||||
|
||||
void unlock_shared() noexcept
|
||||
{
|
||||
// pre: locked shared, not locked exclusive
|
||||
|
||||
state_.fetch_sub( 1, std::memory_order_release );
|
||||
|
||||
// if the writer pending bit is set, there's a writer waiting
|
||||
// let it acquire the lock; it will clear the bit on unlock
|
||||
}
|
||||
|
||||
bool try_lock() noexcept
|
||||
{
|
||||
std::uint32_t st = state_.load( std::memory_order_relaxed );
|
||||
|
||||
if( st & locked_exclusive_mask )
|
||||
{
|
||||
// locked exclusive
|
||||
return false;
|
||||
}
|
||||
|
||||
if( st & reader_lock_count_mask )
|
||||
{
|
||||
// locked shared
|
||||
return false;
|
||||
}
|
||||
|
||||
std::uint32_t newst = locked_exclusive_mask;
|
||||
return state_.compare_exchange_strong( st, newst, std::memory_order_acquire, std::memory_order_relaxed );
|
||||
}
|
||||
|
||||
void lock() noexcept
|
||||
{
|
||||
for( unsigned k = 0; ; ++k )
|
||||
{
|
||||
std::uint32_t st = state_.load( std::memory_order_relaxed );
|
||||
|
||||
if( st & locked_exclusive_mask )
|
||||
{
|
||||
// locked exclusive, spin
|
||||
}
|
||||
else if( ( st & reader_lock_count_mask ) == 0 )
|
||||
{
|
||||
// not locked exclusive, not locked shared, try to lock
|
||||
|
||||
std::uint32_t newst = locked_exclusive_mask;
|
||||
if( state_.compare_exchange_weak( st, newst, std::memory_order_acquire, std::memory_order_relaxed ) ) return;
|
||||
}
|
||||
else if( st & writer_pending_mask )
|
||||
{
|
||||
// writer pending bit already set, nothing to do
|
||||
}
|
||||
else
|
||||
{
|
||||
// locked shared, set writer pending bit
|
||||
|
||||
std::uint32_t newst = st | writer_pending_mask;
|
||||
state_.compare_exchange_weak( st, newst, std::memory_order_relaxed, std::memory_order_relaxed );
|
||||
}
|
||||
|
||||
yield( k );
|
||||
}
|
||||
}
|
||||
|
||||
void unlock() noexcept
|
||||
{
|
||||
// pre: locked exclusive, not locked shared
|
||||
state_.store( 0, std::memory_order_release );
|
||||
}
|
||||
};
|
||||
|
||||
} /* namespace foa */
|
||||
} /* namespace detail */
|
||||
} /* namespace unordered */
|
||||
} /* namespace boost */
|
||||
|
||||
#endif // BOOST_UNORDERED_DETAIL_FOA_RW_SPINLOCK_HPP_INCLUDED
|
||||
53
src/boost/unordered/detail/foa/tuple_rotate_right.hpp
Normal file
53
src/boost/unordered/detail/foa/tuple_rotate_right.hpp
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
/* Copyright 2023-2024 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_FOA_TUPLE_ROTATE_RIGHT_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_FOA_TUPLE_ROTATE_RIGHT_HPP
|
||||
|
||||
#include <boost/mp11/algorithm.hpp>
|
||||
#include <boost/mp11/integer_sequence.hpp>
|
||||
#include <tuple>
|
||||
#include <utility>
|
||||
|
||||
namespace boost{
|
||||
namespace unordered{
|
||||
namespace detail{
|
||||
namespace foa{
|
||||
|
||||
template<std::size_t Offset,typename Tuple>
|
||||
using tuple_rotate_right_return_type=mp11::mp_rotate_right_c<
|
||||
typename std::remove_cv<typename std::remove_reference<Tuple>::type>::type,
|
||||
Offset
|
||||
>;
|
||||
|
||||
template<std::size_t Offset,std::size_t... Is,typename Tuple>
|
||||
tuple_rotate_right_return_type<Offset,Tuple>
|
||||
tuple_rotate_right_aux(mp11::index_sequence<Is...>,Tuple&& x)
|
||||
{
|
||||
return tuple_rotate_right_return_type<Offset,Tuple>{
|
||||
std::get<(Is+sizeof...(Is)-Offset)%sizeof...(Is)>(
|
||||
std::forward<Tuple>(x))...};
|
||||
}
|
||||
|
||||
template<std::size_t Offset=1,typename Tuple>
|
||||
tuple_rotate_right_return_type<Offset,Tuple> tuple_rotate_right(Tuple&& x)
|
||||
{
|
||||
using RawTuple=typename std::remove_cv<
|
||||
typename std::remove_reference<Tuple>::type>::type;
|
||||
|
||||
return tuple_rotate_right_aux<Offset>(
|
||||
mp11::make_index_sequence<std::tuple_size<RawTuple>::value>{},
|
||||
std::forward<Tuple>(x));
|
||||
}
|
||||
|
||||
} /* namespace foa */
|
||||
} /* namespace detail */
|
||||
} /* namespace unordered */
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
172
src/boost/unordered/detail/foa/types_constructibility.hpp
Normal file
172
src/boost/unordered/detail/foa/types_constructibility.hpp
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
// Copyright (C) 2024 Braden Ganetsky
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_FOA_TYPES_CONSTRUCTIBILITY_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_FOA_TYPES_CONSTRUCTIBILITY_HPP
|
||||
|
||||
#include <memory>
|
||||
#include <tuple>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace boost {
|
||||
namespace unordered {
|
||||
namespace detail {
|
||||
namespace foa {
|
||||
template <class Key, class... Args> struct check_key_type_t
|
||||
{
|
||||
static_assert(std::is_constructible<Key, Args...>::value,
|
||||
"key_type must be constructible from Args");
|
||||
};
|
||||
template <class Key> struct check_key_type_t<Key>
|
||||
{
|
||||
static_assert(std::is_constructible<Key>::value,
|
||||
"key_type must be default constructible");
|
||||
};
|
||||
template <class Key> struct check_key_type_t<Key, const Key&>
|
||||
{
|
||||
static_assert(std::is_constructible<Key, const Key&>::value,
|
||||
"key_type must be copy constructible");
|
||||
};
|
||||
template <class Key> struct check_key_type_t<Key, Key&&>
|
||||
{
|
||||
static_assert(std::is_constructible<Key, Key&&>::value,
|
||||
"key_type must be move constructible");
|
||||
};
|
||||
|
||||
template <class Mapped, class... Args> struct check_mapped_type_t
|
||||
{
|
||||
static_assert(std::is_constructible<Mapped, Args...>::value,
|
||||
"mapped_type must be constructible from Args");
|
||||
};
|
||||
template <class Mapped> struct check_mapped_type_t<Mapped>
|
||||
{
|
||||
static_assert(std::is_constructible<Mapped>::value,
|
||||
"mapped_type must be default constructible");
|
||||
};
|
||||
template <class Mapped>
|
||||
struct check_mapped_type_t<Mapped, const Mapped&>
|
||||
{
|
||||
static_assert(std::is_constructible<Mapped, const Mapped&>::value,
|
||||
"mapped_type must be copy constructible");
|
||||
};
|
||||
template <class Mapped> struct check_mapped_type_t<Mapped, Mapped&&>
|
||||
{
|
||||
static_assert(std::is_constructible<Mapped, Mapped&&>::value,
|
||||
"mapped_type must be move constructible");
|
||||
};
|
||||
|
||||
template <class TypePolicy> struct map_types_constructibility
|
||||
{
|
||||
using key_type = typename TypePolicy::key_type;
|
||||
using mapped_type = typename TypePolicy::mapped_type;
|
||||
using init_type = typename TypePolicy::init_type;
|
||||
using value_type = typename TypePolicy::value_type;
|
||||
|
||||
template <class A, class X, class... Args>
|
||||
static void check(A&, X*, Args&&...)
|
||||
{
|
||||
// Pass through, as we cannot say anything about a general allocator
|
||||
}
|
||||
|
||||
template <class... Args> static void check_key_type()
|
||||
{
|
||||
(void)check_key_type_t<key_type, Args...>{};
|
||||
}
|
||||
template <class... Args> static void check_mapped_type()
|
||||
{
|
||||
(void)check_mapped_type_t<mapped_type, Args...>{};
|
||||
}
|
||||
|
||||
template <class Arg>
|
||||
static void check(std::allocator<value_type>&, key_type*, Arg&&)
|
||||
{
|
||||
check_key_type<Arg&&>();
|
||||
}
|
||||
|
||||
template <class Arg1, class Arg2>
|
||||
static void check(
|
||||
std::allocator<value_type>&, value_type*, Arg1&&, Arg2&&)
|
||||
{
|
||||
check_key_type<Arg1&&>();
|
||||
check_mapped_type<Arg2&&>();
|
||||
}
|
||||
template <class Arg1, class Arg2>
|
||||
static void check(std::allocator<value_type>&, value_type*,
|
||||
const std::pair<Arg1, Arg2>&)
|
||||
{
|
||||
check_key_type<const Arg1&>();
|
||||
check_mapped_type<const Arg2&>();
|
||||
}
|
||||
template <class Arg1, class Arg2>
|
||||
static void check(
|
||||
std::allocator<value_type>&, value_type*, std::pair<Arg1, Arg2>&&)
|
||||
{
|
||||
check_key_type<Arg1&&>();
|
||||
check_mapped_type<Arg2&&>();
|
||||
}
|
||||
template <class... Args1, class... Args2>
|
||||
static void check(std::allocator<value_type>&, value_type*,
|
||||
std::piecewise_construct_t, std::tuple<Args1...>&&,
|
||||
std::tuple<Args2...>&&)
|
||||
{
|
||||
check_key_type<Args1&&...>();
|
||||
check_mapped_type<Args2&&...>();
|
||||
}
|
||||
|
||||
template <class Arg1, class Arg2>
|
||||
static void check(
|
||||
std::allocator<value_type>&, init_type*, Arg1&&, Arg2&&)
|
||||
{
|
||||
check_key_type<Arg1&&>();
|
||||
check_mapped_type<Arg2&&>();
|
||||
}
|
||||
template <class Arg1, class Arg2>
|
||||
static void check(std::allocator<value_type>&, init_type*,
|
||||
const std::pair<Arg1, Arg2>&)
|
||||
{
|
||||
check_key_type<const Arg1&>();
|
||||
check_mapped_type<const Arg2&>();
|
||||
}
|
||||
template <class Arg1, class Arg2>
|
||||
static void check(
|
||||
std::allocator<value_type>&, init_type*, std::pair<Arg1, Arg2>&&)
|
||||
{
|
||||
check_key_type<Arg1&&>();
|
||||
check_mapped_type<Arg2&&>();
|
||||
}
|
||||
template <class... Args1, class... Args2>
|
||||
static void check(std::allocator<value_type>&, init_type*,
|
||||
std::piecewise_construct_t, std::tuple<Args1...>&&,
|
||||
std::tuple<Args2...>&&)
|
||||
{
|
||||
check_key_type<Args1&&...>();
|
||||
check_mapped_type<Args2&&...>();
|
||||
}
|
||||
};
|
||||
|
||||
template <class TypePolicy> struct set_types_constructibility
|
||||
{
|
||||
using key_type = typename TypePolicy::key_type;
|
||||
using value_type = typename TypePolicy::value_type;
|
||||
static_assert(std::is_same<key_type, value_type>::value, "");
|
||||
|
||||
template <class A, class X, class... Args>
|
||||
static void check(A&, X*, Args&&...)
|
||||
{
|
||||
// Pass through, as we cannot say anything about a general allocator
|
||||
}
|
||||
|
||||
template <class... Args>
|
||||
static void check(std::allocator<value_type>&, key_type*, Args&&...)
|
||||
{
|
||||
(void)check_key_type_t<key_type, Args&&...>{};
|
||||
}
|
||||
};
|
||||
} // namespace foa
|
||||
} // namespace detail
|
||||
} // namespace unordered
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UNORDERED_DETAIL_FOA_TYPES_CONSTRUCTIBILITY_HPP
|
||||
129
src/boost/unordered/detail/mulx.hpp
Normal file
129
src/boost/unordered/detail/mulx.hpp
Normal file
|
|
@ -0,0 +1,129 @@
|
|||
#ifndef BOOST_UNORDERED_DETAIL_MULX_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_MULX_HPP
|
||||
|
||||
// Copyright 2022 Peter Dimov.
|
||||
// Copyright 2022 Joaquin M Lopez Munoz.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <climits>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(_MSC_VER) && !defined(__clang__)
|
||||
# include <intrin.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace unordered {
|
||||
namespace detail {
|
||||
|
||||
// Bit mixer based on the mulx primitive
|
||||
|
||||
#if defined(_MSC_VER) && defined(_M_X64) && !defined(__clang__)
|
||||
|
||||
__forceinline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
|
||||
{
|
||||
boost::uint64_t r2;
|
||||
boost::uint64_t r = _umul128( x, y, &r2 );
|
||||
return r ^ r2;
|
||||
}
|
||||
|
||||
#elif defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__)
|
||||
|
||||
__forceinline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
|
||||
{
|
||||
boost::uint64_t r = x * y;
|
||||
boost::uint64_t r2 = __umulh( x, y );
|
||||
return r ^ r2;
|
||||
}
|
||||
|
||||
#elif defined(__SIZEOF_INT128__)
|
||||
|
||||
inline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
|
||||
{
|
||||
__uint128_t r = (__uint128_t)x * y;
|
||||
return (boost::uint64_t)r ^ (boost::uint64_t)( r >> 64 );
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
inline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
|
||||
{
|
||||
boost::uint64_t x1 = (boost::uint32_t)x;
|
||||
boost::uint64_t x2 = x >> 32;
|
||||
|
||||
boost::uint64_t y1 = (boost::uint32_t)y;
|
||||
boost::uint64_t y2 = y >> 32;
|
||||
|
||||
boost::uint64_t r3 = x2 * y2;
|
||||
|
||||
boost::uint64_t r2a = x1 * y2;
|
||||
|
||||
r3 += r2a >> 32;
|
||||
|
||||
boost::uint64_t r2b = x2 * y1;
|
||||
|
||||
r3 += r2b >> 32;
|
||||
|
||||
boost::uint64_t r1 = x1 * y1;
|
||||
|
||||
boost::uint64_t r2 = (r1 >> 32) + (boost::uint32_t)r2a + (boost::uint32_t)r2b;
|
||||
|
||||
r1 = (r2 << 32) + (boost::uint32_t)r1;
|
||||
r3 += r2 >> 32;
|
||||
|
||||
return r1 ^ r3;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
inline boost::uint32_t mulx32( boost::uint32_t x, boost::uint32_t y )
|
||||
{
|
||||
boost::uint64_t r = (boost::uint64_t)x * y;
|
||||
|
||||
#if defined(__MSVC_RUNTIME_CHECKS)
|
||||
|
||||
return (boost::uint32_t)(r & UINT32_MAX) ^ (boost::uint32_t)(r >> 32);
|
||||
|
||||
#else
|
||||
|
||||
return (boost::uint32_t)r ^ (boost::uint32_t)(r >> 32);
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined(SIZE_MAX)
|
||||
#if ((((SIZE_MAX >> 16) >> 16) >> 16) >> 15) != 0
|
||||
#define BOOST_UNORDERED_64B_ARCHITECTURE /* >64 bits assumed as 64 bits */
|
||||
#endif
|
||||
#elif defined(UINTPTR_MAX) /* used as proxy for std::size_t */
|
||||
#if ((((UINTPTR_MAX >> 16) >> 16) >> 16) >> 15) != 0
|
||||
#define BOOST_UNORDERED_64B_ARCHITECTURE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
inline std::size_t mulx( std::size_t x ) noexcept
|
||||
{
|
||||
#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
|
||||
|
||||
// multiplier is phi
|
||||
return (std::size_t)mulx64( (boost::uint64_t)x, 0x9E3779B97F4A7C15ull );
|
||||
|
||||
#else /* 32 bits assumed */
|
||||
|
||||
// multiplier from https://arxiv.org/abs/2001.05304
|
||||
return mulx32( x, 0xE817FB2Du );
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef BOOST_UNORDERED_64B_ARCHITECTURE
|
||||
#undef BOOST_UNORDERED_64B_ARCHITECTURE
|
||||
#endif
|
||||
|
||||
} // namespace detail
|
||||
} // namespace unordered
|
||||
} // namespace boost
|
||||
|
||||
#endif // #ifndef BOOST_UNORDERED_DETAIL_MULX_HPP
|
||||
44
src/boost/unordered/detail/narrow_cast.hpp
Normal file
44
src/boost/unordered/detail/narrow_cast.hpp
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/* Copyright 2022 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_NARROW_CAST_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_NARROW_CAST_HPP
|
||||
|
||||
#include <boost/unordered/detail/static_assert.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <type_traits>
|
||||
|
||||
namespace boost{
|
||||
namespace unordered{
|
||||
namespace detail{
|
||||
|
||||
template<typename To,typename From>
|
||||
constexpr To narrow_cast(From x) noexcept
|
||||
{
|
||||
BOOST_UNORDERED_STATIC_ASSERT(std::is_integral<From>::value);
|
||||
BOOST_UNORDERED_STATIC_ASSERT(std::is_integral<To>::value);
|
||||
BOOST_UNORDERED_STATIC_ASSERT(sizeof(From)>=sizeof(To));
|
||||
|
||||
return static_cast<To>(
|
||||
x
|
||||
|
||||
#if defined(__MSVC_RUNTIME_CHECKS)
|
||||
/* Avoids VS's "Run-Time Check Failure #1 - A cast to a smaller data type
|
||||
* has caused a loss of data."
|
||||
*/
|
||||
&static_cast<typename std::make_unsigned<To>::type>(~static_cast<To>(0))
|
||||
#endif
|
||||
);
|
||||
}
|
||||
|
||||
} /* namespace detail */
|
||||
} /* namespace unordered */
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
30
src/boost/unordered/detail/opt_storage.hpp
Normal file
30
src/boost/unordered/detail/opt_storage.hpp
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
// Copyright (C) 2023 Christian Mazakas
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_OPT_STORAGE_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_OPT_STORAGE_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace boost {
|
||||
namespace unordered {
|
||||
namespace detail {
|
||||
template <class T> union opt_storage
|
||||
{
|
||||
BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS T t_;
|
||||
|
||||
opt_storage() {}
|
||||
~opt_storage() {}
|
||||
|
||||
T* address() noexcept { return std::addressof(t_); }
|
||||
T const* address() const noexcept { return std::addressof(t_); }
|
||||
};
|
||||
} // namespace detail
|
||||
} // namespace unordered
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UNORDERED_DETAIL_OPT_STORAGE_HPP
|
||||
74
src/boost/unordered/detail/serialization_version.hpp
Normal file
74
src/boost/unordered/detail/serialization_version.hpp
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
/* Copyright 2023 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_SERIALIZATION_VERSION_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_SERIALIZATION_VERSION_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/core/serialization.hpp>
|
||||
|
||||
namespace boost{
|
||||
namespace unordered{
|
||||
namespace detail{
|
||||
|
||||
/* boost::serialization::load_construct_adl(ar,t,version) requires user code
|
||||
* to pass the serialization version for t, when this information is really
|
||||
* stored in the archive. serialization_version<T> circumvents this design
|
||||
* error by acting as a regular serializable type with the same serialization
|
||||
* version as T; loading/saving serialization_version<T> does nothing with
|
||||
* the archive data itself but captures the stored serialization version
|
||||
* at load() time.
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
struct serialization_version
|
||||
{
|
||||
serialization_version():
|
||||
value(boost::serialization::version<serialization_version>::value){}
|
||||
|
||||
serialization_version& operator=(unsigned int x){value=x;return *this;};
|
||||
|
||||
operator unsigned int()const{return value;}
|
||||
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
|
||||
template<class Archive>
|
||||
void serialize(Archive& ar,unsigned int version)
|
||||
{
|
||||
core::split_member(ar,*this,version);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void save(Archive&,unsigned int)const{}
|
||||
|
||||
template<class Archive>
|
||||
void load(Archive&,unsigned int version)
|
||||
{
|
||||
this->value=version;
|
||||
}
|
||||
|
||||
unsigned int value;
|
||||
};
|
||||
|
||||
} /* namespace detail */
|
||||
} /* namespace unordered */
|
||||
|
||||
namespace serialization{
|
||||
|
||||
template<typename T>
|
||||
struct version<boost::unordered::detail::serialization_version<T> >
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(int,value=version<T>::value);
|
||||
};
|
||||
|
||||
} /* namespace serialization */
|
||||
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
16
src/boost/unordered/detail/static_assert.hpp
Normal file
16
src/boost/unordered/detail/static_assert.hpp
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
// Copyright 2023 Christian Mazakas
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_STATIC_ASSERT_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_STATIC_ASSERT_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#define BOOST_UNORDERED_STATIC_ASSERT(...) \
|
||||
static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
#endif // BOOST_UNORDERED_DETAIL_STATIC_ASSERT_HPP
|
||||
237
src/boost/unordered/detail/type_traits.hpp
Normal file
237
src/boost/unordered/detail/type_traits.hpp
Normal file
|
|
@ -0,0 +1,237 @@
|
|||
// Copyright (C) 2022-2023 Christian Mazakas
|
||||
// Copyright (C) 2024 Braden Ganetsky
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_UNORDERED_DETAIL_TYPE_TRAITS_HPP
|
||||
#define BOOST_UNORDERED_DETAIL_TYPE_TRAITS_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/config/workaround.hpp>
|
||||
|
||||
#if !defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)
|
||||
#include <iterator>
|
||||
#endif
|
||||
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
// BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
|
||||
|
||||
#if !defined(BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES)
|
||||
#if !defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)
|
||||
#define BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES 1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES)
|
||||
#define BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES 0
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace unordered {
|
||||
namespace detail {
|
||||
|
||||
template <class T> struct type_identity
|
||||
{
|
||||
using type = T;
|
||||
};
|
||||
|
||||
template <typename... Ts> struct make_void
|
||||
{
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
template <typename... Ts> using void_t = typename make_void<Ts...>::type;
|
||||
|
||||
template <class T, class = void> struct is_complete : std::false_type
|
||||
{
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_complete<T, void_t<int[sizeof(T)]> > : std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
template <class T>
|
||||
using is_complete_and_move_constructible =
|
||||
typename std::conditional<is_complete<T>::value,
|
||||
std::is_move_constructible<T>, std::false_type>::type;
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 50000)
|
||||
/* std::is_trivially_default_constructible not provided */
|
||||
template <class T>
|
||||
struct is_trivially_default_constructible
|
||||
: public std::integral_constant<bool,
|
||||
std::is_default_constructible<T>::value &&
|
||||
std::has_trivial_default_constructor<T>::value>
|
||||
{
|
||||
};
|
||||
#else
|
||||
using std::is_trivially_default_constructible;
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 50000)
|
||||
/* std::is_trivially_copy_constructible not provided */
|
||||
template <class T>
|
||||
struct is_trivially_copy_constructible
|
||||
: public std::integral_constant<bool,
|
||||
std::is_copy_constructible<T>::value &&
|
||||
std::has_trivial_copy_constructor<T>::value>
|
||||
{
|
||||
};
|
||||
#else
|
||||
using std::is_trivially_copy_constructible;
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 50000)
|
||||
/* std::is_trivially_copy_assignable not provided */
|
||||
template <class T>
|
||||
struct is_trivially_copy_assignable
|
||||
: public std::integral_constant<bool,
|
||||
std::is_copy_assignable<T>::value &&
|
||||
std::has_trivial_copy_assign<T>::value>
|
||||
{
|
||||
};
|
||||
#else
|
||||
using std::is_trivially_copy_assignable;
|
||||
#endif
|
||||
|
||||
namespace type_traits_detail {
|
||||
using std::swap;
|
||||
|
||||
template <class T, class = void> struct is_nothrow_swappable_helper
|
||||
{
|
||||
constexpr static bool const value = false;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_nothrow_swappable_helper<T,
|
||||
void_t<decltype(swap(std::declval<T&>(), std::declval<T&>()))> >
|
||||
{
|
||||
constexpr static bool const value =
|
||||
noexcept(swap(std::declval<T&>(), std::declval<T&>()));
|
||||
};
|
||||
|
||||
} // namespace type_traits_detail
|
||||
|
||||
template <class T>
|
||||
struct is_nothrow_swappable
|
||||
: public std::integral_constant<bool,
|
||||
type_traits_detail::is_nothrow_swappable_helper<T>::value>
|
||||
{
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Type checkers used for the transparent member functions added by C++20
|
||||
// and up
|
||||
|
||||
template <class, class = void>
|
||||
struct is_transparent : public std::false_type
|
||||
{
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_transparent<T,
|
||||
boost::unordered::detail::void_t<typename T::is_transparent> >
|
||||
: public std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
template <class, class Hash, class KeyEqual> struct are_transparent
|
||||
{
|
||||
static bool const value =
|
||||
is_transparent<Hash>::value && is_transparent<KeyEqual>::value;
|
||||
};
|
||||
|
||||
template <class Key, class UnorderedMap> struct transparent_non_iterable
|
||||
{
|
||||
typedef typename UnorderedMap::hasher hash;
|
||||
typedef typename UnorderedMap::key_equal key_equal;
|
||||
typedef typename UnorderedMap::iterator iterator;
|
||||
typedef typename UnorderedMap::const_iterator const_iterator;
|
||||
|
||||
static bool const value =
|
||||
are_transparent<Key, hash, key_equal>::value &&
|
||||
!std::is_convertible<Key, iterator>::value &&
|
||||
!std::is_convertible<Key, const_iterator>::value;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
using remove_cvref_t =
|
||||
typename std::remove_cv<typename std::remove_reference<T>::type>::type;
|
||||
|
||||
template <class T, class U>
|
||||
using is_similar = std::is_same<remove_cvref_t<T>, remove_cvref_t<U> >;
|
||||
|
||||
template <class, class...> struct is_similar_to_any : std::false_type
|
||||
{
|
||||
};
|
||||
template <class T, class U, class... Us>
|
||||
struct is_similar_to_any<T, U, Us...>
|
||||
: std::conditional<is_similar<T, U>::value, is_similar<T, U>,
|
||||
is_similar_to_any<T, Us...> >::type
|
||||
{
|
||||
};
|
||||
|
||||
#if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
|
||||
// https://eel.is/c++draft/container.requirements#container.alloc.reqmts-34
|
||||
// https://eel.is/c++draft/container.requirements#unord.req.general-243
|
||||
|
||||
template <class InputIterator>
|
||||
constexpr bool const is_input_iterator_v =
|
||||
!std::is_integral<InputIterator>::value;
|
||||
|
||||
template <class A, class = void> struct is_allocator
|
||||
{
|
||||
constexpr static bool const value = false;
|
||||
};
|
||||
|
||||
template <class A>
|
||||
struct is_allocator<A,
|
||||
boost::unordered::detail::void_t<typename A::value_type,
|
||||
decltype(std::declval<A&>().allocate(std::size_t{}))> >
|
||||
{
|
||||
constexpr static bool const value = true;
|
||||
};
|
||||
|
||||
template <class A>
|
||||
constexpr bool const is_allocator_v = is_allocator<A>::value;
|
||||
|
||||
template <class H>
|
||||
constexpr bool const is_hash_v =
|
||||
!std::is_integral<H>::value && !is_allocator_v<H>;
|
||||
|
||||
template <class P> constexpr bool const is_pred_v = !is_allocator_v<P>;
|
||||
|
||||
template <typename T>
|
||||
using iter_key_t =
|
||||
typename std::iterator_traits<T>::value_type::first_type;
|
||||
template <typename T>
|
||||
using iter_val_t =
|
||||
typename std::iterator_traits<T>::value_type::second_type;
|
||||
template <typename T>
|
||||
using iter_to_alloc_t =
|
||||
typename std::pair<iter_key_t<T> const, iter_val_t<T> >;
|
||||
#endif
|
||||
|
||||
#if BOOST_CXX_VERSION < 201703L
|
||||
template <class T>
|
||||
constexpr typename std::add_const<T>::type& as_const(T& t) noexcept
|
||||
{
|
||||
return t;
|
||||
}
|
||||
template <class T> void as_const(const T&&) = delete;
|
||||
#else
|
||||
using std::as_const;
|
||||
#endif
|
||||
} // namespace detail
|
||||
} // namespace unordered
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UNORDERED_DETAIL_TYPE_TRAITS_HPP
|
||||
70
src/boost/unordered/hash_traits.hpp
Normal file
70
src/boost/unordered/hash_traits.hpp
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
/* Hash function characterization.
|
||||
*
|
||||
* Copyright 2022-2024 Joaquin M Lopez Munoz.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See https://www.boost.org/libs/unordered for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_UNORDERED_HASH_TRAITS_HPP
|
||||
#define BOOST_UNORDERED_HASH_TRAITS_HPP
|
||||
|
||||
#include <boost/unordered/detail/type_traits.hpp>
|
||||
|
||||
namespace boost{
|
||||
namespace unordered{
|
||||
|
||||
namespace detail{
|
||||
|
||||
template<typename Hash,typename=void>
|
||||
struct hash_is_avalanching_impl:std::false_type{};
|
||||
|
||||
template<typename IsAvalanching>
|
||||
struct avalanching_value
|
||||
{
|
||||
static constexpr bool value=IsAvalanching::value;
|
||||
};
|
||||
|
||||
/* may be explicitly marked as BOOST_DEPRECATED in the future */
|
||||
template<> struct avalanching_value<void>
|
||||
{
|
||||
static constexpr bool value=true;
|
||||
};
|
||||
|
||||
template<typename Hash>
|
||||
struct hash_is_avalanching_impl<
|
||||
Hash,
|
||||
boost::unordered::detail::void_t<typename Hash::is_avalanching>
|
||||
>:std::integral_constant<
|
||||
bool,
|
||||
avalanching_value<typename Hash::is_avalanching>::value
|
||||
>{};
|
||||
|
||||
template<typename Hash>
|
||||
struct hash_is_avalanching_impl<
|
||||
Hash,
|
||||
typename std::enable_if<((void)Hash::is_avalanching,true)>::type
|
||||
>{}; /* Hash::is_avalanching is not a type: compile error downstream */
|
||||
|
||||
} /* namespace detail */
|
||||
|
||||
/* Each trait can be partially specialized by users for concrete hash functions
|
||||
* when actual characterization differs from default.
|
||||
*/
|
||||
|
||||
/* hash_is_avalanching<Hash>::value is:
|
||||
* - false if Hash::is_avalanching is not present.
|
||||
* - Hash::is_avalanching::value if this is present and constexpr-convertible
|
||||
* to a bool.
|
||||
* - true if Hash::is_avalanching is void (deprecated).
|
||||
* - ill-formed otherwise.
|
||||
*/
|
||||
template<typename Hash>
|
||||
struct hash_is_avalanching: detail::hash_is_avalanching_impl<Hash>::type{};
|
||||
|
||||
} /* namespace unordered */
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
59
src/boost/unordered/unordered_flat_map_fwd.hpp
Normal file
59
src/boost/unordered/unordered_flat_map_fwd.hpp
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
|
||||
// Copyright (C) 2022 Christian Mazakas
|
||||
// Copyright (C) 2024 Braden Ganetsky
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_UNORDERED_FLAT_MAP_FWD_HPP_INCLUDED
|
||||
#define BOOST_UNORDERED_FLAT_MAP_FWD_HPP_INCLUDED
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/container_hash/hash_fwd.hpp>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
|
||||
#include <memory_resource>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace unordered {
|
||||
template <class Key, class T, class Hash = boost::hash<Key>,
|
||||
class KeyEqual = std::equal_to<Key>,
|
||||
class Allocator = std::allocator<std::pair<const Key, T> > >
|
||||
class unordered_flat_map;
|
||||
|
||||
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
|
||||
bool operator==(
|
||||
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
|
||||
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);
|
||||
|
||||
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
|
||||
bool operator!=(
|
||||
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
|
||||
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);
|
||||
|
||||
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
|
||||
void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& lhs,
|
||||
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& rhs)
|
||||
noexcept(noexcept(lhs.swap(rhs)));
|
||||
|
||||
#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
|
||||
namespace pmr {
|
||||
template <class Key, class T, class Hash = boost::hash<Key>,
|
||||
class KeyEqual = std::equal_to<Key> >
|
||||
using unordered_flat_map =
|
||||
boost::unordered::unordered_flat_map<Key, T, Hash, KeyEqual,
|
||||
std::pmr::polymorphic_allocator<std::pair<const Key, T> > >;
|
||||
} // namespace pmr
|
||||
#endif
|
||||
} // namespace unordered
|
||||
|
||||
using boost::unordered::unordered_flat_map;
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
414
src/boost/unordered/unordered_printers.hpp
Normal file
414
src/boost/unordered/unordered_printers.hpp
Normal file
|
|
@ -0,0 +1,414 @@
|
|||
// Copyright 2024 Braden Ganetsky
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// Generated on 2024-08-25T17:48:54
|
||||
|
||||
#ifndef BOOST_UNORDERED_UNORDERED_PRINTERS_HPP
|
||||
#define BOOST_UNORDERED_UNORDERED_PRINTERS_HPP
|
||||
|
||||
#ifndef BOOST_ALL_NO_EMBEDDED_GDB_SCRIPTS
|
||||
#if defined(__ELF__)
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Woverlength-strings"
|
||||
#endif
|
||||
__asm__(".pushsection \".debug_gdb_scripts\", \"MS\",%progbits,1\n"
|
||||
".ascii \"\\4gdb.inlined-script.BOOST_UNORDERED_UNORDERED_PRINTERS_HPP\\n\"\n"
|
||||
".ascii \"import gdb.printing\\n\"\n"
|
||||
".ascii \"import gdb.xmethod\\n\"\n"
|
||||
".ascii \"import re\\n\"\n"
|
||||
".ascii \"import math\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedHelpers:\\n\"\n"
|
||||
".ascii \" def maybe_unwrap_atomic(n):\\n\"\n"
|
||||
".ascii \" if f\\\"{n.type.strip_typedefs()}\\\".startswith(\\\"std::atomic<\\\"):\\n\"\n"
|
||||
".ascii \" underlying_type = n.type.template_argument(0)\\n\"\n"
|
||||
".ascii \" return n.cast(underlying_type)\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" return n\\n\"\n"
|
||||
|
||||
".ascii \" def maybe_unwrap_foa_element(e):\\n\"\n"
|
||||
".ascii \" if f\\\"{e.type.strip_typedefs()}\\\".startswith(\\\"boost::unordered::detail::foa::element_type<\\\"):\\n\"\n"
|
||||
".ascii \" return e[\\\"p\\\"]\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" return e\\n\"\n"
|
||||
|
||||
".ascii \" def maybe_unwrap_reference(value):\\n\"\n"
|
||||
".ascii \" if value.type.code == gdb.TYPE_CODE_REF:\\n\"\n"
|
||||
".ascii \" return value.referenced_value()\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" return value\\n\"\n"
|
||||
|
||||
".ascii \" def countr_zero(n):\\n\"\n"
|
||||
".ascii \" for i in range(32):\\n\"\n"
|
||||
".ascii \" if (n & (1 << i)) != 0:\\n\"\n"
|
||||
".ascii \" return i\\n\"\n"
|
||||
".ascii \" return 32\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedPointerCustomizationPoint:\\n\"\n"
|
||||
".ascii \" def __init__(self, any_ptr):\\n\"\n"
|
||||
".ascii \" vis = gdb.default_visualizer(any_ptr)\\n\"\n"
|
||||
".ascii \" if vis is None:\\n\"\n"
|
||||
".ascii \" self.to_address = lambda ptr: ptr\\n\"\n"
|
||||
".ascii \" self.next = lambda ptr, offset: ptr + offset\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" self.to_address = lambda ptr: ptr if (ptr.type.code == gdb.TYPE_CODE_PTR) else type(vis).boost_to_address(ptr)\\n\"\n"
|
||||
".ascii \" self.next = lambda ptr, offset: type(vis).boost_next(ptr, offset)\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedFcaPrinter:\\n\"\n"
|
||||
".ascii \" def __init__(self, val):\\n\"\n"
|
||||
".ascii \" self.val = BoostUnorderedHelpers.maybe_unwrap_reference(val)\\n\"\n"
|
||||
".ascii \" self.name = f\\\"{self.val.type.strip_typedefs()}\\\".split(\\\"<\\\")[0]\\n\"\n"
|
||||
".ascii \" self.name = self.name.replace(\\\"boost::unordered::\\\", \\\"boost::\\\")\\n\"\n"
|
||||
".ascii \" self.is_map = self.name.endswith(\\\"map\\\")\\n\"\n"
|
||||
".ascii \" self.cpo = BoostUnorderedPointerCustomizationPoint(self.val[\\\"table_\\\"][\\\"buckets_\\\"][\\\"buckets\\\"])\\n\"\n"
|
||||
|
||||
".ascii \" def to_string(self):\\n\"\n"
|
||||
".ascii \" size = self.val[\\\"table_\\\"][\\\"size_\\\"]\\n\"\n"
|
||||
".ascii \" return f\\\"{self.name} with {size} elements\\\"\\n\"\n"
|
||||
|
||||
".ascii \" def display_hint(self):\\n\"\n"
|
||||
".ascii \" return \\\"map\\\"\\n\"\n"
|
||||
|
||||
".ascii \" def children(self):\\n\"\n"
|
||||
".ascii \" def generator():\\n\"\n"
|
||||
".ascii \" grouped_buckets = self.val[\\\"table_\\\"][\\\"buckets_\\\"]\\n\"\n"
|
||||
|
||||
".ascii \" size = grouped_buckets[\\\"size_\\\"]\\n\"\n"
|
||||
".ascii \" buckets = grouped_buckets[\\\"buckets\\\"]\\n\"\n"
|
||||
".ascii \" bucket_index = 0\\n\"\n"
|
||||
|
||||
".ascii \" count = 0\\n\"\n"
|
||||
".ascii \" while bucket_index != size:\\n\"\n"
|
||||
".ascii \" current_bucket = self.cpo.next(self.cpo.to_address(buckets), bucket_index)\\n\"\n"
|
||||
".ascii \" node = self.cpo.to_address(current_bucket.dereference()[\\\"next\\\"])\\n\"\n"
|
||||
".ascii \" while node != 0:\\n\"\n"
|
||||
".ascii \" value = node.dereference()[\\\"buf\\\"][\\\"t_\\\"]\\n\"\n"
|
||||
".ascii \" if self.is_map:\\n\"\n"
|
||||
".ascii \" first = value[\\\"first\\\"]\\n\"\n"
|
||||
".ascii \" second = value[\\\"second\\\"]\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", first\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", second\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", count\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", value\\n\"\n"
|
||||
".ascii \" count += 1\\n\"\n"
|
||||
".ascii \" node = self.cpo.to_address(node.dereference()[\\\"next\\\"])\\n\"\n"
|
||||
".ascii \" bucket_index += 1\\n\"\n"
|
||||
|
||||
".ascii \" return generator()\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedFcaIteratorPrinter:\\n\"\n"
|
||||
".ascii \" def __init__(self, val):\\n\"\n"
|
||||
".ascii \" self.val = val\\n\"\n"
|
||||
".ascii \" self.cpo = BoostUnorderedPointerCustomizationPoint(self.val[\\\"p\\\"])\\n\"\n"
|
||||
|
||||
".ascii \" def to_string(self):\\n\"\n"
|
||||
".ascii \" if self.valid():\\n\"\n"
|
||||
".ascii \" value = self.cpo.to_address(self.val[\\\"p\\\"]).dereference()[\\\"buf\\\"][\\\"t_\\\"]\\n\"\n"
|
||||
".ascii \" return f\\\"iterator = {{ {value} }}\\\"\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" return \\\"iterator = { end iterator }\\\"\\n\"\n"
|
||||
|
||||
".ascii \" def valid(self):\\n\"\n"
|
||||
".ascii \" return (self.cpo.to_address(self.val[\\\"p\\\"]) != 0) and (self.cpo.to_address(self.val[\\\"itb\\\"][\\\"p\\\"]) != 0)\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedFoaTableCoreCumulativeStatsPrinter:\\n\"\n"
|
||||
".ascii \" def __init__(self, val):\\n\"\n"
|
||||
".ascii \" self.val = val\\n\"\n"
|
||||
|
||||
".ascii \" def to_string(self):\\n\"\n"
|
||||
".ascii \" return \\\"[stats]\\\"\\n\"\n"
|
||||
|
||||
".ascii \" def display_hint(self):\\n\"\n"
|
||||
".ascii \" return \\\"map\\\"\\n\"\n"
|
||||
|
||||
".ascii \" def children(self):\\n\"\n"
|
||||
".ascii \" def generator():\\n\"\n"
|
||||
".ascii \" members = [\\\"insertion\\\", \\\"successful_lookup\\\", \\\"unsuccessful_lookup\\\"]\\n\"\n"
|
||||
".ascii \" for member in members:\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", member\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", self.val[member]\\n\"\n"
|
||||
".ascii \" return generator()\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedFoaCumulativeStatsPrinter:\\n\"\n"
|
||||
".ascii \" def __init__(self, val):\\n\"\n"
|
||||
".ascii \" self.val = val\\n\"\n"
|
||||
".ascii \" self.n = self.val[\\\"n\\\"]\\n\"\n"
|
||||
".ascii \" self.N = self.val.type.template_argument(0)\\n\"\n"
|
||||
|
||||
".ascii \" def display_hint(self):\\n\"\n"
|
||||
".ascii \" return \\\"map\\\"\\n\"\n"
|
||||
|
||||
".ascii \" def children(self):\\n\"\n"
|
||||
".ascii \" def generator():\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", \\\"count\\\"\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", self.n\\n\"\n"
|
||||
|
||||
".ascii \" sequence_stats_data = gdb.lookup_type(\\\"boost::unordered::detail::foa::sequence_stats_data\\\")\\n\"\n"
|
||||
".ascii \" data = self.val[\\\"data\\\"]\\n\"\n"
|
||||
".ascii \" arr = data.address.reinterpret_cast(sequence_stats_data.pointer())\\n\"\n"
|
||||
".ascii \" def build_string(idx):\\n\"\n"
|
||||
".ascii \" entry = arr[idx]\\n\"\n"
|
||||
".ascii \" avg = float(entry[\\\"m\\\"])\\n\"\n"
|
||||
".ascii \" var = float(entry[\\\"s\\\"] / self.n) if (self.n != 0) else 0.0\\n\"\n"
|
||||
".ascii \" dev = math.sqrt(var)\\n\"\n"
|
||||
".ascii \" return f\\\"{{avg = {avg}, var = {var}, dev = {dev}}}\\\"\\n\"\n"
|
||||
|
||||
".ascii \" if self.N > 0:\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", \\\"probe_length\\\"\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", build_string(0)\\n\"\n"
|
||||
".ascii \" if self.N > 1:\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", \\\"num_comparisons\\\"\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", build_string(1)\\n\"\n"
|
||||
|
||||
".ascii \" return generator()\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedFoaPrinter:\\n\"\n"
|
||||
".ascii \" def __init__(self, val):\\n\"\n"
|
||||
".ascii \" self.val = BoostUnorderedHelpers.maybe_unwrap_reference(val)\\n\"\n"
|
||||
".ascii \" self.name = f\\\"{self.val.type.strip_typedefs()}\\\".split(\\\"<\\\")[0]\\n\"\n"
|
||||
".ascii \" self.name = self.name.replace(\\\"boost::unordered::\\\", \\\"boost::\\\")\\n\"\n"
|
||||
".ascii \" self.is_map = self.name.endswith(\\\"map\\\")\\n\"\n"
|
||||
".ascii \" self.cpo = BoostUnorderedPointerCustomizationPoint(self.val[\\\"table_\\\"][\\\"arrays\\\"][\\\"groups_\\\"])\\n\"\n"
|
||||
|
||||
".ascii \" def to_string(self):\\n\"\n"
|
||||
".ascii \" size = BoostUnorderedHelpers.maybe_unwrap_atomic(self.val[\\\"table_\\\"][\\\"size_ctrl\\\"][\\\"size\\\"])\\n\"\n"
|
||||
".ascii \" return f\\\"{self.name} with {size} elements\\\"\\n\"\n"
|
||||
|
||||
".ascii \" def display_hint(self):\\n\"\n"
|
||||
".ascii \" return \\\"map\\\"\\n\"\n"
|
||||
|
||||
".ascii \" def is_regular_layout(self, group):\\n\"\n"
|
||||
".ascii \" typename = group[\\\"m\\\"].type.strip_typedefs()\\n\"\n"
|
||||
".ascii \" array_size = typename.sizeof // typename.target().sizeof\\n\"\n"
|
||||
".ascii \" if array_size == 16:\\n\"\n"
|
||||
".ascii \" return True\\n\"\n"
|
||||
".ascii \" elif array_size == 2:\\n\"\n"
|
||||
".ascii \" return False\\n\"\n"
|
||||
|
||||
".ascii \" def match_occupied(self, group):\\n\"\n"
|
||||
".ascii \" m = group[\\\"m\\\"]\\n\"\n"
|
||||
".ascii \" at = lambda b: BoostUnorderedHelpers.maybe_unwrap_atomic(m[b][\\\"n\\\"])\\n\"\n"
|
||||
|
||||
".ascii \" if self.is_regular_layout(group):\\n\"\n"
|
||||
".ascii \" bits = [1 << b for b in range(16) if at(b) == 0]\\n\"\n"
|
||||
".ascii \" return 0x7FFF & ~sum(bits)\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" xx = at(0) | at(1)\\n\"\n"
|
||||
".ascii \" yy = xx | (xx >> 32)\\n\"\n"
|
||||
".ascii \" return 0x7FFF & (yy | (yy >> 16))\\n\"\n"
|
||||
|
||||
".ascii \" def is_sentinel(self, group, pos):\\n\"\n"
|
||||
".ascii \" m = group[\\\"m\\\"]\\n\"\n"
|
||||
".ascii \" at = lambda b: BoostUnorderedHelpers.maybe_unwrap_atomic(m[b][\\\"n\\\"])\\n\"\n"
|
||||
|
||||
".ascii \" N = group[\\\"N\\\"]\\n\"\n"
|
||||
".ascii \" sentinel_ = group[\\\"sentinel_\\\"]\\n\"\n"
|
||||
".ascii \" if self.is_regular_layout(group):\\n\"\n"
|
||||
".ascii \" return pos == N-1 and at(N-1) == sentinel_\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" return pos == N-1 and (at(0) & 0x4000400040004000) == 0x4000 and (at(1) & 0x4000400040004000) == 0\\n\"\n"
|
||||
|
||||
".ascii \" def children(self):\\n\"\n"
|
||||
".ascii \" def generator():\\n\"\n"
|
||||
".ascii \" table = self.val[\\\"table_\\\"]\\n\"\n"
|
||||
".ascii \" groups = self.cpo.to_address(table[\\\"arrays\\\"][\\\"groups_\\\"])\\n\"\n"
|
||||
".ascii \" elements = self.cpo.to_address(table[\\\"arrays\\\"][\\\"elements_\\\"])\\n\"\n"
|
||||
|
||||
".ascii \" pc_ = groups.cast(gdb.lookup_type(\\\"unsigned char\\\").pointer())\\n\"\n"
|
||||
".ascii \" p_ = elements\\n\"\n"
|
||||
".ascii \" first_time = True\\n\"\n"
|
||||
".ascii \" mask = 0\\n\"\n"
|
||||
".ascii \" n0 = 0\\n\"\n"
|
||||
".ascii \" n = 0\\n\"\n"
|
||||
|
||||
".ascii \" count = 0\\n\"\n"
|
||||
".ascii \" while p_ != 0:\\n\"\n"
|
||||
".ascii \" # This if block mirrors the condition in the begin() call\\n\"\n"
|
||||
".ascii \" if (not first_time) or (self.match_occupied(groups.dereference()) & 1):\\n\"\n"
|
||||
".ascii \" pointer = BoostUnorderedHelpers.maybe_unwrap_foa_element(p_)\\n\"\n"
|
||||
".ascii \" value = self.cpo.to_address(pointer).dereference()\\n\"\n"
|
||||
".ascii \" if self.is_map:\\n\"\n"
|
||||
".ascii \" first = value[\\\"first\\\"]\\n\"\n"
|
||||
".ascii \" second = value[\\\"second\\\"]\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", first\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", second\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", count\\n\"\n"
|
||||
".ascii \" yield \\\"\\\", value\\n\"\n"
|
||||
".ascii \" count += 1\\n\"\n"
|
||||
".ascii \" first_time = False\\n\"\n"
|
||||
|
||||
".ascii \" n0 = pc_.cast(gdb.lookup_type(\\\"uintptr_t\\\")) % groups.dereference().type.sizeof\\n\"\n"
|
||||
".ascii \" pc_ = self.cpo.next(pc_, -n0)\\n\"\n"
|
||||
|
||||
".ascii \" mask = (self.match_occupied(pc_.cast(groups.type).dereference()) >> (n0+1)) << (n0+1)\\n\"\n"
|
||||
".ascii \" while mask == 0:\\n\"\n"
|
||||
".ascii \" pc_ = self.cpo.next(pc_, groups.dereference().type.sizeof)\\n\"\n"
|
||||
".ascii \" p_ = self.cpo.next(p_, groups.dereference()[\\\"N\\\"])\\n\"\n"
|
||||
".ascii \" mask = self.match_occupied(pc_.cast(groups.type).dereference())\\n\"\n"
|
||||
|
||||
".ascii \" n = BoostUnorderedHelpers.countr_zero(mask)\\n\"\n"
|
||||
".ascii \" if self.is_sentinel(pc_.cast(groups.type).dereference(), n):\\n\"\n"
|
||||
".ascii \" p_ = 0\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" pc_ = self.cpo.next(pc_, n)\\n\"\n"
|
||||
".ascii \" p_ = self.cpo.next(p_, n - n0)\\n\"\n"
|
||||
|
||||
".ascii \" return generator()\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedFoaIteratorPrinter:\\n\"\n"
|
||||
".ascii \" def __init__(self, val):\\n\"\n"
|
||||
".ascii \" self.val = val\\n\"\n"
|
||||
".ascii \" self.cpo = BoostUnorderedPointerCustomizationPoint(self.val[\\\"p_\\\"])\\n\"\n"
|
||||
|
||||
".ascii \" def to_string(self):\\n\"\n"
|
||||
".ascii \" if self.valid():\\n\"\n"
|
||||
".ascii \" element = self.cpo.to_address(self.val[\\\"p_\\\"])\\n\"\n"
|
||||
".ascii \" pointer = BoostUnorderedHelpers.maybe_unwrap_foa_element(element)\\n\"\n"
|
||||
".ascii \" value = self.cpo.to_address(pointer).dereference()\\n\"\n"
|
||||
".ascii \" return f\\\"iterator = {{ {value} }}\\\"\\n\"\n"
|
||||
".ascii \" else:\\n\"\n"
|
||||
".ascii \" return \\\"iterator = { end iterator }\\\"\\n\"\n"
|
||||
|
||||
".ascii \" def valid(self):\\n\"\n"
|
||||
".ascii \" return (self.cpo.to_address(self.val[\\\"p_\\\"]) != 0) and (self.cpo.to_address(self.val[\\\"pc_\\\"]) != 0)\\n\"\n"
|
||||
|
||||
".ascii \"def boost_unordered_build_pretty_printer():\\n\"\n"
|
||||
".ascii \" pp = gdb.printing.RegexpCollectionPrettyPrinter(\\\"boost_unordered\\\")\\n\"\n"
|
||||
".ascii \" add_template_printer = lambda name, printer: pp.add_printer(name, f\\\"^{name}<.*>$\\\", printer)\\n\"\n"
|
||||
".ascii \" add_concrete_printer = lambda name, printer: pp.add_printer(name, f\\\"^{name}$\\\", printer)\\n\"\n"
|
||||
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::unordered_map\\\", BoostUnorderedFcaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::unordered_multimap\\\", BoostUnorderedFcaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::unordered_set\\\", BoostUnorderedFcaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::unordered_multiset\\\", BoostUnorderedFcaPrinter)\\n\"\n"
|
||||
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::detail::iterator_detail::iterator\\\", BoostUnorderedFcaIteratorPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::detail::iterator_detail::c_iterator\\\", BoostUnorderedFcaIteratorPrinter)\\n\"\n"
|
||||
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::unordered_flat_map\\\", BoostUnorderedFoaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::unordered_flat_set\\\", BoostUnorderedFoaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::unordered_node_map\\\", BoostUnorderedFoaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::unordered_node_set\\\", BoostUnorderedFoaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::concurrent_flat_map\\\", BoostUnorderedFoaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::concurrent_flat_set\\\", BoostUnorderedFoaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::concurrent_node_map\\\", BoostUnorderedFoaPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::concurrent_node_set\\\", BoostUnorderedFoaPrinter)\\n\"\n"
|
||||
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::detail::foa::table_iterator\\\", BoostUnorderedFoaIteratorPrinter)\\n\"\n"
|
||||
|
||||
".ascii \" add_concrete_printer(\\\"boost::unordered::detail::foa::table_core_cumulative_stats\\\", BoostUnorderedFoaTableCoreCumulativeStatsPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::detail::foa::cumulative_stats\\\", BoostUnorderedFoaCumulativeStatsPrinter)\\n\"\n"
|
||||
".ascii \" add_template_printer(\\\"boost::unordered::detail::foa::concurrent_cumulative_stats\\\", BoostUnorderedFoaCumulativeStatsPrinter)\\n\"\n"
|
||||
|
||||
".ascii \" return pp\\n\"\n"
|
||||
|
||||
".ascii \"gdb.printing.register_pretty_printer(gdb.current_objfile(), boost_unordered_build_pretty_printer())\\n\"\n"
|
||||
|
||||
|
||||
|
||||
".ascii \"# https://sourceware.org/gdb/current/onlinedocs/gdb.html/Writing-an-Xmethod.html\\n\"\n"
|
||||
".ascii \"class BoostUnorderedFoaGetStatsMethod(gdb.xmethod.XMethod):\\n\"\n"
|
||||
".ascii \" def __init__(self):\\n\"\n"
|
||||
".ascii \" gdb.xmethod.XMethod.__init__(self, \\\"get_stats\\\")\\n\"\n"
|
||||
|
||||
".ascii \" def get_worker(self, method_name):\\n\"\n"
|
||||
".ascii \" if method_name == \\\"get_stats\\\":\\n\"\n"
|
||||
".ascii \" return BoostUnorderedFoaGetStatsWorker()\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedFoaGetStatsWorker(gdb.xmethod.XMethodWorker):\\n\"\n"
|
||||
".ascii \" def get_arg_types(self):\\n\"\n"
|
||||
".ascii \" return None\\n\"\n"
|
||||
|
||||
".ascii \" def get_result_type(self, obj):\\n\"\n"
|
||||
".ascii \" return gdb.lookup_type(\\\"boost::unordered::detail::foa::table_core_cumulative_stats\\\")\\n\"\n"
|
||||
|
||||
".ascii \" def __call__(self, obj):\\n\"\n"
|
||||
".ascii \" try:\\n\"\n"
|
||||
".ascii \" return obj[\\\"table_\\\"][\\\"cstats\\\"]\\n\"\n"
|
||||
".ascii \" except gdb.error:\\n\"\n"
|
||||
".ascii \" print(\\\"Error: Binary was compiled without stats. Recompile with `BOOST_UNORDERED_ENABLE_STATS` defined.\\\")\\n\"\n"
|
||||
".ascii \" return\\n\"\n"
|
||||
|
||||
".ascii \"class BoostUnorderedFoaMatcher(gdb.xmethod.XMethodMatcher):\\n\"\n"
|
||||
".ascii \" def __init__(self):\\n\"\n"
|
||||
".ascii \" gdb.xmethod.XMethodMatcher.__init__(self, 'BoostUnorderedFoaMatcher')\\n\"\n"
|
||||
".ascii \" self.methods = [BoostUnorderedFoaGetStatsMethod()]\\n\"\n"
|
||||
|
||||
".ascii \" def match(self, class_type, method_name):\\n\"\n"
|
||||
".ascii \" template_name = f\\\"{class_type.strip_typedefs()}\\\".split(\\\"<\\\")[0]\\n\"\n"
|
||||
".ascii \" regex = \\\"^boost::unordered::(unordered|concurrent)_(flat|node)_(map|set)$\\\"\\n\"\n"
|
||||
".ascii \" if not re.match(regex, template_name):\\n\"\n"
|
||||
".ascii \" return None\\n\"\n"
|
||||
|
||||
".ascii \" workers = []\\n\"\n"
|
||||
".ascii \" for method in self.methods:\\n\"\n"
|
||||
".ascii \" if method.enabled:\\n\"\n"
|
||||
".ascii \" worker = method.get_worker(method_name)\\n\"\n"
|
||||
".ascii \" if worker:\\n\"\n"
|
||||
".ascii \" workers.append(worker)\\n\"\n"
|
||||
".ascii \" return workers\\n\"\n"
|
||||
|
||||
".ascii \"gdb.xmethod.register_xmethod_matcher(None, BoostUnorderedFoaMatcher())\\n\"\n"
|
||||
|
||||
|
||||
|
||||
".ascii \"\\\"\\\"\\\" Fancy pointer support \\\"\\\"\\\"\\n\"\n"
|
||||
|
||||
".ascii \"\\\"\\\"\\\"\\n\"\n"
|
||||
".ascii \"To allow your own fancy pointer type to interact with Boost.Unordered GDB pretty-printers,\\n\"\n"
|
||||
".ascii \"create a pretty-printer for your own type with the following additional methods.\\n\"\n"
|
||||
|
||||
".ascii \"(Note, this is assuming the presence of a type alias `pointer` for the underlying\\n\"\n"
|
||||
".ascii \"raw pointer type, Substitute whichever name is applicable in your case.)\\n\"\n"
|
||||
|
||||
".ascii \"`boost_to_address(fancy_ptr)`\\n\"\n"
|
||||
".ascii \" * A static method, but `@staticmethod` is not required\\n\"\n"
|
||||
".ascii \" * Parameter `fancy_ptr` of type `gdb.Value`\\n\"\n"
|
||||
".ascii \" * Its `.type` will be your fancy pointer type\\n\"\n"
|
||||
".ascii \" * Returns a `gdb.Value` with the raw pointer equivalent to your fancy pointer\\n\"\n"
|
||||
".ascii \" * This method should be equivalent to calling `operator->()` on your fancy pointer in C++\\n\"\n"
|
||||
|
||||
".ascii \"`boost_next(raw_ptr, offset)`\\n\"\n"
|
||||
".ascii \" * Parameter `raw_ptr` of type `gdb.Value`\\n\"\n"
|
||||
".ascii \" * Its `.type` will be `pointer`\\n\"\n"
|
||||
".ascii \" * Parameter `offset`\\n\"\n"
|
||||
".ascii \" * Either has integer type, or is of type `gdb.Value` with an underlying integer\\n\"\n"
|
||||
".ascii \" * Returns a `gdb.Value` with the raw pointer equivalent to your fancy pointer, as if you did the following operations\\n\"\n"
|
||||
".ascii \" 1. Convert the incoming raw pointer to your fancy pointer\\n\"\n"
|
||||
".ascii \" 2. Use operator+= to add the offset to the fancy pointer\\n\"\n"
|
||||
".ascii \" 3. Convert back to the raw pointer\\n\"\n"
|
||||
".ascii \" * Note, you will not actually do these operations as stated. You will do equivalent lower-level operations that emulate having done the above\\n\"\n"
|
||||
".ascii \" * Ultimately, it will be as if you called `operator+()` on your fancy pointer in C++, but using only raw pointers\\n\"\n"
|
||||
|
||||
".ascii \"Example\\n\"\n"
|
||||
".ascii \"```\\n\"\n"
|
||||
".ascii \"class MyFancyPtrPrinter:\\n\"\n"
|
||||
".ascii \" ...\\n\"\n"
|
||||
|
||||
".ascii \" # Equivalent to `operator->()`\\n\"\n"
|
||||
".ascii \" def boost_to_address(fancy_ptr):\\n\"\n"
|
||||
".ascii \" ...\\n\"\n"
|
||||
".ascii \" return ...\\n\"\n"
|
||||
|
||||
".ascii \" # Equivalent to `operator+()`\\n\"\n"
|
||||
".ascii \" def boost_next(raw_ptr, offset):\\n\"\n"
|
||||
".ascii \" ...\\n\"\n"
|
||||
".ascii \" return ...\\n\"\n"
|
||||
|
||||
".ascii \" ...\\n\"\n"
|
||||
".ascii \"```\\n\"\n"
|
||||
".ascii \"\\\"\\\"\\\"\\n\"\n"
|
||||
|
||||
".byte 0\n"
|
||||
".popsection\n");
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic pop
|
||||
#endif
|
||||
#endif // defined(__ELF__)
|
||||
#endif // !defined(BOOST_ALL_NO_EMBEDDED_GDB_SCRIPTS)
|
||||
|
||||
#endif // !defined(BOOST_UNORDERED_UNORDERED_PRINTERS_HPP)
|
||||
Loading…
Add table
Add a link
Reference in a new issue