3 // Copyright (C) 2005-2015 Free Software Foundation, Inc.
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 terms
7 // of the GNU General Public License as published by the Free Software
8 // Foundation; either version 3, or (at your option) any later
11 // This library is distributed in the hope that it will be useful, but
12 // WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // General Public License for more details.
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.
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/>.
25 // Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
27 // Permission to use, copy, modify, sell, and distribute this software
28 // is hereby granted without fee, provided that the above copyright
29 // notice appears in all copies, and that both that copyright notice
30 // and this permission notice appear in supporting documentation. None
31 // of the above authors, nor IBM Haifa Research Laboratories, make any
32 // representation about the suitability of this software for any
33 // purpose. It is provided "as is" without express or implied
36 /** @file ext/throw_allocator.h
37 * This file is a GNU extension to the Standard C++ Library.
39 * Contains two exception-generating types (throw_value, throw_allocator)
40 * intended to be used as value and allocator types while testing
41 * exception safety in templatized containers and algorithms. The
42 * allocator has additional log and debug features. The exception
43 * generated is of type forced_exception_error.
46 #ifndef _THROW_ALLOCATOR_H
47 #define _THROW_ALLOCATOR_H 1
56 #include <bits/functexcept.h>
57 #include <bits/move.h>
58 #if __cplusplus >= 201103L
59 # include <functional>
62 # include <tr1/functional>
63 # include <tr1/random>
66 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
68 _GLIBCXX_BEGIN_NAMESPACE_VERSION
71 * @brief Thown by exception safety machinery.
74 struct forced_error : public std::exception
77 // Substitute for forced_error object when -fno-exceptions.
79 __throw_forced_error()
80 { _GLIBCXX_THROW_OR_ABORT(forced_error()); }
83 * @brief Base class for checking address and label information
84 * about allocations. Create a std::map between the allocated
85 * address (void*) and a datum for annotations, which are a pair of
86 * numbers corresponding to label and allocated size.
105 insert(void* p, size_t size)
109 std::string error("annotate_base::insert null insert!\n");
110 log_to_string(error, make_entry(p, size));
111 std::__throw_logic_error(error.c_str());
114 const_iterator found = map_alloc().find(p);
115 if (found != map_alloc().end())
117 std::string error("annotate_base::insert double insert!\n");
118 log_to_string(error, make_entry(p, size));
119 log_to_string(error, *found);
120 std::__throw_logic_error(error.c_str());
123 map_alloc().insert(make_entry(p, size));
127 erase(void* p, size_t size)
129 check_allocated(p, size);
130 map_alloc().erase(p);
133 #if __cplusplus >= 201103L
135 insert_construct(void* p)
139 std::string error("annotate_base::insert_construct null!\n");
140 std::__throw_logic_error(error.c_str());
143 auto found = map_construct().find(p);
144 if (found != map_construct().end())
146 std::string error("annotate_base::insert_construct double insert!\n");
147 log_to_string(error, std::make_pair(p, get_label()));
148 log_to_string(error, *found);
149 std::__throw_logic_error(error.c_str());
152 map_construct().insert(std::make_pair(p, get_label()));
156 erase_construct(void* p)
158 check_constructed(p);
159 map_construct().erase(p);
163 // See if a particular address and allocation size has been saved.
165 check_allocated(void* p, size_t size)
167 const_iterator found = map_alloc().find(p);
168 if (found == map_alloc().end())
170 std::string error("annotate_base::check_allocated by value "
172 log_to_string(error, make_entry(p, size));
173 std::__throw_logic_error(error.c_str());
176 if (found->second.second != size)
178 std::string error("annotate_base::check_allocated by value "
179 "wrong-size erase!\n");
180 log_to_string(error, make_entry(p, size));
181 log_to_string(error, *found);
182 std::__throw_logic_error(error.c_str());
186 // See if a given label has been allocated.
192 const_iterator beg = map_alloc().begin();
193 const_iterator end = map_alloc().end();
196 if (beg->second.first == label)
197 log_to_string(found, *beg);
202 #if __cplusplus >= 201103L
204 auto beg = map_construct().begin();
205 auto end = map_construct().end();
208 if (beg->second == label)
209 log_to_string(found, *beg);
217 std::string error("annotate_base::check by label\n");
219 std::__throw_logic_error(error.c_str());
223 // See if there is anything left allocated or constructed.
229 const_iterator beg = map_alloc().begin();
230 const_iterator end = map_alloc().end();
233 log_to_string(found, *beg);
238 #if __cplusplus >= 201103L
240 auto beg = map_construct().begin();
241 auto end = map_construct().end();
244 log_to_string(found, *beg);
252 std::string error("annotate_base::check \n");
254 std::__throw_logic_error(error.c_str());
258 #if __cplusplus >= 201103L
260 check_constructed(void* p)
262 auto found = map_construct().find(p);
263 if (found == map_construct().end())
265 std::string error("annotate_base::check_constructed not "
267 log_to_string(error, std::make_pair(p, get_label()));
268 std::__throw_logic_error(error.c_str());
273 check_constructed(size_t label)
275 auto beg = map_construct().begin();
276 auto end = map_construct().end();
280 if (beg->second == label)
281 log_to_string(found, *beg);
287 std::string error("annotate_base::check_constructed by label\n");
289 std::__throw_logic_error(error.c_str());
295 typedef std::pair<size_t, size_t> data_type;
296 typedef std::map<void*, data_type> map_alloc_type;
297 typedef map_alloc_type::value_type entry_type;
298 typedef map_alloc_type::const_iterator const_iterator;
299 typedef map_alloc_type::const_reference const_reference;
300 #if __cplusplus >= 201103L
301 typedef std::map<void*, size_t> map_construct_type;
305 operator<<(std::ostream&, const annotate_base&);
308 make_entry(void* p, size_t size)
309 { return std::make_pair(p, data_type(get_label(), size)); }
312 log_to_string(std::string& s, const_reference ref)
315 const char tab('\t');
317 unsigned long l = static_cast<unsigned long>(ref.second.first);
318 __builtin_sprintf(buf, "%lu", l);
322 l = static_cast<unsigned long>(ref.second.second);
323 __builtin_sprintf(buf, "%lu", l);
327 __builtin_sprintf(buf, "%p", ref.first);
332 #if __cplusplus >= 201103L
334 log_to_string(std::string& s, const std::pair<const void*, size_t>& ref)
337 const char tab('\t');
339 unsigned long l = static_cast<unsigned long>(ref.second);
340 __builtin_sprintf(buf, "%lu", l);
344 __builtin_sprintf(buf, "%p", ref.first);
353 static size_t _S_label(std::numeric_limits<size_t>::max());
357 static map_alloc_type&
360 static map_alloc_type _S_map;
364 #if __cplusplus >= 201103L
365 static map_construct_type&
368 static map_construct_type _S_map;
375 operator<<(std::ostream& os, const annotate_base& __b)
378 typedef annotate_base base_type;
380 base_type::const_iterator beg = __b.map_alloc().begin();
381 base_type::const_iterator end = __b.map_alloc().end();
382 for (; beg != end; ++beg)
383 __b.log_to_string(error, *beg);
385 #if __cplusplus >= 201103L
387 auto beg = __b.map_construct().begin();
388 auto end = __b.map_construct().end();
389 for (; beg != end; ++beg)
390 __b.log_to_string(error, *beg);
398 * @brief Base struct for condition policy.
400 * Requires a public member function with the signature
401 * void throw_conditionally()
403 struct condition_base
405 virtual ~condition_base() { };
410 * @brief Base class for incremental control and throw.
412 struct limit_condition : public condition_base
414 // Scope-level adjustor objects: set limit for throw at the
415 // beginning of a scope block, and restores to previous limit when
416 // object is destroyed on exiting the block.
420 const size_t _M_orig;
423 adjustor_base() : _M_orig(limit()) { }
426 ~adjustor_base() { set_limit(_M_orig); }
429 /// Never enter the condition.
430 struct never_adjustor : public adjustor_base
432 never_adjustor() { set_limit(std::numeric_limits<size_t>::max()); }
435 /// Always enter the condition.
436 struct always_adjustor : public adjustor_base
438 always_adjustor() { set_limit(count()); }
441 /// Enter the nth condition.
442 struct limit_adjustor : public adjustor_base
444 limit_adjustor(const size_t __l) { set_limit(__l); }
447 // Increment _S_count every time called.
448 // If _S_count matches the limit count, throw.
450 throw_conditionally()
452 if (count() == limit())
453 __throw_forced_error();
460 static size_t _S_count(0);
467 static size_t _S_limit(std::numeric_limits<size_t>::max());
471 // Zero the throw counter, set limit to argument.
473 set_limit(const size_t __l)
482 * @brief Base class for random probability control and throw.
484 struct random_condition : public condition_base
486 // Scope-level adjustor objects: set probability for throw at the
487 // beginning of a scope block, and restores to previous
488 // probability when object is destroyed on exiting the block.
492 const double _M_orig;
495 adjustor_base() : _M_orig(probability()) { }
497 virtual ~adjustor_base()
498 { set_probability(_M_orig); }
502 struct group_adjustor : public adjustor_base
504 group_adjustor(size_t size)
505 { set_probability(1 - std::pow(double(1 - probability()),
506 double(0.5 / (size + 1))));
510 /// Never enter the condition.
511 struct never_adjustor : public adjustor_base
513 never_adjustor() { set_probability(0); }
516 /// Always enter the condition.
517 struct always_adjustor : public adjustor_base
519 always_adjustor() { set_probability(1); }
529 set_probability(double __p)
530 { probability() = __p; }
533 throw_conditionally()
535 if (generate() < probability())
536 __throw_forced_error();
540 seed(unsigned long __s)
541 { engine().seed(__s); }
544 #if __cplusplus >= 201103L
545 typedef std::uniform_real_distribution<double> distribution_type;
546 typedef std::mt19937 engine_type;
548 typedef std::tr1::uniform_real<double> distribution_type;
549 typedef std::tr1::mt19937 engine_type;
555 #if __cplusplus >= 201103L
556 const distribution_type distribution(0, 1);
557 static auto generator = std::bind(distribution, engine());
559 // Use variate_generator to get normalized results.
560 typedef std::tr1::variate_generator<engine_type, distribution_type> gen_t;
561 distribution_type distribution(0, 1);
562 static gen_t generator(engine(), distribution);
565 double random = generator();
566 if (random < distribution.min() || random > distribution.max())
568 std::string __s("random_condition::generate");
570 __s += "random number generated is: ";
572 __builtin_sprintf(buf, "%f", random);
574 std::__throw_out_of_range(__s.c_str());
590 static engine_type _S_e;
597 * @brief Class with exception generation control. Intended to be
598 * used as a value_type in templatized code.
600 * Note: Destructor not allowed to throw.
602 template<typename _Cond>
603 struct throw_value_base : public _Cond
605 typedef _Cond condition_type;
607 using condition_type::throw_conditionally;
611 #ifndef _GLIBCXX_IS_AGGREGATE
612 throw_value_base() : _M_i(0)
613 { throw_conditionally(); }
615 throw_value_base(const throw_value_base& __v) : _M_i(__v._M_i)
616 { throw_conditionally(); }
618 #if __cplusplus >= 201103L
620 throw_value_base(throw_value_base&&) = default;
623 explicit throw_value_base(const std::size_t __i) : _M_i(__i)
624 { throw_conditionally(); }
628 operator=(const throw_value_base& __v)
630 throw_conditionally();
635 #if __cplusplus >= 201103L
638 operator=(throw_value_base&&) = default;
644 throw_conditionally();
650 template<typename _Cond>
652 swap(throw_value_base<_Cond>& __a, throw_value_base<_Cond>& __b)
654 typedef throw_value_base<_Cond> throw_value;
655 throw_value::throw_conditionally();
656 throw_value orig(__a);
661 // General instantiable types requirements.
662 template<typename _Cond>
664 operator==(const throw_value_base<_Cond>& __a,
665 const throw_value_base<_Cond>& __b)
667 typedef throw_value_base<_Cond> throw_value;
668 throw_value::throw_conditionally();
669 bool __ret = __a._M_i == __b._M_i;
673 template<typename _Cond>
675 operator<(const throw_value_base<_Cond>& __a,
676 const throw_value_base<_Cond>& __b)
678 typedef throw_value_base<_Cond> throw_value;
679 throw_value::throw_conditionally();
680 bool __ret = __a._M_i < __b._M_i;
684 // Numeric algorithms instantiable types requirements.
685 template<typename _Cond>
686 inline throw_value_base<_Cond>
687 operator+(const throw_value_base<_Cond>& __a,
688 const throw_value_base<_Cond>& __b)
690 typedef throw_value_base<_Cond> throw_value;
691 throw_value::throw_conditionally();
692 throw_value __ret(__a._M_i + __b._M_i);
696 template<typename _Cond>
697 inline throw_value_base<_Cond>
698 operator-(const throw_value_base<_Cond>& __a,
699 const throw_value_base<_Cond>& __b)
701 typedef throw_value_base<_Cond> throw_value;
702 throw_value::throw_conditionally();
703 throw_value __ret(__a._M_i - __b._M_i);
707 template<typename _Cond>
708 inline throw_value_base<_Cond>
709 operator*(const throw_value_base<_Cond>& __a,
710 const throw_value_base<_Cond>& __b)
712 typedef throw_value_base<_Cond> throw_value;
713 throw_value::throw_conditionally();
714 throw_value __ret(__a._M_i * __b._M_i);
719 /// Type throwing via limit condition.
720 struct throw_value_limit : public throw_value_base<limit_condition>
722 typedef throw_value_base<limit_condition> base_type;
724 #ifndef _GLIBCXX_IS_AGGREGATE
725 throw_value_limit() { }
727 throw_value_limit(const throw_value_limit& __other)
728 : base_type(__other._M_i) { }
730 #if __cplusplus >= 201103L
731 throw_value_limit(throw_value_limit&&) = default;
734 explicit throw_value_limit(const std::size_t __i) : base_type(__i) { }
738 operator=(const throw_value_limit& __other)
740 base_type::operator=(__other);
744 #if __cplusplus >= 201103L
746 operator=(throw_value_limit&&) = default;
750 /// Type throwing via random condition.
751 struct throw_value_random : public throw_value_base<random_condition>
753 typedef throw_value_base<random_condition> base_type;
755 #ifndef _GLIBCXX_IS_AGGREGATE
756 throw_value_random() { }
758 throw_value_random(const throw_value_random& __other)
759 : base_type(__other._M_i) { }
761 #if __cplusplus >= 201103L
762 throw_value_random(throw_value_random&&) = default;
765 explicit throw_value_random(const std::size_t __i) : base_type(__i) { }
769 operator=(const throw_value_random& __other)
771 base_type::operator=(__other);
775 #if __cplusplus >= 201103L
777 operator=(throw_value_random&&) = default;
783 * @brief Allocator class with logging and exception generation control.
784 * Intended to be used as an allocator_type in templatized code.
785 * @ingroup allocators
787 * Note: Deallocate not allowed to throw.
789 template<typename _Tp, typename _Cond>
790 class throw_allocator_base
791 : public annotate_base, public _Cond
794 typedef size_t size_type;
795 typedef ptrdiff_t difference_type;
796 typedef _Tp value_type;
797 typedef value_type* pointer;
798 typedef const value_type* const_pointer;
799 typedef value_type& reference;
800 typedef const value_type& const_reference;
802 #if __cplusplus >= 201103L
803 // _GLIBCXX_RESOLVE_LIB_DEFECTS
804 // 2103. std::allocator propagate_on_container_move_assignment
805 typedef std::true_type propagate_on_container_move_assignment;
809 typedef _Cond condition_type;
811 std::allocator<value_type> _M_allocator;
813 using condition_type::throw_conditionally;
817 max_size() const _GLIBCXX_USE_NOEXCEPT
818 { return _M_allocator.max_size(); }
821 address(reference __x) const _GLIBCXX_NOEXCEPT
822 { return std::__addressof(__x); }
825 address(const_reference __x) const _GLIBCXX_NOEXCEPT
826 { return std::__addressof(__x); }
829 allocate(size_type __n, std::allocator<void>::const_pointer hint = 0)
831 if (__n > this->max_size())
832 std::__throw_bad_alloc();
834 throw_conditionally();
835 pointer const a = _M_allocator.allocate(__n, hint);
836 insert(a, sizeof(value_type) * __n);
840 #if __cplusplus >= 201103L
841 template<typename _Up, typename... _Args>
843 construct(_Up* __p, _Args&&... __args)
845 _M_allocator.construct(__p, std::forward<_Args>(__args)...);
846 insert_construct(__p);
849 template<typename _Up>
853 erase_construct(__p);
854 _M_allocator.destroy(__p);
858 construct(pointer __p, const value_type& val)
859 { return _M_allocator.construct(__p, val); }
863 { _M_allocator.destroy(__p); }
867 deallocate(pointer __p, size_type __n)
869 erase(__p, sizeof(value_type) * __n);
870 _M_allocator.deallocate(__p, __n);
874 check_allocated(pointer __p, size_type __n)
876 size_type __t = sizeof(value_type) * __n;
877 annotate_base::check_allocated(__p, __t);
882 { annotate_base::check(__n); }
885 template<typename _Tp, typename _Cond>
887 operator==(const throw_allocator_base<_Tp, _Cond>&,
888 const throw_allocator_base<_Tp, _Cond>&)
891 template<typename _Tp, typename _Cond>
893 operator!=(const throw_allocator_base<_Tp, _Cond>&,
894 const throw_allocator_base<_Tp, _Cond>&)
897 /// Allocator throwing via limit condition.
898 template<typename _Tp>
899 struct throw_allocator_limit
900 : public throw_allocator_base<_Tp, limit_condition>
902 template<typename _Tp1>
904 { typedef throw_allocator_limit<_Tp1> other; };
906 throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { }
908 throw_allocator_limit(const throw_allocator_limit&)
909 _GLIBCXX_USE_NOEXCEPT { }
911 template<typename _Tp1>
912 throw_allocator_limit(const throw_allocator_limit<_Tp1>&)
913 _GLIBCXX_USE_NOEXCEPT { }
915 ~throw_allocator_limit() _GLIBCXX_USE_NOEXCEPT { }
918 /// Allocator throwing via random condition.
919 template<typename _Tp>
920 struct throw_allocator_random
921 : public throw_allocator_base<_Tp, random_condition>
923 template<typename _Tp1>
925 { typedef throw_allocator_random<_Tp1> other; };
927 throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { }
929 throw_allocator_random(const throw_allocator_random&)
930 _GLIBCXX_USE_NOEXCEPT { }
932 template<typename _Tp1>
933 throw_allocator_random(const throw_allocator_random<_Tp1>&)
934 _GLIBCXX_USE_NOEXCEPT { }
936 ~throw_allocator_random() _GLIBCXX_USE_NOEXCEPT { }
939 _GLIBCXX_END_NAMESPACE_VERSION
942 #if __cplusplus >= 201103L
944 # include <bits/functional_hash.h>
946 namespace std _GLIBCXX_VISIBILITY(default)
948 /// Explicit specialization of std::hash for __gnu_cxx::throw_value_limit.
950 struct hash<__gnu_cxx::throw_value_limit>
951 : public std::unary_function<__gnu_cxx::throw_value_limit, size_t>
954 operator()(const __gnu_cxx::throw_value_limit& __val) const
956 __gnu_cxx::throw_value_limit::throw_conditionally();
957 std::hash<std::size_t> __h;
958 size_t __result = __h(__val._M_i);
963 /// Explicit specialization of std::hash for __gnu_cxx::throw_value_random.
965 struct hash<__gnu_cxx::throw_value_random>
966 : public std::unary_function<__gnu_cxx::throw_value_random, size_t>
969 operator()(const __gnu_cxx::throw_value_random& __val) const
971 __gnu_cxx::throw_value_random::throw_conditionally();
972 std::hash<std::size_t> __h;
973 size_t __result = __h(__val._M_i);
977 } // end namespace std