contrib/llvm-project/libcxx/include/experimental/memory_resource

   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 protected:
 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 protected:
 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 private:
 411     _LIBCPP_INLINE_VISIBILITY
 412     size_t __max_size() const _NOEXCEPT {
 413         return numeric_limits<size_t>::max() - _MaxAlign;
 414     }
 415 };
 416
 417 template <class _Alloc>
 418 using resource_adaptor = __resource_adaptor_imp<
 419     typename allocator_traits<_Alloc>::template rebind_alloc<char>
 420   >;
 421
 422 _LIBCPP_END_NAMESPACE_LFTS_PMR
 423
 424 _LIBCPP_POP_MACROS
 425
 426 #endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */