29 #ifndef _GLIBCXX_MEMORY_RESOURCE
30 #define _GLIBCXX_MEMORY_RESOURCE 1
32 #pragma GCC system_header
34 #if __cplusplus >= 201703L
45 namespace std _GLIBCXX_VISIBILITY(default)
47 _GLIBCXX_BEGIN_NAMESPACE_VERSION
50 #ifdef _GLIBCXX_HAS_GTHREADS
52 # define __cpp_lib_memory_resource 201603
55 # define __cpp_lib_memory_resource 1
58 class memory_resource;
60 #if __cplusplus == 201703L
61 template<
typename _Tp>
62 class polymorphic_allocator;
64 template<
typename _Tp = std::
byte>
65 class polymorphic_allocator;
69 memory_resource* new_delete_resource() noexcept;
70 memory_resource* null_memory_resource() noexcept;
71 memory_resource* set_default_resource(memory_resource* __r) noexcept;
72 memory_resource* get_default_resource() noexcept
73 __attribute__((__returns_nonnull__));
77 #ifdef _GLIBCXX_HAS_GTHREADS
78 class synchronized_pool_resource;
80 class unsynchronized_pool_resource;
81 class monotonic_buffer_resource;
86 static constexpr
size_t _S_max_align =
alignof(max_align_t);
89 memory_resource() =
default;
90 memory_resource(
const memory_resource&) =
default;
91 virtual ~memory_resource();
93 memory_resource& operator=(
const memory_resource&) =
default;
97 allocate(
size_t __bytes,
size_t __alignment = _S_max_align)
98 __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3)))
99 {
return do_allocate(__bytes, __alignment); }
102 deallocate(
void* __p,
size_t __bytes,
size_t __alignment = _S_max_align)
103 __attribute__((__nonnull__))
104 {
return do_deallocate(__p, __bytes, __alignment); }
107 is_equal(
const memory_resource& __other)
const noexcept
108 {
return do_is_equal(__other); }
112 do_allocate(
size_t __bytes,
size_t __alignment) = 0;
115 do_deallocate(
void* __p,
size_t __bytes,
size_t __alignment) = 0;
118 do_is_equal(
const memory_resource& __other)
const noexcept = 0;
122 operator==(
const memory_resource& __a,
const memory_resource& __b) noexcept
123 {
return &__a == &__b || __a.is_equal(__b); }
125 #if __cpp_impl_three_way_comparison < 201907L
127 operator!=(
const memory_resource& __a,
const memory_resource& __b) noexcept
128 {
return !(__a == __b); }
132 template<
typename _Tp>
133 class polymorphic_allocator
137 template<
typename _Up>
138 struct __not_pair {
using type = void; };
140 template<
typename _Up1,
typename _Up2>
141 struct __not_pair<pair<_Up1, _Up2>> { };
144 using value_type = _Tp;
146 polymorphic_allocator() noexcept
147 : _M_resource(get_default_resource())
150 polymorphic_allocator(memory_resource* __r) noexcept
151 __attribute__((__nonnull__))
153 { _GLIBCXX_DEBUG_ASSERT(__r); }
155 polymorphic_allocator(
const polymorphic_allocator& __other) =
default;
157 template<
typename _Up>
158 polymorphic_allocator(
const polymorphic_allocator<_Up>& __x) noexcept
159 : _M_resource(__x.resource())
162 polymorphic_allocator&
163 operator=(
const polymorphic_allocator&) =
delete;
168 __attribute__((__returns_nonnull__))
171 _GLIBCXX_THROW_OR_ABORT(bad_array_new_length());
172 return static_cast<_Tp*>(_M_resource->allocate(__n *
sizeof(_Tp),
177 deallocate(_Tp* __p,
size_t __n) noexcept
178 __attribute__((__nonnull__))
179 { _M_resource->deallocate(__p, __n *
sizeof(_Tp),
alignof(_Tp)); }
181 #if __cplusplus > 201703L
183 allocate_bytes(
size_t __nbytes,
184 size_t __alignment =
alignof(max_align_t))
185 {
return _M_resource->allocate(__nbytes, __alignment); }
188 deallocate_bytes(
void* __p,
size_t __nbytes,
189 size_t __alignment =
alignof(max_align_t))
190 { _M_resource->deallocate(__p, __nbytes, __alignment); }
192 template<
typename _Up>
194 allocate_object(
size_t __n = 1)
197 _GLIBCXX_THROW_OR_ABORT(bad_array_new_length());
198 return static_cast<_Up*>(allocate_bytes(__n *
sizeof(_Up),
202 template<
typename _Up>
204 deallocate_object(_Up* __p,
size_t __n = 1)
205 { deallocate_bytes(__p, __n *
sizeof(_Up),
alignof(_Up)); }
207 template<
typename _Up,
typename... _CtorArgs>
209 new_object(_CtorArgs&&... __ctor_args)
211 _Up* __p = allocate_object<_Up>();
214 construct(__p, std::forward<_CtorArgs>(__ctor_args)...);
218 deallocate_object(__p);
219 __throw_exception_again;
224 template<
typename _Up>
226 delete_object(_Up* __p)
229 deallocate_object(__p);
233 #if __cplusplus == 201703L
234 template<
typename _Tp1,
typename... _Args>
235 __attribute__((__nonnull__))
236 typename __not_pair<_Tp1>::type
237 construct(_Tp1* __p, _Args&&... __args)
242 = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>;
243 if constexpr (is_base_of_v<__uses_alloc0, __use_tag>)
244 ::new(__p) _Tp1(
std::
forward<_Args>(__args)...);
245 else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>)
246 ::new(__p) _Tp1(allocator_arg, *this,
249 ::new(__p) _Tp1(std::forward<_Args>(__args)..., *
this);
252 template<
typename _Tp1,
typename _Tp2,
253 typename... _Args1,
typename... _Args2>
254 __attribute__((__nonnull__))
256 construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t,
257 tuple<_Args1...> __x, tuple<_Args2...> __y)
260 __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this);
262 __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this);
267 _S_construct_p(__x_tag, __x_i, __x),
268 _S_construct_p(__y_tag, __y_i, __y));
271 template<
typename _Tp1,
typename _Tp2>
272 __attribute__((__nonnull__))
274 construct(pair<_Tp1, _Tp2>* __p)
277 template<
typename _Tp1,
typename _Tp2,
typename _Up,
typename _Vp>
278 __attribute__((__nonnull__))
280 construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y)
287 template <
typename _Tp1,
typename _Tp2,
typename _Up,
typename _Vp>
288 __attribute__((__nonnull__))
297 template<
typename _Tp1,
typename _Tp2,
typename _Up,
typename _Vp>
298 __attribute__((__nonnull__))
300 construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr)
307 template<
typename _Tp1,
typename... _Args>
308 __attribute__((__nonnull__))
310 construct(_Tp1* __p, _Args&&... __args)
312 std::uninitialized_construct_using_allocator(__p, *
this,
313 std::forward<_Args>(__args)...);
317 template<
typename _Up>
318 __attribute__((__nonnull__))
323 polymorphic_allocator
324 select_on_container_copy_construction() const noexcept
325 {
return polymorphic_allocator(); }
328 resource() const noexcept
329 __attribute__((__returns_nonnull__))
330 {
return _M_resource; }
333 using __uses_alloc1_ = __uses_alloc1<polymorphic_allocator>;
334 using __uses_alloc2_ = __uses_alloc2<polymorphic_allocator>;
336 template<
typename _Ind,
typename... _Args>
337 static tuple<_Args&&...>
338 _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t)
341 template<
size_t... _Ind,
typename... _Args>
342 static tuple<allocator_arg_t, polymorphic_allocator, _Args&&...>
343 _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>,
344 tuple<_Args...>& __t)
347 allocator_arg, *__ua._M_a, std::get<_Ind>(
std::move(__t))...
351 template<
size_t... _Ind,
typename... _Args>
352 static tuple<_Args&&..., polymorphic_allocator>
353 _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>,
354 tuple<_Args...>& __t)
355 {
return { std::get<_Ind>(
std::move(__t))..., *__ua._M_a }; }
357 memory_resource* _M_resource;
360 template<
typename _Tp1,
typename _Tp2>
362 operator==(
const polymorphic_allocator<_Tp1>& __a,
363 const polymorphic_allocator<_Tp2>& __b) noexcept
364 {
return *__a.resource() == *__b.resource(); }
366 #if __cpp_impl_three_way_comparison < 201907L
367 template<
typename _Tp1,
typename _Tp2>
369 operator!=(
const polymorphic_allocator<_Tp1>& __a,
370 const polymorphic_allocator<_Tp2>& __b) noexcept
371 {
return !(__a == __b); }
382 size_t max_blocks_per_chunk = 0;
389 size_t largest_required_pool_block = 0;
393 class __pool_resource
395 friend class synchronized_pool_resource;
396 friend class unsynchronized_pool_resource;
398 __pool_resource(
const pool_options& __opts, memory_resource* __upstream);
402 __pool_resource(
const __pool_resource&) =
delete;
403 __pool_resource& operator=(
const __pool_resource&) =
delete;
407 allocate(
size_t __bytes,
size_t __alignment);
411 deallocate(
void* __p,
size_t __bytes,
size_t __alignment);
415 void release() noexcept;
417 memory_resource* resource() const noexcept
418 {
return _M_unpooled.get_allocator().resource(); }
422 _Pool* _M_alloc_pools();
424 const pool_options _M_opts;
429 _GLIBCXX_STD_C::pmr::vector<_BigBlock> _M_unpooled;
434 #ifdef _GLIBCXX_HAS_GTHREADS
436 class synchronized_pool_resource :
public memory_resource
439 synchronized_pool_resource(
const pool_options& __opts,
440 memory_resource* __upstream)
441 __attribute__((__nonnull__));
443 synchronized_pool_resource()
448 synchronized_pool_resource(memory_resource* __upstream)
449 __attribute__((__nonnull__))
450 : synchronized_pool_resource(pool_options(), __upstream)
454 synchronized_pool_resource(
const pool_options& __opts)
457 synchronized_pool_resource(
const synchronized_pool_resource&) =
delete;
459 virtual ~synchronized_pool_resource();
461 synchronized_pool_resource&
462 operator=(
const synchronized_pool_resource&) =
delete;
467 upstream_resource() const noexcept
468 __attribute__((__returns_nonnull__))
469 {
return _M_impl.resource(); }
471 pool_options options() const noexcept {
return _M_impl._M_opts; }
475 do_allocate(
size_t __bytes,
size_t __alignment)
override;
478 do_deallocate(
void* __p,
size_t __bytes,
size_t __alignment)
override;
481 do_is_equal(
const memory_resource& __other)
const noexcept
override
482 {
return this == &__other; }
489 _TPools* _M_alloc_tpools(lock_guard<shared_mutex>&);
490 _TPools* _M_alloc_shared_tpools(lock_guard<shared_mutex>&);
491 auto _M_thread_specific_pools() noexcept;
493 __pool_resource _M_impl;
494 __gthread_key_t _M_key;
496 _TPools* _M_tpools =
nullptr;
497 mutable shared_mutex _M_mx;
502 class unsynchronized_pool_resource :
public memory_resource
505 [[__gnu__::__nonnull__]]
506 unsynchronized_pool_resource(
const pool_options& __opts,
507 memory_resource* __upstream);
509 unsynchronized_pool_resource()
513 [[__gnu__::__nonnull__]]
515 unsynchronized_pool_resource(memory_resource* __upstream)
516 : unsynchronized_pool_resource(pool_options(), __upstream)
520 unsynchronized_pool_resource(
const pool_options& __opts)
523 unsynchronized_pool_resource(
const unsynchronized_pool_resource&) =
delete;
525 virtual ~unsynchronized_pool_resource();
527 unsynchronized_pool_resource&
528 operator=(
const unsynchronized_pool_resource&) =
delete;
532 [[__gnu__::__returns_nonnull__]]
534 upstream_resource() const noexcept
535 {
return _M_impl.resource(); }
537 pool_options options() const noexcept {
return _M_impl._M_opts; }
541 do_allocate(
size_t __bytes,
size_t __alignment)
override;
544 do_deallocate(
void* __p,
size_t __bytes,
size_t __alignment)
override;
547 do_is_equal(
const memory_resource& __other)
const noexcept
override
548 {
return this == &__other; }
551 using _Pool = __pool_resource::_Pool;
553 auto _M_find_pool(
size_t) noexcept;
555 __pool_resource _M_impl;
556 _Pool* _M_pools =
nullptr;
559 class monotonic_buffer_resource :
public memory_resource
563 monotonic_buffer_resource(memory_resource* __upstream) noexcept
564 __attribute__((__nonnull__))
565 : _M_upstream(__upstream)
566 { _GLIBCXX_DEBUG_ASSERT(__upstream !=
nullptr); }
568 monotonic_buffer_resource(
size_t __initial_size,
569 memory_resource* __upstream) noexcept
570 __attribute__((__nonnull__))
571 : _M_next_bufsiz(__initial_size),
572 _M_upstream(__upstream)
574 _GLIBCXX_DEBUG_ASSERT(__upstream !=
nullptr);
575 _GLIBCXX_DEBUG_ASSERT(__initial_size > 0);
578 monotonic_buffer_resource(
void* __buffer,
size_t __buffer_size,
579 memory_resource* __upstream) noexcept
580 __attribute__((__nonnull__(4)))
581 : _M_current_buf(__buffer), _M_avail(__buffer_size),
582 _M_next_bufsiz(_S_next_bufsize(__buffer_size)),
583 _M_upstream(__upstream),
584 _M_orig_buf(__buffer), _M_orig_size(__buffer_size)
586 _GLIBCXX_DEBUG_ASSERT(__upstream !=
nullptr);
587 _GLIBCXX_DEBUG_ASSERT(__buffer !=
nullptr || __buffer_size == 0);
590 monotonic_buffer_resource() noexcept
591 : monotonic_buffer_resource(get_default_resource())
595 monotonic_buffer_resource(
size_t __initial_size) noexcept
599 monotonic_buffer_resource(
void* __buffer,
size_t __buffer_size) noexcept
603 monotonic_buffer_resource(
const monotonic_buffer_resource&) =
delete;
605 virtual ~monotonic_buffer_resource();
607 monotonic_buffer_resource&
608 operator=(
const monotonic_buffer_resource&) =
delete;
614 _M_release_buffers();
617 if ((_M_current_buf = _M_orig_buf))
619 _M_avail = _M_orig_size;
620 _M_next_bufsiz = _S_next_bufsize(_M_orig_size);
625 _M_next_bufsiz = _M_orig_size;
630 upstream_resource() const noexcept
631 __attribute__((__returns_nonnull__))
632 {
return _M_upstream; }
636 do_allocate(
size_t __bytes,
size_t __alignment)
override
641 void* __p =
std::align(__alignment, __bytes, _M_current_buf, _M_avail);
644 _M_new_buffer(__bytes, __alignment);
645 __p = _M_current_buf;
647 _M_current_buf = (
char*)_M_current_buf + __bytes;
653 do_deallocate(
void*,
size_t,
size_t)
override
657 do_is_equal(
const memory_resource& __other)
const noexcept
override
658 {
return this == &__other; }
664 _M_new_buffer(
size_t __bytes,
size_t __alignment);
668 _M_release_buffers() noexcept;
671 _S_next_bufsize(
size_t __buffer_size) noexcept
673 if (__buffer_size == 0)
675 return __buffer_size * _S_growth_factor;
678 static constexpr
size_t _S_init_bufsize = 128 *
sizeof(
void*);
679 static constexpr
float _S_growth_factor = 1.5;
681 void* _M_current_buf =
nullptr;
683 size_t _M_next_bufsiz = _S_init_bufsize;
686 memory_resource*
const _M_upstream;
687 void*
const _M_orig_buf =
nullptr;
688 size_t const _M_orig_size = _M_next_bufsiz;
691 _Chunk* _M_head =
nullptr;
695 _GLIBCXX_END_NAMESPACE_VERSION
699 #endif // _GLIBCXX_MEMORY_RESOURCE