stl vector performance
barbaros
Is there any advantage in performing a reserve operation before
inserting a large number of zeroes in an empty vector ?
Let me be more specific. In the code below, does the second line bring
any increase in performance ?
vector<float> v;
v.reserve(1000);
v.insert(v.end(),1000,0.0);
Note: I am not interested in using directly the constructor, e.g.
vector<float> v(1000,0.0);
Thank you. Cristian Barbarosie
http://cmaf.ptmat.fc.ul.pt/~barbaros/
Victor Bazarov
> Is there any advantage in performing a reserve operation before
> inserting a large number of zeroes in an empty vector ?
Impossible to tell without measuring.
> Let me be more specific. In the code below, does the second line bring
> any increase in performance ?
>
> vector<float> v;
> v.reserve(1000);
> v.insert(v.end(),1000,0.0);
You need to have your program run in two variations, with and without
the call on the second line, and then compare the time it takes.
> Note: I am not interested in using directly the constructor, e.g.
> vector<float> v(1000,0.0);
Why? The vector is empty, per requirements. You can always construct
and new vector and assign:
v = vector<float>(1000, 0.0f);
or use the swap idiom:
vector<float>(1000, 0.0f).swap(v);
which basically does the same thing as the assignment, only [usually]
faster.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Bo Persson
> Hello,
>
> Is there any advantage in performing a reserve operation before
> inserting a large number of zeroes in an empty vector ?
>
> Let me be more specific. In the code below, does the second line
> bring any increase in performance ?
>
> vector<float> v;
> v.reserve(1000);
> v.insert(v.end(),1000,0.0);
>
Highly unlikely. The insert function sees that you want to add 1000
new members, and can do a reserve internally if needed.
Generally, you should not try to outsmart your compiler. It hardly
ever works!
Bo Persson
Juha Nieminen
>> vector<float> v;
>> v.reserve(1000);
>> v.insert(v.end(),1000,0.0);
>>
>
> Highly unlikely. The insert function sees that you want to add 1000
> new members, and can do a reserve internally if needed.
>
> Generally, you should not try to outsmart your compiler. It hardly
> ever works!
I think in this case it's completely the work of the library rather
than the compiler.
Juha Nieminen
> Hello,
>
> Is there any advantage in performing a reserve operation before
> inserting a large number of zeroes in an empty vector ?
>
> Let me be more specific. In the code below, does the second line bring
> any increase in performance ?
>
> vector<float> v;
> v.reserve(1000);
> v.insert(v.end(),1000,0.0);
The implementation of std::vector in your compiler would have to be
really, really stupid if its insert() function didn't allocate memory
for all the inserted elements in one single step, given that it knows
exactly how many of them are being inserted.
If you inserted using a forward iterator range, then there might be a
benefit in reserving space for the new elements (if you know how many of
them there are) because the library has no way of knowing in advance
(ie. before traversing the iterator range) how many elements will be
inserted. (If you use a random access iterator range, then some library
implementations might use template magic to detect that this is the
case, in which case it can allocate the necessary memory in advance.
However, this might not be the case with all possible STL implementations.)
barbaros
So, I understand the following four pieces of code should be roughly
equivalent
1: vector<float> v;
v.reserve(1000);
v.insert(v.end(),1000,0.0f);
2: vector<float> v;
v.insert(v.end(),1000,0.0f);
3: vector<float> v;
v = vector<float>(1000, 0.0f);
4: vector<float> v;
vector<float>(1000, 0.0f).swap(v);
Victor Bazarov
Equivalent in the final result, yes. The #3 has a drawback of creating
duplicate storage before the temporary is destroyed, so it might be
slightly less efficient than others.
Why, do you have any timing results to share?
barbaros
> Why, do you have any timing results to share?
No, I was only trying to understand how things work in STL.
By the way, here is why I need this vector:
http://cmaf.ptmat.fc.ul.pt/~barbaros/en/tensor.cpp
It is a class for implementing a tensor of an arbitrary order.
A tensor is like a matrix, but can have more than two indices.
Vectors are order one tensors, matrices are order two tensors.
Cristian Barbarosie
http://cmaf.ptmat.fc.ul.pt/~barbaros
mojmir
> It is a class for implementing a tensor of an arbitrary order.
in many situations you know the order ahead and therefore you
can avoid unnecessary allocations. some solution based on
parametrisation "template <size_t Order>" may perform better.
depends on our needs, of course.
best regards,
mojmir
barbaros
> in many situations you know the order ahead and therefore you
> can avoid unnecessary allocations. some solution based on
> parametrisation "template <size_t Order>" may perform better.
> depends on our needs, of course.
I do not know how to parametrize the number of (int) arguments of the
constructor or of the operator().
Is it possible ?
Cristian Barbarosie
http://cmaf.ptmat.fc.ul.pt/~barbaros
Victor Bazarov
> On Feb 24, 8:08 am, mojmir <svobod...@gmail.com> wrote:
>> in many situations you know the order ahead and therefore you
>> can avoid unnecessary allocations. some solution based on
>> parametrisation "template <size_t Order>" may perform better.
>> depends on our needs, of course.
>
> I do not know how to parametrize the number of (int) arguments of the
> constructor or of the operator().
>
> Is it possible ?
Not currently, AFAIK.
James Kanze
And the complexity requirements of the function in the standard
require the implementation of the library to do the right thing.
--
James Kanze (GABI Software) email:james...@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34