Home | History | Annotate | Line # | Download | only in experimental
memory_resource revision 1.1.1.1 
      1 // -*- C++ -*-
      2 //===------------------------ memory_resource -----------------------------===//
      3 //
      4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      5 // See https://llvm.org/LICENSE.txt for license information.
      6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #ifndef _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE
     11 #define _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE
     12 
     13 /**
     14     experimental/memory_resource synopsis
     15 
     16 // C++1y
     17 
     18 namespace std {
     19 namespace experimental {
     20 inline namespace fundamentals_v1 {
     21 namespace pmr {
     22 
     23   class memory_resource;
     24 
     25   bool operator==(const memory_resource& a,
     26                   const memory_resource& b) noexcept;
     27   bool operator!=(const memory_resource& a,
     28                   const memory_resource& b) noexcept;
     29 
     30   template <class Tp> class polymorphic_allocator;
     31 
     32   template <class T1, class T2>
     33   bool operator==(const polymorphic_allocator<T1>& a,
     34                   const polymorphic_allocator<T2>& b) noexcept;
     35   template <class T1, class T2>
     36   bool operator!=(const polymorphic_allocator<T1>& a,
     37                   const polymorphic_allocator<T2>& b) noexcept;
     38 
     39   // The name resource_adaptor_imp is for exposition only.
     40   template <class Allocator> class resource_adaptor_imp;
     41 
     42   template <class Allocator>
     43     using resource_adaptor = resource_adaptor_imp<
     44       allocator_traits<Allocator>::rebind_alloc<char>>;
     45 
     46   // Global memory resources
     47   memory_resource* new_delete_resource() noexcept;
     48   memory_resource* null_memory_resource() noexcept;
     49 
     50   // The default memory resource
     51   memory_resource* set_default_resource(memory_resource* r) noexcept;
     52   memory_resource* get_default_resource() noexcept;
     53 
     54   // Standard memory resources
     55   struct pool_options;
     56   class synchronized_pool_resource;
     57   class unsynchronized_pool_resource;
     58   class monotonic_buffer_resource;
     59 
     60 } // namespace pmr
     61 } // namespace fundamentals_v1
     62 } // namespace experimental
     63 } // namespace std
     64 
     65  */
     66 
     67 #include <experimental/__config>
     68 #include <experimental/__memory>
     69 #include <limits>
     70 #include <memory>
     71 #include <new>
     72 #include <stdexcept>
     73 #include <__tuple>
     74 #include <type_traits>
     75 #include <utility>
     76 #include <cstddef>
     77 #include <cstdlib>
     78 #include <__debug>
     79 
     80 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
     81 #pragma GCC system_header
     82 #endif
     83 
     84 _LIBCPP_PUSH_MACROS
     85 #include <__undef_macros>
     86 
     87 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
     88 
     89 // Round __s up to next multiple of __a.
     90 inline _LIBCPP_INLINE_VISIBILITY
     91 size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT
     92 {
     93     _LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows");
     94     return (__s + __a - 1) & ~(__a - 1);
     95 }
     96 
     97 // 8.5, memory.resource
     98 class _LIBCPP_TYPE_VIS memory_resource
     99 {
    100     static const size_t __max_align = _LIBCPP_ALIGNOF(max_align_t);
    101 
    102 // 8.5.2, memory.resource.public
    103 public:
    104     virtual ~memory_resource() = default;
    105 
    106     _LIBCPP_INLINE_VISIBILITY
    107     void* allocate(size_t __bytes, size_t __align = __max_align)
    108         { return do_allocate(__bytes, __align); }
    109 
    110     _LIBCPP_INLINE_VISIBILITY
    111     void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
    112         { do_deallocate(__p, __bytes, __align); }
    113 
    114     _LIBCPP_INLINE_VISIBILITY
    115     bool is_equal(memory_resource const & __other) const _NOEXCEPT
    116         { return do_is_equal(__other); }
    117 
    118 // 8.5.3, memory.resource.priv
    119 private:
    120     virtual void* do_allocate(size_t, size_t) = 0;
    121     virtual void do_deallocate(void*, size_t, size_t) = 0;
    122     virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
    123 };
    124 
    125 // 8.5.4, memory.resource.eq
    126 inline _LIBCPP_INLINE_VISIBILITY
    127 bool operator==(memory_resource const & __lhs,
    128                 memory_resource const & __rhs) _NOEXCEPT
    129 {
    130     return &__lhs == &__rhs || __lhs.is_equal(__rhs);
    131 }
    132 
    133 inline _LIBCPP_INLINE_VISIBILITY
    134 bool operator!=(memory_resource const & __lhs,
    135                 memory_resource const & __rhs) _NOEXCEPT
    136 {
    137     return !(__lhs == __rhs);
    138 }
    139 
    140 _LIBCPP_FUNC_VIS
    141 memory_resource * new_delete_resource() _NOEXCEPT;
    142 
    143 _LIBCPP_FUNC_VIS
    144 memory_resource * null_memory_resource() _NOEXCEPT;
    145 
    146 _LIBCPP_FUNC_VIS
    147 memory_resource * get_default_resource() _NOEXCEPT;
    148 
    149 _LIBCPP_FUNC_VIS
    150 memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;
    151 
    152 // 8.6, memory.polymorphic.allocator.class
    153 
    154 // 8.6.1, memory.polymorphic.allocator.overview
    155 template <class _ValueType>
    156 class _LIBCPP_TEMPLATE_VIS polymorphic_allocator
    157 {
    158 public:
    159     typedef _ValueType value_type;
    160 
    161     // 8.6.2, memory.polymorphic.allocator.ctor
    162     _LIBCPP_INLINE_VISIBILITY
    163     polymorphic_allocator() _NOEXCEPT
    164       : __res_(_VSTD_LFTS_PMR::get_default_resource())
    165     {}
    166 
    167     _LIBCPP_INLINE_VISIBILITY
    168     polymorphic_allocator(memory_resource * __r) _NOEXCEPT
    169       : __res_(__r)
    170     {}
    171 
    172     polymorphic_allocator(polymorphic_allocator const &) = default;
    173 
    174     template <class _Tp>
    175     _LIBCPP_INLINE_VISIBILITY
    176     polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
    177       : __res_(__other.resource())
    178     {}
    179 
    180     polymorphic_allocator &
    181     operator=(polymorphic_allocator const &) = delete;
    182 
    183     // 8.6.3, memory.polymorphic.allocator.mem
    184     _LIBCPP_INLINE_VISIBILITY
    185     _ValueType* allocate(size_t __n) {
    186         if (__n > __max_size()) {
    187             __throw_length_error(
    188                 "std::experimental::pmr::polymorphic_allocator<T>::allocate(size_t n)"
    189                 " 'n' exceeds maximum supported size");
    190         }
    191         return static_cast<_ValueType*>(
    192             __res_->allocate(__n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType))
    193         );
    194     }
    195 
    196     _LIBCPP_INLINE_VISIBILITY
    197     void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
    198         _LIBCPP_ASSERT(__n <= __max_size(),
    199                        "deallocate called for size which exceeds max_size()");
    200         __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType));
    201     }
    202 
    203     template <class _Tp, class ..._Ts>
    204     _LIBCPP_INLINE_VISIBILITY
    205     void construct(_Tp* __p, _Ts &&... __args)
    206     {
    207         _VSTD_LFTS::__lfts_user_alloc_construct(
    208             __p, *this, _VSTD::forward<_Ts>(__args)...
    209           );
    210     }
    211 
    212     template <class _T1, class _T2, class ..._Args1, class ..._Args2>
    213     _LIBCPP_INLINE_VISIBILITY
    214     void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
    215                    tuple<_Args1...> __x, tuple<_Args2...> __y)
    216     {
    217         ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct
    218           , __transform_tuple(
    219               typename __lfts_uses_alloc_ctor<
    220                   _T1, polymorphic_allocator&, _Args1...
    221               >::type()
    222             , _VSTD::move(__x)
    223             , typename __make_tuple_indices<sizeof...(_Args1)>::type{}
    224           )
    225           , __transform_tuple(
    226               typename __lfts_uses_alloc_ctor<
    227                   _T2, polymorphic_allocator&, _Args2...
    228               >::type()
    229             , _VSTD::move(__y)
    230             , typename __make_tuple_indices<sizeof...(_Args2)>::type{}
    231           )
    232         );
    233     }
    234 
    235     template <class _T1, class _T2>
    236     _LIBCPP_INLINE_VISIBILITY
    237     void construct(pair<_T1, _T2>* __p) {
    238         construct(__p, piecewise_construct, tuple<>(), tuple<>());
    239     }
    240 
    241     template <class _T1, class _T2, class _Up, class _Vp>
    242     _LIBCPP_INLINE_VISIBILITY
    243     void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) {
    244         construct(__p, piecewise_construct
    245           , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u))
    246           , _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v)));
    247     }
    248 
    249     template <class _T1, class _T2, class _U1, class _U2>
    250     _LIBCPP_INLINE_VISIBILITY
    251     void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) {
    252         construct(__p, piecewise_construct
    253             , _VSTD::forward_as_tuple(__pr.first)
    254             , _VSTD::forward_as_tuple(__pr.second));
    255     }
    256 
    257     template <class _T1, class _T2, class _U1, class _U2>
    258     _LIBCPP_INLINE_VISIBILITY
    259     void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
    260         construct(__p, piecewise_construct
    261             , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first))
    262             , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
    263     }
    264 
    265     template <class _Tp>
    266     _LIBCPP_INLINE_VISIBILITY
    267     void destroy(_Tp * __p) _NOEXCEPT
    268         { __p->~_Tp(); }
    269 
    270     _LIBCPP_INLINE_VISIBILITY
    271     polymorphic_allocator
    272     select_on_container_copy_construction() const _NOEXCEPT
    273         { return polymorphic_allocator(); }
    274 
    275     _LIBCPP_INLINE_VISIBILITY
    276     memory_resource * resource() const _NOEXCEPT
    277         { return __res_; }
    278 
    279 private:
    280     template <class ..._Args, size_t ..._Idx>
    281     _LIBCPP_INLINE_VISIBILITY
    282     tuple<_Args&&...>
    283     __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
    284                       __tuple_indices<_Idx...>) const
    285     {
    286         return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
    287     }
    288 
    289     template <class ..._Args, size_t ..._Idx>
    290     _LIBCPP_INLINE_VISIBILITY
    291     tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
    292     __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
    293                       __tuple_indices<_Idx...>)
    294     {
    295         using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
    296         return _Tup(allocator_arg, *this,
    297                     _VSTD::get<_Idx>(_VSTD::move(__t))...);
    298     }
    299 
    300     template <class ..._Args, size_t ..._Idx>
    301     _LIBCPP_INLINE_VISIBILITY
    302     tuple<_Args&&..., polymorphic_allocator&>
    303     __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
    304                       __tuple_indices<_Idx...>)
    305     {
    306         using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
    307         return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this);
    308     }
    309 
    310     _LIBCPP_INLINE_VISIBILITY
    311     size_t __max_size() const _NOEXCEPT
    312         { return numeric_limits<size_t>::max() / sizeof(value_type); }
    313 
    314     memory_resource * __res_;
    315 };
    316 
    317 // 8.6.4, memory.polymorphic.allocator.eq
    318 
    319 template <class _Tp, class _Up>
    320 inline _LIBCPP_INLINE_VISIBILITY
    321 bool operator==(polymorphic_allocator<_Tp> const & __lhs,
    322                 polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
    323 {
    324     return *__lhs.resource() == *__rhs.resource();
    325 }
    326 
    327 template <class _Tp, class _Up>
    328 inline _LIBCPP_INLINE_VISIBILITY
    329 bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
    330                 polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
    331 {
    332     return !(__lhs == __rhs);
    333 }
    334 
    335 // 8.7, memory.resource.adaptor
    336 
    337 // 8.7.1, memory.resource.adaptor.overview
    338 template <class _CharAlloc>
    339 class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp
    340   : public memory_resource
    341 {
    342     using _CTraits = allocator_traits<_CharAlloc>;
    343     static_assert(is_same<typename _CTraits::value_type, char>::value
    344                && is_same<typename _CTraits::pointer, char*>::value
    345                && is_same<typename _CTraits::void_pointer, void*>::value, "");
    346 
    347     static const size_t _MaxAlign = _LIBCPP_ALIGNOF(max_align_t);
    348 
    349     using _Alloc = typename _CTraits::template rebind_alloc<
    350             typename aligned_storage<_MaxAlign, _MaxAlign>::type
    351         >;
    352 
    353     using _ValueType = typename _Alloc::value_type;
    354 
    355     _Alloc __alloc_;
    356 
    357 public:
    358     typedef _CharAlloc allocator_type;
    359 
    360     __resource_adaptor_imp() = default;
    361     __resource_adaptor_imp(__resource_adaptor_imp const &) = default;
    362     __resource_adaptor_imp(__resource_adaptor_imp &&) = default;
    363 
    364     // 8.7.2, memory.resource.adaptor.ctor
    365 
    366     _LIBCPP_INLINE_VISIBILITY
    367     explicit __resource_adaptor_imp(allocator_type const & __a)
    368       : __alloc_(__a)
    369     {}
    370 
    371     _LIBCPP_INLINE_VISIBILITY
    372     explicit __resource_adaptor_imp(allocator_type && __a)
    373       : __alloc_(_VSTD::move(__a))
    374     {}
    375 
    376     __resource_adaptor_imp &
    377     operator=(__resource_adaptor_imp const &) = default;
    378 
    379     _LIBCPP_INLINE_VISIBILITY
    380     allocator_type get_allocator() const
    381     { return __alloc_; }
    382 
    383 // 8.7.3, memory.resource.adaptor.mem
    384 private:
    385     virtual void * do_allocate(size_t __bytes, size_t)
    386     {
    387         if (__bytes > __max_size()) {
    388             __throw_length_error(
    389                 "std::experimental::pmr::resource_adaptor<T>::do_allocate(size_t bytes, size_t align)"
    390                 " 'bytes' exceeds maximum supported size");
    391         }
    392         size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
    393         return __alloc_.allocate(__s);
    394     }
    395 
    396     virtual void do_deallocate(void * __p, size_t __bytes, size_t)
    397     {
    398         _LIBCPP_ASSERT(__bytes <= __max_size(),
    399             "do_deallocate called for size which exceeds the maximum allocation size");
    400         size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
    401         __alloc_.deallocate((_ValueType*)__p, __s);
    402     }
    403 
    404     virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT {
    405         __resource_adaptor_imp const * __p
    406           = dynamic_cast<__resource_adaptor_imp const *>(&__other);
    407         return __p  ? __alloc_ == __p->__alloc_ : false;
    408     }
    409 
    410     _LIBCPP_INLINE_VISIBILITY
    411     size_t __max_size() const _NOEXCEPT {
    412         return numeric_limits<size_t>::max() - _MaxAlign;
    413     }
    414 };
    415 
    416 template <class _Alloc>
    417 using resource_adaptor = __resource_adaptor_imp<
    418     typename allocator_traits<_Alloc>::template rebind_alloc<char>
    419   >;
    420 
    421 _LIBCPP_END_NAMESPACE_LFTS_PMR
    422 
    423 _LIBCPP_POP_MACROS
    424 
    425 #endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */
    426