46 #ifndef _THROW_ALLOCATOR_H 47 #define _THROW_ALLOCATOR_H 1 58 #if __cplusplus >= 201103L 62 # include <tr1/functional> 63 # include <tr1/random> 67 # if !__has_builtin(__builtin_sprintf) 69 # define _GLIBCXX_NO_BUILTIN_SPRINTF 73 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
75 _GLIBCXX_BEGIN_NAMESPACE_VERSION
86 __throw_forced_error()
101 typedef map_alloc_type::const_iterator const_iterator;
102 typedef map_alloc_type::const_reference const_reference;
103 #if __cplusplus >= 201103L 123 insert(
void* p,
size_t size)
125 entry_type entry = make_entry(p, size);
128 std::string error(
"annotate_base::insert null insert!\n");
129 log_to_string(error, entry);
130 std::__throw_logic_error(error.c_str());
134 = map_alloc().insert(entry);
135 if (!inserted.second)
137 std::string error(
"annotate_base::insert double insert!\n");
138 log_to_string(error, entry);
139 log_to_string(error, *inserted.first);
140 std::__throw_logic_error(error.c_str());
145 erase(
void* p,
size_t size)
146 { map_alloc().erase(check_allocated(p, size)); }
148 #if __cplusplus >= 201103L 150 insert_construct(
void* p)
154 std::string error(
"annotate_base::insert_construct null!\n");
155 std::__throw_logic_error(error.c_str());
158 auto inserted = map_construct().insert(
std::make_pair(p, get_label()));
159 if (!inserted.second)
161 std::string error(
"annotate_base::insert_construct double insert!\n");
163 log_to_string(error, *inserted.first);
164 std::__throw_logic_error(error.c_str());
169 erase_construct(
void* p)
170 { map_construct().erase(check_constructed(p)); }
174 inline map_alloc_type::iterator
175 check_allocated(
void* p,
size_t size)
177 map_alloc_type::iterator found = map_alloc().find(p);
178 if (found == map_alloc().
end())
180 std::string error(
"annotate_base::check_allocated by value " 182 log_to_string(error, make_entry(p, size));
183 std::__throw_logic_error(error.c_str());
186 if (found->second.second != size)
188 std::string error(
"annotate_base::check_allocated by value " 189 "wrong-size erase!\n");
190 log_to_string(error, make_entry(p, size));
191 log_to_string(error, *found);
192 std::__throw_logic_error(error.c_str());
204 const_iterator beg = map_alloc().
begin();
205 const_iterator
end = map_alloc().end();
208 if (beg->second.first == label)
209 log_to_string(found, *beg);
214 #if __cplusplus >= 201103L 216 auto beg = map_construct().begin();
217 auto end = map_construct().end();
220 if (beg->second == label)
221 log_to_string(found, *beg);
229 std::string error(
"annotate_base::check by label\n");
231 std::__throw_logic_error(error.c_str());
241 const_iterator beg = map_alloc().
begin();
242 const_iterator
end = map_alloc().end();
245 log_to_string(found, *beg);
250 #if __cplusplus >= 201103L 252 auto beg = map_construct().begin();
253 auto end = map_construct().end();
256 log_to_string(found, *beg);
266 std::__throw_logic_error(error.c_str());
270 #if __cplusplus >= 201103L 271 inline map_construct_type::iterator
272 check_constructed(
void* p)
274 auto found = map_construct().find(p);
275 if (found == map_construct().
end())
277 std::string error(
"annotate_base::check_constructed not " 280 std::__throw_logic_error(error.c_str());
287 check_constructed(
size_t label)
289 auto beg = map_construct().begin();
290 auto end = map_construct().end();
294 if (beg->second == label)
295 log_to_string(found, *beg);
301 std::string error(
"annotate_base::check_constructed by label\n");
303 std::__throw_logic_error(error.c_str());
313 make_entry(
void* p,
size_t size)
319 #ifdef _GLIBCXX_NO_BUILTIN_SPRINTF 320 __typeof__(&std::sprintf) __builtin_sprintf = &std::sprintf;
324 const char tab(
'\t');
326 unsigned long l =
static_cast<unsigned long>(ref.second.first);
327 __builtin_sprintf(buf,
"%lu", l);
331 l =
static_cast<unsigned long>(ref.second.second);
332 __builtin_sprintf(buf,
"%lu", l);
336 __builtin_sprintf(buf,
"%p", ref.first);
341 #if __cplusplus >= 201103L 345 #ifdef _GLIBCXX_NO_BUILTIN_SPRINTF 346 auto __builtin_sprintf = &std::sprintf;
350 const char tab(
'\t');
352 unsigned long l =
static_cast<unsigned long>(ref.
second);
353 __builtin_sprintf(buf,
"%lu", l);
357 __builtin_sprintf(buf,
"%p", ref.
first);
370 static map_alloc_type&
373 static map_alloc_type _S_map;
377 #if __cplusplus >= 201103L 378 static map_construct_type&
381 static map_construct_type _S_map;
393 base_type::const_iterator beg = __b.map_alloc().
begin();
394 base_type::const_iterator
end = __b.map_alloc().
end();
395 for (; beg !=
end; ++beg)
396 __b.log_to_string(error, *beg);
398 #if __cplusplus >= 201103L 400 auto beg = __b.map_construct().
begin();
401 auto end = __b.map_construct().
end();
402 for (; beg !=
end; ++beg)
403 __b.log_to_string(error, *beg);
418 #if __cplusplus >= 201103L 438 const size_t _M_orig;
441 adjustor_base() : _M_orig(limit()) { }
444 ~adjustor_base() { set_limit(_M_orig); }
468 throw_conditionally()
470 if (count() == limit())
471 __throw_forced_error();
478 static size_t _S_count(0);
491 set_limit(
const size_t __l)
498 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 510 const double _M_orig;
513 adjustor_base() : _M_orig(probability()) { }
515 virtual ~adjustor_base()
516 { set_probability(_M_orig); }
523 { set_probability(1 -
std::pow(
double(1 - probability()),
524 double(0.5 / (size + 1))));
547 set_probability(
double __p)
548 { probability() = __p; }
551 throw_conditionally()
553 if (generate() < probability())
554 __throw_forced_error();
558 seed(
unsigned long __s)
559 { engine().seed(__s); }
562 #if __cplusplus >= 201103L 566 typedef std::tr1::uniform_real<double> distribution_type;
573 #if __cplusplus >= 201103L 574 const distribution_type distribution(0, 1);
575 static auto generator =
std::bind(distribution, engine());
578 typedef std::tr1::variate_generator<engine_type, distribution_type> gen_t;
579 distribution_type distribution(0, 1);
580 static gen_t generator(engine(), distribution);
583 #ifdef _GLIBCXX_NO_BUILTIN_SPRINTF 584 __typeof__(&std::sprintf) __builtin_sprintf = &std::sprintf;
587 double random = generator();
588 if (random < distribution.
min() || random > distribution.
max())
592 __s +=
"random number generated is: ";
594 __builtin_sprintf(buf,
"%f", random);
596 std::__throw_out_of_range(__s.c_str());
612 static engine_type _S_e;
616 #endif // _GLIBCXX_USE_C99_STDINT_TR1 624 template<
typename _Cond>
627 typedef _Cond condition_type;
629 using condition_type::throw_conditionally;
633 #ifndef _GLIBCXX_IS_AGGREGATE 635 { throw_conditionally(); }
638 { throw_conditionally(); }
640 #if __cplusplus >= 201103L 646 { throw_conditionally(); }
652 throw_conditionally();
657 #if __cplusplus >= 201103L 666 throw_conditionally();
672 template<
typename _Cond>
677 throw_value::throw_conditionally();
678 throw_value orig(__a);
684 template<
typename _Cond>
690 throw_value::throw_conditionally();
691 bool __ret = __a._M_i == __b._M_i;
695 template<
typename _Cond>
697 operator<(const throw_value_base<_Cond>& __a,
701 throw_value::throw_conditionally();
702 bool __ret = __a._M_i < __b._M_i;
707 template<
typename _Cond>
713 throw_value::throw_conditionally();
714 throw_value __ret(__a._M_i + __b._M_i);
718 template<
typename _Cond>
724 throw_value::throw_conditionally();
725 throw_value __ret(__a._M_i - __b._M_i);
729 template<
typename _Cond>
735 throw_value::throw_conditionally();
736 throw_value __ret(__a._M_i * __b._M_i);
746 #ifndef _GLIBCXX_IS_AGGREGATE 750 : base_type(__other._M_i) { }
752 #if __cplusplus >= 201103L 762 base_type::operator=(__other);
766 #if __cplusplus >= 201103L 772 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 778 #ifndef _GLIBCXX_IS_AGGREGATE 782 : base_type(__other._M_i) { }
784 #if __cplusplus >= 201103L 794 base_type::operator=(__other);
798 #if __cplusplus >= 201103L 803 #endif // _GLIBCXX_USE_C99_STDINT_TR1 812 template<
typename _Tp,
typename _Cond>
817 typedef size_t size_type;
818 typedef ptrdiff_t difference_type;
819 typedef _Tp value_type;
820 typedef value_type* pointer;
821 typedef const value_type* const_pointer;
822 typedef value_type& reference;
823 typedef const value_type& const_reference;
825 #if __cplusplus >= 201103L 832 typedef _Cond condition_type;
836 using condition_type::throw_conditionally;
840 max_size()
const _GLIBCXX_USE_NOEXCEPT
841 {
return _M_allocator.max_size(); }
844 address(reference __x)
const _GLIBCXX_NOEXCEPT
848 address(const_reference __x)
const _GLIBCXX_NOEXCEPT
851 _GLIBCXX_NODISCARD pointer
854 if (__n > this->max_size())
855 std::__throw_bad_alloc();
857 throw_conditionally();
858 pointer
const a = _M_allocator.allocate(__n, hint);
859 insert(a,
sizeof(value_type) * __n);
863 #if __cplusplus >= 201103L 864 template<
typename _Up,
typename... _Args>
866 construct(_Up* __p, _Args&&... __args)
868 _M_allocator.construct(__p, std::forward<_Args>(__args)...);
869 insert_construct(__p);
872 template<
typename _Up>
876 erase_construct(__p);
877 _M_allocator.destroy(__p);
881 construct(pointer __p,
const value_type& val)
882 {
return _M_allocator.construct(__p, val); }
886 { _M_allocator.destroy(__p); }
890 deallocate(pointer __p, size_type __n)
892 erase(__p,
sizeof(value_type) * __n);
893 _M_allocator.deallocate(__p, __n);
897 check_allocated(pointer __p, size_type __n)
899 size_type __t =
sizeof(value_type) * __n;
900 annotate_base::check_allocated(__p, __t);
905 { annotate_base::check(__n); }
908 template<
typename _Tp,
typename _Cond>
914 template<
typename _Tp,
typename _Cond>
921 template<
typename _Tp>
925 template<
typename _Tp1>
932 _GLIBCXX_USE_NOEXCEPT { }
934 template<
typename _Tp1>
936 _GLIBCXX_USE_NOEXCEPT { }
941 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 943 template<
typename _Tp>
947 template<
typename _Tp1>
954 _GLIBCXX_USE_NOEXCEPT { }
956 template<
typename _Tp1>
958 _GLIBCXX_USE_NOEXCEPT { }
962 #endif // _GLIBCXX_USE_C99_STDINT_TR1 964 _GLIBCXX_END_NAMESPACE_VERSION
967 #undef _GLIBCXX_NO_BUILTIN_SPRINTF 969 #if __cplusplus >= 201103L 973 namespace std _GLIBCXX_VISIBILITY(default)
983 __gnu_cxx::throw_value_limit::throw_conditionally();
985 size_t __result = __h(__val._M_i);
990 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 999 __gnu_cxx::throw_value_random::throw_conditionally();
1001 size_t __result = __h(__val._M_i);
constexpr const _Tp * end(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to one past the last element of the initializer_list. ...
A standard container made up of (key,value) pairs, which can be retrieved based on a key...
Base class for all library exceptions.
result_type min() const
Returns the inclusive lower bound of the distribution range.
Always enter the condition.
mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL > mt19937
ISO C++ entities toplevel namespace is std.
_GLIBCXX_END_NAMESPACE_CXX11 typedef basic_string< char > string
A string of char.
Base class for incremental control and throw.
Properties of fundamental types.
Uniform continuous distribution for random numbers.
_T1 first
second_type is the second bound type
_T2 second
first is a copy of the first object
Struct holding two objects of arbitrary type.
Template class basic_ostream.
Type throwing via random condition.
Primary class template hash.
Always enter the condition.
Thown by exception safety machinery.
Allocator throwing via limit condition.
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
Never enter the condition.
Type throwing via limit condition.
Never enter the condition.
Base class for random probability control and throw.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Allocator throwing via random condition.
GNU extensions for public use.
Allocator class with logging and exception generation control. Intended to be used as an allocator_ty...
Class with exception generation control. Intended to be used as a value_type in templatized code...
constexpr pair< typename __decay_and_strip< _T1 >::__type, typename __decay_and_strip< _T2 >::__type > make_pair(_T1 &&__x, _T2 &&__y)
A convenience wrapper for creating a pair from two objects.
Base struct for condition policy.
_Bind_helper< __is_socketlike< _Func >::value, _Func, _BoundArgs... >::type bind(_Func &&__f, _BoundArgs &&... __args)
Function template for std::bind.
reference_wrapper< _Tp > ref(_Tp &__t) noexcept
Denotes a reference should be taken to a variable.
std::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >
iterator begin() noexcept
result_type max() const
Returns the inclusive upper bound of the distribution range.
Base class for checking address and label information about allocations. Create a std::map between th...