Nabble - gcc - libstdc++

Re: Bug in GCC 4.5 c++0x version of std::list::merge(&&)?

2009-12-08T00:38:05Z

2009/12/8 Jonathan Wakely:

> 2009/12/8 Benjamin Redelings I:
>> Hi,
>
> Hi,
> I've CC'd the libstdc++ list, please reply there instead of the gcc list.
>
>> It seems that many current uses of list<T>::merge( ) fail to compile with
>> -std=c++0x, but I don't see a bug in bugzilla for this. Itseems to result
>> from:
>>
>> list<_Tp, _Alloc>::
>> #ifdef __GXX_EXPERIMENTAL_CXX0X__
>> merge(list&& __x)
>> #else
>> merge(list& __x)
>> #endif
>>
>> For c++0x, don't we need BOTH versions, since lvalues no longer bind to
>> rvalue references, or am I missing something?
>
> The WP only has:
> void merge(list<T,Allocator>&& x);
> template <class Compare> void merge(list<T,Allocator>&& x, Compare comp);
>
> See http://home.roadrunner.com/~hinnant/issue_review/lwg-active.html#1133
> which covers a similar issue with splice.

I've requested that overloads of list::merge be added as well, watch
that issue to see the outcome.

Jonathan

Re: Bug in GCC 4.5 c++0x version of std::list::merge(&&)?

2009-12-08T00:26:42Z

2009/12/8 Benjamin Redelings I:
> Hi,

Hi,
I've CC'd the libstdc++ list, please reply there instead of the gcc list.

> It seems that many current uses of list<T>::merge( ) fail to compile with
> -std=c++0x, but I don't see a bug in bugzilla for this. Itseems to result
> from:
>
> list<_Tp, _Alloc>::
> #ifdef __GXX_EXPERIMENTAL_CXX0X__
> merge(list&& __x)
> #else
> merge(list& __x)
> #endif
>
> For c++0x, don't we need BOTH versions, since lvalues no longer bind to
> rvalue references, or am I missing something?

The WP only has:
void merge(list<T,Allocator>&& x);
template <class Compare> void merge(list<T,Allocator>&& x, Compare comp);

See http://home.roadrunner.com/~hinnant/issue_review/lwg-active.html#1133
which covers a similar issue with splice.

Jonathan

Re: [profile-stdlib] PATCH: Add three diagnostics and implement cost factor parameterization

2009-12-07T14:15:08Z

On Sun, Dec 6, 2009 at 7:38 PM, Changhee Jung <haemil99@...> wrote:
> Hello libstdc++ maintainers,
>

Hello maintainers,

Can this still make it to 4.5, given that it affects only the profile
mode? If so, could you review it as a patch to trunk instead of
branch? There are no other changes on the profile-stdlib branch since
the last merge to trunk, except for very minor fixes.

Thank you,
Silvius

> The attached patch implements the following in the profile-stdlib branch:
> 1) New diagnostics
> - list-to-vector; if data is inserted at the end of the list and
> iteration operation is common, vector is better.
> - list-to-slist; slist is more likely to fit in a cache line due to
> less memory usage.
> - list-to-set; if a find operation, 'std::find', is frequently used
> in the list, set is better.
> 2) Cost factor parameterization; constant factors of the cost models
> for diagnostics can be read from a file, "libstdcxx-profile.conf" or
> environment variables.
>
> There is an issue related to thel instrumentation of 'std::find'.
> It seems that 'bits/stl_algo.h' was modified for the parallel mode so
> that its functions declared in the namespace of '_GLIBCXX_STD_P' can
> be used instead of original functions in the release mode.
> Currently, I did the same thing, conditional compilation stuff, to
> hide the original 'find' function under its wrapper function.
>
> This inevitably causes a modification to the original 'bits/stl_algo.h'.
> Alternatively, it is possible to duplicate the 'bits/stl_algo.h' in
> 'profile/stl_algo.h' and modify the copy to avoid any intrusion from
> the profile mode to the release mode.
> It would be appreciated if you come up with a better idea to deal with this.
>
> Thank you,
> Changhee
>

[v3] Fix libstdc++/42319

2009-12-07T06:29:38Z

Hi,

tested x86_64-linux, committed to mainline.

Paolo.

////////////////////

2009-12-07 Paolo Carlini <paolo.carlini@...>

PR libstdc++/42319
* include/parallel/losertree.h: Include bits/stl_function.h instead
of the whole <functional>.
* include/parallel/base.h: Likewise.
* include/parallel/numeric: Likewise.
* include/parallel/balanced_quicksort.h: Likewise.
* include/parallel/checkers.h: Likewise.
* testsuite/17_intro/headers/c++200x/42319.cc: New.

Index: include/parallel/losertree.h
===================================================================
--- include/parallel/losertree.h (revision 155034)
+++ include/parallel/losertree.h (working copy)
@@ -32,9 +32,8 @@
#ifndef _GLIBCXX_PARALLEL_LOSERTREE_H
#define _GLIBCXX_PARALLEL_LOSERTREE_H 1

-#include <functional>
-
#include <bits/stl_algobase.h>
+#include <bits/stl_function.h>
#include <parallel/features.h>
#include <parallel/base.h>

Index: include/parallel/base.h
===================================================================
--- include/parallel/base.h (revision 155034)
+++ include/parallel/base.h (working copy)
@@ -32,13 +32,13 @@
#ifndef _GLIBCXX_PARALLEL_BASE_H
#define _GLIBCXX_PARALLEL_BASE_H 1

-#include <functional>
+#include <bits/c++config.h>
+#include <bits/stl_function.h>
#include <omp.h>
#include <parallel/features.h>
#include <parallel/basic_iterator.h>
#include <parallel/parallel.h>

-
// Parallel mode namespaces.

/**
Index: include/parallel/numeric
===================================================================
--- include/parallel/numeric (revision 155034)
+++ include/parallel/numeric (working copy)
@@ -39,7 +39,7 @@
#define _GLIBCXX_PARALLEL_NUMERIC_H 1

#include <numeric>
-#include <functional>
+#include <bits/stl_function.h>
#include <parallel/numericfwd.h>
#include <parallel/iterator.h>
#include <parallel/for_each.h>
Index: include/parallel/balanced_quicksort.h
===================================================================
--- include/parallel/balanced_quicksort.h (revision 155034)
+++ include/parallel/balanced_quicksort.h (working copy)
@@ -44,12 +44,12 @@

#include <parallel/basic_iterator.h>
#include <bits/stl_algo.h>
+#include <bits/stl_function.h>

#include <parallel/settings.h>
#include <parallel/partition.h>
#include <parallel/random_number.h>
#include <parallel/queue.h>
-#include <functional>

#if _GLIBCXX_ASSERTIONS
#include <parallel/checkers.h>
Index: include/parallel/checkers.h
===================================================================
--- include/parallel/checkers.h (revision 155034)
+++ include/parallel/checkers.h (working copy)
@@ -32,9 +32,9 @@
#ifndef _GLIBCXX_PARALLEL_CHECKERS_H
#define _GLIBCXX_PARALLEL_CHECKERS_H 1

-#include <functional>
#include <cstdio>
#include <bits/stl_algobase.h>
+#include <bits/stl_function.h>

namespace __gnu_parallel
{
Index: testsuite/17_intro/headers/c++200x/42319.cc
===================================================================
--- testsuite/17_intro/headers/c++200x/42319.cc (revision 0)
+++ testsuite/17_intro/headers/c++200x/42319.cc (revision 0)
@@ -0,0 +1,22 @@
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// libstdc++/42319
+#include <bits/char_traits.h>

Re: [profile-stdlib] PATCH: Add three diagnostics and implement cost factor parameterization

2009-12-07T00:18:33Z

Hi Changee,

Some initial comments, I'll take another look later.

I noticed a few formatting issues in
libstdc++-v3/include/profile/iterator_tracker.h - overlong lines, and
"public:" indented incorrectly.

The doxygen comment for profile/algorithm says:
/** @file parallel/algorithm

This include guard is not in the correct format:
#ifndef PROFCXX_PROFILER_LIST_TO_SLIST_H
That could clash with a user header (I don't like the format used by
the other profile headers, with two trailing underscores, but that
seems to be the form used consistently.)

This is wrong:
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(vector&& __x)
+#else
swap(vector& __x)
+#endif

vector::swap() does not work with rvalues now, the same goes for

+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ template<typename _Tp, typename _Alloc>
+ inline void
+ swap(vector<_Tp, _Alloc>&& __lhs, vector<_Tp, _Alloc>& __rhs)
+ { __lhs.swap(__rhs); }
+
+ template<typename _Tp, typename _Alloc>
+ inline void
+ swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>&& __rhs)
+ { __lhs.swap(__rhs); }
+#endif

Regards,
Jonathan

[profile-stdlib] PATCH: Add three diagnostics and implement cost factor parameterization

2009-12-06T19:38:29Z

Hello libstdc++ maintainers,

The attached patch implements the following in the profile-stdlib branch:
1) New diagnostics
- list-to-vector; if data is inserted at the end of the list and
iteration operation is common, vector is better.
- list-to-slist; slist is more likely to fit in a cache line due to
less memory usage.
- list-to-set; if a find operation, 'std::find', is frequently used
in the list, set is better.
2) Cost factor parameterization; constant factors of the cost models
for diagnostics can be read from a file, "libstdcxx-profile.conf" or
environment variables.

There is an issue related to thel instrumentation of 'std::find'.
It seems that 'bits/stl_algo.h' was modified for the parallel mode so
that its functions declared in the namespace of '_GLIBCXX_STD_P' can
be used instead of original functions in the release mode.
Currently, I did the same thing, conditional compilation stuff, to
hide the original 'find' function under its wrapper function.

This inevitably causes a modification to the original 'bits/stl_algo.h'.
Alternatively, it is possible to duplicate the 'bits/stl_algo.h' in
'profile/stl_algo.h' and modify the copy to avoid any intrusion from
the profile mode to the release mode.
It would be appreciated if you come up with a better idea to deal with this.

Thank you,
Changhee

[profile-stdlib-20091206.patch]

Index: libstdc++-v3/include/Makefile.in =================================================================== --- libstdc++-v3/include/Makefile.in (revision 155023) +++ libstdc++-v3/include/Makefile.in (working copy) @@ -1014,6 +1014,9 @@ profile_srcdir = ${glibcxx_srcdir}/include/profile profile_builddir = ./profile profile_headers = \ + ${profile_srcdir}/algo.h \ + ${profile_srcdir}/algorithm \ + ${profile_srcdir}/iterator_tracker.h \ ${profile_srcdir}/base.h \ ${profile_srcdir}/unordered_map \ ${profile_srcdir}/unordered_set \ @@ -1041,7 +1044,10 @@ ${profile_impl_srcdir}/profiler_state.h \ ${profile_impl_srcdir}/profiler_trace.h \ ${profile_impl_srcdir}/profiler_vector_size.h \ - ${profile_impl_srcdir}/profiler_vector_to_list.h + ${profile_impl_srcdir}/profiler_vector_to_list.h \ + ${profile_impl_srcdir}/profiler_list_to_slist.h \ + ${profile_impl_srcdir}/profiler_list_to_vector.h \ + ${profile_impl_srcdir}/profiler_list_to_set.h @GLIBCXX_C_HEADERS_EXTRA_FALSE@c_base_headers_extra = Index: libstdc++-v3/include/std/algorithm =================================================================== --- libstdc++-v3/include/std/algorithm (revision 155023) +++ libstdc++-v3/include/std/algorithm (working copy) @@ -65,4 +65,8 @@ # include <parallel/algorithm> #endif +#ifdef _GLIBCXX_PROFILE +# include <profile/algorithm> +#endif + #endif /* _GLIBCXX_ALGORITHM */ Index: libstdc++-v3/include/profile/algorithm =================================================================== --- libstdc++-v3/include/profile/algorithm (revision 0) +++ libstdc++-v3/include/profile/algorithm (revision 0) @@ -0,0 +1,38 @@ +// Algorithm extensions -*- C++ -*- + +// Copyright (C) 2009 +// 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 and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file parallel/algorithm + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _PROFILE_ALGORITHM +#define _PROFILE_ALGORITHM 1 + +#pragma GCC system_header + +#include <algorithm> +#include <profile/algo.h> + +#endif Index: libstdc++-v3/include/profile/iterator_tracker.h =================================================================== --- libstdc++-v3/include/profile/iterator_tracker.h (revision 0) +++ libstdc++-v3/include/profile/iterator_tracker.h (revision 0) @@ -0,0 +1,271 @@ +#ifndef _GLIBCXX_ITERATOR_TRACKER +#define _GLIBCXX_ITERATOR_TRACKER 1 + +namespace std +{ +namespace __profile +{ + +template<typename _Iterator, typename _Sequence> +class __iterator_tracker +{ + typedef __iterator_tracker _Self; + // The underlying iterator + _Iterator _M_current; + // The underlying data structure + const _Sequence* _M_ds; + 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; + + __iterator_tracker() : _M_current(), _M_ds(0) { } + __iterator_tracker(const _Iterator& __i, const _Sequence* seq) + : _M_current(__i), _M_ds(seq) { } + __iterator_tracker(const __iterator_tracker& __x) + : _M_current(__x._M_current), _M_ds(__x._M_ds) { } + template<typename _MutableIterator> + __iterator_tracker(const __iterator_tracker<_MutableIterator, typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator, typename _Sequence::iterator::_Base_iterator>::__value), _Sequence>::__type>& __x) + : _M_current(__x.base()), _M_ds(__x._M_get_sequence()) { } + + _Iterator + base() const { return _M_current; } + /** + * @brief Conversion to underlying non-debug iterator to allow + * better interaction with non-profile containers. + */ + operator _Iterator() const { return _M_current; } + + pointer + operator->() const { return &*_M_current; } + + __iterator_tracker& + operator++() + { + _M_ds->_M_profile_iterate(); + ++_M_current; + return *this; + } + + __iterator_tracker& + operator++(int) + { + _M_ds->_M_profile_iterate(); + __iterator_tracker __tmp(*this); + ++_M_current; + return __tmp; + } + + __iterator_tracker& + operator--() + { + _M_ds->_M_profile_iterate(1); + --_M_current; + return *this; + } + + __iterator_tracker& + operator--(int) + { + _M_ds->_M_profile_iterate(1); + __iterator_tracker __tmp(*this); + --_M_current; + return __tmp; + } + + __iterator_tracker& + operator=(const __iterator_tracker& __x) + { + _M_current = __x._M_current; + return *this; + } + + reference + operator*() const + { + return *_M_current; + } + + // ------ Random access iterator requirements ------ + reference + operator[](const difference_type& __n) const + { + return _M_current[__n]; + } + + __iterator_tracker& + operator+=(const difference_type& __n) + { + _M_current += __n; + return *this; + } + + __iterator_tracker + operator+(const difference_type& __n) const + { + __iterator_tracker __tmp(*this); + __tmp += __n; + return __tmp; + } + + __iterator_tracker& + operator-=(const difference_type& __n) + { + _M_current += -__n; + return *this; + } + + __iterator_tracker + operator-(const difference_type& __n) const + { + __iterator_tracker __tmp(*this); + __tmp -= __n; + return __tmp; + } + + void + _M_find() + { + _M_ds->_M_profile_find(); + } + + const _Sequence* + _M_get_sequence() const + { + return static_cast<const _Sequence*>(_M_ds); + } +}; + +template<typename _IteratorL, typename _IteratorR, typename _Sequence> +inline bool +operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) +{ + return __lhs.base() == __rhs.base(); +} + +template<typename _Iterator, typename _Sequence> +inline bool +operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) +{ + return __lhs.base() == __rhs.base(); +} + +template<typename _IteratorL, typename _IteratorR, typename _Sequence> +inline bool +operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) +{ + return __lhs.base() != __rhs.base(); +} + +template<typename _Iterator, typename _Sequence> +inline bool +operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) +{ + return __lhs.base() != __rhs.base(); +} + +template<typename _IteratorL, typename _IteratorR, typename _Sequence> +inline bool +operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) +{ + return __lhs.base() < __rhs.base(); +} + +template<typename _Iterator, typename _Sequence> +inline bool +operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) +{ + return __lhs.base() < __rhs.base(); +} + +template<typename _IteratorL, typename _IteratorR, typename _Sequence> +inline bool +operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) +{ + return __lhs.base() <= __rhs.base(); +} + +template<typename _Iterator, typename _Sequence> +inline bool +operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) +{ + return __lhs.base() <= __rhs.base(); +} + +template<typename _IteratorL, typename _IteratorR, typename _Sequence> +inline bool +operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) +{ + return __lhs.base() > __rhs.base(); +} + +template<typename _Iterator, typename _Sequence> +inline bool +operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) +{ + return __lhs.base() > __rhs.base(); +} + +template<typename _IteratorL, typename _IteratorR, typename _Sequence> +inline bool +operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) +{ + return __lhs.base() >= __rhs.base(); +} + +template<typename _Iterator, typename _Sequence> +inline bool +operator>=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) +{ + return __lhs.base() >= __rhs.base(); +} + +// _GLIBCXX_RESOLVE_LIB_DEFECTS +// According to the resolution of DR179 not only the various comparison +// operators but also operator- must accept mixed iterator/const_iterator +// parameters. + template<typename _IteratorL, typename _IteratorR, typename _Sequence> + inline typename __iterator_tracker<_IteratorL, _Sequence>::difference_type + operator-(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) +{ + return __lhs.base() - __rhs.base(); +} + +template<typename _Iterator, typename _Sequence> +inline typename __iterator_tracker<_Iterator, _Sequence>::difference_type +operator-(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) +{ + return __lhs.base() - __rhs.base(); +} + +template<typename _Iterator, typename _Sequence> +inline __iterator_tracker<_Iterator, _Sequence> +operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type + __n, + const __iterator_tracker<_Iterator, _Sequence>& __i) +{ + return __i + __n; +} + +} // namespace __profile +} // namespace std +#endif Index: libstdc++-v3/include/profile/impl/profiler_list_to_set.h =================================================================== --- libstdc++-v3/include/profile/impl/profiler_list_to_set.h (revision 0) +++ libstdc++-v3/include/profile/impl/profiler_list_to_set.h (revision 0) @@ -0,0 +1,283 @@ +// -*- C++ -*- +// +// Copyright (C) 2008 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 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_list_to_set.h + * @brief diagnostics for list to set. + */ + +// Written by Changhee Jung. + +#ifndef PROFCXX_PROFILER_LIST_TO_SET_H__ +#define PROFCXX_PROFILER_LIST_TO_SET_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include <cstdio> +#include <cstdlib> +#include <cstring> +#else +#include <stdio.h> +#include <stdint.h> +#include <string.h> +#endif +#include <string> +#include <sstream> +#include <math.h> +#include "profile/impl/profiler.h" +#include "profile/impl/profiler_node.h" +#include "profile/impl/profiler_trace.h" + +static inline int __log2(size_t __size) +{ + for (int __bit_count = sizeof(size_t) - 1; __bit_count >= 0; --__bit_count) { + if ((2 << __bit_count) & __size) { + return __bit_count; + } + } + return 0; +} + +namespace __cxxprof_impl +{ + +inline float __set_insert_cost(size_t __size) +{ + return __tables<0>::__set_insert_cost_factor * static_cast<float>( + __log2(__size)); +} + +inline float __set_find_cost(size_t __size) +{ + return __tables<0>::__set_find_cost_factor * static_cast<float>( + __log2(__size)); +} + + +/** @brief A list-to-set instrumentation line in the object table. */ +class __list2set_info: public __object_info_base +{ + public: + __list2set_info() + : _M_insert(0), _M_find(0), _M_list_cost(0.0), + _M_set_cost(0.0), _M_valid(true) {} + __list2set_info(__stack_t __stack) + : __object_info_base(__stack), _M_insert(0), _M_find(0), + _M_list_cost(0.0), _M_set_cost(0.0), _M_valid(true) {} + virtual ~__list2set_info() {} + __list2set_info(const __list2set_info& __o); + void __merge(const __list2set_info& __o); + void __write(FILE* __f) const; + float __magnitude() const { return _M_list_cost - _M_set_cost; } + const char* __advice() const { return "change std::list to std::set"; } + float __list_cost() { return _M_list_cost; } + void __set_list_cost(float __lc) { _M_list_cost = __lc; } + void __set_set_cost(float __vc) { _M_set_cost = __vc; } + bool __is_valid() { return _M_valid; } + void __set_invalid() { _M_valid = false; } + void __opr_insert(size_t __size, size_t __count); + void __opr_find(size_t __size); + +private: + size_t _M_insert; + size_t _M_find; + float _M_list_cost; + float _M_set_cost; + bool _M_valid; +}; + +inline __list2set_info::__list2set_info(const __list2set_info& __o) + : __object_info_base(__o) +{ + _M_insert = __o._M_insert; + _M_find = __o._M_find; + _M_set_cost = __o._M_set_cost; + _M_list_cost = __o._M_list_cost; + _M_valid = __o._M_valid; +} + +inline void __list2set_info::__merge(const __list2set_info& __o) +{ + _M_insert += __o._M_insert; + _M_find += __o._M_find; + _M_set_cost += __o._M_set_cost; + _M_list_cost += __o._M_list_cost; + _M_valid &= __o._M_valid; +} + +inline void __list2set_info::__opr_insert(size_t __size, size_t __count) +{ + _M_insert += __count; + _M_list_cost += __count * __tables<0>::__list_insert_cost; + _M_set_cost += __count * __set_insert_cost(__size); +} + +inline void __list2set_info::__opr_find(size_t __size) +{ + _M_insert += 1; + // Use avererage case complexity rathen than worst case one + _M_list_cost += 3.0/4.0*__size * __tables<0>::__list_find_cost; + _M_set_cost += __set_find_cost(__size); +} + +class __list2set_stack_info: public __list2set_info { + public: + __list2set_stack_info(const __list2set_info& __o) + : __list2set_info(__o) {} +}; + +class __trace_list_to_set + : public __trace_base<__list2set_info, __list2set_stack_info> +{ + public: + __trace_list_to_set(); + ~__trace_list_to_set() {} + + // Insert a new node at construct with object, callstack and initial size. + void __insert(__object_t __obj, __stack_t __stack); + // Call at destruction/clean to set container final size. + void __destruct(const void* __obj); + + // Find the node in the live map. + __list2set_info* __find(const void* __obj); + + // Collect cost of operations. + void __opr_insert(const void* __obj, size_t __size, size_t __count); + void __invalid_operator(const void* __obj); + void __opr_find(const void* __obj, size_t __size); +}; + +inline __trace_list_to_set::__trace_list_to_set() + : __trace_base<__list2set_info, __list2set_stack_info>() +{ + __id = "list-to-set"; +} + +inline void __trace_list_to_set::__insert(__object_t __obj, + __stack_t __stack) +{ + __add_object(__obj, __list2set_info(__stack)); +} + +inline void __list2set_info::__write(FILE* __f) const +{ + + fprintf(__f, "%Zu %Zu %.0f %.0f %s\n", + _M_insert, _M_find, _M_list_cost, _M_set_cost, + _M_valid ? "valid" : "invalid"); +} + +inline void __trace_list_to_set::__destruct(const void* __obj) +{ + if (!__is_on()) + return; + + __list2set_info* __res = __get_object_info(__obj); + if (!__res) + return; + + __retire_object(__obj); +} + +inline void __trace_list_to_set::__opr_insert(const void* __obj, size_t __size, + size_t __count) +{ + __list2set_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_insert(__size, __count); +} + +inline void __trace_list_to_set::__invalid_operator(const void* __obj) +{ + __list2set_info* __res = __get_object_info(__obj); + if (__res) + __res->__set_invalid(); +} + +inline void __trace_list_to_set::__opr_find(const void* __obj, size_t __size) +{ + __list2set_info* __res = __get_object_info(__obj); + if (__res) { + __res->__opr_find(__size); + } +} + +////////////////////////////////////////////////////////////////////////////// +// Initialization and report. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_list_to_set_init() +{ + __tables<0>::_S_list_to_set = new __trace_list_to_set(); +} + +inline void __trace_list_to_set_report(FILE* __f, + __warning_vector_t& __warnings) +{ + if (__tables<0>::_S_list_to_set) { + __tables<0>::_S_list_to_set->__collect_warnings(__warnings); + __tables<0>::_S_list_to_set->__write(__f); + } +} + +////////////////////////////////////////////////////////////////////////////// +// Implementations of instrumentation hooks. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_list_to_set_construct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_set->__insert(__obj, __get_stack()); +} + +inline void __trace_list_to_set_destruct(const void* __obj) +{ + + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_set->__destruct(__obj); +} + +inline void __trace_list_to_set_insert(const void* __obj, size_t __size, + size_t __count = 1) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_set->__opr_insert(__obj, __size, __count); +} + +inline void __trace_list_to_set_find(const void* __obj, size_t __size) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_set->__opr_find(__obj, __size); +} + +} // namespace __cxxprof_impl +#endif /* PROFCXX_PROFILER_LIST_TO_SET_H__ */ Index: libstdc++-v3/include/profile/impl/profiler_list_to_slist.h =================================================================== --- libstdc++-v3/include/profile/impl/profiler_list_to_slist.h (revision 0) +++ libstdc++-v3/include/profile/impl/profiler_list_to_slist.h (revision 0) @@ -0,0 +1,190 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 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 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_list_to_slist.h + * @brief Diagnostics for list to slist. + */ + +// Written by Changhee Jung. + +#ifndef PROFCXX_PROFILER_LIST_TO_SLIST_H +#define PROFCXX_PROFILER_LIST_TO_SLIST_H 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include <cstdlib> +#include <cstdio> +#include <cstring> +#else +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#endif +#include "profile/impl/profiler.h" +#include "profile/impl/profiler_node.h" +#include "profile/impl/profiler_trace.h" + +namespace __cxxprof_impl +{ + +class __list2slist_info: public __object_info_base +{ + public: + __list2slist_info() : _M_rewind(false), _M_operations(0) {} + __list2slist_info(__stack_t __stack) + : _M_rewind(false), _M_operations(0),__object_info_base(__stack) {} + virtual ~__list2slist_info() {} + __list2slist_info(const __list2slist_info& __o) : __object_info_base(__o) + { _M_rewind = __o._M_rewind; _M_operations = __o._M_operations; } + // XXX: the magnitude should be multiplied with a constant factor F, + // where F is 1 when the malloc size class of list nodes is different + // from the malloc size class of slist nodes. When they fall into the same + // class, the only slist benefit is from having to set fewer links, so + // the factor F should be much smaller, closer to 0 than to 1. + // This could be implemented by passing the size classes in the config file. + // For now, we always assume F to be 1. + float __magnitude() const + { if (!_M_rewind) return _M_operations; else return 0; } + void __merge(const __list2slist_info& __o) {}; + void __write(FILE* __f) const; + const char* __advice() const + { return "change std::list to std::forward_list or __gnu_cxx::slist"; } + void __opr_rewind() { _M_rewind = true; _M_valid = false;} + void __record_operation() { _M_operations++; } + bool __has_rewind() { return _M_rewind; } + +private: + bool _M_rewind; + size_t _M_operations; +}; + +class __list2slist_stack_info: public __list2slist_info { + public: + __list2slist_stack_info(const __list2slist_info& __o) + : __list2slist_info(__o) {} +}; + +class __trace_list_to_slist + : public __trace_base<__list2slist_info, __list2slist_stack_info> +{ + public: + ~__trace_list_to_slist() {} + __trace_list_to_slist() + : __trace_base<__list2slist_info, __list2slist_stack_info>() + { __id = "list-to-slist"; } + void __opr_rewind(const void* __obj); + void __record_operation(const void* __obj); + void __insert(const __object_t __obj, __stack_t __stack) + { __add_object(__obj, __list2slist_info(__stack)); } + void __destruct(const void* __obj); +}; + +inline void __list2slist_info::__write(FILE* __f) const +{ + fprintf(__f, "%s\n", _M_rewind ? "invalid" : "valid"); +} + +inline void __trace_list_to_slist::__destruct(const void* __obj) +{ + if (!__is_on()) + return; + + __list2slist_info* __res = __get_object_info(__obj); + if (!__res) + return; + + __retire_object(__obj); +} + +////////////////////////////////////////////////////////////////////////////// +// Initialization and report. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_list_to_slist_init() +{ + __tables<0>::_S_list_to_slist = new __trace_list_to_slist(); +} + +inline void __trace_list_to_slist_report(FILE* __f, + __warning_vector_t& __warnings) +{ + if (__tables<0>::_S_list_to_slist) { + __tables<0>::_S_list_to_slist->__collect_warnings(__warnings); + __tables<0>::_S_list_to_slist->__write(__f); + } +} + +inline void __trace_list_to_slist::__opr_rewind(const void* __obj) +{ + __list2slist_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_rewind(); +} + +inline void __trace_list_to_slist::__record_operation(const void* __obj) +{ + __list2slist_info* __res = __get_object_info(__obj); + if (__res) + __res->__record_operation(); +} + +////////////////////////////////////////////////////////////////////////////// +// Implementations of instrumentation hooks. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_list_to_slist_rewind(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_slist->__opr_rewind(__obj); +} + +inline void __trace_list_to_slist_operation(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_slist->__record_operation(__obj); +} + +inline void __trace_list_to_slist_construct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_slist->__insert(__obj, __get_stack()); +} + +inline void __trace_list_to_slist_destruct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_slist->__destruct(__obj); +} + +} // namespace __cxxprof_impl +#endif /* PROFCXX_PROFILER_LIST_TO_SLIST_H */ Index: libstdc++-v3/include/profile/impl/profiler_trace.h =================================================================== --- libstdc++-v3/include/profile/impl/profiler_trace.h (revision 155023) +++ libstdc++-v3/include/profile/impl/profiler_trace.h (working copy) @@ -54,6 +54,8 @@ #endif #include <algorithm> +#include <fstream> +#include <string> #include <utility> #if defined _GLIBCXX_PROFILE_THREADS && defined HAVE_TLS @@ -132,15 +134,24 @@ class __trace_map2umap; class __trace_vector_size; class __trace_vector_to_list; +class __trace_list_to_slist; +class __trace_list_to_vector; +class __trace_list_to_set; void __trace_vector_size_init(); void __trace_hashtable_size_init(); void __trace_hash_func_init(); void __trace_vector_to_list_init(); +void __trace_list_to_slist_init(); +void __trace_list_to_vector_init(); +void __trace_list_to_set_init(); void __trace_map_to_unordered_map_init(); void __trace_vector_size_report(FILE*, __warning_vector_t&); void __trace_hashtable_size_report(FILE*, __warning_vector_t&); void __trace_hash_func_report(FILE*, __warning_vector_t&); void __trace_vector_to_list_report(FILE*, __warning_vector_t&); +void __trace_list_to_slist_report(FILE*, __warning_vector_t&); +void __trace_list_to_vector_report(FILE*, __warning_vector_t&); +void __trace_list_to_set_report(FILE*, __warning_vector_t&); void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&); // Utility functions. @@ -164,6 +175,33 @@ static __trace_map2umap* _S_map2umap; static __trace_vector_size* _S_vector_size; static __trace_vector_to_list* _S_vector_to_list; + static __trace_list_to_slist* _S_list_to_slist; + static __trace_list_to_vector* _S_list_to_vector; + static __trace_list_to_set* _S_list_to_set; + + static float __vector_shift_cost_factor; + static float __vector_iterate_cost_factor; + static float __vector_resize_cost_factor; + + static float __list_shift_cost_factor; + static float __list_iterate_cost_factor; + static float __list_resize_cost_factor; + + static float __set_insert_cost_factor; + static float __set_find_cost_factor; + + static float __list_insert_cost; + static float __list_find_cost ; + + static float __map_insert_cost_factor ; + static float __map_erase_cost_factor ; + static float __map_find_cost_factor ; + static float __map_iterate_cost; + + static float __umap_insert_cost; + static float __umap_erase_cost ; + static float __umap_find_cost ; + static float __umap_iterate_cost; }; template <int _Unused> @@ -176,7 +214,55 @@ __trace_vector_size* __tables<_Unused>::_S_vector_size = NULL; template <int _Unused> __trace_vector_to_list* __tables<_Unused>::_S_vector_to_list = NULL; +template <int _Unused> +__trace_list_to_slist* __tables<_Unused>::_S_list_to_slist = NULL; +template <int _Unused> +__trace_list_to_vector* __tables<_Unused>::_S_list_to_vector = NULL; +template <int _Unused> +__trace_list_to_set* __tables<_Unused>::_S_list_to_set = NULL; +template <int _Unused> +float __tables<_Unused>::__vector_shift_cost_factor = 1; +template <int _Unused> +float __tables<_Unused>::__vector_iterate_cost_factor = 1; +template <int _Unused> +float __tables<_Unused>::__vector_resize_cost_factor = 1; + +template <int _Unused> +float __tables<_Unused>::__list_shift_cost_factor = 0; +template <int _Unused> +float __tables<_Unused>::__list_iterate_cost_factor = 10; +template <int _Unused> +float __tables<_Unused>::__list_resize_cost_factor = 0; + +template <int _Unused> +float __tables<_Unused>::__set_insert_cost_factor = 1.2; +template <int _Unused> +float __tables<_Unused>::__set_find_cost_factor = 1.0; + +template <int _Unused> +float __tables<_Unused>::__list_insert_cost = 1.0; +template <int _Unused> +float __tables<_Unused>::__list_find_cost = 1.0; + +template <int _Unused> +float __tables<_Unused>::__map_insert_cost_factor = 1.5; +template <int _Unused> +float __tables<_Unused>::__map_erase_cost_factor = 1.5; +template <int _Unused> +float __tables<_Unused>::__map_find_cost_factor = 1; +template <int _Unused> +float __tables<_Unused>::__map_iterate_cost = 2.3; + +template <int _Unused> +float __tables<_Unused>::__umap_insert_cost = 12.0; +template <int _Unused> +float __tables<_Unused>::__umap_erase_cost = 12.0; +template <int _Unused> +float __tables<_Unused>::__umap_find_cost = 10.0; +template <int _Unused> +float __tables<_Unused>::__umap_iterate_cost = 1.7; + /** @brief Storage for user defined parameters. Has only static fields. */ template <int _Unused=0> class __settings { @@ -439,7 +525,6 @@ size_t root_len = strlen(__settings<0>::_S_trace_file_name); size_t ext_len = strlen(extension); char* file_name = new char[root_len + 1 + ext_len + 1]; - char* p = file_name; memcpy(file_name, __settings<0>::_S_trace_file_name, root_len); *(file_name + root_len) = '.'; memcpy(file_name + root_len + 1, extension, ext_len + 1); @@ -470,6 +555,9 @@ __trace_hashtable_size_report(__raw_file, __warnings); __trace_hash_func_report(__raw_file, __warnings); __trace_vector_to_list_report(__raw_file, __warnings); + __trace_list_to_slist_report(__raw_file, __warnings); + __trace_list_to_vector_report(__raw_file, __warnings); + __trace_list_to_set_report(__raw_file, __warnings); __trace_map_to_unordered_map_report(__raw_file, __warnings); fclose(__raw_file); @@ -512,6 +600,82 @@ } } +inline void __read_cost_factors() +{ + std::string conf_file_name(__settings<0>::_S_trace_file_name); + conf_file_name += ".conf"; + + std::ifstream __conf_file( conf_file_name.c_str()); + + if (__conf_file.is_open()) { + std::string line; + + while (getline ( __conf_file, line) ) { + std::string::size_type i = line.find_first_not_of ( " \t\n\v" ); + + if (line.length() <= 0 || line[i] == '#') { + // Skip empty lines or comments. + continue; + } + + // Trim. + line.erase(remove(line.begin(), line.end(), ' '), line.end()); + std::string::size_type pos = line.find("="); + std::string __factor_name = line.substr(0, pos); + std::string::size_type end = line.find_first_of(";\n"); + std::string __factor_value = line.substr(pos + 1, end - pos); + + setenv(__factor_name.c_str(), __factor_value.c_str(), 0); + } + } +} + +inline void __set_cost_factors() +{ + char* __env_cost_factor; + if (__env_cost_factor = getenv("__vector_shift_cost_factor")) + __tables<0>::__vector_shift_cost_factor = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__vector_iterate_cost_factor")) + __tables<0>::__vector_iterate_cost_factor = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__vector_resize_cost_factor")) + __tables<0>::__vector_resize_cost_factor = atof(__env_cost_factor); + + if (__env_cost_factor = getenv("__list_shift_cost_factor")) + __tables<0>::__list_shift_cost_factor = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__list_iterate_cost_factor")) + __tables<0>::__list_iterate_cost_factor = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__list_resize_cost_factor")) + __tables<0>::__list_resize_cost_factor = atof(__env_cost_factor); + + if (__env_cost_factor = getenv("__set_insert_cost_factor")) + __tables<0>::__set_insert_cost_factor = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__set_find_cost_factor")) + __tables<0>::__set_find_cost_factor = atof(__env_cost_factor); + + if (__env_cost_factor = getenv("__list_insert_cost")) + __tables<0>::__list_insert_cost = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__list_find_cost")) + __tables<0>::__list_find_cost = atof(__env_cost_factor); + + if (__env_cost_factor = getenv("__map_insert_cost_factor")) + __tables<0>::__map_insert_cost_factor = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__map_erase_cost_factor")) + __tables<0>::__map_erase_cost_factor = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__map_find_cost_factor")) + __tables<0>::__map_find_cost_factor = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__map_iterate_cost")) + __tables<0>::__map_iterate_cost = atof(__env_cost_factor); + + if (__env_cost_factor = getenv("__umap_insert_cost")) + __tables<0>::__umap_insert_cost = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__umap_erase_cost")) + __tables<0>::__umap_erase_cost = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__umap_find_cost")) + __tables<0>::__umap_find_cost = atof(__env_cost_factor); + if (__env_cost_factor = getenv("__umap_iterate_cost")) + __tables<0>::__umap_iterate_cost = atof(__env_cost_factor); +} + inline void __profcxx_init_unconditional() { __mutex<0>::__lock(__mutex<0>::__global_lock); @@ -529,11 +693,16 @@ __set_max_stack_trace_depth(); __set_max_mem(); __set_trace_path(); + __read_cost_factors(); + __set_cost_factors(); __trace_vector_size_init(); __trace_hashtable_size_init(); __trace_hash_func_init(); __trace_vector_to_list_init(); + __trace_list_to_slist_init(); + __trace_list_to_vector_init(); + __trace_list_to_set_init(); __trace_map_to_unordered_map_init(); atexit(__report); Index: libstdc++-v3/include/profile/impl/profiler_vector_to_list.h =================================================================== --- libstdc++-v3/include/profile/impl/profiler_vector_to_list.h (revision 155023) +++ libstdc++-v3/include/profile/impl/profiler_vector_to_list.h (working copy) @@ -28,8 +28,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/** @file profile/impl/profiler_trace.h - * @brief Data structures to represent profiling traces. +/** @file profile/impl/profiler_vector_to_list.h + * @brief diagnostics for vector to list. */ // Written by Lixia Liu and Silvius Rus. @@ -80,8 +80,9 @@ void __set_invalid() { _M_valid = false; } void __opr_insert(size_t __pos, size_t __num); - void __opr_iterate(size_t __num) { _M_iterate += __num; } + void __opr_iterate(size_t __num); void __resize(size_t __from, size_t __to); + void __opr_find(size_t __size); private: size_t _M_shift_count; @@ -123,6 +124,17 @@ _M_resize += __from; } +inline void __vector2list_info::__opr_iterate(size_t __num) +{ + _M_iterate += __num; +} + +inline void __vector2list_info::__opr_find(size_t __size) +{ + // Use average case complexity + _M_iterate += 3.0 / 4.0 * __size; +} + /** @brief A vector-to-list instrumentation line in the stack table. */ class __vector2list_stack_info: public __vector2list_info { public: @@ -153,6 +165,8 @@ void __resize(const void* __obj, size_t __from, size_t __to); float __vector_cost(size_t __shift, size_t __iterate, size_t __resize); float __list_cost(size_t __shift, size_t __iterate, size_t __resize); + void __opr_find(const void* __obj, size_t __size); + }; inline __trace_vector_to_list::__trace_vector_to_list() @@ -176,25 +190,29 @@ // Cost model. XXX: get this from the cost model database instead. // Vector operation cost: // - Cost per shift: 1 -// - Cost per access: 1 +// - Cost per iterate: 1 // - Cost per resize: 1 // List operation cost: // - Cost per shift: 0 -// - Cost per access: 10 +// - Cost per iterate: 10 // - Cost per resize: 0 inline float __trace_vector_to_list::__vector_cost(size_t __shift, size_t __iterate, size_t __resize) { - return __shift * 1 + __iterate * 1 + __resize * 1; + return __shift * __tables<0>::__vector_shift_cost_factor + + __iterate * __tables<0>::__vector_iterate_cost_factor + + __resize * __tables<0>::__vector_resize_cost_factor; } inline float __trace_vector_to_list::__list_cost(size_t __shift, size_t __iterate, size_t __resize) { - return __shift * 0 + __iterate * 10 + __resize * 0; + return __shift * __tables<0>::__list_shift_cost_factor + + __iterate * __tables<0>::__list_iterate_cost_factor + + __resize * __tables<0>::__list_resize_cost_factor; } inline void __trace_vector_to_list::__destruct(const void* __obj) @@ -247,6 +265,14 @@ __res->__resize(__from, __to); } +inline void __trace_vector_to_list::__opr_find(const void* __obj, + size_t __size) +{ + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_find(__size); +} + ////////////////////////////////////////////////////////////////////////////// // Initialization and report. ////////////////////////////////////////////////////////////////////////////// @@ -292,7 +318,7 @@ } -inline void __trace_vector_to_list_iterate(const void* __obj, size_t __num) +inline void __trace_vector_to_list_iterate(const void* __obj, size_t __num = 1) { if (!__profcxx_init()) return; @@ -314,5 +340,12 @@ __tables<0>::_S_vector_to_list->__resize(__obj, __from, __to); } +inline void __trace_vector_to_list_find(const void* __obj, size_t __size) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_vector_to_list->__opr_find(__obj, __size); +} + } // namespace __cxxprof_impl #endif /* PROFCXX_PROFILER_VECTOR_TO_LIST_H__ */ Index: libstdc++-v3/include/profile/impl/profiler_list_to_vector.h =================================================================== --- libstdc++-v3/include/profile/impl/profiler_list_to_vector.h (revision 0) +++ libstdc++-v3/include/profile/impl/profiler_list_to_vector.h (revision 0) @@ -0,0 +1,320 @@ +// -*- C++ -*- +// +// Copyright (C) 2009 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 2, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. + +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/** @file profile/impl/profiler_list_to_vector.h + * @brief diagnostics for list to vector. + */ + +// Written by Changhee Jung. + +#ifndef PROFCXX_PROFILER_LIST_TO_VECTOR_H__ +#define PROFCXX_PROFILER_LIST_TO_VECTOR_H__ 1 + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include <cstdio> +#include <cstdlib> +#include <cstring> +#else +#include <stdio.h> +#include <stdint.h> +#include <string.h> +#endif +#include <string> +#include <sstream> +#include "profile/impl/profiler.h" +#include "profile/impl/profiler_node.h" +#include "profile/impl/profiler_trace.h" + +namespace __cxxprof_impl +{ + +/** @brief A list-to-vector instrumentation line in the object table. */ +class __list2vector_info: public __object_info_base +{ + public: + __list2vector_info() + :_M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0), + _M_vector_cost(0), _M_valid(true), _M_max_size(0) {} + __list2vector_info(__stack_t __stack) + : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0), + _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true), + _M_max_size(0) {} + virtual ~__list2vector_info() {} + __list2vector_info(const __list2vector_info& __o); + void __merge(const __list2vector_info& __o); + void __write(FILE* __f) const; + float __magnitude() const { return _M_list_cost - _M_vector_cost; } + const char* __advice() const; + size_t __shift_count() { return _M_shift_count; } + size_t __iterate() { return _M_iterate; } + float __list_cost() { return _M_list_cost; } + size_t __resize() { return _M_resize; } + void __set_list_cost(float __lc) { _M_list_cost = __lc; } + void __set_vector_cost(float __vc) { _M_vector_cost = __vc; } + bool __is_valid() { return _M_valid; } + void __set_invalid() { _M_valid = false; } + + void __opr_insert(size_t __shift, size_t __size); + void __opr_iterate(size_t __num) { _M_iterate += __num;} + + void __resize(size_t __from, size_t __to); + +private: + size_t _M_shift_count; + size_t _M_iterate; + size_t _M_resize; + float _M_list_cost; + float _M_vector_cost; + bool _M_valid; + size_t _M_max_size; +}; + +inline __list2vector_info::__list2vector_info(const __list2vector_info& __o) + : __object_info_base(__o) +{ + _M_shift_count = __o._M_shift_count; + _M_iterate = __o._M_iterate; + _M_vector_cost = __o._M_vector_cost; + _M_list_cost = __o._M_list_cost; + _M_valid = __o._M_valid; + _M_resize = __o._M_resize; + _M_max_size = __o._M_max_size; +} + +inline const char* __list2vector_info::__advice() const { + std::stringstream __sstream; + __sstream + << "change std::list to std::vector and its initial size from 0 to " + << _M_max_size; + return __sstream.str().c_str(); +} + +inline void __list2vector_info::__merge(const __list2vector_info& __o) +{ + _M_shift_count += __o._M_shift_count; + _M_iterate += __o._M_iterate; + _M_vector_cost += __o._M_vector_cost; + _M_list_cost += __o._M_list_cost; + _M_valid &= __o._M_valid; + _M_resize += __o._M_resize; + _M_max_size = __max( _M_max_size, __o._M_max_size); +} + +inline void __list2vector_info::__opr_insert(size_t __shift, size_t __size) +{ + _M_shift_count += __shift; + _M_max_size = __max(_M_max_size, __size); +} + +inline void __list2vector_info::__resize(size_t __from, size_t __to) +{ + _M_resize += __from; +} + +class __list2vector_stack_info: public __list2vector_info { + public: + __list2vector_stack_info(const __list2vector_info& __o) + : __list2vector_info(__o) {} +}; + +class __trace_list_to_vector + : public __trace_base<__list2vector_info, __list2vector_stack_info> +{ + public: + __trace_list_to_vector(); + ~__trace_list_to_vector() {} + + // Insert a new node at construct with object, callstack and initial size. + void __insert(__object_t __obj, __stack_t __stack); + // Call at destruction/clean to set container final size. + void __destruct(const void* __obj); + + // Find the node in the live map. + __list2vector_info* __find(const void* __obj); + + // Collect cost of operations. + void __opr_insert(const void* __obj, size_t __shift, size_t __size); + void __opr_iterate(const void* __obj, size_t __num); + void __invalid_operator(const void* __obj); + void __resize(const void* __obj, size_t __from, size_t __to); + float __vector_cost(size_t __shift, size_t __iterate); + float __list_cost(size_t __shift, size_t __iterate); +}; + +inline __trace_list_to_vector::__trace_list_to_vector() + : __trace_base<__list2vector_info, __list2vector_stack_info>() +{ + __id = "list-to-vector"; +} + +inline void __trace_list_to_vector::__insert(__object_t __obj, + __stack_t __stack) +{ + __add_object(__obj, __list2vector_info(__stack)); +} + +inline void __list2vector_info::__write(FILE* __f) const +{ + fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", + _M_shift_count, _M_resize, _M_iterate, _M_vector_cost, _M_list_cost); +} + +inline float __trace_list_to_vector::__vector_cost(size_t __shift, + size_t __iterate) +{ + // The resulting vector will use a 'reserve' method. + return __shift * __tables<0>::__vector_shift_cost_factor + + __iterate * __tables<0>::__vector_iterate_cost_factor ; +} + +inline float __trace_list_to_vector::__list_cost(size_t __shift, + size_t __iterate) +{ + return __shift * __tables<0>::__list_shift_cost_factor + + __iterate * __tables<0>::__list_iterate_cost_factor ; +} + +inline void __trace_list_to_vector::__destruct(const void* __obj) +{ + if (!__is_on()) + return; + + __list2vector_info* __res = __get_object_info(__obj); + if (!__res) + return; + + float __vc = __vector_cost(__res->__shift_count(), __res->__iterate()); + float __lc = __list_cost(__res->__shift_count(), __res->__iterate()); + __res->__set_vector_cost(__vc); + __res->__set_list_cost(__lc); + __retire_object(__obj); +} + +inline void __trace_list_to_vector::__opr_insert(const void* __obj, + size_t __shift, size_t __size) +{ + __list2vector_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_insert(__shift, __size); +} + +inline void __trace_list_to_vector::__opr_iterate(const void* __obj, + size_t __num) +{ + __list2vector_info* __res = __get_object_info(__obj); + if (__res) { + __res->__opr_iterate(__num); + } +} + +inline void __trace_list_to_vector::__invalid_operator(const void* __obj) +{ + __list2vector_info* __res = __get_object_info(__obj); + if (__res) + __res->__set_invalid(); +} + +inline void __trace_list_to_vector::__resize(const void* __obj, size_t __from, + size_t __to) +{ + __list2vector_info* __res = __get_object_info(__obj); + if (__res) + __res->__resize(__from, __to); +} + +////////////////////////////////////////////////////////////////////////////// +// Initialization and report. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_list_to_vector_init() +{ + __tables<0>::_S_list_to_vector = new __trace_list_to_vector(); +} + +inline void __trace_list_to_vector_report(FILE* __f, + __warning_vector_t& __warnings) +{ + if (__tables<0>::_S_list_to_vector) { + __tables<0>::_S_list_to_vector->__collect_warnings(__warnings); + __tables<0>::_S_list_to_vector->__write(__f); + } +} + +////////////////////////////////////////////////////////////////////////////// +// Implementations of instrumentation hooks. +////////////////////////////////////////////////////////////////////////////// + +inline void __trace_list_to_vector_construct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_vector->__insert(__obj, __get_stack()); +} + +inline void __trace_list_to_vector_destruct(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_vector->__destruct(__obj); +} + +inline void __trace_list_to_vector_insert(const void* __obj, + size_t __shift, size_t __size) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_vector->__opr_insert(__obj, __shift, __size); +} + + +inline void __trace_list_to_vector_iterate(const void* __obj, size_t __num = 1) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_vector->__opr_iterate(__obj, __num); +} + +inline void __trace_list_to_vector_invalid_operator(const void* __obj) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_vector->__invalid_operator(__obj); +} + +inline void __trace_list_to_vector_resize(const void* __obj, + size_t __from, size_t __to) +{ + if (!__profcxx_init()) return; + + __tables<0>::_S_list_to_vector->__resize(__obj, __from, __to); +} + +} // namespace __cxxprof_impl +#endif /* PROFCXX_PROFILER_LIST_TO_VECTOR_H__ */ Index: libstdc++-v3/include/profile/impl/profiler.h =================================================================== --- libstdc++-v3/include/profile/impl/profiler.h (revision 155023) +++ libstdc++-v3/include/profile/impl/profiler.h (working copy) @@ -120,6 +120,27 @@ void __trace_vector_to_list_iterate(const void*, size_t); void __trace_vector_to_list_invalid_operator(const void*); void __trace_vector_to_list_resize(const void*, size_t, size_t); +void __trace_vector_to_list_find(const void*, size_t); + +void __trace_list_to_slist_destruct(const void*); +void __trace_list_to_slist_construct(const void*); +void __trace_list_to_slist_rewind(const void*); +void __trace_list_to_slist_operation(const void*); + +void __trace_list_to_vector_destruct(const void*); +void __trace_list_to_vector_construct(const void*); +void __trace_list_to_vector_insert(const void*, size_t, size_t); +void __trace_list_to_vector_iterate(const void*, size_t); +void __trace_list_to_vector_invalid_operator(const void*); +void __trace_list_to_vector_resize(const void*, size_t, size_t); + +void __trace_list_to_set_destruct(const void*); +void __trace_list_to_set_construct(const void*); +void __trace_list_to_set_insert(const void*, size_t, size_t); +void __trace_list_to_set_iterate(const void*, size_t); +void __trace_list_to_set_invalid_operator(const void*); +void __trace_list_to_set_find(const void*, size_t); + void __trace_map_to_unordered_map_construct(const void*); void __trace_map_to_unordered_map_invalidate(const void*); void __trace_map_to_unordered_map_insert(const void*, size_t, size_t); @@ -129,16 +150,39 @@ void __trace_map_to_unordered_map_destruct(const void*); } // namespace __cxxprof_impl -// Master switch turns on all diagnostics. +// Master switch turns on all diagnostics that are not explicitly turned off. #ifdef _GLIBCXX_PROFILE +#ifndef _GLIBCXX_PROFILE_NO_HASHTABLE_TOO_SMALL #define _GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL +#endif +#ifndef _GLIBCXX_PROFILE_NO_HASHTABLE_TOO_LARGE #define _GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE +#endif +#ifndef _GLIBCXX_PROFILE_NO_VECTOR_TOO_SMALL #define _GLIBCXX_PROFILE_VECTOR_TOO_SMALL +#endif +#ifndef _GLIBCXX_PROFILE_NO_VECTOR_TOO_LARGE #define _GLIBCXX_PROFILE_VECTOR_TOO_LARGE +#endif +#ifndef _GLIBCXX_PROFILE_NO_INEFFICIENT_HASH #define _GLIBCXX_PROFILE_INEFFICIENT_HASH +#endif +#ifndef _GLIBCXX_PROFILE_NO_VECTOR_TO_LIST #define _GLIBCXX_PROFILE_VECTOR_TO_LIST +#endif +#ifndef _GLIBCXX_PROFILE_NO_LIST_TO_SLIST +#define _GLIBCXX_PROFILE_LIST_TO_SLIST +#endif +#ifndef _GLIBCXX_PROFILE_NO_LIST_TO_VECTOR +#define _GLIBCXX_PROFILE_LIST_TO_VECTOR +#endif +#ifndef _GLIBCXX_PROFILE_NO_LIST_TO_SET +#define _GLIBCXX_PROFILE_LIST_TO_SET +#endif +#ifndef _GLIBCXX_PROFILE_NO_MAP_TO_UNORDERED_MAP #define _GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP #endif +#endif // Expose global management routines to user code. #ifdef _GLIBCXX_PROFILE @@ -164,10 +208,8 @@ #endif // Turn on/off instrumentation for HASHTABLE_TOO_SMALL and HASHTABLE_TOO_LARGE. -#if ((defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL) \ - && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL)) \ - || (defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE) \ - && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE))) +#if (defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL) \ + || defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE)) #define __profcxx_hashtable_resize(__x...) \ _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ __cxxprof_impl::__trace_hashtable_size_resize(__x)) @@ -184,10 +226,8 @@ #endif // Turn on/off instrumentation for VECTOR_TOO_SMALL and VECTOR_TOO_LARGE. -#if ((defined(_GLIBCXX_PROFILE_VECTOR_TOO_SMALL) \ - && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_SMALL)) \ - || (defined(_GLIBCXX_PROFILE_VECTOR_TOO_LARGE) \ - && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_LARGE))) +#if (defined(_GLIBCXX_PROFILE_VECTOR_TOO_SMALL) \ + || defined(_GLIBCXX_PROFILE_VECTOR_TOO_LARGE)) #define __profcxx_vector_resize(__x...) \ _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ __cxxprof_impl::__trace_vector_size_resize(__x)) @@ -204,8 +244,7 @@ #endif // Turn on/off instrumentation for INEFFICIENT_HASH. -#if (defined(_GLIBCXX_PROFILE_INEFFICIENT_HASH) \ - && !defined(_NO_GLIBCXX_PROFILE_INEFFICIENT_HASH)) +#if defined(_GLIBCXX_PROFILE_INEFFICIENT_HASH) #define __profcxx_hashtable_construct2(__x...) \ _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ __cxxprof_impl::__trace_hash_func_construct(__x)) @@ -218,8 +257,7 @@ #endif // Turn on/off instrumentation for VECTOR_TO_LIST. -#if (defined(_GLIBCXX_PROFILE_VECTOR_TO_LIST) \ - && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TO_LIST)) +#if defined(_GLIBCXX_PROFILE_VECTOR_TO_LIST) #define __profcxx_vector_construct2(__x...) \ _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ __cxxprof_impl::__trace_vector_to_list_construct(__x)) @@ -238,6 +276,9 @@ #define __profcxx_vector_resize2(__x...) \ _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ __cxxprof_impl::__trace_vector_to_list_resize(__x)) +#define __profcxx_vector_find(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_vector_to_list_find(__x)) #else #define __profcxx_vector_destruct2(__x...) #define __profcxx_vector_construct2(__x...) @@ -245,11 +286,78 @@ #define __profcxx_vector_iterate(__x...) #define __profcxx_vector_invalid_operator(__x...) #define __profcxx_vector_resize2(__x...) +#define __profcxx_vector_find(__x...) #endif +// Turn on/off instrumentation for LIST_TO_VECTOR. +#if defined(_GLIBCXX_PROFILE_LIST_TO_VECTOR) +#define __profcxx_list_construct2(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_vector_construct(__x)) +#define __profcxx_list_destruct2(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_vector_destruct(__x)) +#define __profcxx_list_insert(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_vector_insert(__x)) +#define __profcxx_list_iterate(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_vector_iterate(__x)) +#define __profcxx_list_invalid_operator(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_vector_invalid_operator(__x)) +#else +#define __profcxx_list_destruct2(__x...) +#define __profcxx_list_construct2(__x...) +#define __profcxx_list_insert(__x...) +#define __profcxx_list_iterate(__x...) +#define __profcxx_list_invalid_operator(__x...) +#endif + +// Turn on/off instrumentation for LIST_TO_SLIST. +#if defined(_GLIBCXX_PROFILE_LIST_TO_SLIST) +#define __profcxx_list_rewind(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_slist_rewind(__x)) +#define __profcxx_list_operation(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_slist_operation(__x)) +#define __profcxx_list_destruct(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_slist_destruct(__x)) +#define __profcxx_list_construct(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_slist_construct(__x)) +#else +#define __profcxx_list_rewind(__x...) +#define __profcxx_list_operation(__x...) +#define __profcxx_list_destruct(__x...) +#define __profcxx_list_construct(__x...) +#endif + +// Turn on/off instrumentation for LIST_TO_SET. +#if defined(_GLIBCXX_PROFILE_LIST_TO_SET) +#define __profcxx_list_construct3(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_set_construct(__x)) +#define __profcxx_list_destruct3(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_set_destruct(__x)) +#define __profcxx_list_insert3(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_set_insert(__x)) +#define __profcxx_list_find3(__x...) \ + _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ + __cxxprof_impl::__trace_list_to_set_find(__x)) +#else +#define __profcxx_list_destruct3(__x...) +#define __profcxx_list_construct3(__x...) +#define __profcxx_list_insert3(__x...) +#define __profcxx_list_find3(__x...) +#endif + // Turn on/off instrumentation for MAP_TO_UNORDERED_MAP. -#if (defined(_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP) \ - && !defined(_NO_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP)) +#if defined(_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP) #define __profcxx_map_to_unordered_map_construct(__x...) \ _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \ __cxxprof_impl::__trace_map_to_unordered_map_construct(__x)) @@ -322,5 +430,8 @@ #include "profile/impl/profiler_map_to_unordered_map.h" #include "profile/impl/profiler_vector_size.h" #include "profile/impl/profiler_vector_to_list.h" +#include "profile/impl/profiler_list_to_slist.h" +#include "profile/impl/profiler_list_to_vector.h" +#include "profile/impl/profiler_list_to_set.h" #endif // PROFCXX_PROFILER_H__ Index: libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h =================================================================== --- libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h (revision 155023) +++ libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h (working copy) @@ -53,31 +53,10 @@ namespace __cxxprof_impl { -// Cost model. XXX: this must be taken from the machine model instead. -// Map operations: -// - insert: 1.5 * log(size) -// - erase: 1.5 * log(size) -// - find: log(size) -// - iterate: 2.3 -// Unordered map operations: -// - insert: 12 -// - erase: 12 -// - find: 10 -// - iterate: 1.7 - -const float __map_insert_cost_factor = 1.5; -const float __map_erase_cost_factor = 1.5; -const float __map_find_cost_factor = 1; -const float __map_iterate_cost = 2.3; - -const float __umap_insert_cost = 12.0; -const float __umap_erase_cost = 12.0; -const float __umap_find_cost = 10.0; -const float __umap_iterate_cost = 1.7; - inline int __log2(size_t __size) { - for (int __bit_count = sizeof(size_t) - 1; __bit_count >= 0; --__bit_count) { + for (int __bit_count = sizeof(size_t) - 1; __bit_count >= 0; -- __bit_count) + { if ((2 << __bit_count) & __size) { return __bit_count; } @@ -87,17 +66,20 @@ inline float __map_insert_cost(size_t __size) { - return __map_insert_cost_factor * static_cast<float>(__log2(__size)); + return __tables<0>::__map_insert_cost_factor * static_cast<float>( + __log2(__size)); } inline float __map_erase_cost(size_t __size) { - return __map_erase_cost_factor * static_cast<float>(__log2(__size)); + return __tables<0>::__map_erase_cost_factor * static_cast<float>( + __log2(__size)); } inline float __map_find_cost(size_t __size) { - return __map_find_cost_factor * static_cast<float>(__log2(__size)); + return __tables<0>::__map_find_cost_factor * static_cast<float>( + __log2(__size)); } /** @brief A map-to-unordered_map instrumentation line in the object table. */ @@ -163,28 +145,28 @@ { _M_insert += __count; _M_map_cost += __count * __map_insert_cost(__size); - _M_umap_cost += __count * __umap_insert_cost; + _M_umap_cost += __count * __tables<0>::__umap_insert_cost; } inline void __map2umap_info:: __record_erase(size_t __size, size_t __count) { _M_erase += __count; _M_map_cost += __count * __map_erase_cost(__size); - _M_umap_cost += __count * __umap_erase_cost; + _M_umap_cost += __count * __tables<0>::__umap_erase_cost; } inline void __map2umap_info:: __record_find(size_t __size) { _M_find += 1; _M_map_cost += __map_find_cost(__size); - _M_umap_cost += __umap_find_cost; + _M_umap_cost += __tables<0>::__umap_find_cost; } inline void __map2umap_info:: __record_iterate(size_t __count) { _M_iterate += __count; - _M_map_cost += __count * __map_iterate_cost; - _M_umap_cost += __count * __umap_iterate_cost; + _M_map_cost += __count * __tables<0>::__map_iterate_cost; + _M_umap_cost += __count * __tables<0>::__umap_iterate_cost; } inline void __map2umap_info:: __record_invalidate() Index: libstdc++-v3/include/profile/vector =================================================================== --- libstdc++-v3/include/profile/vector (revision 155023) +++ libstdc++-v3/include/profile/vector (working copy) @@ -37,12 +37,12 @@ #include <vector> #include <utility> #include <profile/base.h> +#include <profile/iterator_tracker.h> namespace std { namespace __profile { - /** @brief Vector wrapper with performance instrumentation. */ template<typename _Tp, typename _Allocator = std::allocator<_Tp> > class vector @@ -54,17 +54,21 @@ 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 __iterator_tracker<typename _Base::iterator, vector> + iterator; + typedef __iterator_tracker<typename _Base::const_iterator, vector> + const_iterator; typedef typename _Base::size_type size_type; typedef typename _Base::difference_type difference_type; - typedef _Tp value_type; - typedef _Allocator allocator_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; + _Base& _M_base() { return *this; } @@ -157,6 +161,58 @@ using _Base::assign; using _Base::get_allocator; + + // iterators: + iterator + begin() + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const + { return const_iterator(_Base::begin(), this); } + + iterator + end() + { return iterator(_Base::end(), this); } + + const_iterator + end() const + { return const_iterator(_Base::end(), this); } + + reverse_iterator + rbegin() + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + const_iterator + cbegin() const + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const + { return const_iterator(_Base::end(), this); } + + const_reverse_iterator + crbegin() const + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const + { return const_reverse_iterator(begin()); } +#endif + // 23.2.4.2 capacity: using _Base::size; using _Base::max_size; @@ -225,6 +281,15 @@ } #ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename... _Args> + iterator + emplace(iterator __position, _Args&&... __args) + { + typename _Base::iterator __res = _Base::emplace(__position.base(), + std::forward<_Args>(__args)...); + return iterator(__res, this); + } + void push_back(_Tp&& __x) { @@ -238,22 +303,24 @@ iterator insert(iterator __position, const _Tp& __x) { - __profcxx_vector_insert(this, __position-_Base::begin(), this->size()); + __profcxx_vector_insert(this, __position.base() - _Base::begin(), + this->size()); size_type __old_size = this->capacity(); - typename _Base::iterator __res = _Base::insert(__position,__x); + typename _Base::iterator __res = _Base::insert(__position.base(), __x); _M_profile_resize(this, __old_size, this->capacity()); - return __res; + return iterator(__res, this); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ iterator insert(iterator __position, _Tp&& __x) { - __profcxx_vector_insert(this, __position-_Base::begin(), this->size()); + __profcxx_vector_insert(this, __position.base() - _Base::begin(), + this->size()); size_type __old_size = this->capacity(); - typename _Base::iterator __res = _Base::insert(__position,__x); + typename _Base::iterator __res = _Base::insert(__position.base(), __x); _M_profile_resize(this, __old_size, this->capacity()); - return __res; + return iterator(__res, this); } void @@ -262,8 +329,11 @@ #endif void - +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + swap(vector&& __x) +#else swap(vector& __x) +#endif { _Base::swap(__x); } @@ -272,9 +342,10 @@ void insert(iterator __position, size_type __n, const _Tp& __x) { - __profcxx_vector_insert(this, __position-_Base::begin(), this->size()); + __profcxx_vector_insert(this, __position.base() - _Base::begin(), + this->size()); size_type __old_size = this->capacity(); - _Base::insert(__position, __n, __x); + _Base::insert(__position.base(), __n, __x); _M_profile_resize(this, __old_size, this->capacity()); } @@ -283,12 +354,31 @@ insert(iterator __position, _InputIterator __first, _InputIterator __last) { - __profcxx_vector_insert(this, __position-_Base::begin(), this->size()); + __profcxx_vector_insert(this, __position.base()-_Base::begin(), + this->size()); size_type __old_size = this->capacity(); - _Base::insert(__position, __first, __last); + _Base::insert(__position.base(), __first, __last); _M_profile_resize(this, __old_size, this->capacity()); } + + iterator + erase(iterator __position) + { + typename _Base::iterator __res = _Base::erase(__position.base()); + return iterator(__res, this); + } + + iterator + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + typename _Base::iterator __res = _Base::erase(__first.base(), + __last.base()); + return iterator(__res, this); + } + void clear() { @@ -297,17 +387,14 @@ _Base::clear(); } - // iterators: - iterator - begin() + inline void _M_profile_find() const { - return _Base::begin(); + __profcxx_vector_find(this, size()); } - const_iterator - begin() const + inline void _M_profile_iterate(int __rewind = 0) const { - return _Base::begin(); + __profcxx_vector_iterate(this); } private: @@ -362,6 +449,18 @@ swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs) { __lhs.swap(__rhs); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp, typename _Alloc> + inline void + swap(vector<_Tp, _Alloc>&& __lhs, vector<_Tp, _Alloc>& __rhs) + { __lhs.swap(__rhs); } + + template<typename _Tp, typename _Alloc> + inline void + swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>&& __rhs) + { __lhs.swap(__rhs); } +#endif + } // namespace __profile using _GLIBCXX_STD_D::_S_word_bit; } // namespace std Index: libstdc++-v3/include/profile/algo.h =================================================================== --- libstdc++-v3/include/profile/algo.h (revision 0) +++ libstdc++-v3/include/profile/algo.h (revision 0) @@ -0,0 +1,93 @@ +// -*- C++ -*- + +// Copyright (C) 2009 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 and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** @file parallel/algo.h + * @brief Parallel STL function calls corresponding to the stl_algo.h header. + * + * The functions defined here mainly do case switches and + * call the actual parallelized versions in other files. + * Inlining policy: Functions that basically only contain one function call, + * are declared inline. + * This file is a GNU parallel extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_PROFILE_ALGO_H +#define _GLIBCXX_PROFILE_ALGO_H 1 + +#include <bits/stl_algo.h> +#include <profile/base.h> +#include <profile/iterator_tracker.h> + +namespace std +{ +namespace __profile +{ + + template<typename _Tp> + struct __is_iterator_tracker + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<typename _Iterator, typename _Container> + struct __is_iterator_tracker<__iterator_tracker<_Iterator, _Container> > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<typename _IIter, typename _Tp> + inline _IIter + find(_IIter __begin, _IIter __end, const _Tp& __val) + { + typedef typename __is_iterator_tracker<_IIter>::__type _IterTracker; + return __cxxprof_find(__begin, __end, __val, _IterTracker()); + } + + template<typename _IIter, typename _Tp> + inline _IIter + __cxxprof_find( _IIter __begin, _IIter __end, const _Tp& __val, + __false_type) + { + return _GLIBCXX_STD_ALGO::find(__begin, __end, __val); + } + + template<typename _IterTracker, typename _Tp> + inline _IterTracker + __cxxprof_find( _IterTracker __begin, _IterTracker __end, const _Tp& __val, + __true_type) + { + __begin._M_find(); + typename _IterTracker::_Base_iterator __res = + _GLIBCXX_STD_ALGO::find(__begin.base(), __end.base(), __val); + return _IterTracker(__res, __begin._M_get_sequence()); + } + + + +} // end namespace __profile +} // end namespace std + +#endif Index: libstdc++-v3/include/profile/list =================================================================== --- libstdc++-v3/include/profile/list (revision 155023) +++ libstdc++-v3/include/profile/list (working copy) @@ -30,13 +30,15 @@ #define _GLIBCXX_PROFILE_LIST 1 #include <list> +#include <profile/base.h> +#include <profile/iterator_tracker.h> namespace std { namespace __profile { /** @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_D::list<_Tp, _Allocator> { @@ -46,8 +48,10 @@ 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 __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; @@ -61,36 +65,68 @@ // 23.2.2.1 construct/copy/destroy: explicit list(const _Allocator& __a = _Allocator()) - : _Base(__a) { } + : _Base(__a) + { + __profcxx_list_construct(this); // list2slist + __profcxx_list_construct2(this); // list2vector + __profcxx_list_construct3(this); // list2set + } explicit list(size_type __n, const _Tp& __value = _Tp(), const _Allocator& __a = _Allocator()) - : _Base(__n, __value, __a) { } + : _Base(__n, __value, __a) + { + __profcxx_list_construct(this); + __profcxx_list_construct2(this); + __profcxx_list_construct3(this); + } template<class _InputIterator> list(_InputIterator __first, _InputIterator __last, const _Allocator& __a = _Allocator()) : _Base(__first, __last, __a) - { } + { + __profcxx_list_construct(this); + __profcxx_list_construct2(this); + __profcxx_list_construct3(this); + } list(const list& __x) - : _Base(__x) { } + : _Base(__x) + { + __profcxx_list_construct(this); + __profcxx_list_construct2(this); + __profcxx_list_construct3(this); + } list(const _Base& __x) - : _Base(__x) { } + : _Base(__x) + { + __profcxx_list_construct(this); + __profcxx_list_construct2(this); + __profcxx_list_construct3(this); + } #ifdef __GXX_EXPERIMENTAL_CXX0X__ list(list&& __x) : _Base(std::forward<list>(__x)) - { } + { + __profcxx_list_construct(this); + __profcxx_list_construct2(this); + __profcxx_list_construct3(this); + } list(initializer_list<value_type> __l, const allocator_type& __a = allocator_type()) : _Base(__l, __a) { } #endif - ~list() { } + ~list() { + __profcxx_list_destruct(this); + __profcxx_list_destruct2(this); + __profcxx_list_destruct3(this); + } list& operator=(const list& __x) @@ -141,27 +177,39 @@ // iterators: iterator begin() - { return iterator(_Base::begin()); } + { return iterator(_Base::begin(), this); } const_iterator begin() const - { return const_iterator(_Base::begin()); } + { return const_iterator(_Base::begin(), this); } iterator end() - { return iterator(_Base::end()); } + { + __profcxx_list_rewind(this); + return iterator(_Base::end(), this); + } const_iterator end() const - { return const_iterator(_Base::end()); } + { + __profcxx_list_rewind(this); + return const_iterator(_Base::end(), this); + } reverse_iterator rbegin() - { return reverse_iterator(end()); } + { + __profcxx_list_rewind(this); + return reverse_iterator(end()); + } const_reverse_iterator rbegin() const - { return const_reverse_iterator(end()); } + { + __profcxx_list_rewind(this); + return const_reverse_iterator(end()); + } reverse_iterator rend() @@ -174,11 +222,11 @@ #ifdef __GXX_EXPERIMENTAL_CXX0X__ const_iterator cbegin() const - { return const_iterator(_Base::begin()); } + { return const_iterator(_Base::begin(), this); } const_iterator cend() const - { return const_iterator(_Base::end()); } + { return const_iterator(_Base::end(), this); } const_reverse_iterator crbegin() const @@ -216,17 +264,25 @@ reference back() { + __profcxx_list_rewind(this); return _Base::back(); } const_reference back() const { + __profcxx_list_rewind(this); return _Base::back(); } // 23.2.2.3 modifiers: - using _Base::push_front; + void + push_front(const value_type& __x) + { + __profcxx_list_invalid_operator(this); + __profcxx_list_operation(this); + _Base::push_front(__x); + } #ifdef __GXX_EXPERIMENTAL_CXX0X__ using _Base::emplace_front; @@ -235,7 +291,7 @@ void pop_front() { - iterator __victim = begin(); + __profcxx_list_operation(this); _Base::pop_front(); } @@ -251,6 +307,7 @@ iterator __victim = end(); --__victim; _Base::pop_back(); + __profcxx_list_rewind(this); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ @@ -258,21 +315,29 @@ iterator emplace(iterator __position, _Args&&... __args) { - return iterator(_Base::emplace(__position, - std::forward<_Args>(__args)...)); + return iterator(_Base::emplace(__position.base(), + std::forward<_Args>(__args)...)); } #endif iterator insert(iterator __position, const _Tp& __x) { - return iterator(_Base::insert(__position, __x)); + size_type __size = size(); + _M_profile_insert(this, __position, __size); + __profcxx_list_insert3(this, __size); + return iterator(_Base::insert(__position.base(), __x), this); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ iterator insert(iterator __position, _Tp&& __x) - { return emplace(__position, std::move(__x)); } + { + size_type __size = size(); + _M_profile_insert(this, __position, __size); + __profcxx_list_insert3(this, __size); + return emplace(__position.base(), std::move(__x)); + } void insert(iterator __p, initializer_list<value_type> __l) @@ -284,21 +349,27 @@ void insert(iterator __position, size_type __n, const _Tp& __x) { - _Base::insert(__position, __n, __x); + size_type __size = size(); + _M_profile_insert(this, __position, __size); + __profcxx_list_insert3(this, __size, __n); + _Base::insert(__position.base(), __n, __x); } template<class _InputIterator> void insert(iterator __position, _InputIterator __first, _InputIterator __last) - { - _Base::insert(__position, __first, __last); - } + { + size_type __size = size(); + _M_profile_insert(this, __position, __size); + _Base::insert(__position.base(), __first, __last); + __profcxx_list_insert3(this, __size, size() - __size); + } iterator erase(iterator __position) { - return iterator(_Base::erase(__position)); + return iterator(_Base::erase(__position.base()), this); } iterator @@ -306,7 +377,7 @@ { // _GLIBCXX_RESOLVE_LIB_DEFECTS // 151. can't currently clear() empty container - return iterator(_Base::erase(__position, __last)); + return iterator(_Base::erase(__position.base(), __last.base()), this); } void @@ -329,7 +400,7 @@ splice(iterator __position, list& __x) #endif { - this->splice(__position, _GLIBCXX_MOVE(__x), __x.begin(), __x.end()); + this->splice(__position.base(), _GLIBCXX_MOVE(__x), __x.begin(), __x.end()); } void @@ -343,8 +414,8 @@ // after implementing the relevant bits of N1599. // _GLIBCXX_RESOLVE_LIB_DEFECTS - _Base::splice(__position, _GLIBCXX_MOVE(__x._M_base()), - __i); + _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()), + __i.base()); } void @@ -359,8 +430,8 @@ // We used to perform the splice_alloc check: not anymore, redundant // after implementing the relevant bits of N1599. - _Base::splice(__position, _GLIBCXX_MOVE(__x._M_base()), - __first, __last); + _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()), + __first.base(), __last.base()); } void @@ -381,6 +452,7 @@ { for (iterator __x = begin(); __x != _Base::end(); ) { + __profcxx_list_operation(this); if (__pred(*__x)) __x = erase(__x); else @@ -398,6 +470,7 @@ iterator __next = __first; while (++__next != __last) { + __profcxx_list_operation(this); if (*__first == *__next) erase(__next); else @@ -417,6 +490,7 @@ iterator __next = __first; while (++__next != __last) { + __profcxx_list_operation(this); if (__binary_pred(*__first, *__next)) erase(__next); else @@ -471,6 +545,30 @@ const _Base& _M_base() const { return *this; } + inline void _M_profile_find() const + { + __profcxx_list_find3(this, size()); + } + + inline void _M_profile_iterate(int __rewind = 0) const + { + __profcxx_list_operation(this); + __profcxx_list_iterate(this); + if (__rewind) + __profcxx_list_rewind(this); + } + + private: + size_type _M_profile_insert(void* obj, iterator __pos, size_type __size) + { + size_type __shift = 0; + typename _Base::iterator __it = __pos.base(); + for ( ; __it!=_Base::end(); __it++) + __shift++; + __profcxx_list_rewind(this); + __profcxx_list_operation(this); + __profcxx_list_insert(this, __shift, __size); + } }; template<typename _Tp, typename _Alloc> Index: libstdc++-v3/include/bits/stl_algo.h =================================================================== --- libstdc++-v3/include/bits/stl_algo.h (revision 155023) +++ libstdc++-v3/include/bits/stl_algo.h (working copy) @@ -4278,6 +4278,7 @@ return __f; } +#if !defined(_GLIBCXX_PROFILE) /** * @brief Find the first occurrence of a value in a sequence. * @ingroup non_mutating_algorithms @@ -4300,6 +4301,7 @@ return std::__find(__first, __last, __val, std::__iterator_category(__first)); } +#endif /** * @brief Find the first element in a sequence for which a @@ -6164,4 +6166,41 @@ _GLIBCXX_END_NESTED_NAMESPACE +#if defined(_GLIBCXX_PROFILE) +_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_ALGO) + + // TODO: instrument find_somthing like a find_end + + /** + * @brief Find the first occurrence of a value in a sequence. + * @ingroup non_mutating_algorithms + * @param first An input iterator. + * @param last An input iterator. + * @param val The value to find. + * @return The first iterator @c i in the range @p [first,last) + * such that @c *i == @p val, or @p last if no such iterator exists. + */ + template<typename _InputIterator, typename _Tp> + inline _InputIterator + find(_InputIterator __first, _InputIterator __last, + const _Tp& __val) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_InputIterator>::value_type, _Tp>) + __glibcxx_requires_valid_range(__first, __last); + return std::__find(__first, __last, __val, + std::__iterator_category(__first)); + + } + +_GLIBCXX_END_NESTED_NAMESPACE +#endif + + + + + + #endif /* _STL_ALGO_H */ Index: libstdc++-v3/include/bits/c++config =================================================================== --- libstdc++-v3/include/bits/c++config (revision 155023) +++ libstdc++-v3/include/bits/c++config (working copy) @@ -165,10 +165,19 @@ # error Cannot use -D_GLIBCXX_PROFILE with -D_GLIBCXX_DEBUG or \ -D_GLIBCXX_PARALLEL # endif + +# define _GLIBCXX_STD_P __profile + +// The original algorithm functions are hidden and existing in the following +// namespace. Now, user program sees the wrapper functions in the '__profile' +// namespace. +# define _GLIBCXX_STD_ALGO __profile_algo + # define _GLIBCXX_STD_D __norm -# define _GLIBCXX_STD_P _GLIBCXX_STD # define _GLIBCXX_STD_PR __norm -# define _GLIBCXX_STD __cxx1998 +// This namespace is no longer necessary +//# define _GLIBCXX_STD __cxx1998 + # define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY_ATTR(default) { # define _GLIBCXX_END_NAMESPACE } # endif Index: libstdc++-v3/include/Makefile.am =================================================================== --- libstdc++-v3/include/Makefile.am (revision 155023) +++ libstdc++-v3/include/Makefile.am (working copy) @@ -781,6 +781,9 @@ profile_srcdir = ${glibcxx_srcdir}/include/profile profile_builddir = ./profile profile_headers = \ + ${profile_srcdir}/algo.h \ + ${profile_srcdir}/algorithm \ + ${profile_srcdir}/iterator_tracker.h \ ${profile_srcdir}/base.h \ ${profile_srcdir}/unordered_map \ ${profile_srcdir}/unordered_set \ @@ -807,7 +810,10 @@ ${profile_impl_srcdir}/profiler_state.h \ ${profile_impl_srcdir}/profiler_trace.h \ ${profile_impl_srcdir}/profiler_vector_size.h \ - ${profile_impl_srcdir}/profiler_vector_to_list.h + ${profile_impl_srcdir}/profiler_vector_to_list.h \ + ${profile_impl_srcdir}/profiler_list_to_slist.h \ + ${profile_impl_srcdir}/profiler_list_to_vector.h \ + ${profile_impl_srcdir}/profiler_list_to_set.h # Some of the different "C" header models need extra files. # Some "C" header schemes require the "C" compatibility headers.

Re: [FYI] ChangeLogs cleaned-up a bit

2009-12-04T10:46:49Z

> in my HJ Lu-ish mood, I removed quite a few spurious white spaces and
> tabs lurking in our ChangeLogs files, actually quite annoying in a new
> emacs setup I'm using now (they are all displayed bright red)...

Thanks, had been tempted myself. It is now very distracting!

-benjamin

[FYI] ChangeLogs cleaned-up a bit

2009-12-04T08:35:05Z

Hi,

in my HJ Lu-ish mood, I removed quite a few spurious white spaces and
tabs lurking in our ChangeLogs files, actually quite annoying in a new
emacs setup I'm using now (they are all displayed bright red)...

Paolo.

[v3] Fix libstdc++/42261

2009-12-03T06:21:59Z

Hi,

tested x86_64-linux, committed to mainline.

Paolo.

///////////////////////

2009-12-03 Paolo Carlini <paolo.carlini@...>

PR libstdc++/42261
* include/bits/basic_string.h (_S_construct_aux(_Integer, _Integer,
const _Alloc&, __true_type)): Cast the second argument to value_type.
* include/ext/sso_string_base.h (_M_construct_aux(_Integer, _Integer,
std::__true_type)): Likewise.
* include/ext/rc_string_base.h (_S_construct_aux(_Integer, _Integer,
const _Alloc&, std::__true_type)): Likewise.
* testsuite/21_strings/basic_string/cons/char/42261.cc: New.
* testsuite/21_strings/basic_string/cons/wchar_t/42261.cc: Likewise.

Index: include/ext/rc_string_base.h
===================================================================
--- include/ext/rc_string_base.h (revision 154941)
+++ include/ext/rc_string_base.h (working copy)
@@ -231,7 +231,8 @@
static _CharT*
_S_construct_aux(_Integer __beg, _Integer __end,
const _Alloc& __a, std::__true_type)
- { return _S_construct(static_cast<size_type>(__beg), __end, __a); }
+ { return _S_construct(static_cast<size_type>(__beg),
+ static_cast<value_type>(__end), __a); }

template<typename _InIterator>
static _CharT*
Index: include/ext/sso_string_base.h
===================================================================
--- include/ext/sso_string_base.h (revision 154941)
+++ include/ext/sso_string_base.h (working copy)
@@ -106,7 +106,8 @@
template<typename _Integer>
void
_M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
- { _M_construct(static_cast<size_type>(__beg), __end); }
+ { _M_construct(static_cast<size_type>(__beg),
+ static_cast<value_type>(__end)); }

template<typename _InIterator>
void
Index: include/bits/basic_string.h
===================================================================
--- include/bits/basic_string.h (revision 154941)
+++ include/bits/basic_string.h (working copy)
@@ -1588,7 +1588,8 @@
static _CharT*
_S_construct_aux(_Integer __beg, _Integer __end,
const _Alloc& __a, __true_type)
- { return _S_construct(static_cast<size_type>(__beg), __end, __a); }
+ { return _S_construct(static_cast<size_type>(__beg),
+ static_cast<value_type>(__end), __a); }

template<class _InIterator>
static _CharT*
Index: testsuite/21_strings/basic_string/cons/wchar_t/42261.cc
===================================================================
--- testsuite/21_strings/basic_string/cons/wchar_t/42261.cc (revision 0)
+++ testsuite/21_strings/basic_string/cons/wchar_t/42261.cc (revision 0)
@@ -0,0 +1,35 @@
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <string>
+#include <testsuite_hooks.h>
+
+// libstdc++/42261
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ using namespace std;
+
+ const wstring s(wstring::size_type(6), wstring::size_type(L'f'));
+ VERIFY( s == L"ffffff" );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
Index: testsuite/21_strings/basic_string/cons/char/42261.cc
===================================================================
--- testsuite/21_strings/basic_string/cons/char/42261.cc (revision 0)
+++ testsuite/21_strings/basic_string/cons/char/42261.cc (revision 0)
@@ -0,0 +1,35 @@
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <string>
+#include <testsuite_hooks.h>
+
+// libstdc++/42261
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ using namespace std;
+
+ const string s(string::size_type(6), string::size_type('f'));
+ VERIFY( s == "ffffff" );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}

[v3] Add some std::bind tests

2009-12-03T02:19:57Z

Hi,

checked x86-64-linux, committed to mainline.

Paolo.

////////////////////

2009-12-03 Paolo Carlini <paolo.carlini@...>

* testsuite/20_util/bind/ref.cc: Add.
* testsuite/20_util/bind/all_bound.cc: Likewise.
* testsuite/20_util/bind/nested.cc: Likewise.
* testsuite/20_util/bind/placeholders.cc: Likewise.

Index: testsuite/20_util/bind/ref.cc
===================================================================
--- testsuite/20_util/bind/ref.cc (revision 0)
+++ testsuite/20_util/bind/ref.cc (revision 0)
@@ -0,0 +1,55 @@
+// { dg-options "-std=gnu++0x" }
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.11 Function template bind
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+struct X
+{
+ X() : bar(17) {}
+
+ int foo(int x, int y) { return bar + x + y; }
+
+ int bar;
+
+private:
+ X(const X&);
+ X& operator=(const X&);
+};
+
+// Operations on empty function<> objects
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ using std::bind;
+ using std::ref;
+ ::X x;
+
+ VERIFY( bind(&::X::foo, ref(x), 1, 2)() == 20 );
+ VERIFY( bind<int>(&::X::foo, ref(x), 1, 2)() == 20 );
+ VERIFY( bind(&::X::bar, ref(x))() == 17 );
+ VERIFY( bind<int>(&::X::bar, ref(x))() == 17 );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
Index: testsuite/20_util/bind/all_bound.cc
===================================================================
--- testsuite/20_util/bind/all_bound.cc (revision 0)
+++ testsuite/20_util/bind/all_bound.cc (revision 0)
@@ -0,0 +1,39 @@
+// { dg-options "-std=gnu++0x" }
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.11 Function template bind
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+// Operations on empty function<> objects
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ VERIFY( std::bind(std::plus<int>(), 3, 5)() == 8 );
+ VERIFY( std::bind(std::minus<int>(), 3, 5)() == -2 );
+ VERIFY( std::bind<int>(std::plus<int>(), 3, 5)() == 8 );
+ VERIFY( std::bind<int>(std::minus<int>(), 3, 5)() == -2 );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
Index: testsuite/20_util/bind/nested.cc
===================================================================
--- testsuite/20_util/bind/nested.cc (revision 0)
+++ testsuite/20_util/bind/nested.cc (revision 0)
@@ -0,0 +1,42 @@
+// { dg-options "-std=gnu++0x" }
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.11 Function template bind
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+// Operations on empty function<> objects
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ using namespace std::placeholders;
+
+ int five = 5;
+ int seven = 7;
+ VERIFY( std::bind(std::multiplies<int>(), _1,
+ std::bind(std::minus<int>(), 6, _2))(five, seven) == -5 );
+ VERIFY( std::bind(std::multiplies<int>(), _1,
+ std::bind(std::minus<int>(), 6, _2))(seven, five) == 7 );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
Index: testsuite/20_util/bind/placeholders.cc
===================================================================
--- testsuite/20_util/bind/placeholders.cc (revision 0)
+++ testsuite/20_util/bind/placeholders.cc (revision 0)
@@ -0,0 +1,40 @@
+// { dg-options "-std=gnu++0x" }
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.11 Function template bind
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+// Operations on empty function<> objects
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+ using namespace std::placeholders;
+
+ int five = 5;
+ int seven = 7;
+ VERIFY( std::bind(std::minus<int>(), _1, _2)(five, seven) == -2 );
+ VERIFY( std::bind(std::minus<int>(), _2, _1)(five, seven) == 2 );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}

Committed: Fix ext/profile/mutex_extensions.cc regression

2009-12-02T22:44:48Z

In r154852:154860, there was a change shifting the
libstdc++-v3/include/bits/c++config line-numbers, causing this
test to fail since then on all platforms; see gcc-testresults@.
I'm not sure how regression was missed in testing (other than
perhaps a missing run on a _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
platform), but either way, the trivial fix just committed was:

libstdc++-v3:
* testsuite/ext/profile/mutex_extensions.cc: Adjust dg-error line
number.

Index: testsuite/ext/profile/mutex_extensions.cc
===================================================================
--- testsuite/ext/profile/mutex_extensions.cc (revision 154935)
+++ testsuite/ext/profile/mutex_extensions.cc (working copy)
@@ -22,5 +22,5 @@

#include <vector>

-// { dg-error "Cannot use -D_GLIBCXX_PROFILE with " "" { target *-*-* } 165 }
+// { dg-error "Cannot use -D_GLIBCXX_PROFILE with " "" { target *-*-* } 167 }
// { dg-excess-errors "In file included from" }

brgds, H-P

Re: [C++ PATCH] Optimize C++ comdat ctors/dtors in classes without virtual bases (PR c++/3187, take 3)

2009-12-01T07:05:22Z

On 12/01/2009 02:45 AM, Jakub Jelinek wrote:
> On Mon, Nov 30, 2009 at 10:46:31PM -0500, Jason Merrill wrote:
>> On 11/30/2009 05:36 PM, Jakub Jelinek wrote:
>>> * config/abi/pre/gnu.ver: Don't export certain base dtors that
>>> weren't previously exported.
>>
>> Is this necessary?
>
> Yes.

OK.

>>> + && (SUPPORTS_ONE_ONLY || !DECL_WEAK (fns[0]))
>>
>> This test seems unnecessary; I don't see the problem with using aliases
>> on targets with weak symbols but no one-only support.
>
> This is to fix AIX (and is actually unrelated to this patch, it can be dealt
> with separately). In theory it should work well, but David Edelsohn
> reported that some symbols were missing from libstdc++.so without it. I
> have no access to AIX and have no idea what AIX linker is doing with the
> symbols.

OK.

The patch is OK.

Jason

Re: [C++ PATCH] Optimize C++ comdat ctors/dtors in classes without virtual bases (PR c++/3187, take 3)

2009-11-30T23:45:26Z

On Mon, Nov 30, 2009 at 10:46:31PM -0500, Jason Merrill wrote:
> On 11/30/2009 05:36 PM, Jakub Jelinek wrote:
> > * config/abi/pre/gnu.ver: Don't export certain base dtors that
> > weren't previously exported.
>
> Is this necessary? I thought it was OK to add new exported symbols, but
> you'd know better than I.

Yes. We definitely must not export them with the old symbol versions where
they have not been exported before (GLIBCXX_3.4 and GLIBCXX_3.4.10).
We could export them at @@GLIBCXX_3.4.14 (which would mean the same gnu.ver
changes and mentioning the D2 symbols in GLIBCXX_3.4.14 section), but that
has a problem that we only emit those D2 symbols when HAVE_COMDAT_GROUP, so
in !HAVE_COMDAT_GROUP configurations the exported list would be different.
I have no idea how to force generation of those symbols otherwise so that
they are exported on all targets.

>
> >+ && (SUPPORTS_ONE_ONLY || !DECL_WEAK (fns[0]))
>
> This test seems unnecessary; I don't see the problem with using aliases
> on targets with weak symbols but no one-only support.

This is to fix AIX (and is actually unrelated to this patch, it can be dealt
with separately). In theory it should work well, but David Edelsohn
reported that some symbols were missing from libstdc++.so without it. I
have no access to AIX and have no idea what AIX linker is doing with the
symbols. !SUPPORTS_ONE_ONLY targets don't have DECL_ONE_ONLY, but instead
just use DECL_WEAK symbols, so I thought when we don't do this optimization
on !HAVE_COMDAT_GROUP SUPPORTS_ONE_ONLY targets for comdat and comdat-like
symbols, the world wouldn't end if we didn't support it even on the
far rarer !HAVE_COMDAT_GROUP !SUPPORTS_ONE_ONLY targets.

Jakub

Re: how to get read/write access for profile extension contributor

2009-11-30T13:37:22Z

On Fri, Nov 27, 2009 at 4:49 PM, Benjamin Kosnik <bkoz@...> wrote:

>
> > But the general guideline for write access to the SVN tree is
> > successful submission of a couple of patches. That ensures that the
> > contributor understands gcc's submission and commit policy to at least
> > a minimal degree. Write access is a powerful tool, since we must
> > essentially trust everybody with write access, so the gcc maintainers
> > don't normally give it out on spec.
>
> Yep.
>
> Let's try to work the kinks out with the first couple of patches,
> and then when everything looks good after a bit re-discuss.
>
> -benjamin

Sounds good. I was just a bit confused about the mechanics of
branches vs trunk. It's clear now.

I am working with Changhee offline and he will send out a patch for
discussion very soon.

Thank you, Ian and Benjamin,
Silvius

Re: Libstdc++ as DLL on windows, alternative approach [was Re: cygwin patch review]

2009-11-30T12:13:18Z

Dave Korn wrote:
> [snip]

YA test results:
http://gcc.gnu.org/ml/gcc-testresults/2009-11/msg02971.html

Owing to imminent end of stage I guess I'll just have to check it in without
this part for which I haven't been able to get review in time:

> * gcc.c (LINK_COMMAND_SPEC): Allow and ignore -static-libstdc++
> similarly to -static.
>
> gcc/cp/ChangeLog:
>
> * g++spec.c (SKIPOPT): Delete.
> (lang_specific_driver): Do not skip -static-libstdc++ option.

The end result won't be broken, the remaining parts of the patch will stand
alone, but it will lead to statically linked c++ code needlessly indirecting
through the cygwin dll malloc wrappers when it doesn't have to. That's a
small inefficiency that can be solved whenever the patch can be approved.
It's also eminently suitable to go in as a separate patch anyway, since it
helps fix someone else's PR too.

cheers,
DaveK

Re: [C++0x] add rvalue support to std::function

2009-11-30T01:37:25Z

On 11/30/2009 09:42 AM, Jonathan Wakely wrote:
> OK, thanks, Paolo. I'll continue working on the other bits later today.
>

Done with the below.

I'll try to make progress on the Segmentation fault, I wonder if it's
really a new problem, I can see in Bugzilla a few Seg faults... Anyway,
just as a minor additional data point, Seg faults even without declval...

Paolo.

////////////////

2009-11-30 Paolo Carlini <paolo.carlini@...>

* include/tr1_impl/functional: Remove file, copy its contents,
trivially adjusted...
* include/std/functional: ... here, and...
* include/tr1_impl/functional: ... here.
* include/Makefile.am: Adjust.
* include/Makefile.in: Regenerate.

2009-11-30 Jonathan Wakely <jwakely.gcc@...>

* include/tr1_impl/functional (function): Add rvalue support and
tweak doxygen markup.
* testsuite/20_util/function/assign/move.cc: New.
* testsuite/20_util/function/cons/move.cc: New.
* testsuite/20_util/function/invoke/move_only.cc: New.
* testsuite/20_util/function/cmp/cmp_neg.cc: New.
* testsuite/20_util/function/1.cc: Copy from testsuite/tr1/.
* testsuite/20_util/function/2.cc: Likewise.
* testsuite/20_util/function/3.cc: Likewise.
* testsuite/20_util/function/4.cc: Likewise.
* testsuite/20_util/function/5.cc: Likewise.
* testsuite/20_util/function/6.cc: Likewise.
* testsuite/20_util/function/7.cc: Likewise.
* testsuite/20_util/function/8.cc: Likewise.
* testsuite/20_util/function/9.cc: Likewise.

patch_combo.bz2 (27K) Download Attachment

Re: [C++0x] add rvalue support to std::function

2009-11-30T00:42:27Z

2009/11/30 Paolo Carlini:

> On 11/30/2009 01:34 AM, Jonathan Wakely wrote:
>> This adds move construction and move assignment to std::function, as
>> well function invocation with rvalue arguments, fixing the problem
>> reported at http://gcc.gnu.org/ml/libstdc++/2009-06/msg00013.html
>>
> Jon, thanks for working on this.
>
> I see that even the std::function changes alone mean quite a few
> #ifdefs: given our general plans in this area I think it makes sense to
> split the tr1_impl implementation of functional immediately. Let me take
> care of that, I will incorporate at the same time this work of yours,
> this way you can concentrate on the other std::functional bits...

OK, thanks, Paolo. I'll continue working on the other bits later today.

Cheers,
Jon.

Re: [C++0x] add rvalue support to std::function

2009-11-29T23:58:49Z

On 11/30/2009 01:34 AM, Jonathan Wakely wrote:
> This adds move construction and move assignment to std::function, as
> well function invocation with rvalue arguments, fixing the problem
> reported at http://gcc.gnu.org/ml/libstdc++/2009-06/msg00013.html
>
Jon, thanks for working on this.

I see that even the std::function changes alone mean quite a few
#ifdefs: given our general plans in this area I think it makes sense to
split the tr1_impl implementation of functional immediately. Let me take
care of that, I will incorporate at the same time this work of yours,
this way you can concentrate on the other std::functional bits...

Paolo.

[C++0x] add rvalue support to std::function

2009-11-29T16:34:16Z

This adds move construction and move assignment to std::function, as
well function invocation with rvalue arguments, fixing the problem
reported at http://gcc.gnu.org/ml/libstdc++/2009-06/msg00013.html

Still missing is support for constructing a std::function from a
non-copyable functor, that needs some additional changes to
_Function_base::_Base_manager which can be done at a later date. In
the near future <tr1_impl/functional> should be split into two
separate files for C++1x and TR1 implementations, as they will diverge
further.

2009-11-30 Jonathan Wakely <jwakely.gcc@...>

* include/tr1_impl/functional (function): Add rvalue support and
tweak doxygen markup.
* testsuite/20_util/function/assign/move.cc: New.
* testsuite/20_util/function/cons/move.cc: New.
* testsuite/20_util/function/invoke/move_only.cc: New.
* testsuite/20_util/function/cmp/cmp_neg.cc: New.
* testsuite/20_util/function/1.cc: Copy from testsuite/tr1/.
* testsuite/20_util/function/2.cc: Likewise.
* testsuite/20_util/function/3.cc: Likewise.
* testsuite/20_util/function/4.cc: Likewise.
* testsuite/20_util/function/5.cc: Likewise.
* testsuite/20_util/function/6.cc: Likewise.
* testsuite/20_util/function/7.cc: Likewise.
* testsuite/20_util/function/8.cc: Likewise.
* testsuite/20_util/function/9.cc: Likewise.

tested x86_64/linux, I would like to commit this tomorrow before stage 3 ends.

Jonathan

Index: include/tr1_impl/functional
===================================================================
--- include/tr1_impl/functional (revision 154742)
+++ include/tr1_impl/functional (working copy)
@@ -1651,7 +1651,12 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ return (*_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
+#else
return (*_Base::_M_get_pointer(__functor))(__args...);
+#endif
}
};

@@ -1665,7 +1670,12 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ (*_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
+#else
(*_Base::_M_get_pointer(__functor))(__args...);
+#endif
}
};

@@ -1679,8 +1689,13 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ return __callable_functor(**_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
+#else
return
__callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
+#endif
}
};

@@ -1694,7 +1709,12 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ __callable_functor(**_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
+#else
__callable_functor(**_Base::_M_get_pointer(__functor))(__args...);
+#endif
}
};

@@ -1710,8 +1730,13 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ return mem_fn(_Base::_M_get_pointer(__functor)->__value)(
+ std::forward<_ArgTypes>(__args)...);
+#else
return _GLIBCXX_TR1
mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
+#endif
}
};

@@ -1750,8 +1775,13 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ mem_fn(_Base::_M_get_pointer(__functor)->__value)(
+ std::forward<_ArgTypes>(__args)...);
+#else
_GLIBCXX_TR1
mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...);
+#endif
}
};

@@ -1785,6 +1815,9 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
* @brief Default construct creates an empty function call wrapper.
* @post @c !(bool)*this
*/
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ explicit
+#endif
function() : _Function_base() { }

/**
@@ -1796,12 +1829,28 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
/**
* @brief %Function copy constructor.
* @param x A %function object with identical call signature.
- * @pre @c (bool)*this == (bool)x
+ * @post @c (bool)*this == (bool)x
*
* The newly-created %function contains a copy of the target of @a
* x (if it has one).
*/
function(const function& __x);
+
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ /**
+ * @brief %Function move constructor.
+ * @param x A %function object rvalue with identical call signature.
+ *
+ * The newly-created %function contains the target of @a x
+ * (if it has one).
+ */
+ function(function&& __x) : _Function_base()
+ {
+ __x.swap(*this);
+ }
+
+ // TODO: needs allocator_arg_t
+#endif

/**
* @brief Builds a %function that targets a copy of the incoming
@@ -1835,7 +1884,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
* target, then @c *this will be empty.
*
* If @a x targets a function pointer or a reference to a function
- * object, then this operation will not throw an exception.
+ * object, then this operation will not throw an %exception.
*/
function&
operator=(const function& __x)
@@ -1844,12 +1893,32 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
return *this;
}

+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ /**
+ * @brief %Function move-assignment operator.
+ * @param x A %function rvalue with identical call signature.
+ * @returns @c *this
+ *
+ * The target of @a x is moved to @c *this. If @a x has no
+ * target, then @c *this will be empty.
+ *
+ * If @a x targets a function pointer or a reference to a function
+ * object, then this operation will not throw an %exception.
+ */
+ function&
+ operator=(function&& __x)
+ {
+ function(std::move(__x)).swap(*this);
+ return *this;
+ }
+#endif
+
/**
* @brief %Function assignment to zero.
* @post @c !(bool)*this
* @returns @c *this
*
- * The target of @a *this is deallocated, leaving it empty.
+ * The target of @c *this is deallocated, leaving it empty.
*/
function&
operator=(_M_clear_type*)
@@ -1888,6 +1957,18 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
return *this;
}

+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ /// @overload
+ template<typename _Functor>
+ typename __gnu_cxx::__enable_if<!is_integral<_Functor>::value,
+ function&>::__type
+ operator=(reference_wrapper<_Functor> __f)
+ {
+ function(__f).swap(*this);
+ return *this;
+ }
+#endif
+
// [3.7.2.2] function modifiers

/**
@@ -1895,7 +1976,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
* @param f A %function with identical call signature.
*
* Swap the targets of @c this function object and @a f. This
- * function will not throw an exception.
+ * function will not throw an %exception.
*/
void swap(function& __x)
{
@@ -1909,6 +1990,18 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
_M_invoker = __x._M_invoker;
__x._M_invoker = __old_invoker;
}
+
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ // TODO: needs allocator_arg_t
+ /*
+ template<typename _Functor, typename _Alloc>
+ void
+ assign(_Functor __f, const _Alloc& __a)
+ {
+ function(__f, __a).swap(*this);
+ }
+ */
+#endif

// [3.7.2.3] function capacity

@@ -1918,7 +2011,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
* @return @c true when this %function object contains a target,
* or @c false when it is empty.
*
- * This function will not throw an exception.
+ * This function will not throw an %exception.
*/
#ifdef __GXX_EXPERIMENTAL_CXX0X__
explicit operator bool() const
@@ -1954,7 +2047,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
* @returns the type identifier of the target function object, or
* @c typeid(void) if @c !(bool)*this.
*
- * This function will not throw an exception.
+ * This function will not throw an %exception.
*/
const type_info& target_type() const;

@@ -1965,7 +2058,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
* if @c typeid(Functor).equals(target_type()); otherwise, a NULL
* pointer.
*
- * This function will not throw an exception.
+ * This function will not throw an %exception.
*/
template<typename _Functor> _Functor* target();

@@ -1973,12 +2066,22 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
template<typename _Functor> const _Functor* target() const;
#endif

+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ // deleted overloads
+ template<typename _Res2, typename... _ArgTypes2>
+ void operator==(const function<_Res2(_ArgTypes2...)>&) const = delete;
+ template<typename _Res2, typename... _ArgTypes2>
+ void operator!=(const function<_Res2(_ArgTypes2...)>&) const = delete;
+
+ private:
+#else
private:
// [3.7.2.6] undefined operators
template<typename _Function>
void operator==(const function<_Function>&) const;
template<typename _Function>
void operator!=(const function<_Function>&) const;
+#endif

typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
_Invoker_type _M_invoker;
@@ -2028,7 +2131,11 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
__builtin_abort();
#endif
}
+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
+#else
return _M_invoker(_M_functor, __args...);
+#endif
}

#ifdef __GXX_RTTI
@@ -2083,6 +2190,57 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
}
#endif

+#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
+ // [20.7.15.2.6] null pointer comparisons
+
+ /**
+ * @brief Compares a polymorphic function object wrapper against 0
+ * (the NULL pointer).
+ * @returns @c true if the wrapper has no target, @c false otherwise
+ *
+ * This function will not throw an %exception.
+ */
+ template<typename _Res, typename... _Args>
+ inline bool
+ operator==(const function<_Res(_Args...)>& __f, _M_clear_type*)
+ { return !static_cast<bool>(__f); }
+
+ /// @overload
+ template<typename _Res, typename... _Args>
+ inline bool
+ operator==(_M_clear_type*, const function<_Res(_Args...)>& __f)
+ { return !static_cast<bool>(__f); }
+
+ /**
+ * @brief Compares a polymorphic function object wrapper against 0
+ * (the NULL pointer).
+ * @returns @c false if the wrapper has no target, @c true otherwise
+ *
+ * This function will not throw an %exception.
+ */
+ template<typename _Res, typename... _Args>
+ inline bool
+ operator!=(const function<_Res(_Args...)>& __f, _M_clear_type*)
+ { return static_cast<bool>(__f); }
+
+ /// @overload
+ template<typename _Res, typename... _Args>
+ inline bool
+ operator!=(_M_clear_type*, const function<_Res(_Args...)>& __f)
+ { return static_cast<bool>(__f); }
+
+ // [20.7.15.2.7] specialized algorithms
+
+ /**
+ * @brief Swap the targets of two polymorphic function object wrappers.
+ *
+ * This function will not throw an %exception.
+ */
+ template<typename _Res, typename... _Args>
+ inline void
+ swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
+ { __x.swap(__y); }
+#else
// [3.7.2.7] null pointer comparisons

/**
@@ -2090,7 +2248,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
* (the NULL pointer).
* @returns @c true if the wrapper has no target, @c false otherwise
*
- * This function will not throw an exception.
+ * This function will not throw an %exception.
*/
template<typename _Signature>
inline bool
@@ -2108,7 +2266,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
* (the NULL pointer).
* @returns @c false if the wrapper has no target, @c true otherwise
*
- * This function will not throw an exception.
+ * This function will not throw an %exception.
*/
template<typename _Signature>
inline bool
@@ -2126,12 +2284,13 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
/**
* @brief Swap the targets of two polymorphic function object wrappers.
*
- * This function will not throw an exception.
+ * This function will not throw an %exception.
*/
template<typename _Signature>
inline void
swap(function<_Signature>& __x, function<_Signature>& __y)
{ __x.swap(__y); }
+#endif

_GLIBCXX_END_NAMESPACE_TR1
}
Index: testsuite/20_util/function/assign/move.cc
===================================================================
--- testsuite/20_util/function/assign/move.cc (revision 0)
+++ testsuite/20_util/function/assign/move.cc (revision 0)
@@ -0,0 +1,50 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+int f1() { return 1; }
+struct { int operator()() { return 2; } } f2;
+
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ typedef std::function<int()> function;
+
+ function fo(f1);
+ function fo1;
+ fo1 = (std::move(fo));
+ VERIFY( static_cast<bool>(fo1) );
+ VERIFY( fo1() == 1 );
+
+ fo = function(f2);
+ function fo2;
+ fo2 = (std::move(fo));
+ VERIFY( static_cast<bool>(fo2) );
+ VERIFY( fo2() == 2 );
+}
+
+int main()
+{
+ test01();
+
+ return 0;
+}
Index: testsuite/20_util/function/cons/move.cc
===================================================================
--- testsuite/20_util/function/cons/move.cc (revision 0)
+++ testsuite/20_util/function/cons/move.cc (revision 0)
@@ -0,0 +1,48 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+int f1() { return 1; }
+struct { int operator()() { return 2; } } f2;
+
+void test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ typedef std::function<int()> function;
+
+ function fo(f1);
+ function fo1(std::move(fo));
+ VERIFY( static_cast<bool>(fo1) );
+ VERIFY( fo1() == 1 );
+
+ fo = function(f2);
+ function fo2(std::move(fo));
+ VERIFY( static_cast<bool>(fo2) );
+ VERIFY( fo2() == 2 );
+}
+
+int main()
+{
+ test01();
+
+ return 0;
+}
Index: testsuite/20_util/function/invoke/move_only.cc
===================================================================
--- testsuite/20_util/function/invoke/move_only.cc (revision 0)
+++ testsuite/20_util/function/invoke/move_only.cc (revision 0)
@@ -0,0 +1,61 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <functional>
+
+struct moveable
+{
+ moveable() = default;
+ ~moveable() = default;
+ moveable(const moveable& c) = delete;
+ moveable& operator=(const moveable&) = delete;
+ moveable(moveable&&) { }
+};
+
+void f1(moveable) { }
+void f2(moveable&&) { }
+struct { void operator()(moveable&&) { } } f3;
+
+void test01()
+{
+ std::function<void (moveable)> fo1a(f1);
+ fo1a(moveable());
+
+ std::function<void (moveable)> fo2a(f2);
+ fo2a(moveable());
+
+ std::function<void (moveable)> fo3a(f3);
+ fo3a(moveable());
+
+ std::function<void (moveable&&)> fo1b(f1);
+ fo1b(moveable());
+
+ std::function<void (moveable&&)> fo2b(f2);
+ fo2b(moveable());
+
+ std::function<void (moveable&&)> fo3b(f3);
+ fo3b(moveable());
+}
+
+int main()
+{
+ test01();
+
+ return 0;
+}
Index: testsuite/20_util/function/cmp/cmp_neg.cc
===================================================================
--- testsuite/20_util/function/cmp/cmp_neg.cc (revision 0)
+++ testsuite/20_util/function/cmp/cmp_neg.cc (revision 0)
@@ -0,0 +1,37 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <functional>
+
+void test01()
+{
+ std::function<void()> f1;
+ std::function<void()> f2;
+ f1 == f2; // { dg-error "here" }
+ f1 != f2; // { dg-error "here" }
+ // { dg-excess-errors "" }
+}
+
+int main()
+{
+ test01();
+
+ return 0;
+}
Index: testsuite/20_util/function/1.cc
===================================================================
--- testsuite/20_util/function/1.cc (revision 0)
+++ testsuite/20_util/function/1.cc (revision 0)
@@ -0,0 +1,94 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@...>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Operations on empty function<> objects
+void test01()
+{
+ using std::function;
+ using std::bad_function_call;
+
+ // Default-construction
+ function<int(float)> f1;
+ VERIFY( ((bool)f1 == false) );
+ VERIFY( !f1 );
+ VERIFY( f1 == 0 );
+ VERIFY( 0 == f1 );
+ VERIFY( !(f1 != 0) );
+ VERIFY( !(0 != f1) );
+
+ // Copy-construction
+ function<int(float)> f2(f1);
+ VERIFY( !f2 );
+
+ // Construct with NULL pointer
+ function<int(float)> f3(0);
+ VERIFY( !f3 );
+
+ // Assignment
+ f1 = f2;
+ VERIFY( !f1);
+
+ // Assignment to NULL pointer
+ f1 = 0;
+ VERIFY( !f1 );
+
+ // Swap
+ swap(f1, f2);
+ VERIFY( !f1 );
+ VERIFY( !f2 );
+
+ // Invocation should throw bad_function_call
+ bool thrown = false;
+ try
+ {
+ f1(3.14159f);
+ VERIFY( false );
+ }
+ catch (bad_function_call)
+ {
+ thrown = true;
+ }
+ VERIFY( thrown );
+
+ // target_type returns typeid(void)
+ VERIFY( f1.target_type() == typeid(void) );
+
+ // target() always returns a NULL pointer
+ VERIFY( f1.target<int (*)(float)>() == 0);
+
+ // Check const version
+ const function<int(float)>& f1c = f1;
+ VERIFY( f1c.target<int (*)(float)>() == 0 );
+ VERIFY( !f1c );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
Index: testsuite/20_util/function/2.cc
===================================================================
--- testsuite/20_util/function/2.cc (revision 0)
+++ testsuite/20_util/function/2.cc (revision 0)
@@ -0,0 +1,78 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@...>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put function pointers into function<> wrappers
+void test02()
+{
+ using std::function;
+
+ function<int(float)> f1(truncate_float);
+ VERIFY( f1 );
+ VERIFY( !!f1 );
+ VERIFY( !(f1 == 0) );
+ VERIFY( !(0 == f1) );
+ VERIFY( f1 != 0 );
+ VERIFY( 0 != f1 );
+
+ // Copy-construction
+ function<int(float)> f2(f1);
+ VERIFY( f2 );
+
+ // Invocation
+ VERIFY( f1(3.1f) == 3 );
+ VERIFY( f2(3.1f) == 3 );
+
+ // Assignment to zero
+ f1 = 0;
+ VERIFY( !f1 );
+
+ // Swap
+ f1.swap(f2);
+ VERIFY( f1 );
+ VERIFY( !f2 );
+ VERIFY( f1(3.1f) == 3 );
+
+ // Assignment from a function pointer
+ f2 = truncate_float;
+ VERIFY( f2(3.1f) == 3 );
+
+ // target_type and target() functions
+ const function<int(float)>& f1c = f1;
+ VERIFY( typeid(int(*)(float)) == f1.target_type() );
+ VERIFY( f2.target<int(*)(float)>() != 0 );
+ VERIFY( *f2.target<int(*)(float)>() == &truncate_float );
+ VERIFY( f1c.target<int(*)(float)>() != 0 );
+ VERIFY( *f1c.target<int(*)(float)>() == &truncate_float );
+}
+
+int main()
+{
+ test02();
+ return 0;
+}
Index: testsuite/20_util/function/3.cc
===================================================================
--- testsuite/20_util/function/3.cc (revision 0)
+++ testsuite/20_util/function/3.cc (revision 0)
@@ -0,0 +1,78 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@...>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put nearly-matching function pointers into function<> wrappers
+void test03()
+{
+ using std::function;
+
+ function<int(float)> f1(truncate_double);
+ VERIFY( f1 );
+ VERIFY( !!f1 );
+ VERIFY( !(f1 == 0) );
+ VERIFY( !(0 == f1) );
+ VERIFY( f1 != 0 );
+ VERIFY( 0 != f1 );
+
+ // Copy-construction
+ function<int(float)> f2(f1);
+ VERIFY( f2 );
+
+ // Invocation
+ VERIFY( f1(3.1f) == 3 );
+ VERIFY( f2(3.1f) == 3 );
+
+ // Assignment to zero
+ f1 = 0;
+ VERIFY( !f1 );
+
+ // Swap
+ f1.swap(f2);
+ VERIFY( f1 );
+ VERIFY( !f2 );
+ VERIFY( f1(3.1f) == 3 );
+
+ // Assignment from a function pointer
+ f2 = truncate_double;
+ VERIFY( f2(3.1f) == 3 );
+
+ // target_type and target() functions
+ const function<int(float)>& f1c = f1;
+ VERIFY( typeid(long(*)(double)) == f1.target_type() );
+ VERIFY( f2.target<long(*)(double)>() != 0 );
+ VERIFY( *f2.target<long(*)(double)>() == &truncate_double );
+ VERIFY( f1c.target<long(*)(double)>() != 0 );
+ VERIFY( *f1c.target<long(*)(double)>() == &truncate_double );
+}
+
+int main()
+{
+ test03();
+ return 0;
+}
Index: testsuite/20_util/function/4.cc
===================================================================
--- testsuite/20_util/function/4.cc (revision 0)
+++ testsuite/20_util/function/4.cc (revision 0)
@@ -0,0 +1,82 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@...>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put function objects into function<> wrappers
+void test04()
+{
+ using std::function;
+
+ do_truncate_float_t truncate_float;
+
+ function<int(float)> f1(truncate_float);
+ VERIFY( f1 );
+ VERIFY( !!f1 );
+ VERIFY( !(f1 == 0) );
+ VERIFY( !(0 == f1) );
+ VERIFY( f1 != 0 );
+ VERIFY( 0 != f1 );
+
+ // Copy-construction
+ function<int(float)> f2(f1);
+ VERIFY( f2 );
+
+ // Invocation
+ VERIFY( f1(3.1f) == 3 );
+ VERIFY( f2(3.1f) == 3 );
+
+ // Assignment to zero
+ f1 = 0;
+ VERIFY( !f1 );
+
+ // Swap
+ f1.swap(f2);
+ VERIFY( f1 );
+ VERIFY( !f2 );
+ VERIFY( f1(3.1f) == 3 );
+
+ // Assignment from a function pointer
+ f2 = do_truncate_float_t();
+ VERIFY( f2(3.1f) == 3 );
+
+ // target_type and target() functions
+ const function<int(float)>& f1c = f1;
+ VERIFY( typeid(do_truncate_float_t) == f1.target_type() );
+ VERIFY( f2.target<do_truncate_float_t>() != 0 );
+ VERIFY( f1c.target<do_truncate_float_t>() != 0 );
+}
+
+int main()
+{
+ test04();
+
+ VERIFY( do_truncate_double_t::live_objects == 0 );
+ VERIFY( do_truncate_float_t::live_objects == 0 );
+
+ return 0;
+}
Index: testsuite/20_util/function/5.cc
===================================================================
--- testsuite/20_util/function/5.cc (revision 0)
+++ testsuite/20_util/function/5.cc (revision 0)
@@ -0,0 +1,107 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@...>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put member pointers into function<> wrappers
+void test05()
+{
+ using std::function;
+
+ X x;
+ x.bar = 17;
+
+ function<int(X&)> frm(&X::bar);
+ VERIFY( frm );
+ VERIFY( frm(x) == 17 );
+ VERIFY( typeid(int X::*) == frm.target_type() );
+ VERIFY( *frm.target<int X::*>() == &X::bar );
+
+ function<int(X&)> fr(&X::foo);
+ VERIFY( fr );
+ VERIFY( fr(x) == 1 );
+ VERIFY( typeid(int (X::*)()) == fr.target_type() );
+ VERIFY( *fr.target<int (X::*)()>() == &X::foo );
+
+ function<int(const X&)> frc(&X::foo_c);
+ VERIFY( frc );
+ VERIFY( frc(x) == 2 );
+ VERIFY( typeid(int (X::*)() const) == frc.target_type() );
+ VERIFY( *frc.target<int (X::*)() const >() == &X::foo_c );
+
+ function<int(volatile X&)> frv(&X::foo_v);
+ VERIFY( frv );
+ VERIFY( frv(x) == 3 );
+ VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
+ VERIFY( *frv.target<int (X::*)() volatile >() == &X::foo_v );
+ VERIFY( frv.target<int (X::*)() const volatile>() == 0 );
+
+ function<int(const volatile X&)> frcv(&X::foo_cv);
+ VERIFY( frcv );
+ VERIFY( frcv(x) == 4 );
+ VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
+ VERIFY( *frcv.target<int (X::*)() const volatile >() == &X::foo_cv );
+ VERIFY( frcv.target<int (X::*)() const>() == 0 );
+
+ function<int(X*)> grm(&X::bar);
+ VERIFY( grm );
+ VERIFY( grm(&x) == 17 );
+ VERIFY( typeid(int X::*) == grm.target_type() );
+ VERIFY( *grm.target<int X::*>() == &X::bar );
+
+ function<int(X*)> gr(&X::foo);
+ VERIFY( gr );
+ VERIFY( gr(&x) == 1 );
+ VERIFY( typeid(int (X::*)()) == gr.target_type() );
+ VERIFY( *gr.target<int (X::*)()>() == &X::foo );
+
+ function<int(const X*)> grc(&X::foo_c);
+ VERIFY( grc );
+ VERIFY( grc(&x) == 2 );
+ VERIFY( typeid(int (X::*)() const) == grc.target_type() );
+ VERIFY( *grc.target<int (X::*)() const >() == &X::foo_c );
+
+ function<int(volatile X*)> grv(&X::foo_v);
+ VERIFY( grv );
+ VERIFY( grv(&x) == 3 );
+ VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
+ VERIFY( *grv.target<int (X::*)() volatile >() == &X::foo_v );
+ VERIFY( grv.target<int (X::*)() const volatile>() == 0 );
+
+ function<int(const volatile X*)> grcv(&X::foo_cv);
+ VERIFY( grcv );
+ VERIFY( grcv(&x) == 4 );
+ VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
+ VERIFY( *grcv.target<int (X::*)() const volatile >() == &X::foo_cv );
+ VERIFY( grcv.target<int (X::*)() const>() == 0 );
+}
+
+int main()
+{
+ test05();
+ return 0;
+}
Index: testsuite/20_util/function/6.cc
===================================================================
--- testsuite/20_util/function/6.cc (revision 0)
+++ testsuite/20_util/function/6.cc (revision 0)
@@ -0,0 +1,82 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@...>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+struct secret {};
+
+struct noncopyable_function_object_type
+{
+ noncopyable_function_object_type(secret) {}
+
+ int operator()() const { return 42; }
+ int operator()() { return 17; }
+
+ private:
+ noncopyable_function_object_type();
+ noncopyable_function_object_type(const noncopyable_function_object_type&);
+ void operator=(const noncopyable_function_object_type&);
+};
+
+// Put reference_wrappers into function<> wrappers
+void test06()
+{
+ using std::function;
+ using std::ref;
+ using std::cref;
+
+ secret password;
+ noncopyable_function_object_type x(password);
+
+ function<int()> f(ref(x));
+ VERIFY( f );
+ VERIFY( f() == 17 );
+ VERIFY( f.target_type() == typeid(noncopyable_function_object_type) );
+ VERIFY( f.target<noncopyable_function_object_type>() == &x );
+
+ function<int()> g = f;
+ VERIFY( g );
+ VERIFY( g() == 17 );
+ VERIFY( g.target_type() == typeid(noncopyable_function_object_type) );
+ VERIFY( g.target<noncopyable_function_object_type>() == &x );
+
+ function<int()> h = cref(x);
+ VERIFY( h );
+ VERIFY( h() == 42 );
+ VERIFY( h.target_type() == typeid(noncopyable_function_object_type) );
+ VERIFY( h.target<const noncopyable_function_object_type>() == &x );
+ VERIFY( h.target<const noncopyable_function_object_type>() == &x );
+
+ const function<int()>& hc = h;
+ VERIFY( h.target<noncopyable_function_object_type>() == 0 );
+ VERIFY( hc.target<noncopyable_function_object_type>() == &x );
+}
+
+int main()
+{
+ test06();
+ return 0;
+}
Index: testsuite/20_util/function/7.cc
===================================================================
--- testsuite/20_util/function/7.cc (revision 0)
+++ testsuite/20_util/function/7.cc (revision 0)
@@ -0,0 +1,82 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@...>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put reference_wrappers to function pointers into function<> wrappers
+void test07()
+{
+ using std::function;
+ using std::ref;
+ using std::cref;
+
+ int (*fptr)(float) = truncate_float;
+
+ function<int(float)> f1(ref(fptr));
+ VERIFY( f1 );
+ VERIFY( !!f1 );
+ VERIFY( !(f1 == 0) );
+ VERIFY( !(0 == f1) );
+ VERIFY( f1 != 0 );
+ VERIFY( 0 != f1 );
+
+ // Invocation
+ VERIFY( f1(3.1f) == 3 );
+
+ // target_type and target() functions
+ const function<int(float)>& f1c = f1;
+ VERIFY( typeid(int(*)(float)) == f1.target_type() );
+ VERIFY( f1.target<int(*)(float)>() != 0 );
+ VERIFY( f1.target<int(*)(float)>() == &fptr );
+ VERIFY( f1c.target<int(*)(float)>() != 0 );
+ VERIFY( f1c.target<int(*)(float)>() == &fptr );
+
+ function<int(float)> f2(cref(fptr));
+ VERIFY( f2 );
+ VERIFY( !!f2 );
+ VERIFY( !(f2 == 0) );
+ VERIFY( !(0 == f2) );
+ VERIFY( f2 != 0 );
+ VERIFY( 0 != f2 );
+
+ // Invocation
+ VERIFY( f2(3.1f) == 3 );
+
+ // target_type and target() functions
+ const function<int(float)>& f2c = f2;
+ VERIFY( typeid(int(*)(float)) == f2.target_type() );
+ VERIFY( f2.target<int(*)(float)>() == 0 );
+ VERIFY( f2.target<int(* const)(float)>() == &fptr );
+ VERIFY( f2c.target<int(*)(float)>() != 0 );
+ VERIFY( f2c.target<int(*)(float)>() == &fptr );
+}
+
+int main()
+{
+ test07();
+ return 0;
+}
Index: testsuite/20_util/function/8.cc
===================================================================
--- testsuite/20_util/function/8.cc (revision 0)
+++ testsuite/20_util/function/8.cc (revision 0)
@@ -0,0 +1,148 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@...>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put reference_wrappers to member pointers
+void test08()
+{
+ using std::function;
+ using std::ref;
+ using std::cref;
+
+ int X::* X_bar = &X::bar;
+ int (X::* X_foo)() = &X::foo;
+ int (X::* X_foo_c)() const = &X::foo_c;
+ int (X::* X_foo_v)() volatile = &X::foo_v;
+ int (X::* X_foo_cv)() const volatile = &X::foo_cv;
+
+ X x;
+ x.bar = 17;
+
+ function<int(X&)> frm(ref(X_bar));
+ VERIFY( frm );
+ VERIFY( frm(x) == 17 );
+ VERIFY( typeid(int X::*) == frm.target_type() );
+ VERIFY( frm.target<int X::*>() == &X_bar );
+
+ function<int(X&)> fr(ref(X_foo));
+ VERIFY( fr );
+ VERIFY( fr(x) == 1 );
+ VERIFY( typeid(int (X::*)()) == fr.target_type() );
+ VERIFY( fr.target<int (X::*)()>() == &X_foo );
+
+ function<int(const X&)> frc(ref(X_foo_c));
+ VERIFY( frc );
+ VERIFY( frc(x) == 2 );
+ VERIFY( typeid(int (X::*)() const) == frc.target_type() );
+ VERIFY( frc.target<int (X::*)() const >() == &X_foo_c );
+
+ function<int(volatile X&)> frv(ref(X_foo_v));
+ VERIFY( frv );
+ VERIFY( frv(x) == 3 );
+ VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
+ VERIFY( *frv.target<int (X::*)() volatile >() == X_foo_v );
+ VERIFY( frv.target<int (X::*)() const volatile>() == 0 );
+
+ function<int(const volatile X&)> frcv(ref(X_foo_cv));
+ VERIFY( frcv );
+ VERIFY( frcv(x) == 4 );
+ VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
+ VERIFY( *frcv.target<int (X::*)() const volatile >() == X_foo_cv );
+ VERIFY( frcv.target<int (X::*)() const>() == 0 );
+
+ function<int(X*)> grm(ref(X_bar));
+ VERIFY( grm );
+ VERIFY( grm(&x) == 17 );
+ VERIFY( typeid(int X::*) == grm.target_type() );
+ VERIFY( *grm.target<int X::*>() == X_bar );
+
+ function<int(X*)> gr(ref(X_foo));
+ VERIFY( gr );
+ VERIFY( gr(&x) == 1 );
+ VERIFY( typeid(int (X::*)()) == gr.target_type() );
+ VERIFY( *gr.target<int (X::*)()>() == X_foo );
+
+ function<int(const X*)> grc(ref(X_foo_c));
+ VERIFY( grc );
+ VERIFY( grc(&x) == 2 );
+ VERIFY( typeid(int (X::*)() const) == grc.target_type() );
+ VERIFY( *grc.target<int (X::*)() const >() == X_foo_c );
+
+ function<int(volatile X*)> grv(ref(X_foo_v));
+ VERIFY( grv );
+ VERIFY( grv(&x) == 3 );
+ VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
+ VERIFY( *grv.target<int (X::*)() volatile >() == X_foo_v );
+ VERIFY( grv.target<int (X::*)() const volatile>() == 0 );
+
+ function<int(const volatile X*)> grcv(ref(X_foo_cv));
+ VERIFY( grcv );
+ VERIFY( grcv(&x) == 4 );
+ VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
+ VERIFY( *grcv.target<int (X::*)() const volatile >() == X_foo_cv );
+ VERIFY( grcv.target<int (X::*)() const>() == 0 );
+
+ function<int(X&)> hrm(cref(X_bar));
+ VERIFY( hrm );
+ VERIFY( hrm(x) == 17 );
+ VERIFY( typeid(int X::*) == hrm.target_type() );
+ VERIFY( hrm.target<int X::*>() == 0 );
+ VERIFY( hrm.target<int X::* const>() == &X_bar );
+
+ function<int(X&)> hr(cref(X_foo));
+ VERIFY( hr );
+ VERIFY( hr(x) == 1 );
+ VERIFY( typeid(int (X::*)()) == hr.target_type() );
+ VERIFY( hr.target<int (X::* const)()>() == &X_foo );
+
+ function<int(const X&)> hrc(cref(X_foo_c));
+ VERIFY( hrc );
+ VERIFY( hrc(x) == 2 );
+ VERIFY( typeid(int (X::*)() const) == hrc.target_type() );
+ VERIFY( hrc.target<int (X::* const)() const >() == &X_foo_c );
+
+ function<int(volatile X&)> hrv(cref(X_foo_v));
+ VERIFY( hrv );
+ VERIFY( hrv(x) == 3 );
+ VERIFY( typeid(int (X::*)() volatile) == hrv.target_type() );
+ VERIFY( hrv.target<int (X::* const)() volatile >() == &X_foo_v );
+ VERIFY( hrv.target<int (X::* const)() const volatile>() == 0 );
+
+ function<int(const volatile X&)> hrcv(cref(X_foo_cv));
+ VERIFY( hrcv );
+ VERIFY( hrcv(x) == 4 );
+ VERIFY( typeid(int (X::*)() const volatile) == hrcv.target_type() );
+ VERIFY( hrcv.target<int (X::* const)() const volatile >() == &X_foo_cv );
+ VERIFY( hrcv.target<int (X::* const)() const>() == 0 );
+}
+
+int main()
+{
+ test08();
+ return 0;
+}
Index: testsuite/20_util/function/9.cc
===================================================================
--- testsuite/20_util/function/9.cc (revision 0)
+++ testsuite/20_util/function/9.cc (revision 0)
@@ -0,0 +1,55 @@
+// { dg-options "-std=gnu++0x" }
+// 2005-01-15 Douglas Gregor <dgregor@...>
+//
+// Copyright (C) 2005, 2009 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 20.7.15 polymorphic function object wrapper
+#include <functional>
+#include <testsuite_hooks.h>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+
+bool test __attribute__((unused)) = true;
+
+// Put function objects into a void-returning function<> wrapper
+void test09()
+{
+ using std::function;
+ using std::ref;
+ using std::cref;
+
+ int (X::*X_foo_c)() const = &X::foo_c;
+ function<void(X&)> f(&X::bar);
+ f = &X::foo;
+ f = ref(X_foo_c);
+ f = cref(X_foo_c);
+
+ function<void(float)> g = &truncate_float;
+ g = do_truncate_float_t();
+}
+
+int main()
+{
+ test09();
+
+ VERIFY( do_truncate_double_t::live_objects == 0 );
+ VERIFY( do_truncate_float_t::live_objects == 0 );
+
+ return 0;
+}

forward_list patch for N2913

2009-11-29T15:12:03Z

Posting a patch which changes the template parameters of forward_list types to be in better conformance
with N2913 (SCARY). Added __pointer_traits to retain alternative pointer support.

Tested: Darwin 11 x86_64

libstdc++-v3/ChangeLog:

* include/ext/pointer_traits.h: Add
* include/ext/pointer.h: added struct rebind
* include/bits/forward_list.h: change template args of iterator
and node to use pointer type instead of allocator to support N2913.
* include/bits/forward_list.tcc: same
* include/Makefile.am: added ext/pointer_traits.h
* testsuite/ext/ext_pointer/1_neg.cc: adjust dg-error line numbers
* testsuite/23_containers/forward_list/requirements/dr438/assign_neg.cc:
same
* testsuite/23_containers/forward_list/requirements/dr438/insert_neg.cc:
same
* testsuite/23_containers/forward_list/requirements/dr438/constructor_1_neg.cc:
same
* testsuite/23_containers/forward_list/requirements/dr438/constructor_2_neg.cc:
same

patch (18K) Download Attachment

[v3 patch] add __GXX_RTTI to doxygen predefined macros

2009-11-29T09:34:36Z

2009-11-29 Jonathan Wakely <jwakely.gcc@...>

* doc/doxygen/user.cfg.in: Add __GXX_RTTI to PREDEFINED macros.

This ensures that features which depend on RTTI appear in the doxygen
docs, e.g. std::function::target_type()

Tested doc-html-doxygen target on x86_64/linux

Index: doc/doxygen/user.cfg.in
===================================================================
--- doc/doxygen/user.cfg.in (revision 154736)
+++ doc/doxygen/user.cfg.in (working copy)
@@ -1449,6 +1449,7 @@ PREDEFINED = __cplusplus \
_GLIBCXX_ATOMIC_BUILTINS_8 \
_GLIBCXX_USE_SCHED_YIELD \
_GLIBCXX_USE_NANOSLEEP \
+ __GXX_RTTI \
__glibcxx_function_requires=// \
__glibcxx_class_requires=// \
__glibcxx_class_requires2=// \

Re: Reminder: Stage3 ends Nov 30th

2009-11-29T07:33:39Z

On Sun, 29 Nov 2009, Richard Guenther wrote:

>
> This is a remainder to not catch you in surprise when we announce
> the end of stage 3. Starting Dec 1st the trunk will go into
> regression and documentation fixes only mode (thus, same rules
> apply as for a release branch). When the release criteria
> are fulfilled (mainly zero P1 regressions) we will branch,
> do a release candidate and open trunk for the next stage 1.
> It is very unlikely that this happens before mid January.

I'm having trouble getting the MPC cutover patch reviewed by a build
maintainer.
http://gcc.gnu.org/ml/gcc-patches/2009-11/msg00731.html

Since PR40302 was marked by you as a "regression" to ensure it gets done,
may I assume that this and the approved cleanups can go in during stage4
once someone looks at the configure bits?

Thanks,
--Kaveh

Reminder: Stage3 ends Nov 30th

2009-11-29T03:42:57Z

This is a remainder to not catch you in surprise when we announce
the end of stage 3. Starting Dec 1st the trunk will go into
regression and documentation fixes only mode (thus, same rules
apply as for a release branch). When the release criteria
are fulfilled (mainly zero P1 regressions) we will branch,
do a release candidate and open trunk for the next stage 1.
It is very unlikely that this happens before mid January.

A status report will be sent at the start of "stage 4".

Richard.

--
Richard Guenther <rguenther@...>
Novell / SUSE Labs
SUSE LINUX Products GmbH - Nuernberg - AG Nuernberg - HRB 16746 - GF: Markus Rex

Re: how to get read/write access for profile extension contributor

2009-11-27T16:49:58Z

> But the general guideline for write access to the SVN tree is
> successful submission of a couple of patches. That ensures that the
> contributor understands gcc's submission and commit policy to at least
> a minimal degree. Write access is a powerful tool, since we must
> essentially trust everybody with write access, so the gcc maintainers
> don't normally give it out on spec.

Yep.

Let's try to work the kinks out with the first couple of patches,
and then when everything looks good after a bit re-discuss.

-benjamin

Re: how to get read/write access for profile extension contributor

2009-11-27T06:21:40Z

Silvius Rus <rus@...> writes:

> Changhee is a contributor to the profile extension (cc-ed) and he is
> trying to get read/write access to submit a patch to the
> profile-stdlib branch. I cannot approve his read/write access
> request, as I am not a maintainer. Is it possible for one of you to
> sponsor his request? Again, he would be submitting patches only to
> the profile-stdlib branch for now. Would it help if he sent the first
> patch for discussion? (I'd prefer not to discuss it until it is ready
> for trunk, as it would have to be reviewed at that point anyway.)

The libstdc++ maintainers can of course make their own decision here.

But the general guideline for write access to the SVN tree is
successful submission of a couple of patches. That ensures that the
contributor understands gcc's submission and commit policy to at least
a minimal degree. Write access is a powerful tool, since we must
essentially trust everybody with write access, so the gcc maintainers
don't normally give it out on spec.

Ian

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-27T05:15:26Z

On Fri, Nov 27, 2009 at 7:56 AM, Christian BRUEL <christian.bruel@...> wrote:
> Sure this is what I was precisely doing. I'll copy you
>
> Cheers
>
> Christian
>
Please don't top post. http://daringfireball.net/2007/07/on_top

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-27T01:56:46Z

Sure this is what I was precisely doing. I'll copy you

Cheers

Christian

Gabriel Dos Reis wrote:

> On Fri, Nov 27, 2009 at 3:29 AM, Christian BRUEL <christian.bruel@...> wrote:
>> If you want a complete example of how this is used this you can check the
>> example 14-22 at
>> http://www.linux-kheops.com/doc/casteyde/cours_cpp-1.40.1/htm/x5866.htm#AEN6045
>>
>> that segfaults with g++
>>
>> because the computed assignment is between a source and a destination that
>> have different sizes. It's a user error so easy to step into I guess. The
>> Standard didn't make this point very intuitive.
>
> Thanks. Could you contact the author of the `lecture' and have him/her correct
> that example?
>
> -- Gaby
>

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-27T01:55:21Z

On Fri, Nov 27, 2009 at 3:29 AM, Christian BRUEL <christian.bruel@...> wrote:
> If you want a complete example of how this is used this you can check the
> example 14-22 at
> http://www.linux-kheops.com/doc/casteyde/cours_cpp-1.40.1/htm/x5866.htm#AEN6045
>
> that segfaults with g++
>
> because the computed assignment is between a source and a destination that
> have different sizes. It's a user error so easy to step into I guess. The
> Standard didn't make this point very intuitive.

Thanks. Could you contact the author of the `lecture' and have him/her correct
that example?

-- Gaby

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-27T01:29:14Z

If you want a complete example of how this is used this you can check
the example 14-22 at
http://www.linux-kheops.com/doc/casteyde/cours_cpp-1.40.1/htm/x5866.htm#AEN6045

that segfaults with g++

because the computed assignment is between a source and a destination
that have different sizes. It's a user error so easy to step into I
guess. The Standard didn't make this point very intuitive.

Cheers

Christian

Gabriel Dos Reis wrote:

> On Fri, Nov 27, 2009 at 3:02 AM, Christian BRUEL <christian.bruel@...> wrote:
>> Now that you established that it was a user bug, just wanted to slightly
>> correct the problem characterization by fixing the code with
>>
>> b[0] = foo();
>> dest[b] = src[b];
>>
>> so the problem was the "this" size really, not the runtime dependency on
>> foo(). Hope this could be of interest (regarding all the bogus examples I
>> found including the computed assignment variation).
>
> Are you still having a problem with that? If yes, could
> you send a minimal complete program?
>
> -- Gaby
>

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-27T01:18:04Z

No, I was just posting the fix to my initial test case for information,
since I agree with you that the src and dest size should be the same,
and that size of dest is not size of dest[b] I don't have any issue now.

so

int main(void)
{
int n = 2;

valarray<int> dest(n);
valarray<bool> b(false, n);
valarray<int> src(1, n);

b[0] = foo();

dest[b] = src[b];

cout << dest[0] << endl;
cout << dest[1] << endl;

return 0;
}

Works regardless of the mask_array initialization values.

Cheers

Christian

Gabriel Dos Reis wrote:

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-27T01:09:20Z

On Fri, Nov 27, 2009 at 3:02 AM, Christian BRUEL <christian.bruel@...> wrote:
> Now that you established that it was a user bug, just wanted to slightly
> correct the problem characterization by fixing the code with
>
> b[0] = foo();
> dest[b] = src[b];
>
> so the problem was the "this" size really, not the runtime dependency on
> foo(). Hope this could be of interest (regarding all the bogus examples I
> found including the computed assignment variation).

Are you still having a problem with that? If yes, could
you send a minimal complete program?

-- Gaby

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-27T01:02:13Z

Now that you established that it was a user bug, just wanted to slightly
correct the problem characterization by fixing the code with

b[0] = foo();
dest[b] = src[b];

so the problem was the "this" size really, not the runtime dependency on
foo(). Hope this could be of interest (regarding all the bogus examples
I found including the computed assignment variation).

Cheers

Christian

Gabriel Dos Reis wrote:

> On Thu, Nov 26, 2009 at 9:29 AM, Christian BRUEL <christian.bruel@...> wrote:
>> I think I understand your point. dest[b] has 0 size because there were 0
>> matching elements, correct ?
>
> Yes. That is also the size that dest[b] would have reported if
> dest was const. E.g. modifying you earlier program, run this:
>
>
> #include <valarray>
> #include <iostream>
>
> using namespace std;
>
> int main(void)
> {
> int n = 1;
>
> const valarray<int> dest(n);
>
> valarray<bool> b(false, n);
>
> std::cout << dest[b].size() << std::endl;
>
> return 0;
> }
>
>
>> your definition of size of dest[b] is the
>> number of true elements.
>
> yes (and dest and b are already required to have same length).
>
>> What I found really strange with this interpretation is that the legality of
>> the program depends on a runtime behavior
>
> That is precisely what the Standard says 'undefined behaviour' as opposed
> to 'ill-formed' -- we don't say "legal".
>
> There is nothing strange about it. Not everything can be determined
> at compile time; most interesting stuff happen at run time.
>
>> for instance if the boolean's value is not known at compile time, like with
>>
>> ...
>> b[0] = foo(); // with extern bool foo (void);
>> dest[b] = src;
>> ...
>>
>> Is this legal or not ?
>
> whether the above invokes undefined behaviour depends on the
> value of b[0] and the length of src.
>
>> that's quite disturbing :-(
>
> Not to me. Do you find it disturbing that
> the validity of
>
> int a, b;
> cin >> a >> b;
> return a / b;
>
> depends on the state of 'cin'?
>
> -- Gaby
>

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-26T09:06:50Z

On Thu, Nov 26, 2009 at 9:29 AM, Christian BRUEL <christian.bruel@...> wrote:
> I think I understand your point. dest[b] has 0 size because there were 0
> matching elements, correct ?

Yes. That is also the size that dest[b] would have reported if
dest was const. E.g. modifying you earlier program, run this:

#include <valarray>
#include <iostream>

using namespace std;

int main(void)
{
int n = 1;

const valarray<int> dest(n);

valarray<bool> b(false, n);

std::cout << dest[b].size() << std::endl;

return 0;
}

> your definition of size of dest[b] is the
> number of true elements.

yes (and dest and b are already required to have same length).

>
> What I found really strange with this interpretation is that the legality of
> the program depends on a runtime behavior

That is precisely what the Standard says 'undefined behaviour' as opposed
to 'ill-formed' -- we don't say "legal".

There is nothing strange about it. Not everything can be determined
at compile time; most interesting stuff happen at run time.

>
> for instance if the boolean's value is not known at compile time, like with
>
> ...
> b[0] = foo(); // with extern bool foo (void);
> dest[b] = src;
> ...
>
> Is this legal or not ?

whether the above invokes undefined behaviour depends on the
value of b[0] and the length of src.

> that's quite disturbing :-(

Not to me. Do you find it disturbing that
the validity of

int a, b;
cin >> a >> b;
return a / b;

depends on the state of 'cin'?

-- Gaby

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-26T08:52:11Z

On 26 Nov 2009, at 15:29, Christian BRUEL wrote:

> I think I understand your point. dest[b] has 0 size because there were 0 matching elements, correct ? your definition of size of dest[b] is the number of true elements.
>
> What I found really strange with this interpretation is that the legality of the program depends on a runtime behavior
>
> for instance if the boolean's value is not known at compile time, like with
>
> ...
> b[0] = foo(); // with extern bool foo (void);
> dest[b] = src;
> ...

That surely isn't surprising at all, is this really dissimilar to:

vector<int> v(foo());
v[1] = 1;

Chris

Re: [[patch] valarray (was Re: valarray_copy implementation question)

2009-11-26T07:29:18Z

I think I understand your point. dest[b] has 0 size because there were 0
matching elements, correct ? your definition of size of dest[b] is the
number of true elements.

What I found really strange with this interpretation is that the
legality of the program depends on a runtime behavior

for instance if the boolean's value is not known at compile time, like with

...
b[0] = foo(); // with extern bool foo (void);
dest[b] = src;
...

Is this legal or not ? that's quite disturbing :-( I know a couple of
proprietary and commercial testsuite that fail on this kind of test.
(having n true elements < at the size of src).

Thanks so much and sorry for the noise.

Christian

Gabriel Dos Reis wrote:

> On Thu, Nov 26, 2009 at 5:58 AM, Christian BRUEL <christian.bruel@...> wrote:
>> what about
>>
>> #include <valarray>
>> using namespace std;
>>
>> int main(void)
>> {
>> int n = 1;
>>
>> valarray<int> dest(n);
>> valarray<bool> b(false, n);
>> valarray<int> src(1, n);
>>
>> dest[b] = src;
>
> Christian,
>
> the array expression `dest[b]' has length 0; the array expression `src'
> has length 1. That violates the equal length precondition.
>
>> return 0;
>> }
>>
>> is it a user error also ?
>
> yes; it is user confusion; the same as we discussed before.
>
> -- Gaby
>