libstdc++: memory_resource Source File

libstdc++

experimental/memory_resource
Go to the documentation of this file.
1// <experimental/memory_resource> -*- C++ -*-
2
3// Copyright (C) 2015-2026 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file experimental/memory_resource
26 * This is a TS C++ Library header.
27 * @ingroup libfund-ts
28 */
29
30#ifndef _GLIBCXX_EXPERIMENTAL_MEMORY_RESOURCE
31#define _GLIBCXX_EXPERIMENTAL_MEMORY_RESOURCE 1
32
33#ifdef _GLIBCXX_SYSHDR
34#pragma GCC system_header
35#endif
36
37#include <bits/requires_hosted.h> // experimental is currently omitted
38
39#if __cplusplus >= 201402L
40
41#include <memory> // align, uses_allocator, __uses_alloc
42#include <experimental/utility> // pair, experimental::erased_type
43#include <tuple> // tuple, forward_as_tuple
44#include <atomic> // atomic
45#include <new> // placement new
46#include <cstddef> // max_align_t
47#include <bits/new_allocator.h>
48#include <debug/assertions.h>
49
50namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
51{
52_GLIBCXX_BEGIN_NAMESPACE_VERSION
53 template<typename _Tp> class malloc_allocator;
54_GLIBCXX_END_NAMESPACE_VERSION
55} // namespace __gnu_cxx
56
57namespace std {
58_GLIBCXX_BEGIN_NAMESPACE_VERSION
59
60namespace experimental {
61inline namespace fundamentals_v2 {
62namespace pmr {
63#define __cpp_lib_experimental_memory_resources 201402L
64
65 // Standard memory resources
66
67 // 8.5 Class memory_resource
68 class memory_resource;
69
70 // 8.6 Class template polymorphic_allocator
71 template<typename _Tp>
72 class polymorphic_allocator;
73
74 template<typename _Alloc, typename _Resource = memory_resource>
75 class __resource_adaptor_imp;
76
77 // 8.7 Alias template resource_adaptor
78 template<typename _Alloc>
79 using resource_adaptor = __resource_adaptor_imp<
80 typename allocator_traits<_Alloc>::template rebind_alloc<char>>;
81
82 // 8.8 Global memory resources
83 memory_resource* new_delete_resource() noexcept;
84 memory_resource* null_memory_resource() noexcept;
85 memory_resource* get_default_resource() noexcept;
86 memory_resource* set_default_resource(memory_resource* __r) noexcept;
87
88 // TODO 8.9 Pool resource classes
89
90 class memory_resource
91 {
92 static constexpr size_t _S_max_align = alignof(max_align_t);
93
94 public:
95 memory_resource() = default;
96 memory_resource(const memory_resource&) = default;
97 virtual ~memory_resource() = default;
98
99 memory_resource& operator=(const memory_resource&) = default;
100
101 _GLIBCXX_NODISCARD void*
102 allocate(size_t __bytes, size_t __alignment = _S_max_align)
103 { return do_allocate(__bytes, __alignment); }
104
105 void
106 deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align)
107 { return do_deallocate(__p, __bytes, __alignment); }
108
109 bool
110 is_equal(const memory_resource& __other) const noexcept
111 { return do_is_equal(__other); }
112
113 protected:
114 virtual void*
115 do_allocate(size_t __bytes, size_t __alignment) = 0;
116
117 virtual void
118 do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0;
119
120 virtual bool
121 do_is_equal(const memory_resource& __other) const noexcept = 0;
122 };
123
124 inline bool
125 operator==(const memory_resource& __a, const memory_resource& __b) noexcept
126 { return &__a == &__b || __a.is_equal(__b); }
127
128 inline bool
129 operator!=(const memory_resource& __a, const memory_resource& __b) noexcept
130 { return !(__a == __b); }
131
132
133 template<typename _Tp>
134 class polymorphic_allocator
135 {
136 public:
137 using value_type = _Tp;
138
139 polymorphic_allocator() noexcept
140 : _M_resource(get_default_resource())
141 { }
142
143 polymorphic_allocator(memory_resource* __r)
144 : _M_resource(__r)
145 { _GLIBCXX_DEBUG_ASSERT(__r); }
146
147 polymorphic_allocator(const polymorphic_allocator& __other) = default;
148
149 template <typename _Up>
150 polymorphic_allocator(const polymorphic_allocator<_Up>&
151 __other) noexcept
152 : _M_resource(__other.resource())
153 { }
154
155 polymorphic_allocator&
156 operator=(const polymorphic_allocator& __rhs) = default;
157
158 _GLIBCXX_NODISCARD _Tp* allocate(size_t __n)
159 { return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp),
160 alignof(_Tp))); }
161
162 void
163 deallocate(_Tp* __p, size_t __n)
164 { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); }
165
166 template <typename _Tp1, typename... _Args> //used here
167 void
168 construct(_Tp1* __p, _Args&&... __args)
169 {
170 std::__uses_allocator_construct(this->resource(), __p,
171 std::forward<_Args>(__args)...);
172 }
173
174 // Specializations for pair using piecewise construction
175 template <typename _Tp1, typename _Tp2,
176 typename... _Args1, typename... _Args2>
177 void
178 construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t,
179 tuple<_Args1...> __x, tuple<_Args2...> __y)
180 {
181 memory_resource* const __resource = this->resource();
182 auto __x_use_tag =
183 std::__use_alloc<_Tp1, memory_resource*, _Args1...>(__resource);
184 auto __y_use_tag =
185 std::__use_alloc<_Tp2, memory_resource*, _Args2...>(__resource);
186
187 ::new(__p) std::pair<_Tp1, _Tp2>(piecewise_construct,
188 _M_construct_p(__x_use_tag, __x),
189 _M_construct_p(__y_use_tag, __y));
190 }
191
192 template <typename _Tp1, typename _Tp2>
193 void
194 construct(pair<_Tp1,_Tp2>* __p)
195 { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); }
196
197 template <typename _Tp1, typename _Tp2, typename _Up, typename _Vp>
198 void
199 construct(pair<_Tp1,_Tp2>* __p, _Up&& __x, _Vp&& __y)
200 {
201 this->construct(__p, piecewise_construct,
202 std::forward_as_tuple(std::forward<_Up>(__x)),
203 std::forward_as_tuple(std::forward<_Vp>(__y)));
204 }
205
206 template <typename _Tp1, typename _Tp2, typename _Up, typename _Vp>
207 void
208 construct(pair<_Tp1,_Tp2>* __p, const std::pair<_Up, _Vp>& __pr)
209 {
210 this->construct(__p, piecewise_construct,
211 std::forward_as_tuple(__pr.first),
212 std::forward_as_tuple(__pr.second));
213 }
214
215 template <typename _Tp1, typename _Tp2, typename _Up, typename _Vp>
216 void
217 construct(pair<_Tp1,_Tp2>* __p, pair<_Up, _Vp>&& __pr)
218 {
219 this->construct(__p, piecewise_construct,
220 std::forward_as_tuple(std::forward<_Up>(__pr.first)),
221 std::forward_as_tuple(std::forward<_Vp>(__pr.second)));
222 }
223
224 template <typename _Up>
225 void
226 destroy(_Up* __p)
227 { __p->~_Up(); }
228
229 // Return a default-constructed allocator (no allocator propagation)
230 polymorphic_allocator
231 select_on_container_copy_construction() const
232 { return polymorphic_allocator(); }
233
234 memory_resource* resource() const { return _M_resource; }
235
236 private:
237 using __uses_alloc1_ = __uses_alloc1<memory_resource*>;
238 using __uses_alloc2_ = __uses_alloc2<memory_resource*>;
239
240 template<typename _Tuple>
241 _Tuple&&
242 _M_construct_p(__uses_alloc0, _Tuple& __t)
243 { return std::move(__t); }
244
245 template<typename... _Args>
246 decltype(auto)
247 _M_construct_p(__uses_alloc1_ __ua, tuple<_Args...>& __t)
248 { return tuple_cat(make_tuple(allocator_arg, *(__ua._M_a)),
249 std::move(__t)); }
250
251 template<typename... _Args>
252 decltype(auto)
253 _M_construct_p(__uses_alloc2_ __ua, tuple<_Args...>& __t)
254 { return tuple_cat(std::move(__t), make_tuple(*(__ua._M_a))); }
255
256 memory_resource* _M_resource;
257 };
258
259 template <class _Tp1, class _Tp2>
260 bool
261 operator==(const polymorphic_allocator<_Tp1>& __a,
262 const polymorphic_allocator<_Tp2>& __b) noexcept
263 { return *__a.resource() == *__b.resource(); }
264
265 template <class _Tp1, class _Tp2>
266 bool
267 operator!=(const polymorphic_allocator<_Tp1>& __a,
268 const polymorphic_allocator<_Tp2>& __b) noexcept
269 { return !(__a == __b); }
270
271
272 /// @cond undocumented
273 class __resource_adaptor_common
274 {
275 template<typename, typename> friend class __resource_adaptor_imp;
276
277 struct _AlignMgr
278 {
279 _AlignMgr(size_t __nbytes, size_t __align)
280 : _M_nbytes(__nbytes), _M_align(__align)
281 { }
282
283 // Total size that needs to be allocated.
284 size_t
285 _M_alloc_size() const { return _M_buf_size() + _M_token_size(); }
286
287 void*
288 _M_adjust(void* __ptr) const
289 {
290 const auto __orig_ptr = static_cast<char*>(__ptr);
291 size_t __space = _M_buf_size();
292 // Align the pointer within the buffer:
293 std::align(_M_align, _M_nbytes, __ptr, __space);
294 const auto __aligned_ptr = static_cast<char*>(__ptr);
295 const auto __token_size = _M_token_size();
296 // Store token immediately after the aligned block:
297 char* const __end = __aligned_ptr + _M_nbytes;
298 if (__token_size == 1)
299 _S_write<unsigned char>(__end, __aligned_ptr - __orig_ptr);
300 else if (__token_size == sizeof(short))
301 _S_write<unsigned short>(__end, __aligned_ptr - __orig_ptr);
302 else if (__token_size == sizeof(int) && sizeof(int) < sizeof(char*))
303 _S_write<unsigned int>(__end, __aligned_ptr - __orig_ptr);
304 else // (__token_size == sizeof(char*))
305 // Just store the original pointer:
306 _S_write<char*>(__end, __orig_ptr);
307 return __aligned_ptr;
308 }
309
310 char*
311 _M_unadjust(char* __ptr) const
312 {
313 const char* const __end = __ptr + _M_nbytes;
314 char* __orig_ptr;
315 const auto __token_size = _M_token_size();
316 // Read the token and restore the original pointer:
317 if (__token_size == 1)
318 __orig_ptr = __ptr - _S_read<unsigned char>(__end);
319 else if (__token_size == sizeof(short))
320 __orig_ptr = __ptr - _S_read<unsigned short>(__end);
321 else if (__token_size == sizeof(int)
322 && sizeof(int) < sizeof(char*))
323 __orig_ptr = __ptr - _S_read<unsigned int>(__end);
324 else // (__token_size == sizeof(char*))
325 __orig_ptr = _S_read<char*>(__end);
326 // The adjustment is always less than the requested alignment,
327 // so if that isn't true now then either the wrong size was passed
328 // to deallocate or the token was overwritten by a buffer overflow:
329 __glibcxx_assert(static_cast<size_t>(__ptr - __orig_ptr) < _M_align);
330 return __orig_ptr;
331 }
332
333 private:
334 size_t _M_nbytes;
335 size_t _M_align;
336
337 // Number of bytes needed to fit block of given size and alignment.
338 size_t
339 _M_buf_size() const { return _M_nbytes + _M_align - 1; }
340
341 // Number of additional bytes needed to write the token.
342 int
343 _M_token_size() const
344 {
345 if (_M_align <= (1ul << __CHAR_BIT__))
346 return 1;
347 if (_M_align <= (1ul << (sizeof(short) * __CHAR_BIT__)))
348 return sizeof(short);
349 if (_M_align <= (1ull << (sizeof(int) * __CHAR_BIT__)))
350 return sizeof(int);
351 return sizeof(char*);
352 }
353
354 template<typename _Tp>
355 static void
356 _S_write(void* __to, _Tp __val)
357 { __builtin_memcpy(__to, &__val, sizeof(_Tp)); }
358
359 template<typename _Tp>
360 static _Tp
361 _S_read(const void* __from)
362 {
363 _Tp __val;
364 __builtin_memcpy(&__val, __from, sizeof(_Tp));
365 return __val;
366 }
367 };
368 };
369 /// @endcond
370
371 // 8.7.1 __resource_adaptor_imp
372 template<typename _Alloc, typename _Resource>
373 class __resource_adaptor_imp
374 : public _Resource, private __resource_adaptor_common
375 {
376 using memory_resource = _Resource;
377
378 static_assert(is_same<char,
379 typename allocator_traits<_Alloc>::value_type>::value,
380 "Allocator's value_type is char");
381 static_assert(is_same<char*,
382 typename allocator_traits<_Alloc>::pointer>::value,
383 "Allocator's pointer type is value_type*");
384 static_assert(is_same<const char*,
385 typename allocator_traits<_Alloc>::const_pointer>::value,
386 "Allocator's const_pointer type is value_type const*");
387 static_assert(is_same<void*,
388 typename allocator_traits<_Alloc>::void_pointer>::value,
389 "Allocator's void_pointer type is void*");
390 static_assert(is_same<const void*,
391 typename allocator_traits<_Alloc>::const_void_pointer>::value,
392 "Allocator's const_void_pointer type is void const*");
393
394 public:
395 using allocator_type = _Alloc;
396
397 __resource_adaptor_imp() = default;
398 __resource_adaptor_imp(const __resource_adaptor_imp&) = default;
399 __resource_adaptor_imp(__resource_adaptor_imp&&) = default;
400
401 explicit __resource_adaptor_imp(const _Alloc& __a2)
402 : _M_alloc(__a2)
403 { }
404
405 explicit __resource_adaptor_imp(_Alloc&& __a2)
406 : _M_alloc(std::move(__a2))
407 { }
408
409 __resource_adaptor_imp&
410 operator=(const __resource_adaptor_imp&) = default;
411
412 allocator_type get_allocator() const noexcept { return _M_alloc; }
413
414 protected:
415#if (defined __sun__ || defined __VXWORKS__) && defined __i386__
416// Cannot use max_align_t on 32-bit Solaris x86, see PR libstdc++/77691
417# define _GLIBCXX_MAX_ALIGN_MATCHES_MALLOC 0
418#elif defined __hpux__ && defined __hppa__ && defined __LP64__
419// Ignore inconsistent long double and malloc alignment (libstdc++/77691)
420# define _GLIBCXX_MAX_ALIGN_MATCHES_MALLOC 0
421#else
422# define _GLIBCXX_MAX_ALIGN_MATCHES_MALLOC 1
423#endif
424
425 virtual void*
426 do_allocate(size_t __bytes, size_t __alignment) override
427 {
428#if _GLIBCXX_MAX_ALIGN_MATCHES_MALLOC
429 if (__alignment == alignof(max_align_t))
430 return _M_allocate<alignof(max_align_t)>(__bytes);
431#endif
432 switch (__alignment)
433 {
434 case 1:
435 return _M_alloc.allocate(__bytes);
436 case 2:
437 return _M_allocate<2>(__bytes);
438 case 4:
439 return _M_allocate<4>(__bytes);
440 case 8:
441 return _M_allocate<8>(__bytes);
442 }
443 const _AlignMgr __mgr(__bytes, __alignment);
444 // Assume _M_alloc returns 1-byte aligned memory, so allocate enough
445 // space to fit a block of the right size and alignment, plus some
446 // extra bytes to store a token for retrieving the original pointer.
447 return __mgr._M_adjust(_M_alloc.allocate(__mgr._M_alloc_size()));
448 }
449
450 virtual void
451 do_deallocate(void* __ptr, size_t __bytes, size_t __alignment) noexcept
452 override
453 {
454#if _GLIBCXX_MAX_ALIGN_MATCHES_MALLOC
455 if (__alignment == alignof(max_align_t))
456 return (void) _M_deallocate<alignof(max_align_t)>(__ptr, __bytes);
457#endif
458 switch (__alignment)
459 {
460 case 1:
461 return (void) _M_alloc.deallocate((char*)__ptr, __bytes);
462 case 2:
463 return (void) _M_deallocate<2>(__ptr, __bytes);
464 case 4:
465 return (void) _M_deallocate<4>(__ptr, __bytes);
466 case 8:
467 return (void) _M_deallocate<8>(__ptr, __bytes);
468 }
469 const _AlignMgr __mgr(__bytes, __alignment);
470 // Use the stored token to retrieve the original pointer.
471 _M_alloc.deallocate(__mgr._M_unadjust((char*)__ptr),
472 __mgr._M_alloc_size());
473 }
474
475 virtual bool
476 do_is_equal(const memory_resource& __other) const noexcept override
477 {
478#if __cpp_rtti
479 if (auto __p = dynamic_cast<const __resource_adaptor_imp*>(&__other))
480 return _M_alloc == __p->_M_alloc;
481#else
482 if (this == &__other) // Need RTTI to do better than this.
483 return true;
484#endif
485 return false;
486 }
487
488 private:
489 template<size_t _Num>
490 struct _Aligned_type { alignas(_Num) char __c[_Num]; };
491
492 // Rebind the allocator to the specified type and use it to allocate.
493 template<size_t _Num, typename _Tp = _Aligned_type<_Num>>
494 void*
495 _M_allocate(size_t __bytes)
496 {
497 typename allocator_traits<_Alloc>::template
498 rebind_alloc<_Tp> __a2(_M_alloc);
499 const size_t __n = (__bytes + _Num - 1) / _Num;
500 return __a2.allocate(__n);
501 }
502
503 // Rebind the allocator to the specified type and use it to deallocate.
504 template<size_t _Num, typename _Tp = _Aligned_type<_Num>>
505 void
506 _M_deallocate(void* __ptr, size_t __bytes) noexcept
507 {
508 typename allocator_traits<_Alloc>::template
509 rebind_alloc<_Tp> __a2(_M_alloc);
510 const size_t __n = (__bytes + _Num - 1) / _Num;
511 __a2.deallocate((_Tp*)__ptr, __n);
512 }
513
514 _Alloc _M_alloc{};
515 };
516
517 // Global memory resources
518
519 inline memory_resource*
520 new_delete_resource() noexcept
521 {
522 using type = resource_adaptor<std::__new_allocator<char>>;
523 alignas(type) static unsigned char __buf[sizeof(type)];
524 static type* __r = new(__buf) type;
525 return __r;
526 }
527
528 inline memory_resource*
529 null_memory_resource() noexcept
530 {
531 class type final : public memory_resource
532 {
533 void*
534 do_allocate(size_t, size_t) override
535 { std::__throw_bad_alloc(); }
536
537 void
538 do_deallocate(void*, size_t, size_t) noexcept override
539 { }
540
541 bool
542 do_is_equal(const memory_resource& __other) const noexcept override
543 { return this == &__other; }
544 };
545
546 alignas(type) static unsigned char __buf[sizeof(type)];
547 static type* __r = new(__buf) type;
548 return __r;
549 }
550
551 // The default memory resource
552
553 /// @cond undocumented
554 inline auto&
555 __get_default_resource()
556 {
557#ifndef _GLIBCXX_HAS_GTHREADS
558 struct type {
559 using value_type = memory_resource*;
560 explicit type(value_type __r) : _M_r(__r) { }
561 value_type _M_r;
562 value_type load() const { return _M_r; }
563 value_type exchange(value_type __r) { return std::__exchange(_M_r, __r); }
564 };
565#else
566 using type = atomic<memory_resource*>;
567#endif
568 alignas(type) static unsigned char __buf[sizeof(type)];
569 static type* __r = new(__buf) type(new_delete_resource());
570 return *__r;
571 }
572 /// @endcond
573
574 /// Get the current default resource.
575 inline memory_resource*
576 get_default_resource() noexcept
577 { return __get_default_resource().load(); }
578
579 /// Change the default resource and return the previous one.
580 inline memory_resource*
581 set_default_resource(memory_resource* __r) noexcept
582 {
583 if (__r == nullptr)
584 __r = new_delete_resource();
585 return __get_default_resource().exchange(__r);
586 }
587
588} // namespace pmr
589} // namespace fundamentals_v2
590} // namespace experimental
591
592_GLIBCXX_END_NAMESPACE_VERSION
593} // namespace std
594#endif // C++14
595#endif // _GLIBCXX_EXPERIMENTAL_MEMORY_RESOURCE
new
atomic
cstddef
requires_hosted.h
assertions.h
std::align
void * align(size_t __align, size_t __size, void *&__ptr, size_t &__space) noexcept
Fit aligned storage in buffer.
Definition align.h:60
std::pair::pair
pair(_T1, _T2) -> pair< _T1, _T2 >
Two pairs are equal iff their members are equal.
std::tuple_cat
constexpr auto tuple_cat(_Tpls &&... __tpls) -> typename __tuple_cat_result< _Tpls... >::__type
Create a tuple containing all elements from multiple tuple-like objects.
Definition tuple:2829
std::forward_as_tuple
constexpr tuple< _Elements &&... > forward_as_tuple(_Elements &&... __args) noexcept
Create a tuple of lvalue or rvalue references to the arguments.
Definition tuple:2705
std::make_tuple
constexpr tuple< typename __decay_and_strip< _Elements >::__type... > make_tuple(_Elements &&... __args)
Create a tuple containing copies of the arguments.
Definition tuple:2693
std::move
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:138
std::piecewise_construct
constexpr piecewise_construct_t piecewise_construct
Tag for piecewise construction of std::pair objects.
Definition stl_pair.h:82
std::forward
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
Definition move.h:72
std
ISO C++ entities toplevel namespace is std.
__gnu_cxx
GNU extensions for public use.
std::experimental
Namespace for features defined in ISO Technical Specifications.
std::allocator_traits::void_pointer
typename _Ptr< __v_pointer, void >::type void_pointer
The allocator's void pointer type.
Definition bits/alloc_traits.h:309
std::allocator_traits::pointer
__detected_or_t< value_type *, __pointer, _Alloc > pointer
The allocator's pointer type.
Definition bits/alloc_traits.h:261
std::allocator_traits::const_void_pointer
typename _Ptr< __cv_pointer, const void >::type const_void_pointer
The allocator's const void pointer type.
Definition bits/alloc_traits.h:317
std::allocator_traits::const_pointer
typename _Ptr< __c_pointer, const value_type >::type const_pointer
The allocator's const pointer type.
Definition bits/alloc_traits.h:301
std::allocator_traits::value_type
_Alloc::value_type value_type
The allocated type.
Definition bits/alloc_traits.h:254
std::pair::first
_T1 first
The first member.
Definition stl_pair.h:311
std::pair::second
_T2 second
The second member.
Definition stl_pair.h:312
__gnu_cxx::malloc_allocator
An allocator that uses malloc.
Definition malloc_allocator.h:57
new_allocator.h
memory
std::experimental::fundamentals_v2::pmr::set_default_resource
memory_resource * set_default_resource(memory_resource *__r) noexcept
Change the default resource and return the previous one.
Definition experimental/memory_resource:581
std::experimental::fundamentals_v2::pmr::get_default_resource
memory_resource * get_default_resource() noexcept
Get the current default resource.
Definition experimental/memory_resource:576
tuple
utility