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 # define __cpp_lib_polymorphic_allocator 201902L
65 template<
typename _Tp = std::byte>
66 class polymorphic_allocator;
70 memory_resource* new_delete_resource() noexcept;
71 memory_resource* null_memory_resource() noexcept;
72 memory_resource* set_default_resource(memory_resource* __r) noexcept;
73 memory_resource* get_default_resource() noexcept
74 __attribute__((__returns_nonnull__));
78 #ifdef _GLIBCXX_HAS_GTHREADS
79 class synchronized_pool_resource;
81 class unsynchronized_pool_resource;
82 class monotonic_buffer_resource;
87 static constexpr
size_t _S_max_align =
alignof(max_align_t);
90 memory_resource() =
default;
91 memory_resource(
const memory_resource&) =
default;
92 virtual ~memory_resource();
94 memory_resource& operator=(
const memory_resource&) =
default;
98 allocate(
size_t __bytes,
size_t __alignment = _S_max_align)
99 __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3)))
100 {
return do_allocate(__bytes, __alignment); }
103 deallocate(
void* __p,
size_t __bytes,
size_t __alignment = _S_max_align)
104 __attribute__((__nonnull__))
105 {
return do_deallocate(__p, __bytes, __alignment); }
108 is_equal(
const memory_resource& __other)
const noexcept
109 {
return do_is_equal(__other); }
113 do_allocate(
size_t __bytes,
size_t __alignment) = 0;
116 do_deallocate(
void* __p,
size_t __bytes,
size_t __alignment) = 0;
119 do_is_equal(
const memory_resource& __other)
const noexcept = 0;
123 operator==(
const memory_resource& __a,
const memory_resource& __b) noexcept
124 {
return &__a == &__b || __a.is_equal(__b); }
126 #if __cpp_impl_three_way_comparison < 201907L
128 operator!=(
const memory_resource& __a,
const memory_resource& __b) noexcept
129 {
return !(__a == __b); }
133 template<
typename _Tp>
134 class polymorphic_allocator
138 template<
typename _Up>
139 struct __not_pair {
using type = void; };
141 template<
typename _Up1,
typename _Up2>
142 struct __not_pair<pair<_Up1, _Up2>> { };
145 using value_type = _Tp;
147 polymorphic_allocator() noexcept
148 : _M_resource(get_default_resource())
151 polymorphic_allocator(memory_resource* __r) noexcept
152 __attribute__((__nonnull__))
154 { _GLIBCXX_DEBUG_ASSERT(__r); }
156 polymorphic_allocator(
const polymorphic_allocator& __other) =
default;
158 template<
typename _Up>
159 polymorphic_allocator(
const polymorphic_allocator<_Up>& __x) noexcept
160 : _M_resource(__x.resource())
163 polymorphic_allocator&
164 operator=(
const polymorphic_allocator&) =
delete;
169 __attribute__((__returns_nonnull__))
172 _GLIBCXX_THROW_OR_ABORT(bad_array_new_length());
173 return static_cast<_Tp*
>(_M_resource->allocate(__n *
sizeof(_Tp),
178 deallocate(_Tp* __p,
size_t __n) noexcept
179 __attribute__((__nonnull__))
180 { _M_resource->deallocate(__p, __n *
sizeof(_Tp),
alignof(_Tp)); }
182 #if __cplusplus > 201703L
184 allocate_bytes(
size_t __nbytes,
185 size_t __alignment =
alignof(max_align_t))
186 {
return _M_resource->allocate(__nbytes, __alignment); }
189 deallocate_bytes(
void* __p,
size_t __nbytes,
190 size_t __alignment =
alignof(max_align_t))
191 { _M_resource->deallocate(__p, __nbytes, __alignment); }
193 template<
typename _Up>
195 allocate_object(
size_t __n = 1)
198 _GLIBCXX_THROW_OR_ABORT(bad_array_new_length());
199 return static_cast<_Up*
>(allocate_bytes(__n *
sizeof(_Up),
203 template<
typename _Up>
205 deallocate_object(_Up* __p,
size_t __n = 1)
206 { deallocate_bytes(__p, __n *
sizeof(_Up),
alignof(_Up)); }
208 template<
typename _Up,
typename... _CtorArgs>
210 new_object(_CtorArgs&&... __ctor_args)
212 _Up* __p = allocate_object<_Up>();
215 construct(__p, std::forward<_CtorArgs>(__ctor_args)...);
219 deallocate_object(__p);
220 __throw_exception_again;
225 template<
typename _Up>
227 delete_object(_Up* __p)
230 deallocate_object(__p);
234 #if __cplusplus == 201703L
235 template<
typename _Tp1,
typename... _Args>
236 __attribute__((__nonnull__))
237 typename __not_pair<_Tp1>::type
238 construct(_Tp1* __p, _Args&&... __args)
243 = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>;
244 if constexpr (is_base_of_v<__uses_alloc0, __use_tag>)
245 ::new(__p) _Tp1(std::
forward<_Args>(__args)...);
246 else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>)
247 ::new(__p) _Tp1(allocator_arg, *this,
248 std::
forward<_Args>(__args)...);
250 ::new(__p) _Tp1(std::
forward<_Args>(__args)..., *this);
253 template<typename _Tp1, typename _Tp2,
254 typename... _Args1, typename... _Args2>
255 __attribute__((__nonnull__))
257 construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t,
258 tuple<_Args1...> __x, tuple<_Args2...> __y)
261 __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this);
263 __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this);
268 _S_construct_p(__x_tag, __x_i, __x),
269 _S_construct_p(__y_tag, __y_i, __y));
272 template<typename _Tp1, typename _Tp2>
273 __attribute__((__nonnull__))
275 construct(pair<_Tp1, _Tp2>* __p)
276 { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); }
278 template<
typename _Tp1,
typename _Tp2,
typename _Up,
typename _Vp>
279 __attribute__((__nonnull__))
281 construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y)
283 this->construct(__p, piecewise_construct,
288 template <
typename _Tp1,
typename _Tp2,
typename _Up,
typename _Vp>
289 __attribute__((__nonnull__))
291 construct(pair<_Tp1, _Tp2>* __p, const std::pair<_Up, _Vp>& __pr)
293 this->construct(__p, piecewise_construct,
298 template<
typename _Tp1,
typename _Tp2,
typename _Up,
typename _Vp>
299 __attribute__((__nonnull__))
301 construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr)
303 this->construct(__p, piecewise_construct,
308 template<
typename _Tp1,
typename... _Args>
309 __attribute__((__nonnull__))
311 construct(_Tp1* __p, _Args&&... __args)
313 std::uninitialized_construct_using_allocator(__p, *
this,
314 std::forward<_Args>(__args)...);
318 template<
typename _Up>
319 __attribute__((__nonnull__))
324 polymorphic_allocator
325 select_on_container_copy_construction() const noexcept
326 {
return polymorphic_allocator(); }
329 resource() const noexcept
330 __attribute__((__returns_nonnull__))
331 {
return _M_resource; }
334 using __uses_alloc1_ = __uses_alloc1<polymorphic_allocator>;
335 using __uses_alloc2_ = __uses_alloc2<polymorphic_allocator>;
337 template<
typename _Ind,
typename... _Args>
338 static tuple<_Args&&...>
339 _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t)
342 template<
size_t... _Ind,
typename... _Args>
343 static tuple<allocator_arg_t, polymorphic_allocator, _Args&&...>
344 _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>,
345 tuple<_Args...>& __t)
348 allocator_arg, *__ua._M_a, std::get<_Ind>(
std::move(__t))...
352 template<
size_t... _Ind,
typename... _Args>
353 static tuple<_Args&&..., polymorphic_allocator>
354 _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>,
355 tuple<_Args...>& __t)
356 {
return { std::get<_Ind>(
std::move(__t))..., *__ua._M_a }; }
358 memory_resource* _M_resource;
361 template<
typename _Tp1,
typename _Tp2>
363 operator==(
const polymorphic_allocator<_Tp1>& __a,
364 const polymorphic_allocator<_Tp2>& __b) noexcept
365 {
return *__a.resource() == *__b.resource(); }
367 #if __cpp_impl_three_way_comparison < 201907L
368 template<
typename _Tp1,
typename _Tp2>
370 operator!=(
const polymorphic_allocator<_Tp1>& __a,
371 const polymorphic_allocator<_Tp2>& __b) noexcept
372 {
return !(__a == __b); }
383 size_t max_blocks_per_chunk = 0;
390 size_t largest_required_pool_block = 0;
394 class __pool_resource
396 friend class synchronized_pool_resource;
397 friend class unsynchronized_pool_resource;
399 __pool_resource(
const pool_options& __opts, memory_resource* __upstream);
403 __pool_resource(
const __pool_resource&) =
delete;
404 __pool_resource& operator=(
const __pool_resource&) =
delete;
408 allocate(
size_t __bytes,
size_t __alignment);
412 deallocate(
void* __p,
size_t __bytes,
size_t __alignment);
416 void release() noexcept;
418 memory_resource* resource() const noexcept
419 {
return _M_unpooled.get_allocator().resource(); }
423 _Pool* _M_alloc_pools();
425 const pool_options _M_opts;
430 _GLIBCXX_STD_C::pmr::vector<_BigBlock> _M_unpooled;
435 #ifdef _GLIBCXX_HAS_GTHREADS
437 class synchronized_pool_resource :
public memory_resource
440 synchronized_pool_resource(
const pool_options& __opts,
441 memory_resource* __upstream)
442 __attribute__((__nonnull__));
444 synchronized_pool_resource()
445 : synchronized_pool_resource(pool_options(), get_default_resource())
449 synchronized_pool_resource(memory_resource* __upstream)
450 __attribute__((__nonnull__))
451 : synchronized_pool_resource(pool_options(), __upstream)
455 synchronized_pool_resource(
const pool_options& __opts)
456 : synchronized_pool_resource(__opts, get_default_resource()) { }
458 synchronized_pool_resource(
const synchronized_pool_resource&) =
delete;
460 virtual ~synchronized_pool_resource();
462 synchronized_pool_resource&
463 operator=(
const synchronized_pool_resource&) =
delete;
468 upstream_resource() const noexcept
469 __attribute__((__returns_nonnull__))
470 {
return _M_impl.resource(); }
472 pool_options options() const noexcept {
return _M_impl._M_opts; }
476 do_allocate(
size_t __bytes,
size_t __alignment)
override;
479 do_deallocate(
void* __p,
size_t __bytes,
size_t __alignment)
override;
482 do_is_equal(
const memory_resource& __other)
const noexcept
override
483 {
return this == &__other; }
490 _TPools* _M_alloc_tpools(lock_guard<shared_mutex>&);
491 _TPools* _M_alloc_shared_tpools(lock_guard<shared_mutex>&);
492 auto _M_thread_specific_pools() noexcept;
494 __pool_resource _M_impl;
495 __gthread_key_t _M_key;
497 _TPools* _M_tpools =
nullptr;
498 mutable shared_mutex _M_mx;
503 class unsynchronized_pool_resource :
public memory_resource
506 [[__gnu__::__nonnull__]]
507 unsynchronized_pool_resource(
const pool_options& __opts,
508 memory_resource* __upstream);
510 unsynchronized_pool_resource()
511 : unsynchronized_pool_resource(pool_options(), get_default_resource())
514 [[__gnu__::__nonnull__]]
516 unsynchronized_pool_resource(memory_resource* __upstream)
517 : unsynchronized_pool_resource(pool_options(), __upstream)
521 unsynchronized_pool_resource(
const pool_options& __opts)
522 : unsynchronized_pool_resource(__opts, get_default_resource()) { }
524 unsynchronized_pool_resource(
const unsynchronized_pool_resource&) =
delete;
526 virtual ~unsynchronized_pool_resource();
528 unsynchronized_pool_resource&
529 operator=(
const unsynchronized_pool_resource&) =
delete;
533 [[__gnu__::__returns_nonnull__]]
535 upstream_resource() const noexcept
536 {
return _M_impl.resource(); }
538 pool_options options() const noexcept {
return _M_impl._M_opts; }
542 do_allocate(
size_t __bytes,
size_t __alignment)
override;
545 do_deallocate(
void* __p,
size_t __bytes,
size_t __alignment)
override;
548 do_is_equal(
const memory_resource& __other)
const noexcept
override
549 {
return this == &__other; }
552 using _Pool = __pool_resource::_Pool;
554 auto _M_find_pool(
size_t) noexcept;
556 __pool_resource _M_impl;
557 _Pool* _M_pools =
nullptr;
560 class monotonic_buffer_resource : public memory_resource
564 monotonic_buffer_resource(memory_resource* __upstream) noexcept
565 __attribute__((__nonnull__))
566 : _M_upstream(__upstream)
567 { _GLIBCXX_DEBUG_ASSERT(__upstream !=
nullptr); }
569 monotonic_buffer_resource(
size_t __initial_size,
570 memory_resource* __upstream) noexcept
571 __attribute__((__nonnull__))
572 : _M_next_bufsiz(__initial_size),
573 _M_upstream(__upstream)
575 _GLIBCXX_DEBUG_ASSERT(__upstream !=
nullptr);
576 _GLIBCXX_DEBUG_ASSERT(__initial_size > 0);
579 monotonic_buffer_resource(
void* __buffer,
size_t __buffer_size,
580 memory_resource* __upstream) noexcept
581 __attribute__((__nonnull__(4)))
582 : _M_current_buf(__buffer), _M_avail(__buffer_size),
583 _M_next_bufsiz(_S_next_bufsize(__buffer_size)),
584 _M_upstream(__upstream),
585 _M_orig_buf(__buffer), _M_orig_size(__buffer_size)
587 _GLIBCXX_DEBUG_ASSERT(__upstream !=
nullptr);
588 _GLIBCXX_DEBUG_ASSERT(__buffer !=
nullptr || __buffer_size == 0);
591 monotonic_buffer_resource() noexcept
592 : monotonic_buffer_resource(get_default_resource())
596 monotonic_buffer_resource(
size_t __initial_size) noexcept
597 : monotonic_buffer_resource(__initial_size, get_default_resource())
600 monotonic_buffer_resource(
void* __buffer,
size_t __buffer_size) noexcept
601 : monotonic_buffer_resource(__buffer, __buffer_size, get_default_resource())
604 monotonic_buffer_resource(
const monotonic_buffer_resource&) =
delete;
606 virtual ~monotonic_buffer_resource();
608 monotonic_buffer_resource&
609 operator=(
const monotonic_buffer_resource&) =
delete;
615 _M_release_buffers();
618 if ((_M_current_buf = _M_orig_buf))
620 _M_avail = _M_orig_size;
621 _M_next_bufsiz = _S_next_bufsize(_M_orig_size);
626 _M_next_bufsiz = _M_orig_size;
631 upstream_resource() const noexcept
632 __attribute__((__returns_nonnull__))
633 {
return _M_upstream; }
637 do_allocate(
size_t __bytes,
size_t __alignment)
override
642 void* __p =
std::align(__alignment, __bytes, _M_current_buf, _M_avail);
645 _M_new_buffer(__bytes, __alignment);
646 __p = _M_current_buf;
648 _M_current_buf = (
char*)_M_current_buf + __bytes;
654 do_deallocate(
void*,
size_t,
size_t)
override
658 do_is_equal(
const memory_resource& __other)
const noexcept
override
659 {
return this == &__other; }
665 _M_new_buffer(
size_t __bytes,
size_t __alignment);
669 _M_release_buffers() noexcept;
672 _S_next_bufsize(
size_t __buffer_size) noexcept
674 if (__buffer_size == 0)
676 return __buffer_size * _S_growth_factor;
679 static constexpr
size_t _S_init_bufsize = 128 *
sizeof(
void*);
680 static constexpr
float _S_growth_factor = 1.5;
682 void* _M_current_buf =
nullptr;
684 size_t _M_next_bufsiz = _S_init_bufsize;
687 memory_resource*
const _M_upstream;
688 void*
const _M_orig_buf =
nullptr;
689 size_t const _M_orig_size = _M_next_bufsiz;
692 _Chunk* _M_head =
nullptr;
696 _GLIBCXX_END_NAMESPACE_VERSION
700 #endif // _GLIBCXX_MEMORY_RESOURCE
void * align(size_t __align, size_t __size, void *&__ptr, size_t &__space) noexcept
Fit aligned storage in buffer.This function tries to fit __size bytes of storage with alignment __ali...
constexpr tuple< _Elements &&...> forward_as_tuple(_Elements &&...__args) noexcept
std::forward_as_tuple
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
make_index_sequence< sizeof...(_Types)> index_sequence_for
Alias template index_sequence_for.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.
constexpr piecewise_construct_t piecewise_construct
Tag for piecewise construction of std::pair objects.