From patchwork Thu Jul 4 20:54:14 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?Fran=C3=A7ois_Dumont?= X-Patchwork-Id: 257014 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client CN "localhost", Issuer "www.qmailtoaster.com" (not verified)) by ozlabs.org (Postfix) with ESMTPS id DCC582C0091 for ; Fri, 5 Jul 2013 06:54:28 +1000 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:date:from:mime-version:to:cc:subject:references :in-reply-to:content-type; q=dns; s=default; b=twflk4NdOSRXTOmdT /tvRhGNRvE8NKop/RwnZEU1aBbXL/XYslSq6DH983TWcgim23J3bRgzsjQh1caHX Knm225PydtqrICVk/BPJcEK4D2rOJBzd7NyB9t9kcvoz4TH99EooJnqpyNjgX8bL 811xBMnQUt9mqmNI+Ckc612X9c= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:date:from:mime-version:to:cc:subject:references :in-reply-to:content-type; s=default; bh=XVv2mbB0dq0eW+DveSdwGuB xIv8=; b=pKjotU/qfI/V0OIAzA0ZaG2hQLBaclbNS/bdqkjcJPkEp3qVImJ6kz+ vVDjwrglj9KnnphGo9QKZIOCTXEVPbtfgJPlf0Um6Hyf/saJnrTay45cZYrsfku8 PCATIimqEZtS3Ye4xIocfk7VH93bVYa09zNHMFWilOhegJA+MnqY= Received: (qmail 20390 invoked by alias); 4 Jul 2013 20:54:21 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 20373 invoked by uid 89); 4 Jul 2013 20:54:20 -0000 X-Spam-SWARE-Status: No, score=-3.5 required=5.0 tests=AWL, BAYES_00, FREEMAIL_FROM, KHOP_THREADED, RCVD_IN_DNSWL_LOW, RCVD_IN_HOSTKARMA_YE, SPF_PASS autolearn=ham version=3.3.1 X-Spam-User: qpsmtpd, 2 recipients Received: from mail-wg0-f45.google.com (HELO mail-wg0-f45.google.com) (74.125.82.45) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Thu, 04 Jul 2013 20:54:18 +0000 Received: by mail-wg0-f45.google.com with SMTP id j13so1472304wgh.12 for ; Thu, 04 Jul 2013 13:54:16 -0700 (PDT) X-Received: by 10.194.172.228 with SMTP id bf4mr4377562wjc.36.1372971256210; Thu, 04 Jul 2013 13:54:16 -0700 (PDT) Received: from localhost.localdomain (arf62-1-82-237-250-248.fbx.proxad.net. [82.237.250.248]) by mx.google.com with ESMTPSA id fd3sm37070279wic.10.2013.07.04.13.54.14 for (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Thu, 04 Jul 2013 13:54:15 -0700 (PDT) Message-ID: <51D5E0F6.90406@gmail.com> Date: Thu, 04 Jul 2013 22:54:14 +0200 From: =?UTF-8?B?RnJhbsOnb2lzIER1bW9udA==?= User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:15.0) Gecko/20120829 Thunderbird/15.0 MIME-Version: 1.0 To: Paolo Carlini CC: "libstdc++@gcc.gnu.org" , gcc-patches Subject: Re: unordered containers: reuse nodes on assignment References: <51D083D4.9090401@gmail.com> <61ed3bee-3e86-44ce-88a3-32d3f08f2126@email.android.com> <51D08A74.1020909@oracle.com> <51D1D9F3.9090709@gmail.com> <51D1F635.2030501@oracle.com> In-Reply-To: <51D1F635.2030501@oracle.com> X-Virus-Found: No On 07/01/2013 11:35 PM, Paolo Carlini wrote: > On 07/01/2013 09:35 PM, François Dumont wrote: >> This is it indeed, I am surprised this problem is so old, a Standard >> issue perhaps ? If not I might add it to my todo list. > Yesterday I had a look and I think it's just a bug, I found in > Bugzilla a duplicate too, and another resolved Jon some time ago. > > Paolo. > It doesn't seem to be resolved. And about the patch itself, is it ok ? I only noticed that some lambdas I was using didn't need to capture 'this' so I clean it and here is the updated version of the patch. Tested under linux x86_64. François Index: include/bits/hashtable_policy.h =================================================================== --- include/bits/hashtable_policy.h (revision 200571) +++ include/bits/hashtable_policy.h (working copy) @@ -102,6 +102,90 @@ { return std::get<0>(std::forward<_Tp>(__x)); } }; + // Functor recycling a pool of nodes and using allocation once the pool is + // empty. + template + struct _ReuseOrAllocNode + { + private: + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + using __val_alloc_type = typename __hashtable::_Value_alloc_type; + using __val_alloc_traits = typename __hashtable::_Value_alloc_traits; + using __node_alloc_traits = typename __hashtable::_Node_alloc_traits; + using __node_type = typename __hashtable::__node_type; + + public: + _ReuseOrAllocNode(__node_type* __nodes, __hashtable& __h) + : _M_nodes(__nodes), _M_h(__h) { } + _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete; + + ~_ReuseOrAllocNode() + { _M_h._M_deallocate_nodes(_M_nodes); } + + template + __node_type* + operator()(_Arg&& __arg) const + { + if (_M_nodes) + { + __node_type* __node = _M_nodes; + _M_nodes = _M_nodes->_M_next(); + __node->_M_nxt = nullptr; + __val_alloc_type __a(_M_h._M_node_allocator()); + __val_alloc_traits::destroy(__a, __node->_M_valptr()); + __try + { + __val_alloc_traits::construct(__a, __node->_M_valptr(), + std::forward<_Arg>(__arg)); + } + __catch(...) + { + __node->~__node_type(); + __node_alloc_traits::deallocate(_M_h._M_node_allocator(), + __node, 1); + __throw_exception_again; + } + return __node; + } + return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); + } + + private: + mutable __node_type* _M_nodes; + __hashtable& _M_h; + }; + + // Functor similar to the previous one but without any pool of node to recycle. + template + struct _AllocNode + { + private: + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + using __node_type = typename __hashtable::__node_type; + + public: + _AllocNode(__hashtable& __h) + : _M_h(__h) { } + + template + __node_type* + operator()(_Arg&& __arg) const + { return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); } + + private: + __hashtable& _M_h; + }; + // Auxiliary types used for all instantiations of _Hashtable nodes // and iterators. @@ -597,6 +681,7 @@ typename _RehashPolicy, typename _Traits> struct _Insert_base { + protected: using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; @@ -612,23 +697,34 @@ using __unique_keys = typename __hashtable_base::__unique_keys; using __ireturn_type = typename __hashtable_base::__ireturn_type; + using __node_gen_type = _AllocNode<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; __hashtable& _M_conjure_hashtable() { return *(static_cast<__hashtable*>(this)); } + template + void + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter&); + + public: __ireturn_type insert(const value_type& __v) { __hashtable& __h = _M_conjure_hashtable(); - return __h._M_insert(__v, __unique_keys()); + __node_gen_type __node_gen(__h); + return __h._M_insert(__v, __node_gen, __unique_keys()); } iterator insert(const_iterator __hint, const value_type& __v) { __hashtable& __h = _M_conjure_hashtable(); - return __h._M_insert(__hint, __v, __unique_keys()); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, __v, __node_gen, __unique_keys()); } void @@ -637,18 +733,24 @@ template void - insert(_InputIterator __first, _InputIterator __last); + insert(_InputIterator __first, _InputIterator __last) + { + __hashtable& __h = _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return _M_insert_range(__first, __last, __node_gen); + } }; template - template + template void _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: - insert(_InputIterator __first, _InputIterator __last) + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter& __node_gen) { using __rehash_type = typename __hashtable::__rehash_type; using __rehash_state = typename __hashtable::__rehash_state; @@ -667,7 +769,7 @@ __h._M_rehash(__do_rehash.second, __saved_state); for (; __first != __last; ++__first) - __h._M_insert(*__first, __unique_keys()); + __h._M_insert(*__first, __node_gen, __unique_keys()); } /** @@ -702,6 +804,7 @@ using __unique_keys = typename __base_type::__unique_keys; using __hashtable = typename __base_type::__hashtable; + using __node_gen_type = typename __base_type::__node_gen_type; using __base_type::insert; @@ -709,14 +812,17 @@ insert(value_type&& __v) { __hashtable& __h = this->_M_conjure_hashtable(); - return __h._M_insert(std::move(__v), __unique_keys()); + __node_gen_type __node_gen(__h); + return __h._M_insert(std::move(__v), __node_gen, __unique_keys()); } iterator insert(const_iterator __hint, value_type&& __v) { __hashtable& __h = this->_M_conjure_hashtable(); - return __h._M_insert(__hint, std::move(__v), __unique_keys()); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, std::move(__v), __node_gen, + __unique_keys()); } }; @@ -739,6 +845,7 @@ using __unique_keys = typename __base_type::__unique_keys; using __hashtable = typename __base_type::__hashtable; + using __node_gen_type = typename __base_type::__node_gen_type; using __base_type::insert; @@ -746,14 +853,17 @@ insert(value_type&& __v) { __hashtable& __h = this->_M_conjure_hashtable(); - return __h._M_insert(std::move(__v), __unique_keys()); + __node_gen_type __node_gen(__h); + return __h._M_insert(std::move(__v), __node_gen, __unique_keys()); } iterator insert(const_iterator __hint, value_type&& __v) { __hashtable& __h = this->_M_conjure_hashtable(); - return __h._M_insert(__hint, std::move(__v), __unique_keys()); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, std::move(__v), __node_gen, + __unique_keys()); } }; @@ -1694,120 +1804,6 @@ { } }; - /* - * Following are functors recyclicing a pool of nodes and using allocation - * once the pool is empty. - */ - /// Version using copy semantic through the copy constructor. - template - struct _ReuseOrAllocNode - { - private: - using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _H1, _H2, _Hash, - _RehashPolicy, _Traits>; - using __val_alloc_type = typename __hashtable::_Value_alloc_type; - using __val_alloc_traits = typename __hashtable::_Value_alloc_traits; - using __node_alloc_traits = typename __hashtable::_Node_alloc_traits; - using __node_type = typename __hashtable::__node_type; - - public: - _ReuseOrAllocNode(__node_type* __nodes, __hashtable& __h) - : _M_nodes(__nodes), _M_h(__h) { } - _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete; - - ~_ReuseOrAllocNode() - { _M_h._M_deallocate_nodes(_M_nodes); } - - __node_type* - operator()(const __node_type* __n) const - { - if (_M_nodes) - { - __node_type* __node = _M_nodes; - _M_nodes = _M_nodes->_M_next(); - __node->_M_nxt = nullptr; - __val_alloc_type __a(_M_h._M_node_allocator()); - __val_alloc_traits::destroy(__a, __node->_M_valptr()); - __try - { - __val_alloc_traits::construct(__a, __node->_M_valptr(), - __n->_M_v()); - } - __catch(...) - { - __node->~__node_type(); - __node_alloc_traits::deallocate(_M_h._M_node_allocator(), - __node, 1); - __throw_exception_again; - } - return __node; - } - return _M_h._M_allocate_node(__n->_M_v()); - } - - mutable __node_type* _M_nodes; - __hashtable& _M_h; - }; - - /// Version using move semantic through the move constructor. - template - struct _MoveReuseOrAllocNode - { - private: - using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _H1, _H2, _Hash, - _RehashPolicy, _Traits>; - using __val_alloc_type = typename __hashtable::_Value_alloc_type; - using __val_alloc_traits = typename __hashtable::_Value_alloc_traits; - using __node_alloc_traits = typename __hashtable::_Node_alloc_traits; - using __node_type = typename __hashtable::__node_type; - - public: - _MoveReuseOrAllocNode(__node_type* __nodes, __hashtable& __h) - : _M_nodes(__nodes), _M_h(__h) { } - _MoveReuseOrAllocNode(const _MoveReuseOrAllocNode&) = delete; - - ~_MoveReuseOrAllocNode() - { _M_h._M_deallocate_nodes(_M_nodes); } - - __node_type* - operator()(__node_type* __n) const - { - if (_M_nodes) - { - __node_type* __node = _M_nodes; - _M_nodes = _M_nodes->_M_next(); - __node->_M_nxt = nullptr; - __val_alloc_type __a(_M_h._M_node_allocator()); - __val_alloc_traits::destroy(__a, __node->_M_valptr()); - __try - { - __val_alloc_traits::construct(__a, __node->_M_valptr(), - std::move_if_noexcept(__n->_M_v())); - } - __catch(...) - { - __node->~__node_type(); - __node_alloc_traits::deallocate(_M_h._M_node_allocator(), - __node, 1); - __throw_exception_again; - } - return __node; - } - return _M_h._M_allocate_node(std::move_if_noexcept(__n->_M_v())); - } - - mutable __node_type* _M_nodes; - __hashtable& _M_h; - }; - //@} hashtable-detail _GLIBCXX_END_NAMESPACE_VERSION } // namespace __detail Index: include/bits/hashtable.h =================================================================== --- include/bits/hashtable.h (revision 200571) +++ include/bits/hashtable.h (working copy) @@ -239,6 +239,11 @@ _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; + using __reuse_or_alloc_node_type = + __detail::_ReuseOrAllocNode<_Key, _Value, _Alloc, + _ExtractKey, _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + // Metaprogramming for picking apart hash caching. template using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>; @@ -284,7 +289,6 @@ "Cache the hash code or make functors involved in hash code" " and bucket index computation copy assignable"); - public: template + typename _RehashPolicya, typename _Traitsa> friend struct __detail::_ReuseOrAllocNode; template - friend struct __detail::_MoveReuseOrAllocNode; + typename _RehashPolicya, typename _Traitsa> + friend struct __detail::_AllocNode; + public: using size_type = typename __hashtable_base::size_type; using difference_type = typename __hashtable_base::difference_type; @@ -394,9 +397,9 @@ _M_begin() const { return static_cast<__node_type*>(_M_before_begin()._M_nxt); } - template + template void - _M_assign(const _Hashtable&, const _UnaryOp&); + _M_assign(const _Hashtable&, const _NodeGenerator&); void _M_move_assign(_Hashtable&&, std::true_type); @@ -487,8 +490,10 @@ _Hashtable& operator=(initializer_list __l) { + __reuse_or_alloc_node_type __roan(_M_begin(), *this); + _M_before_begin()._M_nxt = nullptr; clear(); - this->insert(__l.begin(), __l.end()); + this->_M_insert_range(__l.begin(), __l.end(), __roan); return *this; } @@ -701,25 +706,33 @@ iterator _M_emplace(const_iterator, std::false_type, _Args&&... __args); - template + template std::pair - _M_insert(_Arg&&, std::true_type); + _M_insert(_Arg&&, const _NodeGenerator&, std::true_type); - template + template iterator - _M_insert(_Arg&& __arg, std::false_type __uk) - { return _M_insert(cend(), std::forward<_Arg>(__arg), __uk); } + _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, + std::false_type __uk) + { + return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen, + __uk); + } // Insert with hint, not used when keys are unique. - template + template iterator - _M_insert(const_iterator, _Arg&& __arg, std::true_type __uk) - { return _M_insert(std::forward<_Arg>(__arg), __uk).first; } + _M_insert(const_iterator, _Arg&& __arg, const _NodeGenerator& __node_gen, + std::true_type __uk) + { + return + _M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first; + } // Insert with hint when keys are not unique. - template + template iterator - _M_insert(const_iterator, _Arg&&, std::false_type); + _M_insert(const_iterator, _Arg&&, const _NodeGenerator&, std::false_type); size_type _M_erase(std::true_type, const key_type&); @@ -1029,12 +1042,11 @@ __hashtable_base::operator=(__ht); _M_element_count = __ht._M_element_count; _M_rehash_policy = __ht._M_rehash_policy; - __detail::_ReuseOrAllocNode<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _H1, _H2, _Hash, - _RehashPolicy, _Traits> - __roan(_M_begin(), *this); + __reuse_or_alloc_node_type __roan(_M_begin(), *this); _M_before_begin()._M_nxt = nullptr; - _M_assign(__ht, __roan); + _M_assign(__ht, + [&__roan](const __node_type* __n) + { return __roan(__n->_M_v()); }); if (__former_buckets) _M_deallocate_buckets(__former_buckets, __former_bucket_count); } @@ -1059,11 +1071,11 @@ typename _Alloc, typename _ExtractKey, typename _Equal, typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, typename _Traits> - template + template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: - _M_assign(const _Hashtable& __ht, const _UnaryOp& __node_getter) + _M_assign(const _Hashtable& __ht, const _NodeGenerator& __node_gen) { __bucket_type* __buckets = nullptr; if (!_M_buckets) @@ -1077,7 +1089,7 @@ // First deal with the special first node pointed to by // _M_before_begin. __node_type* __ht_n = __ht._M_begin(); - __node_type* __this_n = __node_getter(__ht_n); + __node_type* __this_n = __node_gen(__ht_n); this->_M_copy_code(__this_n, __ht_n); _M_before_begin()._M_nxt = __this_n; _M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin(); @@ -1086,7 +1098,7 @@ __node_base* __prev_n = __this_n; for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next()) { - __this_n = __node_getter(__ht_n); + __this_n = __node_gen(__ht_n); __prev_n->_M_nxt = __this_n; this->_M_copy_code(__this_n, __ht_n); size_type __bkt = _M_bucket_index(__this_n); @@ -1181,12 +1193,11 @@ __hashtable_base::operator=(std::move(__ht)); _M_element_count = __ht._M_element_count; _M_rehash_policy = __ht._M_rehash_policy; - __detail::_MoveReuseOrAllocNode<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _H1, _H2, _Hash, - _RehashPolicy, _Traits> - __mroan(_M_begin(), *this); + __reuse_or_alloc_node_type __roan(_M_begin(), *this); _M_before_begin()._M_nxt = nullptr; - _M_assign(__ht, __mroan); + _M_assign(__ht, + [&__roan](__node_type* __n) + { return __roan(std::move_if_noexcept(__n->_M_v())); }); __ht.clear(); } __catch(...) @@ -1534,11 +1545,13 @@ __node_base* __prev_p = _M_buckets[__n]; if (!__prev_p) return nullptr; - __node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt); - for (;; __p = __p->_M_next()) + + for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);; + __p = __p->_M_next()) { if (this->_M_equals(__k, __code, __p)) return __prev_p; + if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n) break; __prev_p = __p; @@ -1796,14 +1809,14 @@ typename _Alloc, typename _ExtractKey, typename _Equal, typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, typename _Traits> - template + template std::pair::iterator, bool> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: - _M_insert(_Arg&& __v, std::true_type) + _M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, std::true_type) { const key_type& __k = this->_M_extract()(__v); __hash_code __code = this->_M_hash_code(__k); @@ -1813,7 +1826,7 @@ if (__n) return std::make_pair(iterator(__n), false); - __n = _M_allocate_node(std::forward<_Arg>(__v)); + __n = __node_gen(std::forward<_Arg>(__v)); return std::make_pair(_M_insert_unique_node(__bkt, __code, __n), true); } @@ -1822,20 +1835,22 @@ typename _Alloc, typename _ExtractKey, typename _Equal, typename _H1, typename _H2, typename _Hash, typename _RehashPolicy, typename _Traits> - template + template typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>::iterator _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: - _M_insert(const_iterator __hint, _Arg&& __v, std::false_type) + _M_insert(const_iterator __hint, _Arg&& __v, + const _NodeGenerator& __node_gen, + std::false_type) { // First compute the hash code so that we don't do anything if it // throws. __hash_code __code = this->_M_hash_code(this->_M_extract()(__v)); // Second allocate new node so that we don't rehash if it throws. - __node_type* __node = _M_allocate_node(std::forward<_Arg>(__v)); + __node_type* __node = __node_gen(std::forward<_Arg>(__v)); return _M_insert_multi_node(__hint._M_cur, __code, __node); } Index: testsuite/23_containers/unordered_set/not_default_constructible_hash_neg.cc =================================================================== --- testsuite/23_containers/unordered_set/not_default_constructible_hash_neg.cc (revision 200571) +++ testsuite/23_containers/unordered_set/not_default_constructible_hash_neg.cc (working copy) @@ -19,7 +19,7 @@ // with this library; see the file COPYING3. If not see // . -// { dg-error "default constructible" "" { target *-*-* } 271 } +// { dg-error "default constructible" "" { target *-*-* } 276 } #include Index: testsuite/23_containers/unordered_set/instantiation_neg.cc =================================================================== --- testsuite/23_containers/unordered_set/instantiation_neg.cc (revision 200571) +++ testsuite/23_containers/unordered_set/instantiation_neg.cc (working copy) @@ -19,7 +19,7 @@ // with this library; see the file COPYING3. If not see // . -// { dg-error "with noexcept" "" { target *-*-* } 253 } +// { dg-error "with noexcept" "" { target *-*-* } 258 } #include