* profile mode maintenance patch
@ 2014-05-12 20:15 François Dumont
2014-05-12 20:44 ` Paolo Carlini
2014-05-24 11:33 ` profile mode maintenance patch Jonathan Wakely
0 siblings, 2 replies; 16+ messages in thread
From: François Dumont @ 2014-05-12 20:15 UTC (permalink / raw)
To: libstdc++, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 2257 bytes --]
Hi
Here is a maintenance patch for profile mode. It does:
- Use inheritance to limit duplication of code in constructors to
register for the different profiling mode diagnostics data structure.
- Remove many code keeping only instrumented methods or methods that
where the container type itself appears in the signature..
- Extend the map to unordered_map to all ordered containers.
And of course code cleanup and usage of default implementation for
special methods as much as possible.
Regarding Makefile.in I miss last time. I moved to a new system
lately, a Ubuntu based one, and still need to find out what version of
automake/autoreconf I need to install. For the moment I have updated
Makefile.in manually.
2014-05-13 François Dumont <fdumont@gcc.gnu.org>
* include/profile/array: Clean useless white chars.
* include/profile/base.h: Likewise.
* include/profile/iterator_tracker.h: Likewise.
* include/profile/bitset: Code cleanup and remove not instrumented
code.
* include/profile/deque: Likewise.
* include/profile/forward_list: Likewise.
* include/profile/list (std::__profile::_List_profile<>): New.
(std::__profile::list<>): Inherit from latter and adapt.
* include/profile/impl/profiler_map_to_unordered_map.h: Generalize
advise to match any ordered to unordered container conversion.
* include/profile/ordered_base.h (std::__profile::_Ordered_profile<>):
New.
* include/profile/map.h (std::__profile::map<>): Inherit from latter,
remove not instrumented code.
* include/profile/multimap.h (std::__profile::multimap<>): Likewise.
* include/profile/set.h (std::__profile::set<>): Likewise.
* include/profile/multiset.h (std::__profile::multiset<>): Likewise.
* include/profile/unordered_base.h: Add some line feed.
* include/profile/unordered_map: Clean useless white chars and replace
spaces with tabs.
* include/profile/unordered_set: Likewise.
* include/profile/vector (std::__profile::_Vector_profile_pre<>): New.
(std::__profile::_Vector_profile_post<>): New.
(std::__profile::vector<>): Inherit from latter and adapt.
Tested under Linux x86_64 profile mode;
Ok to commit ?
François
[-- Attachment #2: profile.patch --]
[-- Type: text/x-patch, Size: 169220 bytes --]
Index: include/Makefile.am
===================================================================
--- include/Makefile.am (revision 210311)
+++ include/Makefile.am (working copy)
@@ -816,6 +816,7 @@
${profile_srcdir}/map.h \
${profile_srcdir}/multimap.h \
${profile_srcdir}/multiset.h \
+ ${profile_srcdir}/ordered_base.h \
${profile_srcdir}/set \
${profile_srcdir}/set.h \
${profile_srcdir}/iterator_tracker.h
Index: include/profile/array
===================================================================
--- include/profile/array (revision 210311)
+++ include/profile/array (working copy)
@@ -83,19 +83,19 @@
end() const noexcept
{ return const_iterator(data() + _Nm); }
- reverse_iterator
+ reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
- reverse_iterator
+ reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
- const_reverse_iterator
+ const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
@@ -107,22 +107,22 @@
cend() const noexcept
{ return const_iterator(data() + _Nm); }
- const_reverse_iterator
+ const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
// Capacity.
- constexpr size_type
+ constexpr size_type
size() const noexcept { return _Nm; }
- constexpr size_type
+ constexpr size_type
max_size() const noexcept { return _Nm; }
- constexpr bool
+ constexpr bool
empty() const noexcept { return size() == 0; }
// Element access.
@@ -157,23 +157,23 @@
_AT_Type::_S_ref(_M_elems, 0));
}
- reference
+ reference
front() noexcept
{ return *begin(); }
- constexpr const_reference
+ constexpr const_reference
front() const noexcept
{ return _AT_Type::_S_ref(_M_elems, 0); }
- reference
+ reference
back() noexcept
{ return _Nm ? *(end() - 1) : *end(); }
- constexpr const_reference
+ constexpr const_reference
back() const noexcept
{
return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
- : _AT_Type::_S_ref(_M_elems, 0);
+ : _AT_Type::_S_ref(_M_elems, 0);
}
pointer
@@ -187,7 +187,7 @@
// Array comparisons.
template<typename _Tp, std::size_t _Nm>
- inline bool
+ inline bool
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return std::equal(__one.begin(), __one.end(), __two.begin()); }
@@ -199,9 +199,9 @@
template<typename _Tp, std::size_t _Nm>
inline bool
operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
- {
+ {
return std::lexicographical_compare(__a.begin(), __a.end(),
- __b.begin(), __b.end());
+ __b.begin(), __b.end());
}
template<typename _Tp, std::size_t _Nm>
Index: include/profile/base.h
===================================================================
--- include/profile/base.h (revision 210311)
+++ include/profile/base.h (working copy)
@@ -40,9 +40,9 @@
* @namespace std::__profile
* @brief GNU profile code, replaces standard behavior with profile behavior.
*/
-namespace std _GLIBCXX_VISIBILITY(default)
-{
- namespace __profile { }
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+ namespace __profile { }
}
/**
Index: include/profile/bitset
===================================================================
--- include/profile/bitset (revision 210311)
+++ include/profile/bitset (working copy)
@@ -35,7 +35,8 @@
{
namespace __profile
{
- /// Class std::bitset wrapper with performance instrumentation.
+ /// Class std::bitset wrapper with performance instrumentation, none at the
+ /// moment.
template<size_t _Nb>
class bitset
: public _GLIBCXX_STD_C::bitset<_Nb>
@@ -43,60 +44,13 @@
typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;
public:
- // bit reference:
- class reference
- : private _Base::reference
- {
- typedef typename _Base::reference _Base_ref;
-
- friend class bitset;
- reference();
-
- reference(const _Base_ref& __base, bitset* __seq) _GLIBCXX_NOEXCEPT
- : _Base_ref(__base)
- { }
-
- public:
- reference(const reference& __x) _GLIBCXX_NOEXCEPT
- : _Base_ref(__x)
- { }
-
- reference&
- operator=(bool __x) _GLIBCXX_NOEXCEPT
- {
- *static_cast<_Base_ref*>(this) = __x;
- return *this;
- }
-
- reference&
- operator=(const reference& __x) _GLIBCXX_NOEXCEPT
- {
- *static_cast<_Base_ref*>(this) = __x;
- return *this;
- }
-
- bool
- operator~() const _GLIBCXX_NOEXCEPT
- {
- return ~(*static_cast<const _Base_ref*>(this));
- }
-
- operator bool() const _GLIBCXX_NOEXCEPT
- {
- return *static_cast<const _Base_ref*>(this);
- }
-
- reference&
- flip() _GLIBCXX_NOEXCEPT
- {
- _Base_ref::flip();
- return *this;
- }
- };
-
// 23.3.5.1 constructors:
- _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
+#if __cplusplus < 201103L
+ bitset()
: _Base() { }
+#else
+ constexpr bitset() = default;
+#endif
#if __cplusplus >= 201103L
constexpr bitset(unsigned long long __val) noexcept
@@ -106,8 +60,8 @@
: _Base(__val) { }
template<typename _CharT, typename _Traits, typename _Alloc>
- explicit
- bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
+ explicit
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
__pos = 0,
typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
@@ -129,8 +83,8 @@
#if __cplusplus >= 201103L
template<typename _CharT>
- explicit
- bitset(const _CharT* __str,
+ explicit
+ bitset(const _CharT* __str,
typename std::basic_string<_CharT>::size_type __n
= std::basic_string<_CharT>::npos,
_CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
@@ -221,92 +175,6 @@
return *this;
}
- // element access:
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 11. Bitset minor problems
- reference
- operator[](size_t __pos)
- {
- return reference(_M_base()[__pos], this);
- }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 11. Bitset minor problems
- _GLIBCXX_CONSTEXPR bool
- operator[](size_t __pos) const
- {
- return _Base::operator[](__pos);
- }
-
- using _Base::to_ulong;
-#if __cplusplus >= 201103L
- using _Base::to_ullong;
-#endif
-
- template <typename _CharT, typename _Traits, typename _Alloc>
- std::basic_string<_CharT, _Traits, _Alloc>
- to_string() const
- { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 396. what are characters zero and one.
- template<class _CharT, class _Traits, class _Alloc>
- std::basic_string<_CharT, _Traits, _Alloc>
- to_string(_CharT __zero, _CharT __one = _CharT('1')) const
- {
- return _M_base().template
- to_string<_CharT, _Traits, _Alloc>(__zero, __one);
- }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 434. bitset::to_string() hard to use.
- template<typename _CharT, typename _Traits>
- std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
- to_string() const
- { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 853. to_string needs updating with zero and one.
- template<class _CharT, class _Traits>
- std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
- to_string(_CharT __zero, _CharT __one = _CharT('1')) const
- { return to_string<_CharT, _Traits,
- std::allocator<_CharT> >(__zero, __one); }
-
- template<typename _CharT>
- std::basic_string<_CharT, std::char_traits<_CharT>,
- std::allocator<_CharT> >
- to_string() const
- {
- return to_string<_CharT, std::char_traits<_CharT>,
- std::allocator<_CharT> >();
- }
-
- template<class _CharT>
- std::basic_string<_CharT, std::char_traits<_CharT>,
- std::allocator<_CharT> >
- to_string(_CharT __zero, _CharT __one = _CharT('1')) const
- {
- return to_string<_CharT, std::char_traits<_CharT>,
- std::allocator<_CharT> >(__zero, __one);
- }
-
- std::basic_string<char, std::char_traits<char>, std::allocator<char> >
- to_string() const
- {
- return to_string<char,std::char_traits<char>,std::allocator<char> >();
- }
-
- std::basic_string<char, std::char_traits<char>, std::allocator<char> >
- to_string(char __zero, char __one = '1') const
- {
- return to_string<char, std::char_traits<char>,
- std::allocator<char> >(__zero, __one);
- }
-
- using _Base::count;
- using _Base::size;
-
bool
operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
{ return _M_base() == __rhs; }
@@ -315,11 +183,6 @@
operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
{ return _M_base() != __rhs; }
- using _Base::test;
- using _Base::all;
- using _Base::any;
- using _Base::none;
-
bitset<_Nb>
operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT
{ return bitset<_Nb>(_M_base() << __pos); }
Index: include/profile/deque
===================================================================
--- include/profile/deque (revision 210311)
+++ include/profile/deque (working copy)
@@ -43,27 +43,30 @@
typedef _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
public:
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::value_type value_type;
- typedef typename _Base::iterator iterator;
- typedef typename _Base::const_iterator const_iterator;
- typedef typename _Base::reverse_iterator reverse_iterator;
- typedef typename _Base::const_reverse_iterator const_reverse_iterator;
-
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
-
- typedef _Tp value_type;
- typedef _Allocator allocator_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
-
// 23.2.1.1 construct/copy/destroy:
+#if __cplusplus < 201103L
deque()
: _Base() { }
+ deque(const deque& __x)
+ : _Base(__x) { }
+ ~deque() { }
+#else
+ deque() = default;
+ deque(const deque&) = default;
+ deque(deque&&) = default;
+
+ ~deque() = default;
+
+ deque(initializer_list<value_type> __l,
+ const _Allocator& __a = _Allocator())
+ : _Base(__l, __a) { }
+#endif
+
explicit
deque(const _Allocator& __a)
: _Base(__a) { }
@@ -89,346 +92,48 @@
#else
template<typename _InputIterator>
#endif
- deque(_InputIterator __first, _InputIterator __last,
+ deque(_InputIterator __first, _InputIterator __last,
const _Allocator& __a = _Allocator())
: _Base(__first, __last, __a)
- { }
+ { }
- deque(const deque& __x)
- : _Base(__x) { }
-
deque(const _Base& __x)
: _Base(__x) { }
-#if __cplusplus >= 201103L
- deque(deque&& __x)
- : _Base(std::move(__x))
- { }
-
- deque(initializer_list<value_type> __l,
- const allocator_type& __a = allocator_type())
- : _Base(__l, __a) { }
-#endif
-
- ~deque() _GLIBCXX_NOEXCEPT { }
-
+#if __cplusplus < 201103L
deque&
operator=(const deque& __x)
{
- *static_cast<_Base*>(this) = __x;
+ _M_base() = __x;
return *this;
}
+#else
+ deque&
+ operator=(const deque&) = default;
-#if __cplusplus >= 201103L
deque&
- operator=(deque&& __x) noexcept
- {
- // NB: DR 1204.
- // NB: DR 675.
- this->clear();
- this->swap(__x);
- return *this;
- }
+ operator=(deque&&) = default;
deque&
operator=(initializer_list<value_type> __l)
{
- *static_cast<_Base*>(this) = __l;
+ _M_base() = __l;
return *this;
}
#endif
-#if __cplusplus >= 201103L
- template<typename _InputIterator,
- typename = std::_RequireInputIter<_InputIterator>>
-#else
- template<typename _InputIterator>
-#endif
- void
- assign(_InputIterator __first, _InputIterator __last)
- {
- _Base::assign(__first, __last);
- }
-
void
- assign(size_type __n, const _Tp& __t)
- {
- _Base::assign(__n, __t);
- }
-
+ swap(deque& __x)
#if __cplusplus >= 201103L
- void
- assign(initializer_list<value_type> __l)
- {
- _Base::assign(__l);
- }
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
+ { _Base::swap(__x); }
- using _Base::get_allocator;
-
- // iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::begin()); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::begin()); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::end()); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::end()); }
-
- reverse_iterator
- rbegin() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(end()); }
-
- const_reverse_iterator
- rbegin() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(end()); }
-
- reverse_iterator
- rend() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(begin()); }
-
- const_reverse_iterator
- rend() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(begin()); }
-
-#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
- const_reverse_iterator
- crbegin() const noexcept
- { return const_reverse_iterator(end()); }
-
- const_reverse_iterator
- crend() const noexcept
- { return const_reverse_iterator(begin()); }
-#endif
-
- // 23.2.1.2 capacity:
- using _Base::size;
- using _Base::max_size;
-
-#if __cplusplus >= 201103L
- void
- resize(size_type __sz)
- {
- _Base::resize(__sz);
- }
-
- void
- resize(size_type __sz, const _Tp& __c)
- {
- _Base::resize(__sz, __c);
- }
-#else
- void
- resize(size_type __sz, _Tp __c = _Tp())
- {
- _Base::resize(__sz, __c);
- }
-#endif
-
-#if __cplusplus >= 201103L
- using _Base::shrink_to_fit;
-#endif
-
- using _Base::empty;
-
- // element access:
- reference
- operator[](size_type __n) _GLIBCXX_NOEXCEPT
- {
- return _M_base()[__n];
- }
-
- const_reference
- operator[](size_type __n) const _GLIBCXX_NOEXCEPT
- {
- return _M_base()[__n];
- }
-
- using _Base::at;
-
- reference
- front() _GLIBCXX_NOEXCEPT
- {
- return _Base::front();
- }
-
- const_reference
- front() const _GLIBCXX_NOEXCEPT
- {
- return _Base::front();
- }
-
- reference
- back() _GLIBCXX_NOEXCEPT
- {
- return _Base::back();
- }
-
- const_reference
- back() const _GLIBCXX_NOEXCEPT
- {
- return _Base::back();
- }
-
- // 23.2.1.3 modifiers:
- void
- push_front(const _Tp& __x)
- {
- _Base::push_front(__x);
- }
-
- void
- push_back(const _Tp& __x)
- {
- _Base::push_back(__x);
- }
-
-#if __cplusplus >= 201103L
- void
- push_front(_Tp&& __x)
- { emplace_front(std::move(__x)); }
-
- void
- push_back(_Tp&& __x)
- { emplace_back(std::move(__x)); }
-
- template<typename... _Args>
- void
- emplace_front(_Args&&... __args)
- {
- _Base::emplace_front(std::forward<_Args>(__args)...);
- }
-
- template<typename... _Args>
- void
- emplace_back(_Args&&... __args)
- {
- _Base::emplace_back(std::forward<_Args>(__args)...);
- }
-
- template<typename... _Args>
- iterator
- emplace(const_iterator __position, _Args&&... __args)
- {
- typename _Base::iterator __res = _Base::emplace(__position,
- std::forward<_Args>(__args)...);
- return iterator(__res);
- }
-#endif
-
- iterator
-#if __cplusplus >= 201103L
- insert(const_iterator __position, const _Tp& __x)
-#else
- insert(iterator __position, const _Tp& __x)
-#endif
- {
- typename _Base::iterator __res = _Base::insert(__position, __x);
- return iterator(__res);
- }
-
-#if __cplusplus >= 201103L
- iterator
- insert(const_iterator __position, _Tp&& __x)
- { return emplace(__position, std::move(__x)); }
-
- iterator
- insert(const_iterator __p, initializer_list<value_type> __l)
- { return _Base::insert(__p, __l); }
-#endif
-
-#if __cplusplus >= 201103L
- iterator
- insert(const_iterator __position, size_type __n, const _Tp& __x)
- { return _Base::insert(__position, __n, __x); }
-#else
- void
- insert(iterator __position, size_type __n, const _Tp& __x)
- { _Base::insert(__position, __n, __x); }
-#endif
-
-#if __cplusplus >= 201103L
- template<typename _InputIterator,
- typename = std::_RequireInputIter<_InputIterator>>
- iterator
- insert(const_iterator __position,
- _InputIterator __first, _InputIterator __last)
- { return _Base::insert(__position, __first, __last); }
-#else
- template<typename _InputIterator>
- void
- insert(iterator __position,
- _InputIterator __first, _InputIterator __last)
- { _Base::insert(__position, __first, __last); }
-#endif
-
- void
- pop_front() _GLIBCXX_NOEXCEPT
- {
- _Base::pop_front();
- }
-
- void
- pop_back() _GLIBCXX_NOEXCEPT
- {
- _Base::pop_back();
- }
-
- iterator
-#if __cplusplus >= 201103L
- erase(const_iterator __position)
-#else
- erase(iterator __position)
-#endif
- {
- return _Base::erase(__position);
- }
-
- iterator
-#if __cplusplus >= 201103L
- erase(const_iterator __first, const_iterator __last)
-#else
- erase(iterator __first, iterator __last)
-#endif
- {
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 151. can't currently clear() empty container
- return _Base::erase(__first, __last);
- }
-
- void
- swap(deque& __x) _GLIBCXX_NOEXCEPT
- {
- _Base::swap(__x);
- }
-
- void
- clear() _GLIBCXX_NOEXCEPT
- {
- _Base::clear();
- }
-
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
};
template<typename _Tp, typename _Alloc>
Index: include/profile/forward_list
===================================================================
--- include/profile/forward_list (revision 210311)
+++ include/profile/forward_list (working copy)
@@ -46,13 +46,9 @@
{
typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base;
- typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
- rebind<_GLIBCXX_STD_C::_Fwd_list_node<_Tp>>::other _Node_alloc_type;
-
- typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
-
public:
- typedef typename _Base::size_type size_type;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::const_iterator const_iterator;
// 23.2.3.1 construct/copy/destroy:
explicit
@@ -73,98 +69,135 @@
{ }
forward_list(size_type __n, const _Tp& __value,
- const _Alloc& __al = _Alloc())
+ const _Alloc& __al = _Alloc())
: _Base(__n, __value, __al)
{ }
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
- forward_list(_InputIterator __first, _InputIterator __last,
- const _Alloc& __al = _Alloc())
- : _Base(__first, __last, __al)
- { }
+ forward_list(_InputIterator __first, _InputIterator __last,
+ const _Alloc& __al = _Alloc())
+ : _Base(__first, __last, __al)
+ { }
- forward_list(const forward_list& __list)
- : _Base(__list)
- { }
+ forward_list(const forward_list&) = default;
+ forward_list(forward_list&&) = default;
- forward_list(forward_list&& __list) noexcept
- : _Base(std::move(__list)) { }
-
forward_list(std::initializer_list<_Tp> __il,
- const _Alloc& __al = _Alloc())
+ const _Alloc& __al = _Alloc())
: _Base(__il, __al)
{ }
- ~forward_list() noexcept
- { }
+ ~forward_list() = default;
forward_list&
- operator=(const forward_list& __list)
- {
- static_cast<_Base&>(*this) = __list;
- return *this;
- }
+ operator=(const forward_list&) = default;
forward_list&
- operator=(forward_list&& __list)
- noexcept(_Node_alloc_traits::_S_nothrow_move())
- {
- static_cast<_Base&>(*this) = std::move(__list);
- return *this;
- }
+ operator=(forward_list&&) = default;
forward_list&
operator=(std::initializer_list<_Tp> __il)
{
- static_cast<_Base&>(*this) = __il;
- return *this;
+ _M_base() = __il;
+ return *this;
}
+ void
+ swap(forward_list& __fl)
+ noexcept( noexcept(declval<_Base>().swap(__fl)) )
+ { _Base::swap(__fl); }
+
+ void
+ splice_after(const_iterator __pos, forward_list&& __fl)
+ { _Base::splice_after(__pos, std::move(__fl)); }
+
+ void
+ splice_after(const_iterator __pos, forward_list& __list)
+ { _Base::splice_after(__pos, __list); }
+
+ void
+ splice_after(const_iterator __pos, forward_list&& __list,
+ const_iterator __i)
+ { _Base::splice_after(__pos, std::move(__list), __i); }
+
+ void
+ splice_after(const_iterator __pos, forward_list& __list,
+ const_iterator __i)
+ { _Base::splice_after(__pos, __list, __i); }
+
+ void
+ splice_after(const_iterator __pos, forward_list&& __list,
+ const_iterator __before, const_iterator __last)
+ { _Base::splice_after(__pos, std::move(__list), __before, __last); }
+
+ void
+ splice_after(const_iterator __pos, forward_list& __list,
+ const_iterator __before, const_iterator __last)
+ { _Base::splice_after(__pos, __list, __before, __last); }
+
+ void
+ merge(forward_list&& __list)
+ { _Base::merge(std::move(__list)); }
+
+ void
+ merge(forward_list& __list)
+ { _Base::merge(__list); }
+
+ template<typename _Comp>
+ void
+ merge(forward_list&& __list, _Comp __comp)
+ { _Base::merge(std::move(__list), __comp); }
+
+ template<typename _Comp>
+ void
+ merge(forward_list& __list, _Comp __comp)
+ { _Base::merge(__list, __comp); }
+
_Base&
- _M_base() noexcept { return *this; }
+ _M_base() noexcept { return *this; }
const _Base&
- _M_base() const noexcept { return *this; }
+ _M_base() const noexcept { return *this; }
};
template<typename _Tp, typename _Alloc>
inline bool
operator==(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return __lx._M_base() == __ly._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator<(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return __lx._M_base() < __ly._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator!=(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return !(__lx == __ly); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool
operator>(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return (__ly < __lx); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool
operator>=(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return !(__lx < __ly); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool
operator<=(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return !(__ly < __lx); }
/// See std::forward_list::swap().
Index: include/profile/impl/profiler_map_to_unordered_map.h
===================================================================
--- include/profile/impl/profiler_map_to_unordered_map.h (revision 210311)
+++ include/profile/impl/profiler_map_to_unordered_map.h (working copy)
@@ -40,7 +40,7 @@
__log2(std::size_t __size)
{
for (int __bit_count = sizeof(std::size_t) - 1; __bit_count >= 0;
- -- __bit_count)
+ -- __bit_count)
if ((2 << __bit_count) & __size)
return __bit_count;
return 0;
@@ -48,7 +48,7 @@
inline float
__map_insert_cost(std::size_t __size)
- { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value
+ { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value
* static_cast<float>(__log2(__size))); }
inline float
@@ -61,7 +61,7 @@
{ return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value
* static_cast<float>(__log2(__size))); }
- /** @brief A map-to-unordered_map instrumentation line in the
+ /** @brief A map-to-unordered_map instrumentation line in the
object table. */
class __map2umap_info
: public __object_info_base
@@ -70,9 +70,9 @@
__map2umap_info()
: _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0),
_M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { }
-
+
__map2umap_info(__stack_t __stack)
- : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0),
+ : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0),
_M_iterate(0), _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { }
virtual ~__map2umap_info() { }
@@ -108,32 +108,38 @@
std::string
__advice() const
- { return "change std::map to std::unordered_map"; }
+ { return "prefer an unordered container"; }
void
__record_insert(std::size_t __size, std::size_t __count)
{
- _M_insert += __count;
- _M_map_cost += __count * __map_insert_cost(__size);
- _M_umap_cost
- += (__count
- * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value);
+ ++_M_insert;
+ if (__count)
+ {
+ _M_map_cost += __count * __map_insert_cost(__size);
+ _M_umap_cost
+ += (__count
+ * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value);
+ }
}
void
__record_erase(std::size_t __size, std::size_t __count)
{
- _M_erase += __count;
- _M_map_cost += __count * __map_erase_cost(__size);
- _M_umap_cost
- += (__count
- * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value);
+ ++_M_erase;
+ if (__count)
+ {
+ _M_map_cost += __count * __map_erase_cost(__size);
+ _M_umap_cost
+ += (__count
+ * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value);
+ }
}
void
__record_find(std::size_t __size)
{
- _M_find += 1;
+ ++_M_find;
_M_map_cost += __map_find_cost(__size);
_M_umap_cost += _GLIBCXX_PROFILE_DATA(__umap_find_cost_factor).__value;
}
@@ -165,9 +171,9 @@
};
- /** @brief A map-to-unordered_map instrumentation line in the
+ /** @brief A map-to-unordered_map instrumentation line in the
stack table. */
- class __map2umap_stack_info
+ class __map2umap_stack_info
: public __map2umap_info
{
public:
@@ -177,12 +183,12 @@
/** @brief Map-to-unordered_map instrumentation producer. */
class __trace_map2umap
- : public __trace_base<__map2umap_info, __map2umap_stack_info>
+ : public __trace_base<__map2umap_info, __map2umap_stack_info>
{
public:
__trace_map2umap()
: __trace_base<__map2umap_info, __map2umap_stack_info>()
- { __id = "map-to-unordered-map"; }
+ { __id = "ordered-to-unordered"; }
};
inline void
@@ -193,7 +199,7 @@
__trace_map_to_unordered_map_report(FILE* __f,
__warning_vector_t& __warnings)
{
- if (_GLIBCXX_PROFILE_DATA(_S_map2umap))
+ if (_GLIBCXX_PROFILE_DATA(_S_map2umap))
{
_GLIBCXX_PROFILE_DATA(_S_map2umap)->__collect_warnings(__warnings);
_GLIBCXX_PROFILE_DATA(_S_map2umap)->__write(__f);
@@ -220,7 +226,7 @@
}
inline void
- __trace_map_to_unordered_map_insert(const void* __obj,
+ __trace_map_to_unordered_map_insert(const void* __obj,
std::size_t __size, std::size_t __count)
{
if (!__profcxx_init())
@@ -234,13 +240,13 @@
}
inline void
- __trace_map_to_unordered_map_erase(const void* __obj,
+ __trace_map_to_unordered_map_erase(const void* __obj,
std::size_t __size, std::size_t __count)
{
- if (!__profcxx_init())
+ if (!__profcxx_init())
return;
- __map2umap_info* __info
+ __map2umap_info* __info
= _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
if (__info)
@@ -268,7 +274,7 @@
__map2umap_info* __info
= _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
-
+
if (__info)
__info->__record_iterate(__count);
}
Index: include/profile/iterator_tracker.h
===================================================================
--- include/profile/iterator_tracker.h (revision 210311)
+++ include/profile/iterator_tracker.h (working copy)
@@ -35,9 +35,8 @@
{
namespace __profile
{
-
template<typename _Iterator, typename _Sequence>
- class __iterator_tracker
+ class __iterator_tracker
{
typedef __iterator_tracker _Self;
@@ -49,12 +48,12 @@
typedef std::iterator_traits<_Iterator> _Traits;
public:
- typedef _Iterator _Base_iterator;
- typedef typename _Traits::iterator_category iterator_category;
- typedef typename _Traits::value_type value_type;
- typedef typename _Traits::difference_type difference_type;
- typedef typename _Traits::reference reference;
- typedef typename _Traits::pointer pointer;
+ typedef _Iterator _Base_iterator;
+ typedef typename _Traits::iterator_category iterator_category;
+ typedef typename _Traits::value_type value_type;
+ typedef typename _Traits::difference_type difference_type;
+ typedef typename _Traits::reference reference;
+ typedef typename _Traits::pointer pointer;
__iterator_tracker() _GLIBCXX_NOEXCEPT
: _M_current(), _M_ds(0) { }
@@ -67,7 +66,7 @@
: _M_current(__x._M_current), _M_ds(__x._M_ds) { }
template<typename _MutableIterator>
- __iterator_tracker(const __iterator_tracker<_MutableIterator,
+ __iterator_tracker(const __iterator_tracker<_MutableIterator,
typename __gnu_cxx::__enable_if
<(std::__are_same<_MutableIterator, typename
_Sequence::iterator::_Base_iterator>::__value),
@@ -76,7 +75,7 @@
_Iterator
base() const _GLIBCXX_NOEXCEPT { return _M_current; }
-
+
/**
* @brief Conversion to underlying non-debug iterator to allow
* better interaction with non-profile containers.
@@ -199,7 +198,7 @@
template<typename _Iterator, typename _Sequence>
inline bool
operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
- const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+ const __iterator_tracker<_Iterator, _Sequence>& __rhs)
_GLIBCXX_NOEXCEPT
{ return __lhs.base() != __rhs.base(); }
Index: include/profile/list
===================================================================
--- include/profile/list (revision 210311)
+++ include/profile/list (working copy)
@@ -30,81 +30,109 @@
#define _GLIBCXX_PROFILE_LIST 1
#include <list>
-#include <profile/base.h>
-#include <profile/iterator_tracker.h>
+#include <profile/base.h>
+#include <profile/iterator_tracker.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
+ template<typename _List>
+ class _List_profile
+ {
+ _List&
+ _M_conjure()
+ { return *static_cast<_List*>(this); }
+
+ public:
+ _List_profile() _GLIBCXX_NOEXCEPT
+ {
+ __profcxx_list_construct(&_M_conjure()); // list2slist
+ __profcxx_list_construct2(&_M_conjure()); // list2vector
+ }
+
+#if __cplusplus >= 201103L
+ _List_profile(const _List_profile&) noexcept
+ : _List_profile() { }
+ _List_profile(_List_profile&&) noexcept
+ : _List_profile() { }
+
+ _List_profile&
+ operator=(const _List_profile&) = default;
+ _List_profile&
+ operator=(_List_profile&&) = default;
+#endif
+
+ ~_List_profile()
+ {
+ __profcxx_list_destruct(&_M_conjure());
+ __profcxx_list_destruct2(&_M_conjure());
+ }
+ };
+
/** @brief List wrapper with performance instrumentation. */
-template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
+ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class list
- : public _GLIBCXX_STD_C::list<_Tp, _Allocator>
+ : public _GLIBCXX_STD_C::list<_Tp, _Allocator>,
+ public _List_profile<list<_Tp, _Allocator> >
{
- typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base;
public:
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
- typedef __iterator_tracker<typename _Base::iterator, list>
- iterator;
- typedef __iterator_tracker<typename _Base::const_iterator, list>
- const_iterator;
+ typedef __iterator_tracker<typename _Base::iterator, list>
+ iterator;
+ typedef __iterator_tracker<typename _Base::const_iterator, list>
+ const_iterator;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
- typedef _Tp value_type;
- typedef _Allocator allocator_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef _Tp value_type;
+ typedef _Allocator allocator_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// 23.2.2.1 construct/copy/destroy:
- list() _GLIBCXX_NOEXCEPT
- : _Base()
- {
- __profcxx_list_construct(this); // list2slist
- __profcxx_list_construct2(this); // list2vector
- }
+#if __cplusplus < 201103L
+ list() { }
+ list(const list& __x)
+ : _Base(__x) { }
+ ~list() { }
+#else
+ list() = default;
+ list(const list&) = default;
+ list(list&&) = default;
+ ~list() = default;
+
+ list(initializer_list<value_type> __l,
+ const allocator_type& __a = allocator_type())
+ : _Base(__l, __a) { }
+#endif
+
explicit
list(const _Allocator& __a) _GLIBCXX_NOEXCEPT
- : _Base(__a)
- {
- __profcxx_list_construct(this); // list2slist
- __profcxx_list_construct2(this); // list2vector
- }
+ : _Base(__a) { }
#if __cplusplus >= 201103L
explicit
list(size_type __n)
- : _Base(__n)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
+ : _Base(__n) { }
list(size_type __n, const _Tp& __value,
const _Allocator& __a = _Allocator())
- : _Base(__n, __value, __a)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
+ : _Base(__n, __value, __a) { }
#else
explicit
list(size_type __n, const _Tp& __value = _Tp(),
const _Allocator& __a = _Allocator())
- : _Base(__n, __value, __a)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
+ : _Base(__n, __value, __a) { }
#endif
#if __cplusplus >= 201103L
@@ -115,91 +143,33 @@
#endif
list(_InputIterator __first, _InputIterator __last,
const _Allocator& __a = _Allocator())
- : _Base(__first, __last, __a)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
+ : _Base(__first, __last, __a) { }
- list(const list& __x)
- : _Base(__x)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
-
list(const _Base& __x)
- : _Base(__x)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
+ : _Base(__x) { }
-#if __cplusplus >= 201103L
- list(list&& __x) noexcept
- : _Base(std::move(__x))
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
-
- list(initializer_list<value_type> __l,
- const allocator_type& __a = allocator_type())
- : _Base(__l, __a) { }
-#endif
-
- ~list() _GLIBCXX_NOEXCEPT
- {
- __profcxx_list_destruct(this);
- __profcxx_list_destruct2(this);
- }
-
+#if __cplusplus < 201103L
list&
operator=(const list& __x)
{
- static_cast<_Base&>(*this) = __x;
+ _M_base() = __x;
return *this;
}
+#else
+ list&
+ operator=(const list&) = default;
-#if __cplusplus >= 201103L
list&
- operator=(list&& __x)
- {
- // NB: DR 1204.
- // NB: DR 675.
- this->clear();
- this->swap(__x);
- return *this;
- }
+ operator=(list&&) = default;
list&
operator=(initializer_list<value_type> __l)
{
- static_cast<_Base&>(*this) = __l;
+ _M_base() = __l;
return *this;
}
-
- void
- assign(initializer_list<value_type> __l)
- { _Base::assign(__l); }
#endif
-#if __cplusplus >= 201103L
- template<typename _InputIterator,
- typename = std::_RequireInputIter<_InputIterator>>
-#else
- template<class _InputIterator>
-#endif
- void
- assign(_InputIterator __first, _InputIterator __last)
- { _Base::assign(__first, __last); }
-
- void
- assign(size_type __n, const _Tp& __t)
- { _Base::assign(__n, __t); }
-
- using _Base::get_allocator;
-
// iterators:
iterator
begin() _GLIBCXX_NOEXCEPT
@@ -212,29 +182,29 @@
iterator
end() _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
- return iterator(_Base::end(), this);
+ __profcxx_list_rewind(this);
+ return iterator(_Base::end(), this);
}
const_iterator
end() const _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
- return const_iterator(_Base::end(), this);
+ __profcxx_list_rewind(this);
+ return const_iterator(_Base::end(), this);
}
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
- return reverse_iterator(end());
+ __profcxx_list_rewind(this);
+ return reverse_iterator(end());
}
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
- {
- __profcxx_list_rewind(this);
- return const_reverse_iterator(end());
+ {
+ __profcxx_list_rewind(this);
+ return const_reverse_iterator(end());
}
reverse_iterator
@@ -248,11 +218,11 @@
#if __cplusplus >= 201103L
const_iterator
cbegin() const noexcept
- { return const_iterator(_Base::begin(), this); }
+ { return const_iterator(_Base::cbegin(), this); }
const_iterator
cend() const noexcept
- { return const_iterator(_Base::end(), this); }
+ { return const_iterator(_Base::cend(), this); }
const_reverse_iterator
crbegin() const noexcept
@@ -264,44 +234,17 @@
#endif
// 23.2.2.2 capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
-#if __cplusplus >= 201103L
- void
- resize(size_type __sz)
- { _Base::resize(__sz); }
-
- void
- resize(size_type __sz, const _Tp& __c)
- { _Base::resize(__sz, __c); }
-#else
- void
- resize(size_type __sz, _Tp __c = _Tp())
- { _Base::resize(__sz, __c); }
-#endif
-
- // element access:
reference
- front() _GLIBCXX_NOEXCEPT
- { return _Base::front(); }
-
- const_reference
- front() const _GLIBCXX_NOEXCEPT
- { return _Base::front(); }
-
- reference
back() _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
+ __profcxx_list_rewind(this);
return _Base::back();
}
const_reference
back() const _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
+ __profcxx_list_rewind(this);
return _Base::back();
}
@@ -309,44 +252,32 @@
void
push_front(const value_type& __x)
{
- __profcxx_list_invalid_operator(this);
- __profcxx_list_operation(this);
- _Base::push_front(__x);
+ __profcxx_list_invalid_operator(this);
+ __profcxx_list_operation(this);
+ _Base::push_front(__x);
}
-#if __cplusplus >= 201103L
- using _Base::emplace_front;
-#endif
-
void
pop_front() _GLIBCXX_NOEXCEPT
{
- __profcxx_list_operation(this);
+ __profcxx_list_operation(this);
_Base::pop_front();
}
- using _Base::push_back;
-
-#if __cplusplus >= 201103L
- using _Base::emplace_back;
-#endif
-
void
pop_back() _GLIBCXX_NOEXCEPT
{
- iterator __victim = end();
- --__victim;
_Base::pop_back();
- __profcxx_list_rewind(this);
+ __profcxx_list_rewind(this);
}
#if __cplusplus >= 201103L
template<typename... _Args>
- iterator
- emplace(const_iterator __position, _Args&&... __args)
+ iterator
+ emplace(const_iterator __position, _Args&&... __args)
{
return iterator(_Base::emplace(__position.base(),
- std::forward<_Args>(__args)...),
+ std::forward<_Args>(__args)...),
this);
}
#endif
@@ -358,24 +289,24 @@
insert(iterator __position, const _Tp& __x)
#endif
{
- _M_profile_insert(this, __position, size());
- return iterator(_Base::insert(__position.base(), __x), this);
+ _M_profile_insert(this, __position, this->size());
+ return iterator(_Base::insert(__position.base(), __x), this);
}
#if __cplusplus >= 201103L
iterator
insert(const_iterator __position, _Tp&& __x)
{
- _M_profile_insert(this, __position, size());
- return iterator(_Base::emplace(__position.base(), std::move(__x)),
- this);
+ _M_profile_insert(this, __position, this->size());
+ return iterator(_Base::emplace(__position.base(), std::move(__x)),
+ this);
}
iterator
insert(const_iterator __position, initializer_list<value_type> __l)
{
- _M_profile_insert(this, __position, size());
- return iterator(_Base::insert(__position.base(), __l), this);
+ _M_profile_insert(this, __position, this->size());
+ return iterator(_Base::insert(__position.base(), __l), this);
}
#endif
@@ -383,14 +314,14 @@
iterator
insert(const_iterator __position, size_type __n, const _Tp& __x)
{
- _M_profile_insert(this, __position, size());
+ _M_profile_insert(this, __position, this->size());
return iterator(_Base::insert(__position.base(), __n, __x), this);
}
#else
void
insert(iterator __position, size_type __n, const _Tp& __x)
{
- _M_profile_insert(this, __position, size());
+ _M_profile_insert(this, __position, this->size());
_Base::insert(__position.base(), __n, __x);
}
#endif
@@ -399,20 +330,20 @@
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
- insert(const_iterator __position, _InputIterator __first,
+ insert(const_iterator __position, _InputIterator __first,
_InputIterator __last)
{
- _M_profile_insert(this, __position, size());
+ _M_profile_insert(this, __position, this->size());
return iterator(_Base::insert(__position.base(), __first, __last),
this);
}
#else
template<class _InputIterator>
- void
- insert(iterator __position, _InputIterator __first,
+ void
+ insert(iterator __position, _InputIterator __first,
_InputIterator __last)
{
- _M_profile_insert(this, __position, size());
+ _M_profile_insert(this, __position, this->size());
_Base::insert(__position.base(), __first, __last);
}
#endif
@@ -439,12 +370,11 @@
void
swap(list& __x)
+#if __cplusplus >= 201103L
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
+#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { _Base::clear(); }
-
// 23.2.2.4 list operations:
void
#if __cplusplus >= 201103L
@@ -488,9 +418,6 @@
iterator __last)
#endif
{
- // We used to perform the splice_alloc check: not anymore, redundant
- // after implementing the relevant bits of N1599.
-
_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
__first.base(), __last.base());
}
@@ -515,12 +442,12 @@
}
template<class _Predicate>
- void
- remove_if(_Predicate __pred)
- {
+ void
+ remove_if(_Predicate __pred)
+ {
for (iterator __x = begin(); __x != end(); )
{
- __profcxx_list_operation(this);
+ __profcxx_list_operation(this);
if (__pred(*__x))
__x = erase(__x);
else
@@ -538,7 +465,7 @@
iterator __next = __first;
while (++__next != __last)
{
- __profcxx_list_operation(this);
+ __profcxx_list_operation(this);
if (*__first == *__next)
erase(__next);
else
@@ -548,9 +475,9 @@
}
template<class _BinaryPredicate>
- void
- unique(_BinaryPredicate __binary_pred)
- {
+ void
+ unique(_BinaryPredicate __binary_pred)
+ {
iterator __first = begin();
iterator __last = end();
if (__first == __last)
@@ -558,7 +485,7 @@
iterator __next = __first;
while (++__next != __last)
{
- __profcxx_list_operation(this);
+ __profcxx_list_operation(this);
if (__binary_pred(*__first, *__next))
erase(__next);
else
@@ -573,12 +500,7 @@
#else
merge(list& __x)
#endif
- {
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 300. list::merge() specification incomplete
- if (this != &__x)
- { _Base::merge(_GLIBCXX_MOVE(__x._M_base())); }
- }
+ { _Base::merge(_GLIBCXX_MOVE(__x._M_base())); }
#if __cplusplus >= 201103L
void
@@ -587,63 +509,49 @@
#endif
template<class _Compare>
- void
+ void
#if __cplusplus >= 201103L
- merge(list&& __x, _Compare __comp)
+ merge(list&& __x, _Compare __comp)
#else
- merge(list& __x, _Compare __comp)
+ merge(list& __x, _Compare __comp)
#endif
- {
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 300. list::merge() specification incomplete
- if (this != &__x)
- { _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); }
- }
+ { _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); }
#if __cplusplus >= 201103L
template<typename _Compare>
- void
- merge(list& __x, _Compare __comp)
- { this->merge(std::move(__x), __comp); }
+ void
+ merge(list& __x, _Compare __comp)
+ { this->merge(std::move(__x), __comp); }
#endif
- void
- sort() { _Base::sort(); }
-
- template<typename _StrictWeakOrdering>
- void
- sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); }
-
- using _Base::reverse;
-
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
void _M_profile_find() const
{ }
- void _M_profile_iterate(int __rewind = 0) const
+ void _M_profile_iterate(int __rewind = 0) const
{
- __profcxx_list_operation(this);
- __profcxx_list_iterate(this);
- if (__rewind)
- __profcxx_list_rewind(this);
+ __profcxx_list_operation(this);
+ __profcxx_list_iterate(this);
+ if (__rewind)
+ __profcxx_list_rewind(this);
}
private:
size_type
_M_profile_insert(void* obj, const_iterator __pos, size_type __size)
{
- size_type __shift = 0;
- typename _Base::const_iterator __it = __pos.base();
- for (; __it != _Base::end(); ++__it)
- __shift++;
- __profcxx_list_rewind(this);
- __profcxx_list_operation(this);
- __profcxx_list_insert(this, __shift, __size);
+ size_type __shift = 0;
+ typename _Base::const_iterator __it = __pos.base();
+ for (; __it != _Base::end(); ++__it)
+ __shift++;
+ __profcxx_list_rewind(this);
+ __profcxx_list_operation(this);
+ __profcxx_list_insert(this, __shift, __size);
}
};
Index: include/profile/map.h
===================================================================
--- include/profile/map.h (revision 210311)
+++ include/profile/map.h (working copy)
@@ -28,8 +28,8 @@
#ifndef _GLIBCXX_PROFILE_MAP_H
#define _GLIBCXX_PROFILE_MAP_H 1
-#include <utility>
#include <profile/base.h>
+#include <profile/ordered_base.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
@@ -39,44 +39,47 @@
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class map
- : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>
+ : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>,
+ public _Ordered_profile<map<_Key, _Tp, _Compare, _Allocator> >
{
typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base;
-#if __cplusplus >= 201103L
- typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
-#endif
-
public:
// types:
- typedef _Key key_type;
- typedef _Tp mapped_type;
- typedef std::pair<const _Key, _Tp> value_type;
- typedef _Compare key_compare;
- typedef _Allocator allocator_type;
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef _Key key_type;
+ typedef _Tp mapped_type;
+ typedef typename _Base::value_type value_type;
+ typedef _Compare key_compare;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
- typedef typename _Base::iterator iterator;
- typedef typename _Base::const_iterator const_iterator;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::reverse_iterator reverse_iterator;
+ typedef typename _Base::const_reverse_iterator const_reverse_iterator;
// 23.3.1.1 construct/copy/destroy:
+#if __cplusplus < 201103L
map()
- : _Base()
- { __profcxx_map_to_unordered_map_construct(this); }
+ : _Base() { }
+ map(const map& __x)
+ : _Base(__x) { }
+ ~map()
+ { }
+#else
+ map() = default;
+ map(const map&) = default;
+ map(map&&) = default;
+ ~map() = default;
+#endif
explicit
map(const _Compare& __comp,
const _Allocator& __a = _Allocator())
- : _Base(__comp, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ : _Base(__comp, __a) { }
#if __cplusplus >= 201103L
template<typename _InputIterator,
@@ -84,61 +87,40 @@
#else
template<typename _InputIterator>
#endif
- map(_InputIterator __first, _InputIterator __last,
+ map(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
- : _Base(__first, __last, __comp, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ : _Base(__first, __last, __comp, __a) { }
- map(const map& __x)
- : _Base(__x)
- { __profcxx_map_to_unordered_map_construct(this); }
-
map(const _Base& __x)
- : _Base(__x)
- { __profcxx_map_to_unordered_map_construct(this); }
+ : _Base(__x) { }
#if __cplusplus >= 201103L
- map(map&& __x)
- noexcept(is_nothrow_copy_constructible<_Compare>::value)
- : _Base(std::move(__x))
- { __profcxx_map_to_unordered_map_construct(this); }
-
map(initializer_list<value_type> __l,
const _Compare& __c = _Compare(),
- const allocator_type& __a = allocator_type())
- : _Base(__l, __c, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ const _Allocator& __a = _Allocator())
+ : _Base(__l, __c, __a) { }
explicit
- map(const allocator_type& __a)
- : _Base(__a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(const _Allocator& __a)
+ : _Base(__a) { }
- map(const map& __x, const allocator_type& __a)
- : _Base(__x, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(const map& __x, const _Allocator& __a)
+ : _Base(__x, __a) { }
- map(map&& __x, const allocator_type& __a)
- noexcept(is_nothrow_copy_constructible<_Compare>::value
- && _Alloc_traits::_S_always_equal())
- : _Base(std::move(__x), __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(map&& __x, const _Allocator& __a)
+ noexcept( noexcept(_Base(std::move(__x), __a)) )
+ : _Base(std::move(__x), __a) { }
- map(initializer_list<value_type> __l, const allocator_type& __a)
- : _Base(__l, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(initializer_list<value_type> __l, const _Allocator& __a)
+ : _Base(__l, __a) { }
template<typename _InputIterator>
- map(_InputIterator __first, _InputIterator __last,
- const allocator_type& __a)
- : _Base(__first, __last, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(_InputIterator __first, _InputIterator __last,
+ const _Allocator& __a)
+ : _Base(__first, __last, __a) { }
#endif
- ~map() _GLIBCXX_NOEXCEPT
- { __profcxx_map_to_unordered_map_destruct(this); }
-
#if __cplusplus < 201103L
map&
operator=(const map& __x)
@@ -161,113 +143,79 @@
}
#endif
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 133. map missing get_allocator()
- using _Base::get_allocator;
-
- // iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return _Base::begin(); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return _Base::begin(); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return _Base::end(); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return _Base::end(); }
-
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return reverse_iterator(end());
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
}
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_reverse_iterator(end());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
}
reverse_iterator
rend() _GLIBCXX_NOEXCEPT
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return reverse_iterator(begin());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
}
const_reverse_iterator
rend() const _GLIBCXX_NOEXCEPT
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_reverse_iterator(begin());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
}
#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
const_reverse_iterator
crbegin() const noexcept
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_reverse_iterator(end());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crbegin();
}
const_reverse_iterator
crend() const noexcept
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_reverse_iterator(begin());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crend();
}
#endif
- // capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
// 23.3.1.2 element access:
mapped_type&
operator[](const key_type& __k)
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::operator[](__k);
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::operator[](__k);
}
#if __cplusplus >= 201103L
mapped_type&
operator[](key_type&& __k)
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::operator[](std::move(__k));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::operator[](std::move(__k));
}
#endif
mapped_type&
at(const key_type& __k)
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::at(__k);
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::at(__k);
}
const mapped_type&
at(const key_type& __k) const
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::at(__k);
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::at(__k);
}
// modifiers:
@@ -276,21 +224,20 @@
std::pair<iterator, bool>
emplace(_Args&&... __args)
{
- __profcxx_map_to_unordered_map_insert(this, size(), 1);
- auto __res = _Base::emplace(std::forward<_Args>(__args)...);
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ // The cost is the same whether or not the element is inserted so we
+ // always report insertion of 1 element.
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::emplace(std::forward<_Args>(__args)...);
}
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
- size_type size_before = size();
- auto __res = _Base::emplace_hint(__pos,
- std::forward<_Args>(__args)...);
+ auto size_before = this->size();
+ auto __res = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...);
__profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
+ _M_hint_used(__pos, __res) ? 0 : 1);
return __res;
}
#endif
@@ -298,67 +245,56 @@
std::pair<iterator, bool>
insert(const value_type& __x)
{
- __profcxx_map_to_unordered_map_insert(this, size(), 1);
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(__x);
}
#if __cplusplus >= 201103L
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- std::pair<iterator, bool>
- insert(_Pair&& __x)
- {
- __profcxx_map_to_unordered_map_insert(this, size(), 1);
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, bool> __res
- = _Base::insert(std::forward<_Pair>(__x));
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ std::pair<iterator, bool>
+ insert(_Pair&& __x)
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(std::forward<_Pair>(__x));
}
#endif
#if __cplusplus >= 201103L
void
insert(std::initializer_list<value_type> __list)
- {
- size_type size_before = size();
- _Base::insert(__list);
- __profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
- }
+ { insert(__list.begin(), __list.end()); }
#endif
iterator
#if __cplusplus >= 201103L
- insert(const_iterator __position, const value_type& __x)
+ insert(const_iterator __pos, const value_type& __x)
#else
- insert(iterator __position, const value_type& __x)
+ insert(iterator __pos, const value_type& __x)
#endif
{
- size_type size_before = size();
- iterator __i = iterator(_Base::insert(__position, __x));
- __profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
- return __i;
+ size_type size_before = this->size();
+ iterator __res = _Base::insert(__pos, __x);
+
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#if __cplusplus >= 201103L
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- iterator
- insert(const_iterator __position, _Pair&& __x)
- {
- size_type size_before = size();
- iterator __i
- = iterator(_Base::insert(__position, std::forward<_Pair>(__x)));
- __profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
- return __i;
+ iterator
+ insert(const_iterator __pos, _Pair&& __x)
+ {
+ size_type size_before = this->size();
+ auto __res = _Base::insert(__pos, std::forward<_Pair>(__x));
+
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#endif
@@ -368,151 +304,163 @@
#else
template<typename _InputIterator>
#endif
- void
- insert(_InputIterator __first, _InputIterator __last)
- {
- size_type size_before = size();
- _Base::insert(__first, __last);
- __profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+ for (; __first != __last; ++__first)
+ insert(*__first);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __position)
{
- iterator __i = _Base::erase(__position);
- __profcxx_map_to_unordered_map_erase(this, size(), 1);
- return __i;
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__position);
}
iterator
erase(iterator __position)
- { return erase(const_iterator(__position)); }
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__position);
+ }
#else
void
erase(iterator __position)
{
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
_Base::erase(__position);
- __profcxx_map_to_unordered_map_erase(this, size(), 1);
}
#endif
size_type
erase(const key_type& __x)
{
- iterator __victim = find(__x);
- if (__victim == end())
- return 0;
- else
- {
- _Base::erase(__victim);
- return 1;
- }
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__x);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __first, const_iterator __last)
- { return iterator(_Base::erase(__first, __last)); }
+ {
+ if (__first != __last)
+ {
+ iterator __ret;
+ for (; __first != __last;)
+ __ret = erase(__first++);
+ return __ret;
+ }
+ else
+ return _Base::erase(__first, __last);
+ }
#else
void
erase(iterator __first, iterator __last)
- { _Base::erase(__first, __last); }
+ {
+ for (; __first != __last;)
+ erase(__first++);
+ }
#endif
void
swap(map& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { this->erase(begin(), end()); }
-
- // observers:
- using _Base::key_comp;
- using _Base::value_comp;
-
// 23.3.1.3 map operations:
iterator
find(const key_type& __x)
{
- __profcxx_map_to_unordered_map_find(this, size());
- return iterator(_Base::find(__x));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
}
const_iterator
find(const key_type& __x) const
{
- __profcxx_map_to_unordered_map_find(this, size());
- return const_iterator(_Base::find(__x));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
}
size_type
count(const key_type& __x) const
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::count(__x);
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::count(__x);
}
iterator
lower_bound(const key_type& __x)
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return iterator(_Base::lower_bound(__x));
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
}
const_iterator
lower_bound(const key_type& __x) const
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_iterator(_Base::lower_bound(__x));
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
}
iterator
upper_bound(const key_type& __x)
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return iterator(_Base::upper_bound(__x));
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
}
const_iterator
upper_bound(const key_type& __x) const
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_iterator(_Base::upper_bound(__x));
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
}
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(iterator(__res.first),
- iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
std::pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{
- __profcxx_map_to_unordered_map_find(this, size());
- typedef typename _Base::const_iterator _Base_const_iterator;
- std::pair<_Base_const_iterator, _Base_const_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(const_iterator(__res.first),
- const_iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
- _Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _Base&
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ private:
+ /** If hint is used we consider that the map and unordered_map
+ * operations have equivalent insertion cost so we do not update metrics
+ * about it.
+ * Note that to find out if hint has been used is libstdc++
+ * implementation dependant.
+ */
+ bool
+ _M_hint_used(const_iterator __hint, iterator __res)
+ {
+ return (__hint == __res ||
+ (__hint == this->end() && ++__res == this->end()) ||
+ (__hint != this->end() && (++__hint == __res ||
+ ++__res == --__hint)));
+ }
};
template<typename _Key, typename _Tp,
@@ -520,10 +468,10 @@
inline bool
operator==(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
- {
+ {
__profcxx_map_to_unordered_map_invalidate(&__lhs);
__profcxx_map_to_unordered_map_invalidate(&__rhs);
- return __lhs._M_base() == __rhs._M_base();
+ return __lhs._M_base() == __rhs._M_base();
}
template<typename _Key, typename _Tp,
@@ -531,10 +479,10 @@
inline bool
operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
- {
+ {
__profcxx_map_to_unordered_map_invalidate(&__lhs);
__profcxx_map_to_unordered_map_invalidate(&__rhs);
- return __lhs._M_base() != __rhs._M_base();
+ return __lhs._M_base() != __rhs._M_base();
}
template<typename _Key, typename _Tp,
@@ -545,7 +493,7 @@
{
__profcxx_map_to_unordered_map_invalidate(&__lhs);
__profcxx_map_to_unordered_map_invalidate(&__rhs);
- return __lhs._M_base() < __rhs._M_base();
+ return __lhs._M_base() < __rhs._M_base();
}
template<typename _Key, typename _Tp,
Index: include/profile/multimap.h
===================================================================
--- include/profile/multimap.h (revision 210311)
+++ include/profile/multimap.h (working copy)
@@ -29,7 +29,8 @@
#ifndef _GLIBCXX_PROFILE_MULTIMAP_H
#define _GLIBCXX_PROFILE_MULTIMAP_H 1
-#include <utility>
+#include <profile/base.h>
+#include <profile/ordered_base.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
@@ -39,38 +40,44 @@
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class multimap
- : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>
+ : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>,
+ public _Ordered_profile<map<_Key, _Tp, _Compare, _Allocator> >
{
typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
-#if __cplusplus >= 201103L
- typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
-#endif
-
public:
// types:
- typedef _Key key_type;
- typedef _Tp mapped_type;
- typedef std::pair<const _Key, _Tp> value_type;
- typedef _Compare key_compare;
- typedef _Allocator allocator_type;
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef _Key key_type;
+ typedef _Tp mapped_type;
+ typedef std::pair<const _Key, _Tp> value_type;
+ typedef _Compare key_compare;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
- typedef typename _Base::iterator iterator;
- typedef typename _Base::const_iterator const_iterator;
- typedef typename _Base::reverse_iterator reverse_iterator;
- typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::reverse_iterator reverse_iterator;
+ typedef typename _Base::const_reverse_iterator const_reverse_iterator;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
// 23.3.1.1 construct/copy/destroy:
+#if __cplusplus < 201103L
multimap()
: _Base() { }
+ multimap(const multimap& __x)
+ : _Base(__x) { }
+ ~multimap() { }
+#else
+ multimap() = default;
+ multimap(const multimap&) = default;
+ multimap(multimap&&) = default;
+ ~multimap() = default;
+#endif
explicit multimap(const _Compare& __comp,
const _Allocator& __a = _Allocator())
@@ -82,49 +89,40 @@
#else
template<typename _InputIterator>
#endif
- multimap(_InputIterator __first, _InputIterator __last,
- const _Compare& __comp = _Compare(),
- const _Allocator& __a = _Allocator())
- : _Base(__first, __last, __comp, __a) { }
+ multimap(_InputIterator __first, _InputIterator __last,
+ const _Compare& __comp = _Compare(),
+ const _Allocator& __a = _Allocator())
+ : _Base(__first, __last, __comp, __a) { }
-#if __cplusplus < 201103L
- multimap(const multimap& __x)
- : _Base(__x) { }
-#else
- multimap(const multimap&) = default;
- multimap(multimap&&) = default;
-
+#if __cplusplus >= 201103L
multimap(initializer_list<value_type> __l,
const _Compare& __c = _Compare(),
- const allocator_type& __a = allocator_type())
+ const _Allocator& __a = _Allocator())
: _Base(__l, __c, __a) { }
explicit
- multimap(const allocator_type& __a)
- : _Base(__a) { }
+ multimap(const _Allocator& __a)
+ : _Base(__a) { }
- multimap(const multimap& __x, const allocator_type& __a)
+ multimap(const multimap& __x, const _Allocator& __a)
: _Base(__x, __a) { }
- multimap(multimap&& __x, const allocator_type& __a)
- noexcept(is_nothrow_copy_constructible<_Compare>::value
- && _Alloc_traits::_S_always_equal())
+ multimap(multimap&& __x, const _Allocator& __a)
+ noexcept( noexcept(_Base(std::move(__x), __a)) )
: _Base(std::move(__x), __a) { }
- multimap(initializer_list<value_type> __l, const allocator_type& __a)
+ multimap(initializer_list<value_type> __l, const _Allocator& __a)
: _Base(__l, __a) { }
template<typename _InputIterator>
- multimap(_InputIterator __first, _InputIterator __last,
- const allocator_type& __a)
- : _Base(__first, __last, __a) { }
+ multimap(_InputIterator __first, _InputIterator __last,
+ const _Allocator& __a)
+ : _Base(__first, __last, __a) { }
#endif
multimap(const _Base& __x)
: _Base(__x) { }
- ~multimap() _GLIBCXX_NOEXCEPT { }
-
#if __cplusplus < 201103L
multimap&
operator=(const multimap& __x)
@@ -147,117 +145,125 @@
}
#endif
- using _Base::get_allocator;
-
- // iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::begin()); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::begin()); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::end()); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::end()); }
-
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
reverse_iterator
rend() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
const_reverse_iterator
rend() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
const_reverse_iterator
crbegin() const noexcept
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crbegin();
+ }
const_reverse_iterator
crend() const noexcept
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crend();
+ }
#endif
- // capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
// modifiers:
#if __cplusplus >= 201103L
template<typename... _Args>
iterator
emplace(_Args&&... __args)
{
- return iterator(_Base::emplace(std::forward<_Args>(__args)...));
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::emplace(std::forward<_Args>(__args)...);
}
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
- return iterator(_Base::emplace_hint(__pos,
- std::forward<_Args>(__args)...));
+ auto size_before = this->size();
+ auto __res
+ = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#endif
-
+
iterator
insert(const value_type& __x)
- { return iterator(_Base::insert(__x)); }
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(__x);
+ }
#if __cplusplus >= 201103L
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- iterator
- insert(_Pair&& __x)
- { return iterator(_Base::insert(std::forward<_Pair>(__x))); }
+ iterator
+ insert(_Pair&& __x)
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(std::forward<_Pair>(__x));
+ }
#endif
#if __cplusplus >= 201103L
void
insert(std::initializer_list<value_type> __list)
- { _Base::insert(__list); }
+ { insert(__list.begin(), __list.end()); }
#endif
iterator
#if __cplusplus >= 201103L
- insert(const_iterator __position, const value_type& __x)
+ insert(const_iterator __pos, const value_type& __x)
#else
- insert(iterator __position, const value_type& __x)
+ insert(iterator __pos, const value_type& __x)
#endif
- { return iterator(_Base::insert(__position, __x)); }
+ {
+ size_type size_before = this->size();
+ iterator __res = _Base::insert(__pos, __x);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#if __cplusplus >= 201103L
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- iterator
- insert(const_iterator __position, _Pair&& __x)
- { return iterator(_Base::insert(__position,
- std::forward<_Pair>(__x))); }
+ iterator
+ insert(const_iterator __pos, _Pair&& __x)
+ {
+ size_type size_before = this->size();
+ auto __res = _Base::insert(__pos, std::forward<_Pair>(__x));
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#endif
#if __cplusplus >= 201103L
@@ -266,115 +272,163 @@
#else
template<typename _InputIterator>
#endif
- void
- insert(_InputIterator __first, _InputIterator __last)
- { _Base::insert(__first, __last); }
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+ for (; __first != __last; ++__first)
+ insert(*__first);
+ }
#if __cplusplus >= 201103L
iterator
- erase(const_iterator __position)
- { return iterator(_Base::erase(__position)); }
+ erase(const_iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__pos);
+ }
iterator
- erase(iterator __position)
- { return iterator(_Base::erase(__position)); }
+ erase(iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__pos);
+ }
#else
void
- erase(iterator __position)
- { _Base::erase(__position); }
+ erase(iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ _Base::erase(__pos);
+ }
#endif
size_type
erase(const key_type& __x)
{
- std::pair<iterator, iterator> __victims = this->equal_range(__x);
- size_type __count = 0;
- while (__victims.first != __victims.second)
- {
- iterator __victim = __victims.first++;
- _Base::erase(__victim);
- ++__count;
- }
- return __count;
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__x);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __first, const_iterator __last)
- { return iterator(_Base::erase(__first, __last)); }
+ {
+ if (__first != __last)
+ {
+ iterator __ret;
+ for (; __first != __last;)
+ __ret = erase(__first++);
+ return __ret;
+ }
+ else
+ return _Base::erase(__first, __last);
+ }
#else
void
erase(iterator __first, iterator __last)
- { _Base::erase(__first, __last); }
+ {
+ for (; __first != __last;)
+ erase(__first++);
+ }
#endif
void
swap(multimap& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { this->erase(begin(), end()); }
-
- // observers:
- using _Base::key_comp;
- using _Base::value_comp;
-
// 23.3.1.3 multimap operations:
iterator
find(const key_type& __x)
- { return iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
const_iterator
find(const key_type& __x) const
- { return const_iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
- using _Base::count;
+ size_type
+ count(const key_type& __x) const
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::count(__x);
+ }
iterator
lower_bound(const key_type& __x)
- { return iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
const_iterator
lower_bound(const key_type& __x) const
- { return const_iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
iterator
upper_bound(const key_type& __x)
- { return iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
const_iterator
upper_bound(const key_type& __x) const
- { return const_iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(iterator(__res.first),
- iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
std::pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{
- typedef typename _Base::const_iterator _Base_const_iterator;
- std::pair<_Base_const_iterator, _Base_const_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(const_iterator(__res.first),
- const_iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+ private:
+ /** If hint is used we consider that the map and unordered_map
+ * operations have equivalent insertion cost so we do not update metrics
+ * about it.
+ * Note that to find out if hint has been used is libstdc++
+ * implementation dependant.
+ */
+ bool
+ _M_hint_used(const_iterator __hint, iterator __res)
+ {
+ return (__hint == __res ||
+ (__hint == this->end() && ++__res == this->end()) ||
+ (__hint != this->end() && (++__hint == __res ||
+ ++__res == --__hint)));
+ }
};
template<typename _Key, typename _Tp,
Index: include/profile/multiset.h
===================================================================
--- include/profile/multiset.h (revision 210311)
+++ include/profile/multiset.h (working copy)
@@ -29,7 +29,8 @@
#ifndef _GLIBCXX_PROFILE_MULTISET_H
#define _GLIBCXX_PROFILE_MULTISET_H 1
-#include <utility>
+#include <profile/base.h>
+#include <profile/ordered_base.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
@@ -39,38 +40,45 @@
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class multiset
- : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>
+ : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>,
+ public _Ordered_profile<multiset<_Key, _Compare, _Allocator> >
{
typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
-#if __cplusplus >= 201103L
- typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
-#endif
-
public:
// types:
- typedef _Key key_type;
- typedef _Key value_type;
- typedef _Compare key_compare;
- typedef _Compare value_compare;
- typedef _Allocator allocator_type;
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+ typedef _Allocator allocator_type;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
- typedef typename _Base::iterator iterator;
- typedef typename _Base::const_iterator const_iterator;
- typedef typename _Base::reverse_iterator reverse_iterator;
- typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::reverse_iterator reverse_iterator;
+ typedef typename _Base::const_reverse_iterator const_reverse_iterator;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
// 23.3.3.1 construct/copy/destroy:
+#if __cplusplus < 201103L
multiset()
: _Base() { }
+ multiset(const multiset& __x)
+ : _Base(__x) { }
+ ~multiset() { }
+#else
+ multiset() = default;
+ multiset(const multiset&) = default;
+ multiset(multiset&&) = default;
+ ~multiset() = default;
+#endif
explicit multiset(const _Compare& __comp,
const _Allocator& __a = _Allocator())
@@ -82,18 +90,12 @@
#else
template<typename _InputIterator>
#endif
- multiset(_InputIterator __first, _InputIterator __last,
+ multiset(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__first, __last, __comp, __a) { }
-#if __cplusplus < 201103L
- multiset(const multiset& __x)
- : _Base(__x) { }
-#else
- multiset(const multiset&) = default;
- multiset(multiset&&) = default;
-
+#if __cplusplus >= 201103L
multiset(initializer_list<value_type> __l,
const _Compare& __comp = _Compare(),
const allocator_type& __a = allocator_type())
@@ -101,30 +103,27 @@
explicit
multiset(const allocator_type& __a)
- : _Base(__a) { }
+ : _Base(__a) { }
multiset(const multiset& __x, const allocator_type& __a)
: _Base(__x, __a) { }
multiset(multiset&& __x, const allocator_type& __a)
- noexcept(is_nothrow_copy_constructible<_Compare>::value
- && _Alloc_traits::_S_always_equal())
+ noexcept( noexcept(_Base(std::move(__x), __a)) )
: _Base(std::move(__x), __a) { }
multiset(initializer_list<value_type> __l, const allocator_type& __a)
: _Base(__l, __a) { }
template<typename _InputIterator>
- multiset(_InputIterator __first, _InputIterator __last,
- const allocator_type& __a)
- : _Base(__first, __last, __a) { }
+ multiset(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a)
+ : _Base(__first, __last, __a) { }
#endif
multiset(const _Base& __x)
: _Base(__x) { }
- ~multiset() _GLIBCXX_NOEXCEPT { }
-
#if __cplusplus < 201103L
multiset&
operator=(const multiset& __x)
@@ -147,98 +146,112 @@
}
#endif
- using _Base::get_allocator;
-
// iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::begin()); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::begin()); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::end()); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::end()); }
-
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
reverse_iterator
rend() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
const_reverse_iterator
rend() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
const_reverse_iterator
crbegin() const noexcept
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crbegin();
+ }
const_reverse_iterator
crend() const noexcept
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crend();
+ }
#endif
- // capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
// modifiers:
#if __cplusplus >= 201103L
template<typename... _Args>
iterator
emplace(_Args&&... __args)
- { return iterator(_Base::emplace(std::forward<_Args>(__args)...)); }
+ {
+ // The cost is the same whether or not the element is inserted so we
+ // always report insertion of 1 element.
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::emplace(std::forward<_Args>(__args)...);
+ }
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
- return iterator(_Base::emplace_hint(__pos,
- std::forward<_Args>(__args)...));
+ auto size_before = this->size();
+ auto __res = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#endif
iterator
insert(const value_type& __x)
- { return iterator(_Base::insert(__x)); }
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(__x);
+ }
#if __cplusplus >= 201103L
iterator
insert(value_type&& __x)
- { return iterator(_Base::insert(std::move(__x))); }
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(std::move(__x));
+ }
#endif
iterator
- insert(const_iterator __position, const value_type& __x)
- { return iterator(_Base::insert(__position, __x)); }
+ insert(const_iterator __pos, const value_type& __x)
+ {
+ size_type size_before = this->size();
+ iterator __res = _Base::insert(__pos, __x);
+
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#if __cplusplus >= 201103L
iterator
- insert(const_iterator __position, value_type&& __x)
- { return iterator(_Base::insert(__position, std::move(__x))); }
+ insert(const_iterator __pos, value_type&& __x)
+ {
+ auto size_before = this->size();
+ auto __res = _Base::insert(__pos, std::move(__x));
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#endif
#if __cplusplus >= 201103L
@@ -247,106 +260,137 @@
#else
template<typename _InputIterator>
#endif
- void
- insert(_InputIterator __first, _InputIterator __last)
- { _Base::insert(__first, __last); }
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+ for (; __first != __last; ++__first)
+ insert(*__first);
+ }
#if __cplusplus >= 201103L
void
insert(initializer_list<value_type> __l)
- { _Base::insert(__l); }
+ { insert(__l.begin(), __l.end()); }
#endif
#if __cplusplus >= 201103L
iterator
- erase(const_iterator __position)
- { return iterator(_Base::erase(__position)); }
+ erase(const_iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__pos);
+ }
#else
void
- erase(iterator __position)
- { _Base::erase(__position); }
+ erase(iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ _Base::erase(__pos);
+ }
#endif
size_type
erase(const key_type& __x)
{
- std::pair<iterator, iterator> __victims = this->equal_range(__x);
- size_type __count = 0;
- while (__victims.first != __victims.second)
- {
- iterator __victim = __victims.first++;
- _Base::erase(__victim);
- ++__count;
- }
- return __count;
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__x);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __first, const_iterator __last)
- { return iterator(_Base::erase(__first, __last)); }
+ {
+ if (__first != __last)
+ {
+ iterator __ret;
+ for (; __first != __last;)
+ __ret = erase(__first++);
+ return __ret;
+ }
+ else
+ return _Base::erase(__first, __last);
+ }
#else
void
erase(iterator __first, iterator __last)
- { _Base::erase(__first, __last); }
+ {
+ for (; __first != __last;)
+ erase(__first++);
+ }
#endif
void
swap(multiset& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { this->erase(begin(), end()); }
-
- // observers:
- using _Base::key_comp;
- using _Base::value_comp;
-
// multiset operations:
iterator
find(const key_type& __x)
- { return iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
const_iterator
find(const key_type& __x) const
- { return const_iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
- using _Base::count;
+ size_type
+ count(const key_type& __x) const
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::count(__x);
+ }
iterator
lower_bound(const key_type& __x)
- { return iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::lower_bound(__x);
+ }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
const_iterator
lower_bound(const key_type& __x) const
- { return const_iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
iterator
upper_bound(const key_type& __x)
- { return iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
const_iterator
upper_bound(const key_type& __x) const
- { return const_iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(iterator(__res.first),
- iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
@@ -354,19 +398,31 @@
std::pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{
- typedef typename _Base::const_iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(const_iterator(__res.first),
- const_iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ private:
+ /** If hint is used we consider that the map and unordered_map
+ * operations have equivalent insertion cost so we do not update metrics
+ * about it.
+ * Note that to find out if hint has been used is libstdc++
+ * implementation dependant.
+ */
+ bool
+ _M_hint_used(const_iterator __hint, iterator __res)
+ {
+ return (__hint == __res ||
+ (__hint == this->end() && ++__res == this->end()) ||
+ (__hint != this->end() && (++__hint == __res ||
+ ++__res == --__hint)));
+ }
};
template<typename _Key, typename _Compare, typename _Allocator>
Index: include/profile/ordered_base.h
===================================================================
--- include/profile/ordered_base.h (revision 0)
+++ include/profile/ordered_base.h (working copy)
@@ -0,0 +1,65 @@
+// Profiling unordered containers implementation details -*- C++ -*-
+
+// Copyright (C) 2014 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/ordered_base.h
+ * This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_ORDERED
+#define _GLIBCXX_PROFILE_ORDERED 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+ template<typename _Cont>
+ class _Ordered_profile
+ {
+ _Cont&
+ _M_conjure()
+ { return *static_cast<_Cont*>(this); }
+
+ public:
+ _Ordered_profile() _GLIBCXX_NOEXCEPT
+ { __profcxx_map_to_unordered_map_construct(&_M_conjure()); }
+
+#if __cplusplus >= 201103L
+ _Ordered_profile(const _Ordered_profile&) noexcept
+ : _Ordered_profile() { }
+ _Ordered_profile(_Ordered_profile&&) noexcept
+ : _Ordered_profile() { }
+
+ _Ordered_profile&
+ operator=(const _Ordered_profile&) = default;
+ _Ordered_profile&
+ operator=(_Ordered_profile&&) = default;
+#endif
+
+ ~_Ordered_profile()
+ { __profcxx_map_to_unordered_map_destruct(&_M_conjure()); }
+ };
+
+} // namespace __profile
+} // namespace std
+
+#endif
Index: include/profile/set.h
===================================================================
--- include/profile/set.h (revision 210311)
+++ include/profile/set.h (working copy)
@@ -29,9 +29,10 @@
#ifndef _GLIBCXX_PROFILE_SET_H
#define _GLIBCXX_PROFILE_SET_H 1
-#include <utility>
+#include <profile/base.h>
+#include <profile/ordered_base.h>
-namespace std _GLIBCXX_VISIBILITY(default)
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
@@ -39,7 +40,8 @@
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class set
- : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>
+ : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>,
+ public _Ordered_profile<set<_Key, _Compare, _Allocator> >
{
typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base;
@@ -49,28 +51,36 @@
public:
// types:
- typedef _Key key_type;
- typedef _Key value_type;
- typedef _Compare key_compare;
- typedef _Compare value_compare;
- typedef _Allocator allocator_type;
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
- typedef typename _Base::iterator iterator;
- typedef typename _Base::const_iterator const_iterator;
- typedef typename _Base::reverse_iterator reverse_iterator;
- typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::reverse_iterator reverse_iterator;
+ typedef typename _Base::const_reverse_iterator const_reverse_iterator;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
// 23.3.3.1 construct/copy/destroy:
-
+#if __cplusplus < 201103L
set()
: _Base() { }
+ set(const set& __x)
+ : _Base(__x) { }
+ ~set() { }
+#else
+ set() = default;
+ set(const set&) = default;
+ set(set&&) = default;
+ ~set() = default;
+#endif
explicit set(const _Compare& __comp,
const _Allocator& __a = _Allocator())
@@ -82,49 +92,40 @@
#else
template<typename _InputIterator>
#endif
- set(_InputIterator __first, _InputIterator __last,
+ set(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__first, __last, __comp, __a) { }
-#if __cplusplus < 201103L
- set(const set& __x)
- : _Base(__x) { }
-#else
- set(const set&) = default;
- set(set&&) = default;
-
+#if __cplusplus >= 201103L
set(initializer_list<value_type> __l,
const _Compare& __comp = _Compare(),
- const allocator_type& __a = allocator_type())
+ const _Allocator& __a = _Allocator())
: _Base(__l, __comp, __a) { }
explicit
- set(const allocator_type& __a)
- : _Base(__a) { }
+ set(const _Allocator& __a)
+ : _Base(__a) { }
- set(const set& __x, const allocator_type& __a)
+ set(const set& __x, const _Allocator& __a)
: _Base(__x, __a) { }
- set(set&& __x, const allocator_type& __a)
- noexcept(is_nothrow_copy_constructible<_Compare>::value
- && _Alloc_traits::_S_always_equal())
+ set(set&& __x, const _Allocator& __a)
+ noexcept( noexcept(_Base(std::move(__x), __a)) )
: _Base(std::move(__x), __a) { }
- set(initializer_list<value_type> __l, const allocator_type& __a)
+ set(initializer_list<value_type> __l, const _Allocator& __a)
: _Base(__l, __a) { }
template<typename _InputIterator>
- set(_InputIterator __first, _InputIterator __last,
- const allocator_type& __a)
- : _Base(__first, __last, __a) { }
+ set(_InputIterator __first, _InputIterator __last,
+ const _Allocator& __a)
+ : _Base(__first, __last, __a) { }
#endif
set(const _Base& __x)
: _Base(__x) { }
- ~set() _GLIBCXX_NOEXCEPT { }
-
#if __cplusplus < 201103L
set&
operator=(const set& __x)
@@ -147,108 +148,98 @@
}
#endif
- using _Base::get_allocator;
-
- // iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::begin()); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::begin()); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::end()); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::end()); }
-
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
reverse_iterator
rend() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
const_reverse_iterator
rend() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
const_reverse_iterator
crbegin() const noexcept
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crbegin();
+ }
const_reverse_iterator
crend() const noexcept
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crend();
+ }
#endif
- // capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
// modifiers:
#if __cplusplus >= 201103L
template<typename... _Args>
std::pair<iterator, bool>
emplace(_Args&&... __args)
{
- auto __res = _Base::emplace(std::forward<_Args>(__args)...);
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::emplace(std::forward<_Args>(__args)...);
}
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
- return iterator(_Base::emplace_hint(__pos,
- std::forward<_Args>(__args)...));
+ auto size_before = this->size();
+ auto __res
+ = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#endif
std::pair<iterator, bool>
insert(const value_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(__x);
}
#if __cplusplus >= 201103L
std::pair<iterator, bool>
insert(value_type&& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, bool> __res
- = _Base::insert(std::move(__x));
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(std::move(__x));
}
#endif
iterator
- insert(const_iterator __position, const value_type& __x)
- { return iterator(_Base::insert(__position, __x)); }
+ insert(const_iterator __pos, const value_type& __x)
+ {
+ size_type size_before = this->size();
+ iterator __res = _Base::insert(__pos, __x);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#if __cplusplus >= 201103L
iterator
@@ -262,125 +253,162 @@
#else
template<typename _InputIterator>
#endif
- void
- insert(_InputIterator __first, _InputIterator __last)
- { _Base::insert(__first, __last); }
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+ for (; __first != __last; ++__first)
+ insert(*__first);
+ }
#if __cplusplus >= 201103L
void
insert(initializer_list<value_type> __l)
- { _Base::insert(__l); }
+ { insert(__l.begin(), __l.end()); }
#endif
#if __cplusplus >= 201103L
iterator
- erase(const_iterator __position)
- { return iterator(_Base::erase(__position)); }
+ erase(const_iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__pos);
+ }
#else
void
- erase(iterator __position)
- { _Base::erase(__position); }
+ erase(iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ _Base::erase(__pos);
+ }
#endif
size_type
erase(const key_type& __x)
{
- iterator __victim = find(__x);
- if (__victim == end())
- return 0;
- else
- {
- _Base::erase(__victim);
- return 1;
- }
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__x);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __first, const_iterator __last)
- { return iterator(_Base::erase(__first, __last)); }
+ {
+ if (__first != __last)
+ {
+ iterator __ret;
+ for (; __first != __last;)
+ __ret = erase(__first++);
+ return __ret;
+ }
+
+ return _Base::erase(__first, __last);
+ }
#else
void
erase(iterator __first, iterator __last)
- { _Base::erase(__first, __last); }
+ {
+ for (; __first != __last;)
+ erase(__first++);
+ }
#endif
void
swap(set& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { this->erase(begin(), end()); }
-
- // observers:
- using _Base::key_comp;
- using _Base::value_comp;
-
// set operations:
iterator
find(const key_type& __x)
- { return iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 214. set::find() missing const overload
const_iterator
find(const key_type& __x) const
- { return const_iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
- using _Base::count;
+ size_type
+ count(const key_type& __x) const
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::count(__x);
+ }
iterator
lower_bound(const key_type& __x)
- { return iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 214. set::find() missing const overload
const_iterator
lower_bound(const key_type& __x) const
- { return const_iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
iterator
upper_bound(const key_type& __x)
- { return iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 214. set::find() missing const overload
const_iterator
upper_bound(const key_type& __x) const
- { return const_iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
- std::pair<iterator,iterator>
+ std::pair<iterator, iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(iterator(__res.first),
- iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 214. set::find() missing const overload
- std::pair<const_iterator,const_iterator>
+ std::pair<const_iterator, const_iterator>
equal_range(const key_type& __x) const
{
- typedef typename _Base::const_iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(const_iterator(__res.first),
- const_iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ private:
+ /** If hint is used we consider that the map and unordered_map
+ * operations have equivalent insertion cost so we do not update metrics
+ * about it.
+ * Note that to find out if hint has been used is libstdc++
+ * implementation dependant.
+ */
+ bool
+ _M_hint_used(const_iterator __hint, iterator __res)
+ {
+ return (__hint == __res ||
+ (__hint == this->end() && ++__res == this->end()) ||
+ (__hint != this->end() && (++__hint == __res ||
+ ++__res == --__hint)));
+ }
};
template<typename _Key, typename _Compare, typename _Allocator>
Index: include/profile/unordered_base.h
===================================================================
--- include/profile/unordered_base.h (revision 210311)
+++ include/profile/unordered_base.h (working copy)
@@ -157,7 +157,7 @@
_Unordered_profile()
{
auto& __uc = _M_conjure();
- __profcxx_hashtable_construct(&__uc, __uc.bucket_count());
+ __profcxx_hashtable_construct(&__uc, __uc.bucket_count());
__profcxx_hashtable_construct2(&__uc);
}
_Unordered_profile(const _Unordered_profile&)
@@ -168,8 +168,8 @@
~_Unordered_profile() noexcept
{
auto& __uc = _M_conjure();
- __profcxx_hashtable_destruct(&__uc, __uc.bucket_count(), __uc.size());
- _M_profile_destruct();
+ __profcxx_hashtable_destruct(&__uc, __uc.bucket_count(), __uc.size());
+ _M_profile_destruct();
}
_Unordered_profile&
@@ -210,6 +210,7 @@
auto __lend = __uc.end(__bkt);
for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit)
++__chain;
+
if (__chain)
{
++__chain;
@@ -245,6 +246,7 @@
__pit = __it;
}
}
+
if (__chain)
{
++__chain;
Index: include/profile/unordered_map
===================================================================
--- include/profile/unordered_map (revision 210311)
+++ include/profile/unordered_map (working copy)
@@ -56,73 +56,66 @@
typedef typename _GLIBCXX_STD_BASE _Base;
_Base&
- _M_base() noexcept { return *this; }
+ _M_base() noexcept { return *this; }
const _Base&
- _M_base() const noexcept { return *this; }
+ _M_base() const noexcept { return *this; }
public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
- typedef typename _Base::key_type key_type;
- typedef typename _Base::value_type value_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
- typedef typename _Base::mapped_type mapped_type;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+ typedef typename _Base::key_type key_type;
+ typedef typename _Base::value_type value_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
+ typedef typename _Base::mapped_type mapped_type;
- typedef typename _Base::iterator iterator;
- typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
explicit
unordered_map(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __eql, __a)
- { }
+ : _Base(__n, __hf, __eql, __a) { }
template<typename _InputIterator>
- unordered_map(_InputIterator __f, _InputIterator __l,
+ unordered_map(_InputIterator __f, _InputIterator __l,
size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __eql, __a)
- { }
+ : _Base(__f, __l, __n, __hf, __eql, __a) { }
unordered_map(const unordered_map&) = default;
unordered_map(const _Base& __x)
- : _Base(__x)
- { }
+ : _Base(__x) { }
unordered_map(unordered_map&&) = default;
explicit
unordered_map(const allocator_type& __a)
- : _Base(__a)
- { }
+ : _Base(__a) { }
unordered_map(const unordered_map& __umap,
const allocator_type& __a)
- : _Base(__umap, __a)
- { }
+ : _Base(__umap, __a) { }
unordered_map(unordered_map&& __umap,
const allocator_type& __a)
- : _Base(std::move(__umap._M_base()), __a)
- { }
+ : _Base(std::move(__umap._M_base()), __a) { }
unordered_map(initializer_list<value_type> __l,
size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
- : _Base(__l, __n, __hf, __eql, __a)
- { }
+ : _Base(__l, __n, __hf, __eql, __a) { }
unordered_map&
operator=(const unordered_map&) = default;
@@ -140,9 +133,9 @@
void
clear() noexcept
{
- __profcxx_hashtable_destruct(this, _Base::bucket_count(),
+ __profcxx_hashtable_destruct(this, _Base::bucket_count(),
_Base::size());
- this->_M_profile_destruct();
+ this->_M_profile_destruct();
_Base::clear();
}
@@ -170,81 +163,81 @@
void
insert(std::initializer_list<value_type> __l)
- {
- size_type __old_size = _Base::bucket_count();
- _Base::insert(__l);
- _M_profile_resize(__old_size);
+ {
+ size_type __old_size = _Base::bucket_count();
+ _Base::insert(__l);
+ _M_profile_resize(__old_size);
}
std::pair<iterator, bool>
insert(const value_type& __obj)
{
- size_type __old_size = _Base::bucket_count();
- std::pair<iterator, bool> __res = _Base::insert(__obj);
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ std::pair<iterator, bool> __res = _Base::insert(__obj);
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(const_iterator __iter, const value_type& __v)
- {
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__iter, __v);
- _M_profile_resize(__old_size);
- return __res;
+ {
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, __v);
+ _M_profile_resize(__old_size);
+ return __res;
}
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- std::pair<iterator, bool>
- insert(_Pair&& __obj)
- {
+ std::pair<iterator, bool>
+ insert(_Pair&& __obj)
+ {
size_type __old_size = _Base::bucket_count();
std::pair<iterator, bool> __res
= _Base::insert(std::forward<_Pair>(__obj));
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
return __res;
}
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- iterator
- insert(const_iterator __iter, _Pair&& __v)
- {
- size_type __old_size = _Base::bucket_count();
+ iterator
+ insert(const_iterator __iter, _Pair&& __v)
+ {
+ size_type __old_size = _Base::bucket_count();
iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
return __res;
}
template<typename _InputIter>
- void
- insert(_InputIter __first, _InputIter __last)
- {
- size_type __old_size = _Base::bucket_count();
+ void
+ insert(_InputIter __first, _InputIter __last)
+ {
+ size_type __old_size = _Base::bucket_count();
_Base::insert(__first, __last);
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
}
// operator[]
mapped_type&
operator[](const _Key& __k)
{
- size_type __old_size = _Base::bucket_count();
- mapped_type& __res = _M_base()[__k];
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ mapped_type& __res = _M_base()[__k];
+ _M_profile_resize(__old_size);
+ return __res;
}
mapped_type&
operator[](_Key&& __k)
{
- size_type __old_size = _Base::bucket_count();
- mapped_type& __res = _M_base()[std::move(__k)];
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ mapped_type& __res = _M_base()[std::move(__k)];
+ _M_profile_resize(__old_size);
+ return __res;
}
void
@@ -256,7 +249,7 @@
{
size_type __old_size = _Base::bucket_count();
_Base::rehash(__n);
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
}
private:
@@ -305,76 +298,69 @@
public _Unordered_profile<unordered_multimap<_Key, _Tp,
_Hash, _Pred, _Alloc>,
false>
- {
+ {
typedef typename _GLIBCXX_STD_BASE _Base;
_Base&
- _M_base() noexcept { return *this; }
+ _M_base() noexcept { return *this; }
const _Base&
- _M_base() const noexcept { return *this; }
+ _M_base() const noexcept { return *this; }
public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
- typedef typename _Base::key_type key_type;
- typedef typename _Base::value_type value_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+ typedef typename _Base::key_type key_type;
+ typedef typename _Base::value_type value_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
- typedef typename _Base::iterator iterator;
- typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
explicit
unordered_multimap(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
- : _Base(__n, __hf, __eql, __a)
- { }
+ : _Base(__n, __hf, __eql, __a) { }
template<typename _InputIterator>
- unordered_multimap(_InputIterator __f, _InputIterator __l,
+ unordered_multimap(_InputIterator __f, _InputIterator __l,
size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
- : _Base(__f, __l, __n, __hf, __eql, __a)
- { }
+ : _Base(__f, __l, __n, __hf, __eql, __a) { }
unordered_multimap(const unordered_multimap&) = default;
unordered_multimap(const _Base& __x)
- : _Base(__x)
- { }
+ : _Base(__x) { }
unordered_multimap(unordered_multimap&&) = default;
explicit
unordered_multimap(const allocator_type& __a)
- : _Base(__a)
- { }
+ : _Base(__a) { }
unordered_multimap(const unordered_multimap& __ummap,
const allocator_type& __a)
- : _Base(__ummap._M_base(), __a)
- { }
+ : _Base(__ummap._M_base(), __a) { }
unordered_multimap(unordered_multimap&& __ummap,
const allocator_type& __a)
- : _Base(std::move(__ummap._M_base()), __a)
- { }
+ : _Base(std::move(__ummap._M_base()), __a) { }
unordered_multimap(initializer_list<value_type> __l,
size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
- : _Base(__l, __n, __hf, __eql, __a)
- { }
+ : _Base(__l, __n, __hf, __eql, __a) { }
unordered_multimap&
operator=(const unordered_multimap&) = default;
@@ -392,7 +378,7 @@
void
clear() noexcept
{
- __profcxx_hashtable_destruct(this, _Base::bucket_count(),
+ __profcxx_hashtable_destruct(this, _Base::bucket_count(),
_Base::size());
this->_M_profile_destruct();
_Base::clear();
@@ -422,61 +408,61 @@
void
insert(std::initializer_list<value_type> __l)
- {
- size_type __old_size = _Base::bucket_count();
- _Base::insert(__l);
- _M_profile_resize(__old_size);
+ {
+ size_type __old_size = _Base::bucket_count();
+ _Base::insert(__l);
+ _M_profile_resize(__old_size);
}
iterator
insert(const value_type& __obj)
{
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__obj);
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__obj);
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(const_iterator __iter, const value_type& __v)
- {
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__iter, __v);
- _M_profile_resize(__old_size);
- return __res;
+ {
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, __v);
+ _M_profile_resize(__old_size);
+ return __res;
}
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- iterator
- insert(_Pair&& __obj)
- {
+ iterator
+ insert(_Pair&& __obj)
+ {
size_type __old_size = _Base::bucket_count();
iterator __res = _Base::insert(std::forward<_Pair>(__obj));
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
return __res;
}
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- iterator
- insert(const_iterator __iter, _Pair&& __v)
- {
- size_type __old_size = _Base::bucket_count();
+ iterator
+ insert(const_iterator __iter, _Pair&& __v)
+ {
+ size_type __old_size = _Base::bucket_count();
iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
return __res;
}
template<typename _InputIter>
- void
- insert(_InputIter __first, _InputIter __last)
- {
- size_type __old_size = _Base::bucket_count();
+ void
+ insert(_InputIter __first, _InputIter __last)
+ {
+ size_type __old_size = _Base::bucket_count();
_Base::insert(__first, __last);
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
}
void
@@ -487,9 +473,9 @@
void
rehash(size_type __n)
{
- size_type __old_size = _Base::bucket_count();
- _Base::rehash(__n);
- _M_profile_resize(__old_size);
+ size_type __old_size = _Base::bucket_count();
+ _Base::rehash(__n);
+ _M_profile_resize(__old_size);
}
private:
@@ -497,8 +483,8 @@
_M_profile_resize(size_type __old_size)
{
size_type __new_size = _Base::bucket_count();
- if (__old_size != __new_size)
- __profcxx_hashtable_resize(this, __old_size, __new_size);
+ if (__old_size != __new_size)
+ __profcxx_hashtable_resize(this, __old_size, __new_size);
}
};
Index: include/profile/unordered_set
===================================================================
--- include/profile/unordered_set (revision 210311)
+++ include/profile/unordered_set (working copy)
@@ -44,7 +44,7 @@
namespace __profile
{
/** @brief Unordered_set wrapper with performance instrumentation. */
- template<typename _Key,
+ template<typename _Key,
typename _Hash = std::hash<_Key>,
typename _Pred = std::equal_to<_Key>,
typename _Alloc = std::allocator<_Key> >
@@ -62,18 +62,18 @@
_M_base() const noexcept { return *this; }
public:
- typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::allocator_type allocator_type;
- typedef typename _Base::key_type key_type;
- typedef typename _Base::value_type value_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::allocator_type allocator_type;
+ typedef typename _Base::key_type key_type;
+ typedef typename _Base::value_type value_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
- typedef typename _Base::iterator iterator;
- typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
explicit
unordered_set(size_type __n = 10,
@@ -84,7 +84,7 @@
{ }
template<typename _InputIterator>
- unordered_set(_InputIterator __f, _InputIterator __l,
+ unordered_set(_InputIterator __f, _InputIterator __l,
size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
@@ -144,10 +144,10 @@
void
clear() noexcept
{
- __profcxx_hashtable_destruct(this, _Base::bucket_count(),
- _Base::size());
- this->_M_profile_destruct();
- _Base::clear();
+ __profcxx_hashtable_destruct(this, _Base::bucket_count(),
+ _Base::size());
+ this->_M_profile_destruct();
+ _Base::clear();
}
template<typename... _Args>
@@ -174,63 +174,63 @@
void
insert(std::initializer_list<value_type> __l)
- {
- size_type __old_size = _Base::bucket_count();
- _Base::insert(__l);
- _M_profile_resize(__old_size);
+ {
+ size_type __old_size = _Base::bucket_count();
+ _Base::insert(__l);
+ _M_profile_resize(__old_size);
}
std::pair<iterator, bool>
insert(const value_type& __obj)
{
- size_type __old_size = _Base::bucket_count();
- std::pair<iterator, bool> __res = _Base::insert(__obj);
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ std::pair<iterator, bool> __res = _Base::insert(__obj);
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(const_iterator __iter, const value_type& __v)
- {
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__iter, __v);
- _M_profile_resize(__old_size);
- return __res;
+ {
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, __v);
+ _M_profile_resize(__old_size);
+ return __res;
}
std::pair<iterator, bool>
insert(value_type&& __obj)
{
- size_type __old_size = _Base::bucket_count();
- std::pair<iterator, bool> __res = _Base::insert(std::move(__obj));
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ std::pair<iterator, bool> __res = _Base::insert(std::move(__obj));
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(const_iterator __iter, value_type&& __v)
- {
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__iter, std::move(__v));
- _M_profile_resize(__old_size);
- return __res;
+ {
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, std::move(__v));
+ _M_profile_resize(__old_size);
+ return __res;
}
template<typename _InputIter>
- void
- insert(_InputIter __first, _InputIter __last)
- {
- size_type __old_size = _Base::bucket_count();
+ void
+ insert(_InputIter __first, _InputIter __last)
+ {
+ size_type __old_size = _Base::bucket_count();
_Base::insert(__first, __last);
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
}
void
rehash(size_type __n)
{
- size_type __old_size = _Base::bucket_count();
- _Base::rehash(__n);
- _M_profile_resize(__old_size);
+ size_type __old_size = _Base::bucket_count();
+ _Base::rehash(__n);
+ _M_profile_resize(__old_size);
}
private:
@@ -287,10 +287,10 @@
public:
typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
+ typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
- typedef typename _Base::key_type key_type;
+ typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
typedef typename _Base::difference_type difference_type;
typedef typename _Base::reference reference;
@@ -308,7 +308,7 @@
{ }
template<typename _InputIterator>
- unordered_multiset(_InputIterator __f, _InputIterator __l,
+ unordered_multiset(_InputIterator __f, _InputIterator __l,
size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
@@ -368,10 +368,10 @@
void
clear() noexcept
{
- __profcxx_hashtable_destruct(this, _Base::bucket_count(),
- _Base::size());
- this->_M_profile_destruct();
- _Base::clear();
+ __profcxx_hashtable_destruct(this, _Base::bucket_count(),
+ _Base::size());
+ this->_M_profile_destruct();
+ _Base::clear();
}
template<typename... _Args>
@@ -397,63 +397,63 @@
void
insert(std::initializer_list<value_type> __l)
- {
- size_type __old_size = _Base::bucket_count();
- _Base::insert(__l);
- _M_profile_resize(__old_size);
+ {
+ size_type __old_size = _Base::bucket_count();
+ _Base::insert(__l);
+ _M_profile_resize(__old_size);
}
iterator
insert(const value_type& __obj)
{
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__obj);
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__obj);
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(const_iterator __iter, const value_type& __v)
{
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__iter, __v);
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, __v);
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(value_type&& __obj)
{
size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(std::move(__obj));
- _M_profile_resize(__old_size);
- return __res;
+ iterator __res = _Base::insert(std::move(__obj));
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(const_iterator __iter, value_type&& __v)
{
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__iter, std::move(__v));
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, std::move(__v));
+ _M_profile_resize(__old_size);
+ return __res;
}
template<typename _InputIter>
- void
- insert(_InputIter __first, _InputIter __last)
- {
- size_type __old_size = _Base::bucket_count();
+ void
+ insert(_InputIter __first, _InputIter __last)
+ {
+ size_type __old_size = _Base::bucket_count();
_Base::insert(__first, __last);
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
}
void
rehash(size_type __n)
{
- size_type __old_size = _Base::bucket_count();
- _Base::rehash(__n);
- _M_profile_resize(__old_size);
+ size_type __old_size = _Base::bucket_count();
+ _Base::rehash(__n);
+ _M_profile_resize(__old_size);
}
private:
@@ -461,8 +461,8 @@
_M_profile_resize(size_type __old_size)
{
size_type __new_size = _Base::bucket_count();
- if (__old_size != __new_size)
- __profcxx_hashtable_resize(this, __old_size, __new_size);
+ if (__old_size != __new_size)
+ __profcxx_hashtable_resize(this, __old_size, __new_size);
}
};
Index: include/profile/vector
===================================================================
--- include/profile/vector (revision 210311)
+++ include/profile/vector (working copy)
@@ -37,87 +37,134 @@
{
namespace __profile
{
+ template<typename _Vector>
+ class _Vector_profile_pre
+ {
+ _Vector&
+ _M_conjure()
+ { return *static_cast<_Vector*>(this); }
+
+ public:
+#if __cplusplus >= 201103L
+ _Vector_profile_pre() = default;
+ _Vector_profile_pre(const _Vector_profile_pre&) = default;
+ _Vector_profile_pre(_Vector_profile_pre&&) = default;
+
+ _Vector_profile_pre&
+ operator=(const _Vector_profile_pre&) = default;
+
+ _Vector_profile_pre&
+ operator=(_Vector_profile_pre&&) noexcept
+ { _M_profile_destruct(); }
+#endif
+
+ void
+ _M_profile_destruct()
+ {
+ __profcxx_vector_destruct2(&_M_conjure());
+ __profcxx_vector_destruct(&_M_conjure(),
+ _M_conjure().capacity(), _M_conjure().size());
+ }
+ };
+
+ template<typename _Vector>
+ class _Vector_profile_post
+ {
+ _Vector&
+ _M_conjure()
+ { return *static_cast<_Vector*>(this); }
+
+ protected:
+ _Vector_profile_post() _GLIBCXX_NOEXCEPT
+ {
+ __profcxx_vector_construct(&_M_conjure(), _M_conjure().capacity());
+ __profcxx_vector_construct2(&_M_conjure());
+ }
+
+#if __cplusplus >= 201103L
+ _Vector_profile_post(const _Vector_profile_post&) noexcept
+ : _Vector_profile_post() { }
+ _Vector_profile_post(_Vector_profile_post&&) noexcept
+ : _Vector_profile_post() { }
+
+ _Vector_profile_post&
+ operator=(const _Vector_profile_post&) = default;
+ _Vector_profile_post&
+ operator=(_Vector_profile_post&&) = default;
+#endif
+
+ ~_Vector_profile_post()
+ { _M_conjure()._M_profile_destruct(); }
+ };
+
template<typename _Tp,
typename _Allocator = std::allocator<_Tp> >
class vector
- : public _GLIBCXX_STD_C::vector<_Tp, _Allocator>
+ : public _Vector_profile_pre<vector<_Tp, _Allocator> >,
+ public _GLIBCXX_STD_C::vector<_Tp, _Allocator>,
+ public _Vector_profile_post<vector<_Tp, _Allocator> >
{
- typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
- typedef typename _Base::iterator _Base_iterator;
- typedef typename _Base::const_iterator _Base_const_iterator;
+ typedef typename _Base::iterator _Base_iterator;
+ typedef typename _Base::const_iterator _Base_const_iterator;
-#if __cplusplus >= 201103L
- typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
-#endif
-
public:
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
typedef __iterator_tracker<_Base_iterator, vector>
- iterator;
+ iterator;
typedef __iterator_tracker<_Base_const_iterator, vector>
- const_iterator;
+ const_iterator;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
- typedef _Tp value_type;
- typedef _Allocator allocator_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
+ typedef _Tp value_type;
+ typedef _Allocator allocator_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
// 23.2.4.1 construct/copy/destroy:
- vector() _GLIBCXX_NOEXCEPT
- : _Base()
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+#if __cplusplus < 201103L
+ vector()
+ { }
+ vector(const vector& __x)
+ : _Base(__x) { }
+#else
+ vector() = default;
+ vector(const vector&) = default;
+ vector(vector&&) = default;
+#endif
+
explicit
vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT
- : _Base(__a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__a) { }
#if __cplusplus >= 201103L
explicit
vector(size_type __n, const _Allocator& __a = _Allocator())
- : _Base(__n, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__n, __a) { }
vector(size_type __n, const _Tp& __value,
const _Allocator& __a = _Allocator())
- : _Base(__n, __value, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__n, __value, __a) { }
#else
explicit
vector(size_type __n, const _Tp& __value = _Tp(),
const _Allocator& __a = _Allocator())
- : _Base(__n, __value, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__n, __value, __a) { }
#endif
#if __cplusplus >= 201103L
@@ -126,91 +173,48 @@
#else
template<typename _InputIterator>
#endif
- vector(_InputIterator __first, _InputIterator __last,
+ vector(_InputIterator __first, _InputIterator __last,
const _Allocator& __a = _Allocator())
- : _Base(__first, __last, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__first, __last, __a) { }
- vector(const vector& __x)
- : _Base(__x)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
-
- /// Construction from a release-mode vector
+ /// Construction from a normal-mode vector
vector(const _Base& __x)
- : _Base(__x)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__x) { }
#if __cplusplus >= 201103L
- vector(vector&& __x) noexcept
- : _Base(std::move(__x))
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
-
vector(const _Base& __x, const _Allocator& __a)
- : _Base(__x, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__x, __a) { }
vector(vector&& __x, const _Allocator& __a)
- : _Base(std::move(__x), __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(std::move(__x), __a) { }
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__l, __a) { }
#endif
- ~vector() _GLIBCXX_NOEXCEPT
- {
- __profcxx_vector_destruct(this, this->capacity(), this->size());
- __profcxx_vector_destruct2(this);
- }
-
+#if __cplusplus < 201103L
vector&
operator=(const vector& __x)
{
- static_cast<_Base&>(*this) = __x;
- return *this;
+ _M_base() = __x;
+ return *this;
}
+#else
+ vector&
+ operator=(const vector&) = default;
-#if __cplusplus >= 201103L
vector&
- operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
- {
- __profcxx_vector_destruct(this, this->capacity(), this->size());
- __profcxx_vector_destruct2(this);
- static_cast<_Base&>(*this) = std::move(__x);
- return *this;
- }
+ operator=(vector&&) = default;
vector&
operator=(initializer_list<value_type> __l)
{
- static_cast<_Base&>(*this) = __l;
+ _M_base() = __l;
return *this;
}
#endif
- using _Base::assign;
- using _Base::get_allocator;
-
-
// iterators:
iterator
begin() _GLIBCXX_NOEXCEPT
@@ -263,183 +267,135 @@
#endif
// 23.2.4.2 capacity:
- using _Base::size;
- using _Base::max_size;
#if __cplusplus >= 201103L
void
resize(size_type __sz)
{
- __profcxx_vector_invalid_operator(this);
- _M_profile_resize(this, this->capacity(), __sz);
- _Base::resize(__sz);
+ __profcxx_vector_invalid_operator(this);
+ _M_profile_resize(this->capacity(), __sz);
+ _Base::resize(__sz);
}
void
resize(size_type __sz, const _Tp& __c)
{
- __profcxx_vector_invalid_operator(this);
- _M_profile_resize(this, this->capacity(), __sz);
- _Base::resize(__sz, __c);
+ __profcxx_vector_invalid_operator(this);
+ _M_profile_resize(this->capacity(), __sz);
+ _Base::resize(__sz, __c);
}
#else
void
resize(size_type __sz, _Tp __c = _Tp())
{
- __profcxx_vector_invalid_operator(this);
- _M_profile_resize(this, this->capacity(), __sz);
- _Base::resize(__sz, __c);
+ __profcxx_vector_invalid_operator(this);
+ _M_profile_resize(this->capacity(), __sz);
+ _Base::resize(__sz, __c);
}
#endif
-#if __cplusplus >= 201103L
- using _Base::shrink_to_fit;
-#endif
-
- using _Base::empty;
-
// element access:
reference
operator[](size_type __n) _GLIBCXX_NOEXCEPT
{
- __profcxx_vector_invalid_operator(this);
- return _M_base()[__n];
+ __profcxx_vector_invalid_operator(this);
+ return _M_base()[__n];
}
const_reference
operator[](size_type __n) const _GLIBCXX_NOEXCEPT
{
- __profcxx_vector_invalid_operator(this);
- return _M_base()[__n];
+ __profcxx_vector_invalid_operator(this);
+ return _M_base()[__n];
}
- using _Base::at;
-
- reference
- front() _GLIBCXX_NOEXCEPT
- {
- return _Base::front();
- }
-
- const_reference
- front() const _GLIBCXX_NOEXCEPT
- {
- return _Base::front();
- }
-
- reference
- back() _GLIBCXX_NOEXCEPT
- {
- return _Base::back();
- }
-
- const_reference
- back() const _GLIBCXX_NOEXCEPT
- {
- return _Base::back();
- }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // DR 464. Suggestion for new member functions in standard containers.
- using _Base::data;
-
// 23.2.4.3 modifiers:
void
push_back(const _Tp& __x)
{
- size_type __old_size = this->capacity();
+ size_type __old_size = this->capacity();
_Base::push_back(__x);
- _M_profile_resize(this, __old_size, this->capacity());
+ _M_profile_resize(__old_size, this->capacity());
}
#if __cplusplus >= 201103L
void
push_back(_Tp&& __x)
{
- size_type __old_size = this->capacity();
- _Base::push_back(std::move(__x));
- _M_profile_resize(this, __old_size, this->capacity());
+ size_type __old_size = this->capacity();
+ _Base::push_back(std::move(__x));
+ _M_profile_resize(__old_size, this->capacity());
}
#endif
iterator
#if __cplusplus >= 201103L
- insert(const_iterator __position, const _Tp& __x)
+ insert(const_iterator __pos, const _Tp& __x)
#else
- insert(iterator __position, const _Tp& __x)
+ insert(iterator __pos, const _Tp& __x)
#endif
{
- __profcxx_vector_insert(this, __position.base() - _Base::begin(),
- this->size());
- size_type __old_size = this->capacity();
- _Base_iterator __res = _Base::insert(__position.base(), __x);
- _M_profile_resize(this, __old_size, this->capacity());
+ __profcxx_vector_insert(this, __pos.base() - _Base::begin(),
+ this->size());
+ size_type __old_size = this->capacity();
+ _Base_iterator __res = _Base::insert(__pos.base(), __x);
+ _M_profile_resize(__old_size, this->capacity());
return iterator(__res, this);
}
#if __cplusplus >= 201103L
iterator
- insert(const_iterator __position, _Tp&& __x)
+ insert(const_iterator __pos, _Tp&& __x)
{
- __profcxx_vector_insert(this, __position.base() - _Base::cbegin(),
- this->size());
- size_type __old_size = this->capacity();
- _Base_iterator __res = _Base::insert(__position.base(), __x);
- _M_profile_resize(this, __old_size, this->capacity());
+ __profcxx_vector_insert(this, __pos.base() - _Base::cbegin(),
+ this->size());
+ size_type __old_size = this->capacity();
+ _Base_iterator __res = _Base::insert(__pos.base(), __x);
+ _M_profile_resize(__old_size, this->capacity());
return iterator(__res, this);
}
template<typename... _Args>
- iterator
- emplace(const_iterator __position, _Args&&... __args)
- {
- _Base_iterator __res = _Base::emplace(__position.base(),
+ iterator
+ emplace(const_iterator __pos, _Args&&... __args)
+ {
+ _Base_iterator __res = _Base::emplace(__pos.base(),
std::forward<_Args>(__args)...);
return iterator(__res, this);
}
iterator
- insert(const_iterator __position, initializer_list<value_type> __l)
- { return this->insert(__position, __l.begin(), __l.end()); }
+ insert(const_iterator __pos, initializer_list<value_type> __l)
+ { return this->insert(__pos, __l.begin(), __l.end()); }
#endif
-#if __cplusplus >= 201103L
void
- swap(vector&& __x)
- {
- _Base::swap(__x);
- }
-#endif
-
- void
swap(vector& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
- {
- _Base::swap(__x);
- }
+ { _Base::swap(__x); }
#if __cplusplus >= 201103L
iterator
- insert(const_iterator __position, size_type __n, const _Tp& __x)
+ insert(const_iterator __pos, size_type __n, const _Tp& __x)
{
- __profcxx_vector_insert(this, __position.base() - _Base::cbegin(),
- this->size());
- size_type __old_size = this->capacity();
- _Base_iterator __res = _Base::insert(__position, __n, __x);
- _M_profile_resize(this, __old_size, this->capacity());
+ __profcxx_vector_insert(this, __pos.base() - _Base::cbegin(),
+ this->size());
+ size_type __old_size = this->capacity();
+ _Base_iterator __res = _Base::insert(__pos, __n, __x);
+ _M_profile_resize(__old_size, this->capacity());
return iterator(__res, this);
}
#else
void
- insert(iterator __position, size_type __n, const _Tp& __x)
+ insert(iterator __pos, size_type __n, const _Tp& __x)
{
- __profcxx_vector_insert(this, __position.base() - _Base::begin(),
- this->size());
- size_type __old_size = this->capacity();
- _Base::insert(__position, __n, __x);
- _M_profile_resize(this, __old_size, this->capacity());
+ __profcxx_vector_insert(this, __pos.base() - _Base::begin(),
+ this->size());
+ size_type __old_size = this->capacity();
+ _Base::insert(__pos, __n, __x);
+ _M_profile_resize(__old_size, this->capacity());
}
#endif
@@ -447,40 +403,37 @@
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
- insert(const_iterator __position,
+ insert(const_iterator __pos,
_InputIterator __first, _InputIterator __last)
- {
- __profcxx_vector_insert(this, __position.base() - _Base::cbegin(),
+ {
+ __profcxx_vector_insert(this, __pos.base() - _Base::cbegin(),
this->size());
size_type __old_size = this->capacity();
- _Base_iterator __res = _Base::insert(__position, __first, __last);
- _M_profile_resize(this, __old_size, this->capacity());
+ _Base_iterator __res = _Base::insert(__pos, __first, __last);
+ _M_profile_resize(__old_size, this->capacity());
return iterator(__res, this);
}
#else
template<typename _InputIterator>
void
- insert(iterator __position,
+ insert(iterator __pos,
_InputIterator __first, _InputIterator __last)
- {
- __profcxx_vector_insert(this, __position.base() - _Base::begin(),
+ {
+ __profcxx_vector_insert(this, __pos.base() - _Base::begin(),
this->size());
size_type __old_size = this->capacity();
- _Base::insert(__position, __first, __last);
- _M_profile_resize(this, __old_size, this->capacity());
+ _Base::insert(__pos, __first, __last);
+ _M_profile_resize(__old_size, this->capacity());
}
#endif
iterator
#if __cplusplus >= 201103L
- erase(const_iterator __position)
+ erase(const_iterator __pos)
#else
- erase(iterator __position)
+ erase(iterator __pos)
#endif
- {
- _Base_iterator __res = _Base::erase(__position.base());
- return iterator(__res, this);
- }
+ { return iterator(_Base::erase(__pos.base()), this); }
iterator
#if __cplusplus >= 201103L
@@ -488,76 +441,66 @@
#else
erase(iterator __first, iterator __last)
#endif
- {
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 151. can't currently clear() empty container
- _Base_iterator __res = _Base::erase(__first.base(), __last.base());
- return iterator(__res, this);
- }
+ { return iterator(_Base::erase(__first.base(), __last.base()), this); }
void
clear() _GLIBCXX_NOEXCEPT
{
- __profcxx_vector_destruct(this, this->capacity(), this->size());
- __profcxx_vector_destruct2(this);
- _Base::clear();
+ this->_M_profile_destruct();
+ _Base::clear();
}
- inline void _M_profile_find() const
- {
- __profcxx_vector_find(this, size());
- }
+ inline void _M_profile_find() const
+ { __profcxx_vector_find(this, this->size()); }
- inline void _M_profile_iterate(int __rewind = 0) const
- {
- __profcxx_vector_iterate(this);
- }
+ inline void _M_profile_iterate(int __rewind = 0) const
+ { __profcxx_vector_iterate(this); }
private:
- void _M_profile_resize(void* obj, size_type __old_size,
- size_type __new_size)
+ void _M_profile_resize(size_type __old_size, size_type __new_size)
{
- if (__old_size < __new_size) {
- __profcxx_vector_resize(this, this->size(), __new_size);
- __profcxx_vector_resize2(this, this->size(), __new_size);
- }
+ if (__old_size < __new_size)
+ {
+ __profcxx_vector_resize(this, this->size(), __new_size);
+ __profcxx_vector_resize2(this, this->size(), __new_size);
+ }
}
};
template<typename _Tp, typename _Alloc>
inline bool
operator==(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() == __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator!=(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator<(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() < __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator<=(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() <= __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator>=(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator>(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() > __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: profile mode maintenance patch
2014-05-12 20:15 profile mode maintenance patch François Dumont
@ 2014-05-12 20:44 ` Paolo Carlini
2014-05-12 20:50 ` François Dumont
2014-05-23 20:32 ` libstdc++ automake version François Dumont
2014-05-24 11:33 ` profile mode maintenance patch Jonathan Wakely
1 sibling, 2 replies; 16+ messages in thread
From: Paolo Carlini @ 2014-05-12 20:44 UTC (permalink / raw)
To: François Dumont, libstdc++, gcc-patches
Hi,
On 05/12/2014 10:14 PM, François Dumont wrote:
> Regarding Makefile.in I miss last time. I moved to a new system
> lately, a Ubuntu based one, and still need to find out what version of
> automake/autoreconf I need to install. For the moment I have updated
> Makefile.in manually.
Isn't this clear enough
http://gcc.gnu.org/install/prerequisites.html
?
Paolo.
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: profile mode maintenance patch
2014-05-12 20:44 ` Paolo Carlini
@ 2014-05-12 20:50 ` François Dumont
2014-05-23 20:32 ` libstdc++ automake version François Dumont
1 sibling, 0 replies; 16+ messages in thread
From: François Dumont @ 2014-05-12 20:50 UTC (permalink / raw)
To: Paolo Carlini, libstdc++, gcc-patches
On 12/05/2014 22:42, Paolo Carlini wrote:
> Hi,
>
> On 05/12/2014 10:14 PM, François Dumont wrote:
>> Regarding Makefile.in I miss last time. I moved to a new system
>> lately, a Ubuntu based one, and still need to find out what version
>> of automake/autoreconf I need to install. For the moment I have
>> updated Makefile.in manually.
> Isn't this clear enough
>
> http://gcc.gnu.org/install/prerequisites.html
>
> ?
>
> Paolo.
>
Perfectly clear, thanks.
François
^ permalink raw reply [flat|nested] 16+ messages in thread
* libstdc++ automake version
2014-05-12 20:44 ` Paolo Carlini
2014-05-12 20:50 ` François Dumont
@ 2014-05-23 20:32 ` François Dumont
2014-05-23 20:37 ` Tim Shen
2014-05-23 20:52 ` Paolo Carlini
1 sibling, 2 replies; 16+ messages in thread
From: François Dumont @ 2014-05-23 20:32 UTC (permalink / raw)
To: Paolo Carlini, libstdc++, gcc-patches
On 12/05/2014 22:42, Paolo Carlini wrote:
> Hi,
>
> On 05/12/2014 10:14 PM, François Dumont wrote:
>> Regarding Makefile.in I miss last time. I moved to a new system
>> lately, a Ubuntu based one, and still need to find out what version
>> of automake/autoreconf I need to install. For the moment I have
>> updated Makefile.in manually.
> Isn't this clear enough
>
> http://gcc.gnu.org/install/prerequisites.html
>
> ?
>
> Paolo.
>
In fact not that much. It is saying:
"For directories that use automake, GCC requires the latest release in
the 1.11 series, which is currently 1.11.1. When regenerating a
directory to a newer version, please update all the directories using an
older 1.11 to the latest released version."
But now latest 1.11 version is at least 1.11.6, the version Ubuntu is
proposing when installing automake1.11 package. And considering all
impacts it has on the Makefile.in i guess it is not correct, is it ?
Looks like I will have to build automake 1.11.1 myself otherwise.
François
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: libstdc++ automake version
2014-05-23 20:32 ` libstdc++ automake version François Dumont
@ 2014-05-23 20:37 ` Tim Shen
2014-05-23 20:52 ` Paolo Carlini
1 sibling, 0 replies; 16+ messages in thread
From: Tim Shen @ 2014-05-23 20:37 UTC (permalink / raw)
To: François Dumont; +Cc: Paolo Carlini, libstdc++, gcc-patches
On Fri, May 23, 2014 at 1:32 PM, François Dumont <frs.dumont@gmail.com> wrote:
> Looks like I will have to build automake 1.11.1 myself otherwise.
Yes I do.
--
Regards,
Tim Shen
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: libstdc++ automake version
2014-05-23 20:32 ` libstdc++ automake version François Dumont
2014-05-23 20:37 ` Tim Shen
@ 2014-05-23 20:52 ` Paolo Carlini
1 sibling, 0 replies; 16+ messages in thread
From: Paolo Carlini @ 2014-05-23 20:52 UTC (permalink / raw)
To: François Dumont, libstdc++, gcc-patches
Hi,
On 05/23/2014 10:32 PM, François Dumont wrote:
> On 12/05/2014 22:42, Paolo Carlini wrote:
>> Hi,
>>
>> On 05/12/2014 10:14 PM, François Dumont wrote:
>>> Regarding Makefile.in I miss last time. I moved to a new system
>>> lately, a Ubuntu based one, and still need to find out what version
>>> of automake/autoreconf I need to install. For the moment I have
>>> updated Makefile.in manually.
>> Isn't this clear enough
>>
>> http://gcc.gnu.org/install/prerequisites.html
>>
>> ?
>>
>> Paolo.
>>
> In fact not that much.
The *first* two lines, before the lines you quoted seem clear enough to
me. Anyway, if you are curious about what *I* personally do when in
doubt, I find much simpler to open the Makefile.in I want to regenerate.
The first line reads:
# Makefile.in generated by automake 1.11.1 from Makefile.am.
which I personally find very clear, I don't know about you ;) About
autoconf, likewise I open configure.ac:
# Process this file with autoreconf to produce a configure script.
AC_PREREQ(2.64)
which seems also very clear to me.
Paolo.
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: profile mode maintenance patch
2014-05-12 20:15 profile mode maintenance patch François Dumont
2014-05-12 20:44 ` Paolo Carlini
@ 2014-05-24 11:33 ` Jonathan Wakely
2014-05-24 21:10 ` François Dumont
1 sibling, 1 reply; 16+ messages in thread
From: Jonathan Wakely @ 2014-05-24 11:33 UTC (permalink / raw)
To: François Dumont; +Cc: libstdc++, gcc-patches
On 12/05/14 22:14 +0200, François Dumont wrote:
>Hi
>
> Here is a maintenance patch for profile mode. It does:
>
>- Use inheritance to limit duplication of code in constructors to
>register for the different profiling mode diagnostics data structure.
>- Remove many code keeping only instrumented methods or methods that
>where the container type itself appears in the signature..
>- Extend the map to unordered_map to all ordered containers.
>
> And of course code cleanup and usage of default implementation for
>special methods as much as possible.
>
> Regarding Makefile.in I miss last time. I moved to a new system
>lately, a Ubuntu based one, and still need to find out what version of
>automake/autoreconf I need to install. For the moment I have updated
>Makefile.in manually.
This is OK
(I'm in favour of any change that reduces the amount of code in the
Profile Mode :)
Please correct a minor spelling mistake (in two places) before
committing:
>+ /** If hint is used we consider that the map and unordered_map
>+ * operations have equivalent insertion cost so we do not update metrics
>+ * about it.
>+ * Note that to find out if hint has been used is libstdc++
>+ * implementation dependant.
s/dependant/dependent/
Thanks!
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: profile mode maintenance patch
2014-05-24 11:33 ` profile mode maintenance patch Jonathan Wakely
@ 2014-05-24 21:10 ` François Dumont
2014-05-24 21:39 ` Jonathan Wakely
0 siblings, 1 reply; 16+ messages in thread
From: François Dumont @ 2014-05-24 21:10 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: libstdc++, gcc-patches
On 24/05/2014 13:33, Jonathan Wakely wrote:
> On 12/05/14 22:14 +0200, François Dumont wrote:
>> Hi
>>
>> Here is a maintenance patch for profile mode. It does:
>>
>> - Use inheritance to limit duplication of code in constructors to
>> register for the different profiling mode diagnostics data structure.
>> - Remove many code keeping only instrumented methods or methods that
>> where the container type itself appears in the signature..
>> - Extend the map to unordered_map to all ordered containers.
>>
>> And of course code cleanup and usage of default implementation for
>> special methods as much as possible.
>>
>> Regarding Makefile.in I miss last time. I moved to a new system
>> lately, a Ubuntu based one, and still need to find out what version
>> of automake/autoreconf I need to install. For the moment I have
>> updated Makefile.in manually.
>
> This is OK
>
> (I'm in favour of any change that reduces the amount of code in the
> Profile Mode :)
>
> Please correct a minor spelling mistake (in two places) before
> committing:
>
>> + /** If hint is used we consider that the map and unordered_map
>> + * operations have equivalent insertion cost so we do not
>> update metrics
>> + * about it.
>> + * Note that to find out if hint has been used is libstdc++
>> + * implementation dependant.
>
> s/dependant/dependent/
>
> Thanks!
>
Done but I forgot to fix the spelling. I will fix it in the future patch.
François
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: profile mode maintenance patch
2014-05-24 21:10 ` François Dumont
@ 2014-05-24 21:39 ` Jonathan Wakely
2014-05-25 8:34 ` Paolo Carlini
0 siblings, 1 reply; 16+ messages in thread
From: Jonathan Wakely @ 2014-05-24 21:39 UTC (permalink / raw)
To: François Dumont; +Cc: Jonathan Wakely, libstdc++, gcc-patches
On 24 May 2014 22:10, François Dumont wrote:
> Done but I forgot to fix the spelling. I will fix it in the future patch.
No problem, it's clear what the comment means.
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: profile mode maintenance patch
2014-05-24 21:39 ` Jonathan Wakely
@ 2014-05-25 8:34 ` Paolo Carlini
0 siblings, 0 replies; 16+ messages in thread
From: Paolo Carlini @ 2014-05-25 8:34 UTC (permalink / raw)
To: Jonathan Wakely, François Dumont
Cc: Jonathan Wakely, libstdc++, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 285 bytes --]
Hi,
On 05/24/2014 11:39 PM, Jonathan Wakely wrote:
> On 24 May 2014 22:10, François Dumont wrote:
>> Done but I forgot to fix the spelling. I will fix it in the future patch.
> No problem, it's clear what the comment means.
I'm committing the below.
Paolo.
/////////////////////
[-- Attachment #2: CL --]
[-- Type: text/plain, Size: 242 bytes --]
2014-05-25 Paolo Carlini <paolo.carlini@oracle.com>
* include/profile/map.h: Fix typo in comment; minor formatting fix.
* include/profile/multimap.h: Likewise.
* include/profile/set.h: Likewise.
* include/profile/multiset.h: Likewise.
[-- Attachment #3: patchlet --]
[-- Type: text/plain, Size: 3606 bytes --]
Index: include/profile/map.h
===================================================================
--- include/profile/map.h (revision 210911)
+++ include/profile/map.h (working copy)
@@ -451,15 +451,15 @@
* operations have equivalent insertion cost so we do not update metrics
* about it.
* Note that to find out if hint has been used is libstdc++
- * implementation dependant.
+ * implementation dependent.
*/
bool
_M_hint_used(const_iterator __hint, iterator __res)
{
- return (__hint == __res ||
- (__hint == this->end() && ++__res == this->end()) ||
- (__hint != this->end() && (++__hint == __res ||
- ++__res == --__hint)));
+ return (__hint == __res
+ || (__hint == this->end() && ++__res == this->end())
+ || (__hint != this->end() && (++__hint == __res
+ || ++__res == --__hint)));
}
};
Index: include/profile/multimap.h
===================================================================
--- include/profile/multimap.h (revision 210911)
+++ include/profile/multimap.h (working copy)
@@ -419,15 +419,15 @@
* operations have equivalent insertion cost so we do not update metrics
* about it.
* Note that to find out if hint has been used is libstdc++
- * implementation dependant.
+ * implementation dependent.
*/
bool
_M_hint_used(const_iterator __hint, iterator __res)
{
- return (__hint == __res ||
- (__hint == this->end() && ++__res == this->end()) ||
- (__hint != this->end() && (++__hint == __res ||
- ++__res == --__hint)));
+ return (__hint == __res
+ || (__hint == this->end() && ++__res == this->end())
+ || (__hint != this->end() && (++__hint == __res
+ || ++__res == --__hint)));
}
};
Index: include/profile/multiset.h
===================================================================
--- include/profile/multiset.h (revision 210911)
+++ include/profile/multiset.h (working copy)
@@ -413,15 +413,15 @@
* operations have equivalent insertion cost so we do not update metrics
* about it.
* Note that to find out if hint has been used is libstdc++
- * implementation dependant.
+ * implementation dependent.
*/
bool
_M_hint_used(const_iterator __hint, iterator __res)
{
- return (__hint == __res ||
- (__hint == this->end() && ++__res == this->end()) ||
- (__hint != this->end() && (++__hint == __res ||
- ++__res == --__hint)));
+ return (__hint == __res
+ || (__hint == this->end() && ++__res == this->end())
+ || (__hint != this->end() && (++__hint == __res
+ || ++__res == --__hint)));
}
};
Index: include/profile/set.h
===================================================================
--- include/profile/set.h (revision 210911)
+++ include/profile/set.h (working copy)
@@ -399,15 +399,15 @@
* operations have equivalent insertion cost so we do not update metrics
* about it.
* Note that to find out if hint has been used is libstdc++
- * implementation dependant.
+ * implementation dependent.
*/
bool
_M_hint_used(const_iterator __hint, iterator __res)
{
- return (__hint == __res ||
- (__hint == this->end() && ++__res == this->end()) ||
- (__hint != this->end() && (++__hint == __res ||
- ++__res == --__hint)));
+ return (__hint == __res
+ || (__hint == this->end() && ++__res == this->end())
+ || (__hint != this->end() && (++__hint == __res
+ || ++__res == --__hint)));
}
};
^ permalink raw reply [flat|nested] 16+ messages in thread
* Profile mode maintenance patch
@ 2014-09-21 21:29 François Dumont
2014-09-23 11:27 ` Jonathan Wakely
0 siblings, 1 reply; 16+ messages in thread
From: François Dumont @ 2014-09-21 21:29 UTC (permalink / raw)
To: libstdc++, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 1931 bytes --]
Hi
Here is the promise major patch for the profile mode. Here are the
most important modifications.
Now instance of profiling structs are kept as pointers in the
containers themselves. It has an impact on the container ABI but it
greatly enhance performances as we do not need to move through a search
in an unordered container which also imply a lock during this research.
I have even been able to remove those unordered containers eventually
just keeping a counter of allocated bytes to know if we should stop
creating new profiling structs.
I get rid of the re-entrancy mechanism. The only reason for it was
a potential hook in the memory allocator potentially creating new
profiling structs and so long forever. I prefer to put it just where it
is necessary that is to say when we first allocate memory for profiling
which is then we create the back-trace.
I wonder if we shouldn't emit a #error when trying to activate
profiling mode without backtrace feature cause in this case we simply
won't collect anything.
I finalize ordered to unordered profiling by adding the missing
__iterator_tracker on the ordered containers (map, multimap, set, multiset).
I clean all useless stuff like __stack_info_base class.
I fixed many memory leak and added a cleanup at exit of the
application.
Profiling of containers is reseted as soon as one of the following
operations occur: copy assignment, move assignment, initialization from
an initialization list, clear.
I have added usage of atomic operations to maintain some counters
that might be updated from different threads. Do not hesitate to review
those closely. Especially __objects_byte_size which I am using in
profiler_trace.h without atomic operation, is it fine ?
With all those modifications I have been able to run all testsuite
in profile mode with success.
Ok to commit ?
François
[-- Attachment #2: profile.patch.bz2 --]
[-- Type: application/x-bzip, Size: 15946 bytes --]
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: Profile mode maintenance patch
2014-09-21 21:29 Profile " François Dumont
@ 2014-09-23 11:27 ` Jonathan Wakely
2014-09-23 21:20 ` François Dumont
2014-10-04 20:54 ` François Dumont
0 siblings, 2 replies; 16+ messages in thread
From: Jonathan Wakely @ 2014-09-23 11:27 UTC (permalink / raw)
To: François Dumont; +Cc: libstdc++, gcc-patches
On 21/09/14 23:29 +0200, François Dumont wrote:
> With all those modifications I have been able to run all testsuite
>in profile mode with success.
I've looked over the patch and it looks fine.
I don't know the details of the Profile Mode, so if you're happy that
these changes are an improvement and all tests pass then that's good
enough for me.
> Ok to commit ?
Yes, OK for trunk - thanks very much.
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: Profile mode maintenance patch
2014-09-23 11:27 ` Jonathan Wakely
@ 2014-09-23 21:20 ` François Dumont
2014-09-23 22:45 ` Jonathan Wakely
2014-10-04 20:54 ` François Dumont
1 sibling, 1 reply; 16+ messages in thread
From: François Dumont @ 2014-09-23 21:20 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: libstdc++, gcc-patches
On 23/09/2014 13:27, Jonathan Wakely wrote:
> On 21/09/14 23:29 +0200, François Dumont wrote:
>> With all those modifications I have been able to run all testsuite
>> in profile mode with success.
>
> I've looked over the patch and it looks fine.
>
> I don't know the details of the Profile Mode, so if you're happy that
> these changes are an improvement and all tests pass then that's good
> enough for me.
>
>> Ok to commit ?
>
> Yes, OK for trunk - thanks very much.
>
>
Ok but could you just let me know what you think of this method:
template<typename __object_info, typename __stack_info>
__object_info*
__trace_base<__object_info, __stack_info>::
__add_object(const __object_info& __info)
{
if (__max_mem() != 0 && __objects_byte_size >= __max_mem())
{
delete __info.__stack();
return 0;
}
__object_info* __ret = new(std::nothrow) __object_info(__info);
if (!__ret)
{
delete __info.__stack();
return 0;
}
__gnu_cxx::__atomic_add(&__objects_byte_size, sizeof(__object_info));
return __ret;
}
This method can be called from several threads. I check condition
accessing __object_byte_size and then update it with an atomic operation
to make sure it stays consistent. Does it look ok to you too ?
François
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: Profile mode maintenance patch
2014-09-23 21:20 ` François Dumont
@ 2014-09-23 22:45 ` Jonathan Wakely
0 siblings, 0 replies; 16+ messages in thread
From: Jonathan Wakely @ 2014-09-23 22:45 UTC (permalink / raw)
To: François Dumont; +Cc: Jonathan Wakely, libstdc++, gcc-patches
On 23 September 2014 22:19, François Dumont wrote:
> On 23/09/2014 13:27, Jonathan Wakely wrote:
>>
>> On 21/09/14 23:29 +0200, François Dumont wrote:
>>>
>>> With all those modifications I have been able to run all testsuite in
>>> profile mode with success.
>>
>>
>> I've looked over the patch and it looks fine.
>>
>> I don't know the details of the Profile Mode, so if you're happy that
>> these changes are an improvement and all tests pass then that's good
>> enough for me.
>>
>>> Ok to commit ?
>>
>>
>> Yes, OK for trunk - thanks very much.
>>
>>
>
> Ok but could you just let me know what you think of this method:
>
> template<typename __object_info, typename __stack_info>
> __object_info*
> __trace_base<__object_info, __stack_info>::
> __add_object(const __object_info& __info)
> {
> if (__max_mem() != 0 && __objects_byte_size >= __max_mem())
> {
> delete __info.__stack();
> return 0;
> }
>
> __object_info* __ret = new(std::nothrow) __object_info(__info);
> if (!__ret)
> {
> delete __info.__stack();
> return 0;
> }
>
> __gnu_cxx::__atomic_add(&__objects_byte_size, sizeof(__object_info));
> return __ret;
> }
>
> This method can be called from several threads. I check condition accessing
> __object_byte_size and then update it with an atomic operation to make sure
> it stays consistent. Does it look ok to you too ?
It can result in a data race if the non-atomic access happens
concurrently with the atomic update.
The read should be an atomic load to solve that, but we don't have a
dispatch function in <ext/atomicity.h> for atomic loads.
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: Profile mode maintenance patch
2014-09-23 11:27 ` Jonathan Wakely
2014-09-23 21:20 ` François Dumont
@ 2014-10-04 20:54 ` François Dumont
2014-10-06 9:28 ` Jonathan Wakely
1 sibling, 1 reply; 16+ messages in thread
From: François Dumont @ 2014-10-04 20:54 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: libstdc++, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 930 bytes --]
On 23/09/2014 13:27, Jonathan Wakely wrote:
>
> Yes, OK for trunk - thanks very much.
>
Hi
There was in fact one last test failing, ext/profile/mh.cc, a
profile mode specific test. It must have been failing for quite a while
since malloc hooks has been deprecated. It is normally testing the
profile mode protection against recursion if memory allocation functions
are redefined. It was based on malloc but we use in fact new operator.
So I rewrite the test using new/delete operators.
This new test version is attached, I removed those 2 lines at the
beginning:
// { dg-do compile { target *-*-linux* *-*-gnu* } }
// { dg-xfail-if "" { uclibc } { "*" } { "" } }
I think that this test can now be executed and see no reason why it
should fail with uclibc. Do you confirm ?
I attached the full patch again. I also remove useless virtual
destructor or methods, no need for polymorphism.
François
[-- Attachment #2: profile.patch.bz2 --]
[-- Type: application/x-bzip, Size: 17339 bytes --]
[-- Attachment #3: mh.cc --]
[-- Type: text/x-c++src, Size: 1355 bytes --]
// -*- C++ -*-
// Copyright (C) 2006-2014 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// { dg-require-profile-mode "" }
#include <vector>
using std::vector;
void* operator new(std::size_t size) throw(std::bad_alloc)
{
void* p = std::malloc(size);
if (!p)
throw std::bad_alloc();
return p;
}
void* operator new (std::size_t size, const std::nothrow_t&) throw()
{
// With _GLIBCXX_PROFILE, the instrumentation of the vector constructor
// will call back into this new operator.
vector<int> v;
return std::malloc(size);
}
void operator delete(void* p) throw()
{
if (p)
std::free(p);
}
int
main()
{
vector<int> v;
return 0;
}
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: Profile mode maintenance patch
2014-10-04 20:54 ` François Dumont
@ 2014-10-06 9:28 ` Jonathan Wakely
0 siblings, 0 replies; 16+ messages in thread
From: Jonathan Wakely @ 2014-10-06 9:28 UTC (permalink / raw)
To: François Dumont; +Cc: libstdc++, gcc-patches
On 04/10/14 22:54 +0200, François Dumont wrote:
>On 23/09/2014 13:27, Jonathan Wakely wrote:
>>
>>Yes, OK for trunk - thanks very much.
>>
>Hi
>
> There was in fact one last test failing, ext/profile/mh.cc, a
>profile mode specific test. It must have been failing for quite a
>while since malloc hooks has been deprecated.
I don't understand why that would make it fail, deprecated doesn't
mean it doesn't work.
However, the declaration of __malloc_initialize_hook has changed at
some point between glibc 2.11 and 2.18, so the test doesn't compile
for me on Fedora 20.
Secondly, the test is useless if it isn't actually run, so the
{ dg-do compile } must be removed.
Finally, the test returns 1, so even if it is executed it causes a
FAIL.
What a mess.
>It is normally testing
>the profile mode protection against recursion if memory allocation
>functions are redefined. It was based on malloc but we use in fact new
>operator. So I rewrite the test using new/delete operators.
OK.
> This new test version is attached, I removed those 2 lines at the
>beginning:
>
>// { dg-do compile { target *-*-linux* *-*-gnu* } }
>// { dg-xfail-if "" { uclibc } { "*" } { "" } }
>
> I think that this test can now be executed and see no reason why
>it should fail with uclibc. Do you confirm ?
Yes, the test should be portable now, and should actually PASS.
The name of the test doesn't make much sense now though, maybe rename
it from mh.cc to replace_new.cc or something.
> I attached the full patch again. I also remove useless virtual
>destructor or methods, no need for polymorphism.
OK.
(I still think we should just remove the whole Profile Mode ...)
^ permalink raw reply [flat|nested] 16+ messages in thread
end of thread, other threads:[~2014-10-06 9:28 UTC | newest]
Thread overview: 16+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-05-12 20:15 profile mode maintenance patch François Dumont
2014-05-12 20:44 ` Paolo Carlini
2014-05-12 20:50 ` François Dumont
2014-05-23 20:32 ` libstdc++ automake version François Dumont
2014-05-23 20:37 ` Tim Shen
2014-05-23 20:52 ` Paolo Carlini
2014-05-24 11:33 ` profile mode maintenance patch Jonathan Wakely
2014-05-24 21:10 ` François Dumont
2014-05-24 21:39 ` Jonathan Wakely
2014-05-25 8:34 ` Paolo Carlini
2014-09-21 21:29 Profile " François Dumont
2014-09-23 11:27 ` Jonathan Wakely
2014-09-23 21:20 ` François Dumont
2014-09-23 22:45 ` Jonathan Wakely
2014-10-04 20:54 ` François Dumont
2014-10-06 9:28 ` Jonathan Wakely
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).