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