This is the mail archive of the
libstdc++@gcc.gnu.org
mailing list for the libstdc++ project.
profile mode maintenance patch
- From: François Dumont <frs dot dumont at gmail dot com>
- To: "libstdc++ at gcc dot gnu dot org" <libstdc++ at gcc dot gnu dot org>, gcc-patches <gcc-patches at gcc dot gnu dot org>
- Date: Mon, 12 May 2014 22:14:58 +0200
- Subject: profile mode maintenance patch
- Authentication-results: sourceware.org; auth=none
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
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>