libstdc++
memory_resource
Go to the documentation of this file.
1 // <memory_resource> -*- C++ -*-
2 
3 // Copyright (C) 2018-2021 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 include/memory_resource
26  * This is a Standard C++ Library header.
27  */
28 
29 #ifndef _GLIBCXX_MEMORY_RESOURCE
30 #define _GLIBCXX_MEMORY_RESOURCE 1
31 
32 #pragma GCC system_header
33 
34 #if __cplusplus >= 201703L
35 
36 #include <vector> // vector
37 #include <cstddef> // size_t, max_align_t, byte
38 #include <shared_mutex> // shared_mutex
39 #include <bits/align.h> // align
40 #include <bits/functexcept.h> // __throw_bad_array_new_length
41 #include <bits/uses_allocator.h> // __use_alloc
42 #include <bits/uses_allocator_args.h> // uninitialized_construct_using_alloc
43 #include <ext/numeric_traits.h>
44 #include <debug/assertions.h>
45 
46 #if ! __cpp_lib_make_obj_using_allocator
47 # include <utility> // pair, index_sequence
48 # include <tuple> // tuple, forward_as_tuple
49 #endif
50 
51 namespace std _GLIBCXX_VISIBILITY(default)
52 {
53 _GLIBCXX_BEGIN_NAMESPACE_VERSION
54 namespace pmr
55 {
56 #ifdef _GLIBCXX_HAS_GTHREADS
57  // Header and all contents are present.
58 # define __cpp_lib_memory_resource 201603L
59 #else
60  // The pmr::synchronized_pool_resource type is missing.
61 # define __cpp_lib_memory_resource 1
62 #endif
63 
64  class memory_resource;
65 
66 #if __cplusplus == 201703L
67  template<typename _Tp>
68  class polymorphic_allocator;
69 #else // C++20
70 # define __cpp_lib_polymorphic_allocator 201902L
71  template<typename _Tp = std::byte>
72  class polymorphic_allocator;
73 #endif
74 
75  // Global memory resources
76  memory_resource* new_delete_resource() noexcept;
77  memory_resource* null_memory_resource() noexcept;
78  memory_resource* set_default_resource(memory_resource* __r) noexcept;
79  memory_resource* get_default_resource() noexcept
80  __attribute__((__returns_nonnull__));
81 
82  // Pool resource classes
83  struct pool_options;
84 #ifdef _GLIBCXX_HAS_GTHREADS
85  class synchronized_pool_resource;
86 #endif
87  class unsynchronized_pool_resource;
88  class monotonic_buffer_resource;
89 
90  /// Class memory_resource
91  class memory_resource
92  {
93  static constexpr size_t _S_max_align = alignof(max_align_t);
94 
95  public:
96  memory_resource() = default;
97  memory_resource(const memory_resource&) = default;
98  virtual ~memory_resource(); // key function
99 
100  memory_resource& operator=(const memory_resource&) = default;
101 
102  [[nodiscard]]
103  void*
104  allocate(size_t __bytes, size_t __alignment = _S_max_align)
105  __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3)))
106  { return do_allocate(__bytes, __alignment); }
107 
108  void
109  deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align)
110  __attribute__((__nonnull__))
111  { return do_deallocate(__p, __bytes, __alignment); }
112 
113  bool
114  is_equal(const memory_resource& __other) const noexcept
115  { return do_is_equal(__other); }
116 
117  private:
118  virtual void*
119  do_allocate(size_t __bytes, size_t __alignment) = 0;
120 
121  virtual void
122  do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0;
123 
124  virtual bool
125  do_is_equal(const memory_resource& __other) const noexcept = 0;
126  };
127 
128  inline bool
129  operator==(const memory_resource& __a, const memory_resource& __b) noexcept
130  { return &__a == &__b || __a.is_equal(__b); }
131 
132 #if __cpp_impl_three_way_comparison < 201907L
133  inline bool
134  operator!=(const memory_resource& __a, const memory_resource& __b) noexcept
135  { return !(__a == __b); }
136 #endif
137 
138  // C++17 23.12.3 Class template polymorphic_allocator
139  template<typename _Tp>
140  class polymorphic_allocator
141  {
142  // _GLIBCXX_RESOLVE_LIB_DEFECTS
143  // 2975. Missing case for pair construction in polymorphic allocators
144  template<typename _Up>
145  struct __not_pair { using type = void; };
146 
147  template<typename _Up1, typename _Up2>
148  struct __not_pair<pair<_Up1, _Up2>> { };
149 
150  public:
151  using value_type = _Tp;
152 
153  polymorphic_allocator() noexcept
154  : _M_resource(get_default_resource())
155  { }
156 
157  polymorphic_allocator(memory_resource* __r) noexcept
158  __attribute__((__nonnull__))
159  : _M_resource(__r)
160  { _GLIBCXX_DEBUG_ASSERT(__r); }
161 
162  polymorphic_allocator(const polymorphic_allocator& __other) = default;
163 
164  template<typename _Up>
165  polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept
166  : _M_resource(__x.resource())
167  { }
168 
169  polymorphic_allocator&
170  operator=(const polymorphic_allocator&) = delete;
171 
172  [[nodiscard]]
173  _Tp*
174  allocate(size_t __n)
175  __attribute__((__returns_nonnull__))
176  {
177  if ((__gnu_cxx::__int_traits<size_t>::__max / sizeof(_Tp)) < __n)
178  std::__throw_bad_array_new_length();
179  return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp),
180  alignof(_Tp)));
181  }
182 
183  void
184  deallocate(_Tp* __p, size_t __n) noexcept
185  __attribute__((__nonnull__))
186  { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); }
187 
188 #if __cplusplus > 201703L
189  [[nodiscard]] void*
190  allocate_bytes(size_t __nbytes,
191  size_t __alignment = alignof(max_align_t))
192  { return _M_resource->allocate(__nbytes, __alignment); }
193 
194  void
195  deallocate_bytes(void* __p, size_t __nbytes,
196  size_t __alignment = alignof(max_align_t))
197  { _M_resource->deallocate(__p, __nbytes, __alignment); }
198 
199  template<typename _Up>
200  [[nodiscard]] _Up*
201  allocate_object(size_t __n = 1)
202  {
203  if ((__gnu_cxx::__int_traits<size_t>::__max / sizeof(_Up)) < __n)
204  std::__throw_bad_array_new_length();
205  return static_cast<_Up*>(allocate_bytes(__n * sizeof(_Up),
206  alignof(_Up)));
207  }
208 
209  template<typename _Up>
210  void
211  deallocate_object(_Up* __p, size_t __n = 1)
212  { deallocate_bytes(__p, __n * sizeof(_Up), alignof(_Up)); }
213 
214  template<typename _Up, typename... _CtorArgs>
215  [[nodiscard]] _Up*
216  new_object(_CtorArgs&&... __ctor_args)
217  {
218  _Up* __p = allocate_object<_Up>();
219  __try
220  {
221  construct(__p, std::forward<_CtorArgs>(__ctor_args)...);
222  }
223  __catch (...)
224  {
225  deallocate_object(__p);
226  __throw_exception_again;
227  }
228  return __p;
229  }
230 
231  template<typename _Up>
232  void
233  delete_object(_Up* __p)
234  {
235  destroy(__p);
236  deallocate_object(__p);
237  }
238 #endif // C++2a
239 
240 #if ! __cpp_lib_make_obj_using_allocator
241  template<typename _Tp1, typename... _Args>
242  __attribute__((__nonnull__))
243  typename __not_pair<_Tp1>::type
244  construct(_Tp1* __p, _Args&&... __args)
245  {
246  // _GLIBCXX_RESOLVE_LIB_DEFECTS
247  // 2969. polymorphic_allocator::construct() shouldn't pass resource()
248  using __use_tag
249  = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>;
250  if constexpr (is_base_of_v<__uses_alloc0, __use_tag>)
251  ::new(__p) _Tp1(std::forward<_Args>(__args)...);
252  else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>)
253  ::new(__p) _Tp1(allocator_arg, *this,
254  std::forward<_Args>(__args)...);
255  else
256  ::new(__p) _Tp1(std::forward<_Args>(__args)..., *this);
257  }
258 
259  template<typename _Tp1, typename _Tp2,
260  typename... _Args1, typename... _Args2>
261  __attribute__((__nonnull__))
262  void
263  construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t,
264  tuple<_Args1...> __x, tuple<_Args2...> __y)
265  {
266  auto __x_tag =
267  __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this);
268  auto __y_tag =
269  __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this);
270  index_sequence_for<_Args1...> __x_i;
271  index_sequence_for<_Args2...> __y_i;
272 
273  ::new(__p) pair<_Tp1, _Tp2>(piecewise_construct,
274  _S_construct_p(__x_tag, __x_i, __x),
275  _S_construct_p(__y_tag, __y_i, __y));
276  }
277 
278  template<typename _Tp1, typename _Tp2>
279  __attribute__((__nonnull__))
280  void
281  construct(pair<_Tp1, _Tp2>* __p)
282  { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); }
283 
284  template<typename _Tp1, typename _Tp2, typename _Up, typename _Vp>
285  __attribute__((__nonnull__))
286  void
287  construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y)
288  {
289  this->construct(__p, piecewise_construct,
290  std::forward_as_tuple(std::forward<_Up>(__x)),
291  std::forward_as_tuple(std::forward<_Vp>(__y)));
292  }
293 
294  template <typename _Tp1, typename _Tp2, typename _Up, typename _Vp>
295  __attribute__((__nonnull__))
296  void
297  construct(pair<_Tp1, _Tp2>* __p, const std::pair<_Up, _Vp>& __pr)
298  {
299  this->construct(__p, piecewise_construct,
300  std::forward_as_tuple(__pr.first),
301  std::forward_as_tuple(__pr.second));
302  }
303 
304  template<typename _Tp1, typename _Tp2, typename _Up, typename _Vp>
305  __attribute__((__nonnull__))
306  void
307  construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr)
308  {
309  this->construct(__p, piecewise_construct,
310  std::forward_as_tuple(std::forward<_Up>(__pr.first)),
311  std::forward_as_tuple(std::forward<_Vp>(__pr.second)));
312  }
313 #else // make_obj_using_allocator
314  template<typename _Tp1, typename... _Args>
315  __attribute__((__nonnull__))
316  void
317  construct(_Tp1* __p, _Args&&... __args)
318  {
319  std::uninitialized_construct_using_allocator(__p, *this,
320  std::forward<_Args>(__args)...);
321  }
322 #endif
323 
324  template<typename _Up>
325  _GLIBCXX20_DEPRECATED_SUGGEST("allocator_traits::destroy")
326  __attribute__((__nonnull__))
327  void
328  destroy(_Up* __p)
329  { __p->~_Up(); }
330 
331  polymorphic_allocator
332  select_on_container_copy_construction() const noexcept
333  { return polymorphic_allocator(); }
334 
335  memory_resource*
336  resource() const noexcept
337  __attribute__((__returns_nonnull__))
338  { return _M_resource; }
339 
340  private:
341  using __uses_alloc1_ = __uses_alloc1<polymorphic_allocator>;
342  using __uses_alloc2_ = __uses_alloc2<polymorphic_allocator>;
343 
344 #if ! __cpp_lib_make_obj_using_allocator
345  template<typename _Ind, typename... _Args>
346  static tuple<_Args&&...>
347  _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t)
348  { return std::move(__t); }
349 
350  template<size_t... _Ind, typename... _Args>
351  static tuple<allocator_arg_t, polymorphic_allocator, _Args&&...>
352  _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>,
353  tuple<_Args...>& __t)
354  {
355  return {
356  allocator_arg, *__ua._M_a, std::get<_Ind>(std::move(__t))...
357  };
358  }
359 
360  template<size_t... _Ind, typename... _Args>
361  static tuple<_Args&&..., polymorphic_allocator>
362  _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>,
363  tuple<_Args...>& __t)
364  { return { std::get<_Ind>(std::move(__t))..., *__ua._M_a }; }
365 #endif
366 
367  memory_resource* _M_resource;
368  };
369 
370  template<typename _Tp1, typename _Tp2>
371  inline bool
372  operator==(const polymorphic_allocator<_Tp1>& __a,
373  const polymorphic_allocator<_Tp2>& __b) noexcept
374  { return *__a.resource() == *__b.resource(); }
375 
376 #if __cpp_impl_three_way_comparison < 201907L
377  template<typename _Tp1, typename _Tp2>
378  inline bool
379  operator!=(const polymorphic_allocator<_Tp1>& __a,
380  const polymorphic_allocator<_Tp2>& __b) noexcept
381  { return !(__a == __b); }
382 #endif
383 
384  /// Parameters for tuning a pool resource's behaviour.
385  struct pool_options
386  {
387  /** @brief Upper limit on number of blocks in a chunk.
388  *
389  * A lower value prevents allocating huge chunks that could remain mostly
390  * unused, but means pools will need to replenished more frequently.
391  */
392  size_t max_blocks_per_chunk = 0;
393 
394  /* @brief Largest block size (in bytes) that should be served from pools.
395  *
396  * Larger allocations will be served directly by the upstream resource,
397  * not from one of the pools managed by the pool resource.
398  */
399  size_t largest_required_pool_block = 0;
400  };
401 
402  // Common implementation details for un-/synchronized pool resources.
403  class __pool_resource
404  {
405  friend class synchronized_pool_resource;
406  friend class unsynchronized_pool_resource;
407 
408  __pool_resource(const pool_options& __opts, memory_resource* __upstream);
409 
410  ~__pool_resource();
411 
412  __pool_resource(const __pool_resource&) = delete;
413  __pool_resource& operator=(const __pool_resource&) = delete;
414 
415  // Allocate a large unpooled block.
416  void*
417  allocate(size_t __bytes, size_t __alignment);
418 
419  // Deallocate a large unpooled block.
420  void
421  deallocate(void* __p, size_t __bytes, size_t __alignment);
422 
423 
424  // Deallocate unpooled memory.
425  void release() noexcept;
426 
427  memory_resource* resource() const noexcept
428  { return _M_unpooled.get_allocator().resource(); }
429 
430  struct _Pool;
431 
432  _Pool* _M_alloc_pools();
433 
434  const pool_options _M_opts;
435 
436  struct _BigBlock;
437  // Collection of blocks too big for any pool, sorted by address.
438  // This also stores the only copy of the upstream memory resource pointer.
439  _GLIBCXX_STD_C::pmr::vector<_BigBlock> _M_unpooled;
440 
441  const int _M_npools;
442  };
443 
444 #ifdef _GLIBCXX_HAS_GTHREADS
445  /// A thread-safe memory resource that manages pools of fixed-size blocks.
446  class synchronized_pool_resource : public memory_resource
447  {
448  public:
449  synchronized_pool_resource(const pool_options& __opts,
450  memory_resource* __upstream)
451  __attribute__((__nonnull__));
452 
453  synchronized_pool_resource()
454  : synchronized_pool_resource(pool_options(), get_default_resource())
455  { }
456 
457  explicit
458  synchronized_pool_resource(memory_resource* __upstream)
459  __attribute__((__nonnull__))
460  : synchronized_pool_resource(pool_options(), __upstream)
461  { }
462 
463  explicit
464  synchronized_pool_resource(const pool_options& __opts)
465  : synchronized_pool_resource(__opts, get_default_resource()) { }
466 
467  synchronized_pool_resource(const synchronized_pool_resource&) = delete;
468 
469  virtual ~synchronized_pool_resource();
470 
471  synchronized_pool_resource&
472  operator=(const synchronized_pool_resource&) = delete;
473 
474  void release();
475 
476  memory_resource*
477  upstream_resource() const noexcept
478  __attribute__((__returns_nonnull__))
479  { return _M_impl.resource(); }
480 
481  pool_options options() const noexcept { return _M_impl._M_opts; }
482 
483  protected:
484  void*
485  do_allocate(size_t __bytes, size_t __alignment) override;
486 
487  void
488  do_deallocate(void* __p, size_t __bytes, size_t __alignment) override;
489 
490  bool
491  do_is_equal(const memory_resource& __other) const noexcept override
492  { return this == &__other; }
493 
494  public:
495  // Thread-specific pools (only public for access by implementation details)
496  struct _TPools;
497 
498  private:
499  _TPools* _M_alloc_tpools(lock_guard<shared_mutex>&);
500  _TPools* _M_alloc_shared_tpools(lock_guard<shared_mutex>&);
501  auto _M_thread_specific_pools() noexcept;
502 
503  __pool_resource _M_impl;
504  __gthread_key_t _M_key;
505  // Linked list of thread-specific pools. All threads share _M_tpools[0].
506  _TPools* _M_tpools = nullptr;
507  mutable shared_mutex _M_mx;
508  };
509 #endif
510 
511  /// A non-thread-safe memory resource that manages pools of fixed-size blocks.
512  class unsynchronized_pool_resource : public memory_resource
513  {
514  public:
515  [[__gnu__::__nonnull__]]
516  unsynchronized_pool_resource(const pool_options& __opts,
517  memory_resource* __upstream);
518 
519  unsynchronized_pool_resource()
520  : unsynchronized_pool_resource(pool_options(), get_default_resource())
521  { }
522 
523  [[__gnu__::__nonnull__]]
524  explicit
525  unsynchronized_pool_resource(memory_resource* __upstream)
526  : unsynchronized_pool_resource(pool_options(), __upstream)
527  { }
528 
529  explicit
530  unsynchronized_pool_resource(const pool_options& __opts)
531  : unsynchronized_pool_resource(__opts, get_default_resource()) { }
532 
533  unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete;
534 
535  virtual ~unsynchronized_pool_resource();
536 
537  unsynchronized_pool_resource&
538  operator=(const unsynchronized_pool_resource&) = delete;
539 
540  void release();
541 
542  [[__gnu__::__returns_nonnull__]]
543  memory_resource*
544  upstream_resource() const noexcept
545  { return _M_impl.resource(); }
546 
547  pool_options options() const noexcept { return _M_impl._M_opts; }
548 
549  protected:
550  void*
551  do_allocate(size_t __bytes, size_t __alignment) override;
552 
553  void
554  do_deallocate(void* __p, size_t __bytes, size_t __alignment) override;
555 
556  bool
557  do_is_equal(const memory_resource& __other) const noexcept override
558  { return this == &__other; }
559 
560  private:
561  using _Pool = __pool_resource::_Pool;
562 
563  auto _M_find_pool(size_t) noexcept;
564 
565  __pool_resource _M_impl;
566  _Pool* _M_pools = nullptr;
567  };
568 
569  class monotonic_buffer_resource : public memory_resource
570  {
571  public:
572  explicit
573  monotonic_buffer_resource(memory_resource* __upstream) noexcept
574  __attribute__((__nonnull__))
575  : _M_upstream(__upstream)
576  { _GLIBCXX_DEBUG_ASSERT(__upstream != nullptr); }
577 
578  monotonic_buffer_resource(size_t __initial_size,
579  memory_resource* __upstream) noexcept
580  __attribute__((__nonnull__))
581  : _M_next_bufsiz(__initial_size),
582  _M_upstream(__upstream)
583  {
584  _GLIBCXX_DEBUG_ASSERT(__upstream != nullptr);
585  _GLIBCXX_DEBUG_ASSERT(__initial_size > 0);
586  }
587 
588  monotonic_buffer_resource(void* __buffer, size_t __buffer_size,
589  memory_resource* __upstream) noexcept
590  __attribute__((__nonnull__(4)))
591  : _M_current_buf(__buffer), _M_avail(__buffer_size),
592  _M_next_bufsiz(_S_next_bufsize(__buffer_size)),
593  _M_upstream(__upstream),
594  _M_orig_buf(__buffer), _M_orig_size(__buffer_size)
595  {
596  _GLIBCXX_DEBUG_ASSERT(__upstream != nullptr);
597  _GLIBCXX_DEBUG_ASSERT(__buffer != nullptr || __buffer_size == 0);
598  }
599 
600  monotonic_buffer_resource() noexcept
601  : monotonic_buffer_resource(get_default_resource())
602  { }
603 
604  explicit
605  monotonic_buffer_resource(size_t __initial_size) noexcept
606  : monotonic_buffer_resource(__initial_size, get_default_resource())
607  { }
608 
609  monotonic_buffer_resource(void* __buffer, size_t __buffer_size) noexcept
610  : monotonic_buffer_resource(__buffer, __buffer_size, get_default_resource())
611  { }
612 
613  monotonic_buffer_resource(const monotonic_buffer_resource&) = delete;
614 
615  virtual ~monotonic_buffer_resource(); // key function
616 
617  monotonic_buffer_resource&
618  operator=(const monotonic_buffer_resource&) = delete;
619 
620  void
621  release() noexcept
622  {
623  if (_M_head)
624  _M_release_buffers();
625 
626  // reset to initial state at contruction:
627  if ((_M_current_buf = _M_orig_buf))
628  {
629  _M_avail = _M_orig_size;
630  _M_next_bufsiz = _S_next_bufsize(_M_orig_size);
631  }
632  else
633  {
634  _M_avail = 0;
635  _M_next_bufsiz = _M_orig_size;
636  }
637  }
638 
639  memory_resource*
640  upstream_resource() const noexcept
641  __attribute__((__returns_nonnull__))
642  { return _M_upstream; }
643 
644  protected:
645  void*
646  do_allocate(size_t __bytes, size_t __alignment) override
647  {
648  if (__builtin_expect(__bytes == 0, false))
649  __bytes = 1; // Ensures we don't return the same pointer twice.
650 
651  void* __p = std::align(__alignment, __bytes, _M_current_buf, _M_avail);
652  if (__builtin_expect(__p == nullptr, false))
653  {
654  _M_new_buffer(__bytes, __alignment);
655  __p = _M_current_buf;
656  }
657  _M_current_buf = (char*)_M_current_buf + __bytes;
658  _M_avail -= __bytes;
659  return __p;
660  }
661 
662  void
663  do_deallocate(void*, size_t, size_t) override
664  { }
665 
666  bool
667  do_is_equal(const memory_resource& __other) const noexcept override
668  { return this == &__other; }
669 
670  private:
671  // Update _M_current_buf and _M_avail to refer to a new buffer with
672  // at least the specified size and alignment, allocated from upstream.
673  void
674  _M_new_buffer(size_t __bytes, size_t __alignment);
675 
676  // Deallocate all buffers obtained from upstream.
677  void
678  _M_release_buffers() noexcept;
679 
680  static size_t
681  _S_next_bufsize(size_t __buffer_size) noexcept
682  {
683  if (__builtin_expect(__buffer_size == 0, false))
684  __buffer_size = 1;
685  return __buffer_size * _S_growth_factor;
686  }
687 
688  static constexpr size_t _S_init_bufsize = 128 * sizeof(void*);
689  static constexpr float _S_growth_factor = 1.5;
690 
691  void* _M_current_buf = nullptr;
692  size_t _M_avail = 0;
693  size_t _M_next_bufsiz = _S_init_bufsize;
694 
695  // Initial values set at construction and reused by release():
696  memory_resource* const _M_upstream;
697  void* const _M_orig_buf = nullptr;
698  size_t const _M_orig_size = _M_next_bufsiz;
699 
700  class _Chunk;
701  _Chunk* _M_head = nullptr;
702  };
703 
704 } // namespace pmr
705 _GLIBCXX_END_NAMESPACE_VERSION
706 } // namespace std
707 
708 #endif // C++17
709 #endif // _GLIBCXX_MEMORY_RESOURCE