libstdc++-v3/testsuite/util/testsuite_allocator.h

   1 // -*- C++ -*-
   2 // Testing allocator for the C++ library testsuite.
   3 //
   4 // Copyright (C) 2002-2014 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 <tr1/unordered_map>
  30 #include <bits/move.h>
  31 #include <ext/pointer.h>
  32 #include <ext/alloc_traits.h>
  33 #include <testsuite_hooks.h>
  34
  35 namespace __gnu_test
  36 {
  37   class tracker_allocator_counter
  38   {
  39   public:
  40     typedef std::size_t    size_type;
  41
  42     static void
  43     allocate(size_type blocksize)
  44     { allocationCount_ += blocksize; }
  45
  46     static void
  47     construct() { ++constructCount_; }
  48
  49     static void
  50     destroy() { ++destructCount_; }
  51
  52     static void
  53     deallocate(size_type blocksize)
  54     { deallocationCount_ += blocksize; }
  55
  56     static size_type
  57     get_allocation_count() { return allocationCount_; }
  58
  59     static size_type
  60     get_deallocation_count() { return deallocationCount_; }
  61
  62     static int
  63     get_construct_count() { return constructCount_; }
  64
  65     static int
  66     get_destruct_count() { return destructCount_; }
  67
  68     static void
  69     reset()
  70     {
  71       allocationCount_ = 0;
  72       deallocationCount_ = 0;
  73       constructCount_ = 0;
  74       destructCount_ = 0;
  75     }
  76
  77  private:
  78     static size_type  allocationCount_;
  79     static size_type  deallocationCount_;
  80     static int        constructCount_;
  81     static int        destructCount_;
  82   };
  83
  84   // Helper to detect inconsistency between type used to instantiate an
  85   // allocator and the underlying allocator value_type.
  86   template<typename T, typename Alloc,
  87            typename = typename Alloc::value_type>
  88     struct check_consistent_alloc_value_type;
  89
  90   template<typename T, typename Alloc>
  91     struct check_consistent_alloc_value_type<T, Alloc, T>
  92     { typedef T value_type; };
  93
  94   // An allocator facade that intercepts allocate/deallocate/construct/destroy
  95   // calls and track them through the tracker_allocator_counter class. This
  96   // class is templated on the target object type, but tracker isn't.
  97   template<typename T, typename Alloc = std::allocator<T> >
  98     class tracker_allocator : public Alloc
  99     {
 100     private:
 101       typedef tracker_allocator_counter counter_type;
 102
 103       typedef __gnu_cxx::__alloc_traits<Alloc> AllocTraits;
 104
 105     public:
 106       typedef typename
 107       check_consistent_alloc_value_type<T, Alloc>::value_type value_type;
 108       typedef typename AllocTraits::pointer pointer;
 109       typedef typename AllocTraits::size_type size_type;
 110
 111       template<class U>
 112         struct rebind
 113         {
 114           typedef tracker_allocator<U,
 115                 typename AllocTraits::template rebind<U>::other> other;
 116         };
 117
 118 #if __cplusplus >= 201103L
 119       tracker_allocator() = default;
 120       tracker_allocator(const tracker_allocator&) = default;
 121       tracker_allocator(tracker_allocator&&) = default;
 122
 123       // Perfect forwarding constructor.
 124       template<typename... _Args>
 125         tracker_allocator(_Args&&... __args)
 126           : Alloc(std::forward<_Args>(__args)...)
 127         { }
 128 #else
 129       tracker_allocator()
 130       { }
 131
 132       tracker_allocator(const tracker_allocator&)
 133       { }
 134
 135       ~tracker_allocator()
 136       { }
 137 #endif
 138
 139       template<class U>
 140         tracker_allocator(const tracker_allocator<U,
 141           typename AllocTraits::template rebind<U>::other>& alloc)
 142             _GLIBCXX_USE_NOEXCEPT
 143           : Alloc(alloc)
 144         { }
 145
 146       pointer
 147       allocate(size_type n, const void* = 0)
 148       {
 149         pointer p = AllocTraits::allocate(*this, n);
 150         counter_type::allocate(n * sizeof(T));
 151         return p;
 152       }
 153
 154 #if __cplusplus >= 201103L
 155       template<typename U, typename... Args>
 156         void
 157         construct(U* p, Args&&... args)
 158         {
 159           AllocTraits::construct(*this, p, std::forward<Args>(args)...);
 160           counter_type::construct();
 161         }
 162
 163       template<typename U>
 164         void
 165         destroy(U* p)
 166         {
 167           AllocTraits::destroy(*this, p);
 168           counter_type::destroy();
 169         }
 170 #else
 171       void
 172       construct(pointer p, const T& value)
 173       {
 174         AllocTraits::construct(*this, p, value);
 175         counter_type::construct();
 176       }
 177
 178       void
 179       destroy(pointer p)
 180       {
 181         AllocTraits::destroy(*this, p);
 182         counter_type::destroy();
 183       }
 184 #endif
 185
 186       void
 187       deallocate(pointer p, size_type num)
 188       {
 189         counter_type::deallocate(num * sizeof(T));
 190         AllocTraits::deallocate(*this, p, num);
 191       }
 192
 193       // Implement swap for underlying allocators that might need it.
 194       friend inline void
 195       swap(tracker_allocator& a, tracker_allocator& b)
 196       {
 197         using std::swap;
 198
 199         Alloc& aa = a;
 200         Alloc& ab = b;
 201         swap(aa, ab);
 202       }
 203     };
 204
 205   template<class T1, class Alloc1, class T2, class Alloc2>
 206     bool
 207     operator==(const tracker_allocator<T1, Alloc1>& lhs,
 208                const tracker_allocator<T2, Alloc2>& rhs) throw()
 209     {
 210       const Alloc1& alloc1 = lhs;
 211       const Alloc2& alloc2 = rhs;
 212       return lhs == rhs;
 213     }
 214
 215   template<class T1, class Alloc1, class T2, class Alloc2>
 216     bool
 217     operator!=(const tracker_allocator<T1, Alloc1>& lhs,
 218                const tracker_allocator<T2, Alloc2>& rhs) throw()
 219     { return !(lhs == rhs); }
 220
 221   bool
 222   check_construct_destroy(const char* tag, int expected_c, int expected_d);
 223
 224   template<typename Alloc>
 225     bool
 226     check_deallocate_null()
 227     {
 228       // Let's not core here...
 229       Alloc a;
 230       a.deallocate(0, 1);
 231       a.deallocate(0, 10);
 232       return true;
 233     }
 234
 235   template<typename Alloc>
 236     bool
 237     check_allocate_max_size()
 238     {
 239       Alloc a;
 240       try
 241         {
 242           a.allocate(a.max_size() + 1);
 243         }
 244       catch(std::bad_alloc&)
 245         {
 246           return true;
 247         }
 248       catch(...)
 249         {
 250           throw;
 251         }
 252       throw;
 253     }
 254
 255   // A simple allocator which can be constructed endowed of a given
 256   // "personality" (an integer), queried in operator== to simulate the
 257   // behavior of realworld "unequal" allocators (i.e., not exploiting
 258   // the provision in 20.1.5/4, first bullet).  A global unordered_map,
 259   // filled at allocation time with (pointer, personality) pairs, is
 260   // then consulted to enforce the requirements in Table 32 about
 261   // deallocation vs allocator equality.  Note that this allocator is
 262   // swappable, not copy assignable, consistently with Option 3 of DR 431
 263   // (see N1599).
 264   struct uneq_allocator_base
 265   {
 266     typedef std::tr1::unordered_map<void*, int>   map_type;
 267
 268     // Avoid static initialization troubles and/or bad interactions
 269     // with tests linking testsuite_allocator.o and playing globally
 270     // with operator new/delete.
 271     static map_type&
 272     get_map()
 273     {
 274       static map_type alloc_map;
 275       return alloc_map;
 276     }
 277   };
 278
 279   template<typename Tp, typename Alloc = std::allocator<Tp> >
 280     class uneq_allocator
 281     : private uneq_allocator_base,
 282       public Alloc
 283     {
 284       typedef __gnu_cxx::__alloc_traits<Alloc> AllocTraits;
 285
 286       Alloc& base() { return *this; }
 287       const Alloc& base() const  { return *this; }
 288       void swap_base(Alloc& b) { swap(b, this->base()); }
 289
 290     public:
 291       typedef typename check_consistent_alloc_value_type<Tp, Alloc>::value_type
 292         value_type;
 293       typedef typename AllocTraits::size_type   size_type;
 294       typedef typename AllocTraits::pointer     pointer;
 295
 296 #if __cplusplus >= 201103L
 297       typedef std::true_type                    propagate_on_container_swap;
 298 #endif
 299
 300       template<typename Tp1>
 301         struct rebind
 302         {
 303           typedef uneq_allocator<Tp1,
 304                 typename AllocTraits::template rebind<Tp1>::other> other;
 305         };
 306
 307       uneq_allocator() _GLIBCXX_USE_NOEXCEPT
 308       : personality(0) { }
 309
 310       uneq_allocator(int person) _GLIBCXX_USE_NOEXCEPT
 311       : personality(person) { }
 312
 313       template<typename Tp1>
 314         uneq_allocator(const uneq_allocator<Tp1,
 315                        typename AllocTraits::template rebind<Tp1>::other>& b)
 316         _GLIBCXX_USE_NOEXCEPT
 317         : personality(b.get_personality()) { }
 318
 319       ~uneq_allocator() _GLIBCXX_USE_NOEXCEPT
 320       { }
 321
 322       int get_personality() const { return personality; }
 323
 324       pointer
 325       allocate(size_type n, const void* hint = 0)
 326       {
 327         pointer p = AllocTraits::allocate(*this, n);
 328         try
 329           {
 330             get_map().insert(map_type::value_type(reinterpret_cast<void*>(p),
 331                                                   personality));
 332           }
 333         catch(...)
 334           {
 335             AllocTraits::deallocate(*this, p, n);
 336             __throw_exception_again;
 337           }
 338         return p;
 339       }
 340
 341       void
 342       deallocate(pointer p, size_type n)
 343       {
 344         bool test __attribute__((unused)) = true;
 345
 346         VERIFY( p );
 347
 348         map_type::iterator it = get_map().find(reinterpret_cast<void*>(p));
 349         VERIFY( it != get_map().end() );
 350
 351         // Enforce requirements in Table 32 about deallocation vs
 352         // allocator equality.
 353         VERIFY( it->second == personality );
 354
 355         get_map().erase(it);
 356         AllocTraits::deallocate(*this, p, n);
 357       }
 358
 359 #if __cplusplus >= 201103L
 360       // Not copy assignable...
 361       uneq_allocator&
 362       operator=(const uneq_allocator&) = delete;
 363
 364       // ... but still moveable if base allocator is.
 365       uneq_allocator&
 366       operator=(uneq_allocator&&) = default;
 367 #else
 368     private:
 369       // Not assignable...
 370       uneq_allocator&
 371       operator=(const uneq_allocator&);
 372 #endif
 373
 374     private:
 375       // ... yet swappable!
 376       friend inline void
 377       swap(uneq_allocator& a, uneq_allocator& b)
 378       {
 379         std::swap(a.personality, b.personality);
 380         a.swap_base(b);
 381       }
 382
 383       template<typename Tp1>
 384         friend inline bool
 385         operator==(const uneq_allocator& a,
 386                    const uneq_allocator<Tp1,
 387                    typename AllocTraits::template rebind<Tp1>::other>& b)
 388         { return a.personality == b.personality; }
 389
 390       template<typename Tp1>
 391         friend inline bool
 392         operator!=(const uneq_allocator& a,
 393                    const uneq_allocator<Tp1,
 394                    typename AllocTraits::template rebind<Tp1>::other>& b)
 395         { return !(a == b); }
 396
 397       int personality;
 398     };
 399
 400 #if __cplusplus >= 201103L
 401   // An uneq_allocator which can be used to test allocator propagation.
 402   template<typename Tp, bool Propagate, typename Alloc = std::allocator<Tp>>
 403     class propagating_allocator : public uneq_allocator<Tp, Alloc>
 404     {
 405       typedef __gnu_cxx::__alloc_traits<Alloc> AllocTraits;
 406
 407       typedef uneq_allocator<Tp, Alloc> base_alloc;
 408       base_alloc& base() { return *this; }
 409       const base_alloc& base() const  { return *this; }
 410       void swap_base(base_alloc& b) { swap(b, this->base()); }
 411
 412       typedef std::integral_constant<bool, Propagate> trait_type;
 413
 414     public:
 415       // default allocator_traits::rebind_alloc would select
 416       // uneq_allocator::rebind so we must define rebind here
 417       template<typename Up>
 418         struct rebind
 419         {
 420           typedef propagating_allocator<Up, Propagate,
 421                 typename AllocTraits::template rebind<Up>::other> other;
 422         };
 423
 424       propagating_allocator(int i) noexcept
 425       : base_alloc(i)
 426       { }
 427
 428       template<typename Up>
 429         propagating_allocator(const propagating_allocator<Up, Propagate,
 430                               typename AllocTraits::template rebind<Up>::other>& a)
 431         noexcept
 432         : base_alloc(a)
 433         { }
 434
 435       propagating_allocator() noexcept = default;
 436
 437       propagating_allocator(const propagating_allocator&) noexcept = default;
 438
 439       propagating_allocator&
 440       operator=(const propagating_allocator& a) noexcept
 441       {
 442         static_assert(Propagate, "assigning propagating_allocator<T, true>");
 443         propagating_allocator(a).swap_base(*this);
 444         return *this;
 445       }
 446
 447       template<bool P2>
 448         propagating_allocator&
 449         operator=(const propagating_allocator<Tp, P2, Alloc>& a) noexcept
 450         {
 451           static_assert(P2, "assigning propagating_allocator<T, true>");
 452           propagating_allocator(a).swap_base(*this);
 453           return *this;
 454         }
 455
 456       // postcondition: a.get_personality() == 0
 457       propagating_allocator(propagating_allocator&& a) noexcept
 458       : base_alloc()
 459       { swap_base(a); }
 460
 461       // postcondition: a.get_personality() == 0
 462       propagating_allocator&
 463       operator=(propagating_allocator&& a) noexcept
 464       {
 465         propagating_allocator(std::move(a)).swap_base(*this);
 466         return *this;
 467       }
 468
 469       typedef trait_type propagate_on_container_copy_assignment;
 470       typedef trait_type propagate_on_container_move_assignment;
 471       typedef trait_type propagate_on_container_swap;
 472
 473       propagating_allocator select_on_container_copy_construction() const
 474       { return Propagate ? *this : propagating_allocator(); }
 475     };
 476
 477   // Class template supporting the minimal interface that satisfies the
 478   // Allocator requirements, from example in [allocator.requirements]
 479   template <class Tp>
 480     struct SimpleAllocator
 481     {
 482       typedef Tp value_type;
 483
 484       SimpleAllocator() noexcept { }
 485
 486       template <class T>
 487         SimpleAllocator(const SimpleAllocator<T>& other) { }
 488
 489       Tp *allocate(std::size_t n)
 490       { return std::allocator<Tp>().allocate(n); }
 491
 492       void deallocate(Tp *p, std::size_t n)
 493       { std::allocator<Tp>().deallocate(p, n); }
 494     };
 495
 496   template <class T, class U>
 497     bool operator==(const SimpleAllocator<T>&, const SimpleAllocator<U>&)
 498     { return true; }
 499   template <class T, class U>
 500     bool operator!=(const SimpleAllocator<T>&, const SimpleAllocator<U>&)
 501     { return false; }
 502
 503 #endif
 504
 505   template<typename Tp>
 506     struct ExplicitConsAlloc : std::allocator<Tp>
 507     {
 508       ExplicitConsAlloc() { }
 509
 510       template<typename Up>
 511         explicit
 512         ExplicitConsAlloc(const ExplicitConsAlloc<Up>&) { }
 513
 514       template<typename Up>
 515         struct rebind
 516         { typedef ExplicitConsAlloc<Up> other; };
 517     };
 518
 519 #if __cplusplus >= 201103L
 520   template<typename Tp>
 521     class CustomPointerAlloc : public std::allocator<Tp>
 522     {
 523       template<typename Up, typename Sp = __gnu_cxx::_Std_pointer_impl<Up>>
 524         using Ptr =  __gnu_cxx::_Pointer_adapter<Sp>;
 525
 526     public:
 527       CustomPointerAlloc() = default;
 528
 529       template<typename Up>
 530         CustomPointerAlloc(const CustomPointerAlloc<Up>&) { }
 531
 532       template<typename Up>
 533         struct rebind
 534         { typedef CustomPointerAlloc<Up> other; };
 535
 536       typedef Ptr<Tp>           pointer;
 537       typedef Ptr<const Tp>     const_pointer;
 538       typedef Ptr<void>         void_pointer;
 539       typedef Ptr<const void>   const_void_pointer;
 540
 541       pointer allocate(std::size_t n, pointer = {})
 542       { return pointer(std::allocator<Tp>::allocate(n)); }
 543
 544       void deallocate(pointer p, std::size_t n)
 545       { std::allocator<Tp>::deallocate(std::addressof(*p), n); }
 546     };
 547
 548   // Utility for use as CRTP base class of custom pointer types
 549   template<typename Derived, typename T>
 550     struct PointerBase
 551     {
 552       typedef T element_type;
 553
 554       // typedefs for iterator_traits
 555       typedef T value_type;
 556       typedef std::ptrdiff_t difference_type;
 557       typedef std::random_access_iterator_tag iterator_category;
 558       typedef Derived pointer;
 559       typedef T& reference;
 560
 561       T* value;
 562
 563       explicit PointerBase(T* p = nullptr) : value(p) { }
 564
 565       template<typename D, typename U,
 566                typename = decltype(static_cast<T*>(std::declval<U*>()))>
 567         PointerBase(const PointerBase<D, U>& p) : value(p.value) { }
 568
 569       T& operator*() const { return *value; }
 570       T* operator->() const { return value; }
 571
 572       Derived& operator++() { ++value; return derived(); }
 573       Derived operator++(int) { Derived tmp(derived()); ++value; return tmp; }
 574       Derived& operator--() { --value; return derived(); }
 575       Derived operator--(int) { Derived tmp(derived()); --value; return tmp; }
 576
 577       Derived& operator+=(difference_type n) { value += n; return derived(); }
 578       Derived& operator-=(difference_type n) { value -= n; return derived(); }
 579
 580       explicit operator bool() const { return value != nullptr; }
 581
 582       Derived
 583       operator+(difference_type n) const
 584       {
 585         Derived p(derived());
 586         return p += n;
 587       }
 588
 589       Derived
 590       operator-(difference_type n) const
 591       {
 592         Derived p(derived());
 593         return p -= n;
 594       }
 595
 596     private:
 597       Derived& derived() { return static_cast<Derived&>(*this); }
 598     };
 599
 600     template<typename D, typename T>
 601     std::ptrdiff_t operator-(PointerBase<D, T> l, PointerBase<D, T> r)
 602     { return l.value - r.value; }
 603
 604     template<typename D, typename T>
 605     bool operator==(PointerBase<D, T> l, PointerBase<D, T> r)
 606     { return l.value == r.value; }
 607
 608     template<typename D, typename T>
 609     bool operator!=(PointerBase<D, T> l, PointerBase<D, T> r)
 610     { return l.value != r.value; }
 611
 612     // implementation for void specializations
 613     template<typename T>
 614     struct PointerBase_void
 615     {
 616       typedef T element_type;
 617
 618       // typedefs for iterator_traits
 619       typedef T value_type;
 620       typedef std::ptrdiff_t difference_type;
 621       typedef std::random_access_iterator_tag iterator_category;
 622
 623       T* value;
 624
 625       explicit PointerBase_void(T* p = nullptr) : value(p) { }
 626
 627       template<typename D, typename U,
 628                typename = decltype(static_cast<T*>(std::declval<U*>()))>
 629         PointerBase_void(const PointerBase<D, U>& p) : value(p.value) { }
 630
 631       explicit operator bool() const { return value != nullptr; }
 632     };
 633
 634     template<typename Derived>
 635     struct PointerBase<Derived, void> : PointerBase_void<void>
 636     {
 637       using PointerBase_void::PointerBase_void;
 638       typedef Derived pointer;
 639     };
 640
 641     template<typename Derived>
 642     struct PointerBase<Derived, const void> : PointerBase_void<const void>
 643     {
 644       using PointerBase_void::PointerBase_void;
 645       typedef Derived pointer;
 646     };
 647 #endif
 648
 649 } // namespace __gnu_test
 650
 651 #endif // _GLIBCXX_TESTSUITE_ALLOCATOR_H