Re: std::vector move assign patch

[Jonathan Wakely <jwakely at redhat dot com>]

On 25/04/17 13:52 +0100, Jonathan Wakely wrote:
> On 24/04/17 22:10 +0200, Marc Glisse wrote:
> > It seems that this patch had 2 consequences that may or may not have 
> > been planned. Consider this example (from PR64601)
> >
> > #include <vector>
> > typedef std::vector<int> V;
> > void f(V&v,V&w){ V(std::move(w)).swap(v); }
> > void g(V&v,V&w){ v=std::move(w); }
> >
> > 1) We generate shorter code for f than for g, probably since the fix 
> > for PR59738. g ends up zeroing v, copying w to v, and finally 
> > zeroing w, and for weird reasons (and because we swap the members 
> > one by one) the standard prevents us from assuming that v and w do 
> > not overlap in weird ways so we cannot optimize as much as one might 
> > expect.
>
> f has an additional precondition (that the allocators of the vectors
> being swapped must propagate on swap or be equal) and so the swap code
> doesn't have to worry about non-equal allocators.
>
> g has to be able to cope with the case where the allocator doesn't
> propagate and isn't equal, and so is more complicated.
>
> However, the propagation trait is known at compile-time, and for the
> common case so is the equality condition, so it's unfortunate if that
> can't be simplified (I'm sure you've analysed it carefully already
> though!)

I tried the attached patch, but it doesn't make any difference
(unsurprisingly, because after inlining we know that:

 if (__rv.get_allocator() != __m)

is false, so making it a compile-time condition doesn't change
anything).

It might be a nice improvement anyway, as it means the
allocator-extended constructor doesn't require movable types if the
allocators are always equal. It extends the set of types that can be
used with that constructor.


> > 2) g(v,v) seems to turn v into a nice empty vector,
>
> Yes.
>
> > while f(v,v) turns it into an invalid vector pointing at released 
> > memory.
>
> Does it?! I don't see that happening, and it's a bug if it does.
>
> > Since 2) is a nice side-effect, it may not be worth rewriting 
> > operator= in a way that improves 1) but loses 2). Anyway, just 
> > mentioning this here.

diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h
index fb88212..97c03ac 100644
--- a/libstdc++-v3/include/bits/stl_vector.h
+++ b/libstdc++-v3/include/bits/stl_vector.h
@@ -359,14 +359,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       noexcept(_Alloc_traits::_S_always_equal())
       : _Base(std::move(__rv), __m)
       {
-	if (__rv.get_allocator() != __m)
-	  {
-	    this->_M_impl._M_finish =
-	      std::__uninitialized_move_a(__rv.begin(), __rv.end(),
-					  this->_M_impl._M_start,
-					  _M_get_Tp_allocator());
-	    __rv.clear();
-	  }
+	_M_move_elements(std::move(__rv), __m,
+			 __bool_constant<_Alloc_traits::_S_always_equal()>());
       }
 
       /**
@@ -1522,14 +1516,33 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
 
 #if __cplusplus >= 201103L
     private:
+      // Used by allocator-extended move constructor for always-equal allocator
+      void
+      _M_move_elements(vector&& __rv, const allocator_type& __m, true_type)
+      { }
+
+      // Used by allocator-extended move constructor for allocators that might
+      // be unequal.
+      void
+      _M_move_elements(vector&& __rv, const allocator_type& __m, false_type)
+      {
+	if (__rv.get_allocator() != __m)
+	  {
+	    this->_M_impl._M_finish =
+	      std::__uninitialized_move_a(__rv.begin(), __rv.end(),
+					  this->_M_impl._M_start,
+					  _M_get_Tp_allocator());
+	    __rv.clear();
+	  }
+      }
+
       // Constant-time move assignment when source object's memory can be
       // moved, either because the source's allocator will move too
       // or because the allocators are equal.
       void
       _M_move_assign(vector&& __x, std::true_type) noexcept
       {
-	vector __tmp(get_allocator());
-	this->_M_impl._M_swap_data(__tmp._M_impl);
+	const vector __tmp(std::move(*this), get_allocator());
 	this->_M_impl._M_swap_data(__x._M_impl);
 	std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
       }