std::vector move assign patch

Marc Glisse marc.glisse@inria.fr
Tue Apr 25 21:02:00 GMT 2017


On Tue, 25 Apr 2017, Jonathan Wakely wrote:

>>>> That's only 5 more memory operations. If I tweak vector swapping to avoid 
>>>> calling swap on each member (which drops type-based aliasing information, 
>>>> that was the topic of PR64601)
>>> 
>>> I didn't really understand the discussion in the PR. I find that's
>>> true of most TBAA discussions.
>>> 
>>> std::swap(T& x, T& y) is hard to optimise because we don't know that
>>> the dynamic type of the thing at &x is the same type as T?
>> 
>> std::swap<int*> only knows that it is dealing with pointers to integers, so 
>> _M_start from one vector might be in the same location as _M_finish from 
>> some other vector...
>> 
>> When I access __x._M_start directly, I am accessing some part of a 
>> _Vector_impl, and 2 _Vector_impl can only be the same or disjoint, they 
>> cannot partially overlap.
>
> I see. I'm surprised that after the std::swap calls get inlined, so
> that the references can be "seen through", the pessimisation is still
> present.

(this is my understanding of how compilers handle TBAA)

The only things that carry information are the declaration of an object, 
and accesses (read/write). Pointers and references are meaningless until 
the object is accessed, they are just a fancy way to do pointer 
arithmetic, and the way the object is accessed carries the whole 
information. If I have a reference p to std::pair<int,int>, p.first=42 or 
x=p.first access the first element of a pair, while *&p.first=42 or 
x=*&p.first are only accesses to an int. p.first and q.second cannot 
alias, while *&p.first and *&q.second can.

In other words
illegal: ((std::pair<int,int>*)&p.second)->first=2
allowed: *(int*)&((std::pair<int,int>*)&p.second)->first=2
because there is no actual access through the "wrong" pointers (I added a 
redundant cast to int* to try and clarify the difference).

(actually, gcc wrongly optimizes *&x to x so you need to use an 
intermediate variable to notice this: auto y=&x; ... *y ... while clang is 
stricter)

I think this is horrible but that's not a fight I feel capable of leading.

If what I said is too hard to understand, it is fine to ignore. And if it 
is wrong, I'll be happy to learn that :-)

>> By the way, do we have a policy on writing if(p)delete p; vs directly 
>> delete p; which does nothing for p==0? There are cases where the extra 
>> shortcut is a nice optimization, others where it is redundant work. At -Os, 
>> the middle-end could optimize if(p)free(p) to free(p) in the future.
>
> No official policy. I always consider the if (p) to be redundant
> noise, but that's based on readability and correctness, not
> performance.

I was going to say we have that in std::vector's destructor, but 
allocators do not have the same property as free/delete, deallocate can 
only be called with something allocate returned, not 0. So we don't have a 
choice.

-- 
Marc Glisse



More information about the Libstdc++ mailing list