1 // -*- C++ -*- 2 // Testing allocator for the C++ library testsuite. 3 // 4 // Copyright (C) 2002-2021 Free Software Foundation, Inc. 5 // 6 // This file is part of the GNU ISO C++ Library. This library is free 7 // software; you can redistribute it and/or modify it under the 8 // terms of the GNU General Public License as published by the 9 // Free Software Foundation; either version 3, or (at your option) 10 // any later version. 11 // 12 // This library is distributed in the hope that it will be useful, 13 // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 // GNU General Public License for more details. 16 // 17 // You should have received a copy of the GNU General Public License along 18 // with this library; see the file COPYING3. If not see 19 // <http://www.gnu.org/licenses/>. 20 // 21 22 // This file provides an test instrumentation allocator that can be 23 // used to verify allocation functionality of standard library 24 // containers. 2002.11.25 smw 25 26 #ifndef _GLIBCXX_TESTSUITE_ALLOCATOR_H 27 #define _GLIBCXX_TESTSUITE_ALLOCATOR_H 28 29 #include <bits/move.h> 30 #include <ext/pointer.h> 31 #include <ext/alloc_traits.h> 32 #include <testsuite_hooks.h> 33 #if __cplusplus >= 201703L 34 # include <memory_resource> 35 # include <new> 36 #endif 37 38 #if __cplusplus >= 201103L 39 # include <unordered_map> 40 namespace unord = std; 41 #else 42 # include <tr1/unordered_map> 43 namespace unord = std::tr1; 44 #endif 45 46 namespace __gnu_test 47 { 48 // A common API for calling max_size() on an allocator in any -std mode. 49 template<typename A> 50 typename A::size_type max_size(const A & a)51 max_size(const A& a) 52 { 53 #if __cplusplus >= 201103L 54 return std::allocator_traits<A>::max_size(a); 55 #else 56 return a.max_size(); 57 #endif 58 } 59 60 class tracker_allocator_counter 61 { 62 public: 63 typedef std::size_t size_type; 64 65 static void allocate(size_type blocksize)66 allocate(size_type blocksize) 67 { allocationCount_ += blocksize; } 68 69 static void construct()70 construct() { ++constructCount_; } 71 72 static void destroy()73 destroy() { ++destructCount_; } 74 75 static void deallocate(size_type blocksize)76 deallocate(size_type blocksize) 77 { deallocationCount_ += blocksize; } 78 79 static size_type get_allocation_count()80 get_allocation_count() { return allocationCount_; } 81 82 static size_type get_deallocation_count()83 get_deallocation_count() { return deallocationCount_; } 84 85 static int get_construct_count()86 get_construct_count() { return constructCount_; } 87 88 static int get_destruct_count()89 get_destruct_count() { return destructCount_; } 90 91 static void reset()92 reset() 93 { 94 allocationCount_ = 0; 95 deallocationCount_ = 0; 96 constructCount_ = 0; 97 destructCount_ = 0; 98 } 99 100 private: 101 static size_type allocationCount_; 102 static size_type deallocationCount_; 103 static int constructCount_; 104 static int destructCount_; 105 }; 106 107 // Helper to detect inconsistency between type used to instantiate an 108 // allocator and the underlying allocator value_type. 109 template<typename T, typename Alloc, 110 typename = typename Alloc::value_type> 111 struct check_consistent_alloc_value_type; 112 113 template<typename T, typename Alloc> 114 struct check_consistent_alloc_value_type<T, Alloc, T> 115 { typedef T value_type; }; 116 117 // An allocator facade that intercepts allocate/deallocate/construct/destroy 118 // calls and track them through the tracker_allocator_counter class. This 119 // class is templated on the target object type, but tracker isn't. 120 template<typename T, typename Alloc = std::allocator<T> > 121 class tracker_allocator : public Alloc 122 { 123 private: 124 typedef tracker_allocator_counter counter_type; 125 126 typedef __gnu_cxx::__alloc_traits<Alloc> AllocTraits; 127 128 public: 129 typedef typename 130 check_consistent_alloc_value_type<T, Alloc>::value_type value_type; 131 typedef typename AllocTraits::pointer pointer; 132 typedef typename AllocTraits::size_type size_type; 133 134 template<class U> 135 struct rebind 136 { 137 typedef tracker_allocator<U, 138 typename AllocTraits::template rebind<U>::other> other; 139 }; 140 141 #if __cplusplus >= 201103L 142 tracker_allocator() = default; 143 tracker_allocator(const tracker_allocator&) = default; 144 tracker_allocator(tracker_allocator&&) = default; 145 tracker_allocator& operator=(const tracker_allocator&) = default; 146 tracker_allocator& operator=(tracker_allocator&&) = default; 147 148 // Perfect forwarding constructor. 149 template<typename... _Args> 150 tracker_allocator(_Args&&... __args) 151 : Alloc(std::forward<_Args>(__args)...) 152 { } 153 #else 154 tracker_allocator() 155 { } 156 157 tracker_allocator(const tracker_allocator&) 158 { } 159 160 ~tracker_allocator() 161 { } 162 #endif 163 164 template<class U> 165 tracker_allocator(const tracker_allocator<U, 166 typename AllocTraits::template rebind<U>::other>& alloc) 167 _GLIBCXX_USE_NOEXCEPT 168 : Alloc(alloc) 169 { } 170 171 pointer 172 allocate(size_type n, const void* = 0) 173 { 174 pointer p = AllocTraits::allocate(*this, n); 175 counter_type::allocate(n * sizeof(T)); 176 return p; 177 } 178 179 #if __cplusplus >= 201103L 180 template<typename U, typename... Args> 181 void 182 construct(U* p, Args&&... args) 183 { 184 AllocTraits::construct(*this, p, std::forward<Args>(args)...); 185 counter_type::construct(); 186 } 187 188 template<typename U> 189 void 190 destroy(U* p) 191 { 192 AllocTraits::destroy(*this, p); 193 counter_type::destroy(); 194 } 195 #else 196 void 197 construct(pointer p, const T& value) 198 { 199 AllocTraits::construct(*this, p, value); 200 counter_type::construct(); 201 } 202 203 void 204 destroy(pointer p) 205 { 206 AllocTraits::destroy(*this, p); 207 counter_type::destroy(); 208 } 209 #endif 210 211 void 212 deallocate(pointer p, size_type num) 213 { 214 counter_type::deallocate(num * sizeof(T)); 215 AllocTraits::deallocate(*this, p, num); 216 } 217 218 // Implement swap for underlying allocators that might need it. 219 friend inline void 220 swap(tracker_allocator& a, tracker_allocator& b) 221 { 222 using std::swap; 223 224 Alloc& aa = a; 225 Alloc& ab = b; 226 swap(aa, ab); 227 } 228 }; 229 230 template<class T1, class Alloc1, class T2, class Alloc2> 231 bool 232 operator==(const tracker_allocator<T1, Alloc1>& lhs, 233 const tracker_allocator<T2, Alloc2>& rhs) throw() 234 { 235 const Alloc1& alloc1 = lhs; 236 const Alloc2& alloc2 = rhs; 237 return alloc1 == alloc2; 238 } 239 240 template<class T1, class Alloc1, class T2, class Alloc2> 241 bool 242 operator!=(const tracker_allocator<T1, Alloc1>& lhs, 243 const tracker_allocator<T2, Alloc2>& rhs) throw() 244 { return !(lhs == rhs); } 245 246 bool 247 check_construct_destroy(const char* tag, int expected_c, int expected_d); 248 249 template<typename Alloc> 250 bool 251 check_deallocate_null() 252 { 253 // Let's not core here... 254 Alloc a; 255 a.deallocate(0, 1); 256 a.deallocate(0, 10); 257 return true; 258 } 259 260 #if __cpp_exceptions 261 template<typename Alloc> 262 bool 263 check_allocate_max_size() 264 { 265 Alloc a; 266 try 267 { 268 (void) a.allocate(__gnu_test::max_size(a) + 1); 269 } 270 catch(std::bad_alloc&) 271 { 272 return true; 273 } 274 catch(...) 275 { 276 throw; 277 } 278 throw; 279 } 280 #endif 281 282 // A simple allocator which can be constructed endowed of a given 283 // "personality" (an integer), queried in operator== to simulate the 284 // behavior of realworld "unequal" allocators (i.e., not exploiting 285 // the provision in 20.1.5/4, first bullet). A global unordered_map, 286 // filled at allocation time with (pointer, personality) pairs, is 287 // then consulted to enforce the requirements in Table 32 about 288 // deallocation vs allocator equality. Note that this allocator is 289 // swappable, not copy assignable, consistently with Option 3 of DR 431 290 // (see N1599). 291 struct uneq_allocator_base 292 { 293 typedef unord::unordered_map<void*, int> map_type; 294 295 // Avoid static initialization troubles and/or bad interactions 296 // with tests linking testsuite_allocator.o and playing globally 297 // with operator new/delete. 298 static map_type& 299 get_map() 300 { 301 static map_type alloc_map; 302 return alloc_map; 303 } 304 }; 305 306 template<typename Tp, typename Alloc = std::allocator<Tp> > 307 class uneq_allocator 308 : private uneq_allocator_base, 309 public Alloc 310 { 311 typedef __gnu_cxx::__alloc_traits<Alloc> AllocTraits; 312 313 Alloc& base() { return *this; } 314 const Alloc& base() const { return *this; } 315 void swap_base(Alloc& b) { using std::swap; swap(b, this->base()); } 316 317 public: 318 typedef typename check_consistent_alloc_value_type<Tp, Alloc>::value_type 319 value_type; 320 typedef typename AllocTraits::size_type size_type; 321 typedef typename AllocTraits::pointer pointer; 322 323 #if __cplusplus >= 201103L 324 typedef std::true_type propagate_on_container_swap; 325 typedef std::false_type is_always_equal; 326 #endif 327 328 template<typename Tp1> 329 struct rebind 330 { 331 typedef uneq_allocator<Tp1, 332 typename AllocTraits::template rebind<Tp1>::other> other; 333 }; 334 335 uneq_allocator() _GLIBCXX_USE_NOEXCEPT 336 : personality(0) { } 337 338 uneq_allocator(int person) _GLIBCXX_USE_NOEXCEPT 339 : personality(person) { } 340 341 #if __cplusplus >= 201103L 342 uneq_allocator(const uneq_allocator&) = default; 343 uneq_allocator(uneq_allocator&&) = default; 344 #endif 345 346 template<typename Tp1> 347 uneq_allocator(const uneq_allocator<Tp1, 348 typename AllocTraits::template rebind<Tp1>::other>& b) 349 _GLIBCXX_USE_NOEXCEPT 350 : personality(b.get_personality()) { } 351 352 ~uneq_allocator() _GLIBCXX_USE_NOEXCEPT 353 { } 354 355 int get_personality() const { return personality; } 356 357 pointer 358 allocate(size_type n, const void* = 0) 359 { 360 pointer p = AllocTraits::allocate(*this, n); 361 362 try 363 { 364 get_map().insert(map_type::value_type(reinterpret_cast<void*>(p), 365 personality)); 366 } 367 catch(...) 368 { 369 AllocTraits::deallocate(*this, p, n); 370 __throw_exception_again; 371 } 372 373 return p; 374 } 375 376 void 377 deallocate(pointer p, size_type n) 378 { 379 VERIFY( p ); 380 381 map_type::iterator it = get_map().find(reinterpret_cast<void*>(p)); 382 VERIFY( it != get_map().end() ); 383 384 // Enforce requirements in Table 32 about deallocation vs 385 // allocator equality. 386 VERIFY( it->second == personality ); 387 388 get_map().erase(it); 389 AllocTraits::deallocate(*this, p, n); 390 } 391 392 #if __cplusplus >= 201103L 393 // Not copy assignable... 394 uneq_allocator& 395 operator=(const uneq_allocator&) = delete; 396 397 // ... but still moveable if base allocator is. 398 uneq_allocator& 399 operator=(uneq_allocator&&) = default; 400 #else 401 private: 402 // Not assignable... 403 uneq_allocator& 404 operator=(const uneq_allocator&); 405 #endif 406 407 private: 408 // ... yet swappable! 409 friend inline void 410 swap(uneq_allocator& a, uneq_allocator& b) 411 { 412 std::swap(a.personality, b.personality); 413 a.swap_base(b); 414 } 415 416 template<typename Tp1> 417 friend inline bool 418 operator==(const uneq_allocator& a, 419 const uneq_allocator<Tp1, 420 typename AllocTraits::template rebind<Tp1>::other>& b) 421 { return a.personality == b.personality; } 422 423 template<typename Tp1> 424 friend inline bool 425 operator!=(const uneq_allocator& a, 426 const uneq_allocator<Tp1, 427 typename AllocTraits::template rebind<Tp1>::other>& b) 428 { return !(a == b); } 429 430 int personality; 431 }; 432 433 #if __cplusplus >= 201103L 434 // An uneq_allocator which can be used to test allocator propagation. 435 template<typename Tp, bool Propagate, typename Alloc = std::allocator<Tp>> 436 class propagating_allocator : public uneq_allocator<Tp, Alloc> 437 { 438 typedef __gnu_cxx::__alloc_traits<Alloc> AllocTraits; 439 440 typedef uneq_allocator<Tp, Alloc> base_alloc; 441 base_alloc& base() { return *this; } 442 const base_alloc& base() const { return *this; } 443 void swap_base(base_alloc& b) { swap(b, this->base()); } 444 445 typedef std::integral_constant<bool, Propagate> trait_type; 446 447 public: 448 // default allocator_traits::rebind_alloc would select 449 // uneq_allocator::rebind so we must define rebind here 450 template<typename Up> 451 struct rebind 452 { 453 typedef propagating_allocator<Up, Propagate, 454 typename AllocTraits::template rebind<Up>::other> other; 455 }; 456 457 propagating_allocator(int i) noexcept 458 : base_alloc(i) 459 { } 460 461 template<typename Up> 462 propagating_allocator(const propagating_allocator<Up, Propagate, 463 typename AllocTraits::template rebind<Up>::other>& a) 464 noexcept 465 : base_alloc(a) 466 { } 467 468 propagating_allocator() noexcept = default; 469 470 propagating_allocator(const propagating_allocator&) noexcept = default; 471 472 propagating_allocator& 473 operator=(const propagating_allocator& a) noexcept 474 { 475 static_assert(Propagate, "assigning propagating_allocator<T, true>"); 476 propagating_allocator(a).swap_base(*this); 477 return *this; 478 } 479 480 template<bool P2> 481 propagating_allocator& 482 operator=(const propagating_allocator<Tp, P2, Alloc>& a) noexcept 483 { 484 static_assert(P2, "assigning propagating_allocator<T, true>"); 485 propagating_allocator(a).swap_base(*this); 486 return *this; 487 } 488 489 // postcondition: LWG2593 a.get_personality() un-changed. 490 propagating_allocator(propagating_allocator&& a) noexcept 491 : base_alloc(std::move(a.base())) 492 { } 493 494 // postcondition: LWG2593 a.get_personality() un-changed 495 propagating_allocator& 496 operator=(propagating_allocator&& a) noexcept 497 { 498 propagating_allocator(std::move(a)).swap_base(*this); 499 return *this; 500 } 501 502 typedef trait_type propagate_on_container_copy_assignment; 503 typedef trait_type propagate_on_container_move_assignment; 504 typedef trait_type propagate_on_container_swap; 505 506 propagating_allocator select_on_container_copy_construction() const 507 { return Propagate ? *this : propagating_allocator(); } 508 }; 509 510 // Class template supporting the minimal interface that satisfies the 511 // Allocator requirements, from example in [allocator.requirements] 512 template <class Tp> 513 struct SimpleAllocator 514 { 515 typedef Tp value_type; 516 517 SimpleAllocator() noexcept { } 518 519 template <class T> 520 SimpleAllocator(const SimpleAllocator<T>&) { } 521 522 Tp *allocate(std::size_t n) 523 { return std::allocator<Tp>().allocate(n); } 524 525 void deallocate(Tp *p, std::size_t n) 526 { std::allocator<Tp>().deallocate(p, n); } 527 }; 528 529 template <class T, class U> 530 bool operator==(const SimpleAllocator<T>&, const SimpleAllocator<U>&) 531 { return true; } 532 template <class T, class U> 533 bool operator!=(const SimpleAllocator<T>&, const SimpleAllocator<U>&) 534 { return false; } 535 536 template<typename T> 537 struct default_init_allocator 538 { 539 using value_type = T; 540 541 default_init_allocator() = default; 542 543 template<typename U> 544 default_init_allocator(const default_init_allocator<U>& a) 545 : state(a.state) 546 { } 547 548 T* 549 allocate(std::size_t n) 550 { return std::allocator<T>().allocate(n); } 551 552 void 553 deallocate(T* p, std::size_t n) 554 { std::allocator<T>().deallocate(p, n); } 555 556 int state; 557 }; 558 559 template<typename T, typename U> 560 bool operator==(const default_init_allocator<T>& t, 561 const default_init_allocator<U>& u) 562 { return t.state == u.state; } 563 564 template<typename T, typename U> 565 bool operator!=(const default_init_allocator<T>& t, 566 const default_init_allocator<U>& u) 567 { return !(t == u); } 568 #endif 569 570 template<typename Tp> 571 struct ExplicitConsAlloc : std::allocator<Tp> 572 { 573 ExplicitConsAlloc() { } 574 575 template<typename Up> 576 explicit 577 ExplicitConsAlloc(const ExplicitConsAlloc<Up>&) { } 578 579 template<typename Up> 580 struct rebind 581 { typedef ExplicitConsAlloc<Up> other; }; 582 }; 583 584 #if __cplusplus >= 201103L 585 template<typename Tp> 586 class CustomPointerAlloc : public std::allocator<Tp> 587 { 588 template<typename Up, typename Sp = __gnu_cxx::_Std_pointer_impl<Up>> 589 using Ptr = __gnu_cxx::_Pointer_adapter<Sp>; 590 591 public: 592 CustomPointerAlloc() = default; 593 594 template<typename Up> 595 CustomPointerAlloc(const CustomPointerAlloc<Up>&) { } 596 597 template<typename Up> 598 struct rebind 599 { typedef CustomPointerAlloc<Up> other; }; 600 601 typedef Ptr<Tp> pointer; 602 typedef Ptr<const Tp> const_pointer; 603 typedef Ptr<void> void_pointer; 604 typedef Ptr<const void> const_void_pointer; 605 606 pointer allocate(std::size_t n, const_void_pointer = {}) 607 { return pointer(std::allocator<Tp>::allocate(n)); } 608 609 void deallocate(pointer p, std::size_t n) 610 { std::allocator<Tp>::deallocate(std::addressof(*p), n); } 611 }; 612 613 // A class type meeting *only* the Cpp17NullablePointer requirements. 614 // Can be used as a base class for fancy pointers (like PointerBase, below) 615 // or to wrap a built-in pointer type to remove operations not required 616 // by the Cpp17NullablePointer requirements (dereference, increment etc.) 617 template<typename Ptr> 618 struct NullablePointer 619 { 620 // N.B. default constructor does not initialize value 621 NullablePointer() = default; 622 NullablePointer(std::nullptr_t) noexcept : value() { } 623 624 explicit operator bool() const noexcept { return value != nullptr; } 625 626 friend inline bool 627 operator==(NullablePointer lhs, NullablePointer rhs) noexcept 628 { return lhs.value == rhs.value; } 629 630 friend inline bool 631 operator!=(NullablePointer lhs, NullablePointer rhs) noexcept 632 { return lhs.value != rhs.value; } 633 634 protected: 635 explicit NullablePointer(Ptr p) noexcept : value(p) { } 636 Ptr value; 637 }; 638 639 // NullablePointer<void> is an empty type that models Cpp17NullablePointer. 640 template<> 641 struct NullablePointer<void> 642 { 643 NullablePointer() = default; 644 NullablePointer(std::nullptr_t) noexcept { } 645 explicit NullablePointer(const volatile void*) noexcept { } 646 647 explicit operator bool() const noexcept { return false; } 648 649 friend inline bool 650 operator==(NullablePointer, NullablePointer) noexcept 651 { return true; } 652 653 friend inline bool 654 operator!=(NullablePointer, NullablePointer) noexcept 655 { return false; } 656 }; 657 658 // Utility for use as CRTP base class of custom pointer types 659 template<typename Derived, typename T> 660 struct PointerBase : NullablePointer<T*> 661 { 662 typedef T element_type; 663 664 // typedefs for iterator_traits 665 typedef T value_type; 666 typedef std::ptrdiff_t difference_type; 667 typedef std::random_access_iterator_tag iterator_category; 668 typedef Derived pointer; 669 typedef T& reference; 670 671 using NullablePointer<T*>::NullablePointer; 672 673 // Public (but explicit) constructor from raw pointer: 674 explicit PointerBase(T* p) noexcept : NullablePointer<T*>(p) { } 675 676 template<typename D, typename U, 677 typename = decltype(static_cast<T*>(std::declval<U*>()))> 678 PointerBase(const PointerBase<D, U>& p) 679 : NullablePointer<T*>(p.operator->()) { } 680 681 T& operator*() const { return *this->value; } 682 T* operator->() const { return this->value; } 683 T& operator[](difference_type n) const { return this->value[n]; } 684 685 Derived& operator++() { ++this->value; return derived(); } 686 Derived& operator--() { --this->value; return derived(); } 687 688 Derived operator++(int) { return Derived(this->value++); } 689 690 Derived operator--(int) { return Derived(this->value--); } 691 692 Derived& operator+=(difference_type n) 693 { 694 this->value += n; 695 return derived(); 696 } 697 698 Derived& operator-=(difference_type n) 699 { 700 this->value -= n; 701 return derived(); 702 } 703 704 Derived 705 operator+(difference_type n) const 706 { 707 Derived p(derived()); 708 return p += n; 709 } 710 711 Derived 712 operator-(difference_type n) const 713 { 714 Derived p(derived()); 715 return p -= n; 716 } 717 718 private: 719 friend std::ptrdiff_t operator-(PointerBase l, PointerBase r) 720 { return l.value - r.value; } 721 722 Derived& 723 derived() { return static_cast<Derived&>(*this); } 724 725 const Derived& 726 derived() const { return static_cast<const Derived&>(*this); } 727 }; 728 729 // implementation for pointer-to-void specializations 730 template<typename T> 731 struct PointerBase_void : NullablePointer<T*> 732 { 733 typedef T element_type; 734 735 // typedefs for iterator_traits 736 typedef T value_type; 737 typedef std::ptrdiff_t difference_type; 738 typedef std::random_access_iterator_tag iterator_category; 739 740 using NullablePointer<T*>::NullablePointer; 741 742 T* operator->() const { return this->value; } 743 744 template<typename D, typename U, 745 typename = decltype(static_cast<T*>(std::declval<U*>()))> 746 PointerBase_void(const PointerBase<D, U>& p) 747 : NullablePointer<T*>(p.operator->()) { } 748 }; 749 750 template<typename Derived> 751 struct PointerBase<Derived, void> : PointerBase_void<void> 752 { 753 using PointerBase_void::PointerBase_void; 754 typedef Derived pointer; 755 }; 756 757 template<typename Derived> 758 struct PointerBase<Derived, const void> : PointerBase_void<const void> 759 { 760 using PointerBase_void::PointerBase_void; 761 typedef Derived pointer; 762 }; 763 #endif // C++11 764 765 #if __cplusplus >= 201703L 766 #if __cpp_aligned_new 767 // A concrete memory_resource, with error checking. 768 class memory_resource : public std::pmr::memory_resource 769 { 770 public: 771 memory_resource() 772 : lists(new allocation_lists) 773 { } 774 775 memory_resource(const memory_resource& r) noexcept 776 : lists(r.lists) 777 { lists->refcount++; } 778 779 memory_resource& operator=(const memory_resource&) = delete; 780 781 ~memory_resource() 782 { 783 if (lists->refcount-- == 1) 784 delete lists; // last one out turns out the lights 785 } 786 787 struct bad_size { }; 788 struct bad_alignment { }; 789 struct bad_address { }; 790 791 // Deallocate everything (moving the tracking info to the freed list) 792 void 793 deallocate_everything() 794 { 795 while (lists->active) 796 { 797 auto a = lists->active; 798 // Intentionally virtual dispatch, to inform derived classes: 799 this->do_deallocate(a->p, a->bytes, a->alignment); 800 } 801 } 802 803 // Clear the freed list 804 void 805 forget_freed_allocations() 806 { lists->forget_allocations(lists->freed); } 807 808 // Count how many allocations have been done and not freed. 809 std::size_t 810 number_of_active_allocations() const noexcept 811 { 812 std::size_t n = 0; 813 for (auto a = lists->active; a != nullptr; a = a->next) 814 ++n; 815 return n; 816 } 817 818 protected: 819 void* 820 do_allocate(std::size_t bytes, std::size_t alignment) override 821 { 822 // TODO perform a single allocation and put the allocation struct 823 // in the buffer using placement new? It means deallocation won't 824 // actually return memory to the OS, as it will stay in lists->freed. 825 // 826 // TODO adjust the returned pointer to be minimally aligned? 827 // e.g. if alignment==1 don't return something aligned to 2 bytes. 828 // Maybe not worth it, at least monotonic_buffer_resource will 829 // never ask upstream for anything with small alignment. 830 void* p = ::operator new(bytes, std::align_val_t(alignment)); 831 lists->active = new allocation{p, bytes, alignment, lists->active}; 832 return p; 833 } 834 835 void 836 do_deallocate(void* p, std::size_t bytes, std::size_t alignment) override 837 { 838 allocation** aptr = &lists->active; 839 while (*aptr) 840 { 841 allocation* a = *aptr; 842 if (p == a->p) 843 { 844 if (bytes != a->bytes) 845 _S_throw<bad_size>(); 846 if (alignment != a->alignment) 847 _S_throw<bad_alignment>(); 848 #if __cpp_sized_deallocation 849 ::operator delete(p, bytes, std::align_val_t(alignment)); 850 #else 851 ::operator delete(p, std::align_val_t(alignment)); 852 #endif 853 *aptr = a->next; 854 a->next = lists->freed; 855 lists->freed = a; 856 return; 857 } 858 aptr = &a->next; 859 } 860 _S_throw<bad_address>(); 861 } 862 863 bool 864 do_is_equal(const std::pmr::memory_resource& r) const noexcept override 865 { 866 #if __cpp_rtti 867 // Equality is determined by sharing the same allocation_lists object. 868 if (auto p = dynamic_cast<const memory_resource*>(&r)) 869 return p->lists == lists; 870 #else 871 if (this == &r) // Is this the best we can do without RTTI? 872 return true; 873 #endif 874 return false; 875 } 876 877 private: 878 template<typename E> 879 static void 880 _S_throw() 881 { 882 #if __cpp_exceptions 883 throw E(); 884 #else 885 __builtin_abort(); 886 #endif 887 } 888 889 struct allocation 890 { 891 void* p; 892 std::size_t bytes; 893 std::size_t alignment; 894 allocation* next; 895 }; 896 897 // Maintain list of allocated blocks and list of freed blocks. 898 // Copies of this memory_resource share the same ref-counted lists. 899 struct allocation_lists 900 { 901 unsigned refcount = 1; 902 allocation* active = nullptr; 903 allocation* freed = nullptr; 904 905 void forget_allocations(allocation*& list) 906 { 907 while (list) 908 { 909 auto p = list; 910 list = list->next; 911 delete p; 912 } 913 } 914 915 ~allocation_lists() 916 { 917 forget_allocations(active); // Anything in this list is a leak! 918 forget_allocations(freed); 919 } 920 }; 921 922 allocation_lists* lists; 923 }; 924 #endif // aligned-new 925 926 // Set the default resource, and restore the previous one on destruction. 927 struct default_resource_mgr 928 { 929 explicit default_resource_mgr(std::pmr::memory_resource* r) 930 : prev(std::pmr::set_default_resource(r)) 931 { } 932 933 ~default_resource_mgr() 934 { std::pmr::set_default_resource(prev); } 935 936 std::pmr::memory_resource* prev; 937 }; 938 939 #endif // C++17 940 941 } // namespace __gnu_test 942 943 #endif // _GLIBCXX_TESTSUITE_ALLOCATOR_H 944