| // -*- C++ -*- |
| //===------------------------ memory_resource -----------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE |
| #define _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE |
| |
| /** |
| experimental/memory_resource synopsis |
| |
| // C++1y |
| |
| namespace std { |
| namespace experimental { |
| inline namespace fundamentals_v1 { |
| namespace pmr { |
| |
| class memory_resource; |
| |
| bool operator==(const memory_resource& a, |
| const memory_resource& b) noexcept; |
| bool operator!=(const memory_resource& a, |
| const memory_resource& b) noexcept; |
| |
| template <class Tp> class polymorphic_allocator; |
| |
| template <class T1, class T2> |
| bool operator==(const polymorphic_allocator<T1>& a, |
| const polymorphic_allocator<T2>& b) noexcept; |
| template <class T1, class T2> |
| bool operator!=(const polymorphic_allocator<T1>& a, |
| const polymorphic_allocator<T2>& b) noexcept; |
| |
| // The name resource_adaptor_imp is for exposition only. |
| template <class Allocator> class resource_adaptor_imp; |
| |
| template <class Allocator> |
| using resource_adaptor = resource_adaptor_imp< |
| allocator_traits<Allocator>::rebind_alloc<char>>; |
| |
| // Global memory resources |
| memory_resource* new_delete_resource() noexcept; |
| memory_resource* null_memory_resource() noexcept; |
| |
| // The default memory resource |
| memory_resource* set_default_resource(memory_resource* r) noexcept; |
| memory_resource* get_default_resource() noexcept; |
| |
| // Standard memory resources |
| struct pool_options; |
| class synchronized_pool_resource; |
| class unsynchronized_pool_resource; |
| class monotonic_buffer_resource; |
| |
| } // namespace pmr |
| } // namespace fundamentals_v1 |
| } // namespace experimental |
| } // namespace std |
| |
| */ |
| |
| #include <experimental/__config> |
| #include <experimental/__memory> |
| #include <limits> |
| #include <memory> |
| #include <new> |
| #include <stdexcept> |
| #include <__tuple> |
| #include <type_traits> |
| #include <utility> |
| #include <cstddef> |
| #include <cstdlib> |
| #include <__debug> |
| |
| #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
| #pragma GCC system_header |
| #endif |
| |
| _LIBCPP_PUSH_MACROS |
| #include <__undef_macros> |
| |
| _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR |
| |
| // Round __s up to next multiple of __a. |
| inline _LIBCPP_INLINE_VISIBILITY |
| size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT |
| { |
| _LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows"); |
| return (__s + __a - 1) & ~(__a - 1); |
| } |
| |
| // 8.5, memory.resource |
| class _LIBCPP_TYPE_VIS memory_resource |
| { |
| static const size_t __max_align = _LIBCPP_ALIGNOF(max_align_t); |
| |
| // 8.5.2, memory.resource.public |
| public: |
| virtual ~memory_resource() = default; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| void* allocate(size_t __bytes, size_t __align = __max_align) |
| { return do_allocate(__bytes, __align); } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| void deallocate(void * __p, size_t __bytes, size_t __align = __max_align) |
| { do_deallocate(__p, __bytes, __align); } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| bool is_equal(memory_resource const & __other) const _NOEXCEPT |
| { return do_is_equal(__other); } |
| |
| // 8.5.3, memory.resource.priv |
| private: |
| virtual void* do_allocate(size_t, size_t) = 0; |
| virtual void do_deallocate(void*, size_t, size_t) = 0; |
| virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0; |
| }; |
| |
| // 8.5.4, memory.resource.eq |
| inline _LIBCPP_INLINE_VISIBILITY |
| bool operator==(memory_resource const & __lhs, |
| memory_resource const & __rhs) _NOEXCEPT |
| { |
| return &__lhs == &__rhs || __lhs.is_equal(__rhs); |
| } |
| |
| inline _LIBCPP_INLINE_VISIBILITY |
| bool operator!=(memory_resource const & __lhs, |
| memory_resource const & __rhs) _NOEXCEPT |
| { |
| return !(__lhs == __rhs); |
| } |
| |
| _LIBCPP_FUNC_VIS |
| memory_resource * new_delete_resource() _NOEXCEPT; |
| |
| _LIBCPP_FUNC_VIS |
| memory_resource * null_memory_resource() _NOEXCEPT; |
| |
| _LIBCPP_FUNC_VIS |
| memory_resource * get_default_resource() _NOEXCEPT; |
| |
| _LIBCPP_FUNC_VIS |
| memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT; |
| |
| // 8.6, memory.polymorphic.allocator.class |
| |
| // 8.6.1, memory.polymorphic.allocator.overview |
| template <class _ValueType> |
| class _LIBCPP_TEMPLATE_VIS polymorphic_allocator |
| { |
| public: |
| typedef _ValueType value_type; |
| |
| // 8.6.2, memory.polymorphic.allocator.ctor |
| _LIBCPP_INLINE_VISIBILITY |
| polymorphic_allocator() _NOEXCEPT |
| : __res_(_VSTD_LFTS_PMR::get_default_resource()) |
| {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| polymorphic_allocator(memory_resource * __r) _NOEXCEPT |
| : __res_(__r) |
| {} |
| |
| polymorphic_allocator(polymorphic_allocator const &) = default; |
| |
| template <class _Tp> |
| _LIBCPP_INLINE_VISIBILITY |
| polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT |
| : __res_(__other.resource()) |
| {} |
| |
| polymorphic_allocator & |
| operator=(polymorphic_allocator const &) = delete; |
| |
| // 8.6.3, memory.polymorphic.allocator.mem |
| _LIBCPP_INLINE_VISIBILITY |
| _ValueType* allocate(size_t __n) { |
| if (__n > __max_size()) { |
| __throw_length_error( |
| "std::experimental::pmr::polymorphic_allocator<T>::allocate(size_t n)" |
| " 'n' exceeds maximum supported size"); |
| } |
| return static_cast<_ValueType*>( |
| __res_->allocate(__n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType)) |
| ); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT { |
| _LIBCPP_ASSERT(__n <= __max_size(), |
| "deallocate called for size which exceeds max_size()"); |
| __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType)); |
| } |
| |
| template <class _Tp, class ..._Ts> |
| _LIBCPP_INLINE_VISIBILITY |
| void construct(_Tp* __p, _Ts &&... __args) |
| { |
| _VSTD_LFTS::__lfts_user_alloc_construct( |
| __p, *this, _VSTD::forward<_Ts>(__args)... |
| ); |
| } |
| |
| template <class _T1, class _T2, class ..._Args1, class ..._Args2> |
| _LIBCPP_INLINE_VISIBILITY |
| void construct(pair<_T1, _T2>* __p, piecewise_construct_t, |
| tuple<_Args1...> __x, tuple<_Args2...> __y) |
| { |
| ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct |
| , __transform_tuple( |
| typename __lfts_uses_alloc_ctor< |
| _T1, polymorphic_allocator&, _Args1... |
| >::type() |
| , _VSTD::move(__x) |
| , typename __make_tuple_indices<sizeof...(_Args1)>::type{} |
| ) |
| , __transform_tuple( |
| typename __lfts_uses_alloc_ctor< |
| _T2, polymorphic_allocator&, _Args2... |
| >::type() |
| , _VSTD::move(__y) |
| , typename __make_tuple_indices<sizeof...(_Args2)>::type{} |
| ) |
| ); |
| } |
| |
| template <class _T1, class _T2> |
| _LIBCPP_INLINE_VISIBILITY |
| void construct(pair<_T1, _T2>* __p) { |
| construct(__p, piecewise_construct, tuple<>(), tuple<>()); |
| } |
| |
| template <class _T1, class _T2, class _Up, class _Vp> |
| _LIBCPP_INLINE_VISIBILITY |
| void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) { |
| construct(__p, piecewise_construct |
| , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u)) |
| , _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v))); |
| } |
| |
| template <class _T1, class _T2, class _U1, class _U2> |
| _LIBCPP_INLINE_VISIBILITY |
| void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) { |
| construct(__p, piecewise_construct |
| , _VSTD::forward_as_tuple(__pr.first) |
| , _VSTD::forward_as_tuple(__pr.second)); |
| } |
| |
| template <class _T1, class _T2, class _U1, class _U2> |
| _LIBCPP_INLINE_VISIBILITY |
| void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){ |
| construct(__p, piecewise_construct |
| , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first)) |
| , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second))); |
| } |
| |
| template <class _Tp> |
| _LIBCPP_INLINE_VISIBILITY |
| void destroy(_Tp * __p) _NOEXCEPT |
| { __p->~_Tp(); } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| polymorphic_allocator |
| select_on_container_copy_construction() const _NOEXCEPT |
| { return polymorphic_allocator(); } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| memory_resource * resource() const _NOEXCEPT |
| { return __res_; } |
| |
| private: |
| template <class ..._Args, size_t ..._Idx> |
| _LIBCPP_INLINE_VISIBILITY |
| tuple<_Args&&...> |
| __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, |
| __tuple_indices<_Idx...>) const |
| { |
| return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...); |
| } |
| |
| template <class ..._Args, size_t ..._Idx> |
| _LIBCPP_INLINE_VISIBILITY |
| tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...> |
| __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t, |
| __tuple_indices<_Idx...>) |
| { |
| using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>; |
| return _Tup(allocator_arg, *this, |
| _VSTD::get<_Idx>(_VSTD::move(__t))...); |
| } |
| |
| template <class ..._Args, size_t ..._Idx> |
| _LIBCPP_INLINE_VISIBILITY |
| tuple<_Args&&..., polymorphic_allocator&> |
| __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t, |
| __tuple_indices<_Idx...>) |
| { |
| using _Tup = tuple<_Args&&..., polymorphic_allocator&>; |
| return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t __max_size() const _NOEXCEPT |
| { return numeric_limits<size_t>::max() / sizeof(value_type); } |
| |
| memory_resource * __res_; |
| }; |
| |
| // 8.6.4, memory.polymorphic.allocator.eq |
| |
| template <class _Tp, class _Up> |
| inline _LIBCPP_INLINE_VISIBILITY |
| bool operator==(polymorphic_allocator<_Tp> const & __lhs, |
| polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT |
| { |
| return *__lhs.resource() == *__rhs.resource(); |
| } |
| |
| template <class _Tp, class _Up> |
| inline _LIBCPP_INLINE_VISIBILITY |
| bool operator!=(polymorphic_allocator<_Tp> const & __lhs, |
| polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT |
| { |
| return !(__lhs == __rhs); |
| } |
| |
| // 8.7, memory.resource.adaptor |
| |
| // 8.7.1, memory.resource.adaptor.overview |
| template <class _CharAlloc> |
| class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp |
| : public memory_resource |
| { |
| using _CTraits = allocator_traits<_CharAlloc>; |
| static_assert(is_same<typename _CTraits::value_type, char>::value |
| && is_same<typename _CTraits::pointer, char*>::value |
| && is_same<typename _CTraits::void_pointer, void*>::value, ""); |
| |
| static const size_t _MaxAlign = _LIBCPP_ALIGNOF(max_align_t); |
| |
| using _Alloc = typename _CTraits::template rebind_alloc< |
| typename aligned_storage<_MaxAlign, _MaxAlign>::type |
| >; |
| |
| using _ValueType = typename _Alloc::value_type; |
| |
| _Alloc __alloc_; |
| |
| public: |
| typedef _CharAlloc allocator_type; |
| |
| __resource_adaptor_imp() = default; |
| __resource_adaptor_imp(__resource_adaptor_imp const &) = default; |
| __resource_adaptor_imp(__resource_adaptor_imp &&) = default; |
| |
| // 8.7.2, memory.resource.adaptor.ctor |
| |
| _LIBCPP_INLINE_VISIBILITY |
| explicit __resource_adaptor_imp(allocator_type const & __a) |
| : __alloc_(__a) |
| {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| explicit __resource_adaptor_imp(allocator_type && __a) |
| : __alloc_(_VSTD::move(__a)) |
| {} |
| |
| __resource_adaptor_imp & |
| operator=(__resource_adaptor_imp const &) = default; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| allocator_type get_allocator() const |
| { return __alloc_; } |
| |
| // 8.7.3, memory.resource.adaptor.mem |
| private: |
| virtual void * do_allocate(size_t __bytes, size_t) |
| { |
| if (__bytes > __max_size()) { |
| __throw_length_error( |
| "std::experimental::pmr::resource_adaptor<T>::do_allocate(size_t bytes, size_t align)" |
| " 'bytes' exceeds maximum supported size"); |
| } |
| size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign; |
| return __alloc_.allocate(__s); |
| } |
| |
| virtual void do_deallocate(void * __p, size_t __bytes, size_t) |
| { |
| _LIBCPP_ASSERT(__bytes <= __max_size(), |
| "do_deallocate called for size which exceeds the maximum allocation size"); |
| size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign; |
| __alloc_.deallocate((_ValueType*)__p, __s); |
| } |
| |
| virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT { |
| __resource_adaptor_imp const * __p |
| = dynamic_cast<__resource_adaptor_imp const *>(&__other); |
| return __p ? __alloc_ == __p->__alloc_ : false; |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t __max_size() const _NOEXCEPT { |
| return numeric_limits<size_t>::max() - _MaxAlign; |
| } |
| }; |
| |
| template <class _Alloc> |
| using resource_adaptor = __resource_adaptor_imp< |
| typename allocator_traits<_Alloc>::template rebind_alloc<char> |
| >; |
| |
| _LIBCPP_END_NAMESPACE_LFTS_PMR |
| |
| _LIBCPP_POP_MACROS |
| |
| #endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */ |