I have do an extensive calculation on a big vector of integers. The vector size is not changed during the calculation. The size of the vector is frequently accessed by the code. What is faster in general: using the <code>vector::size()</code> function or using helper constant <code>vectorSize</code> storing the size of the vector? I know that compilers usually able to inline the <code>size()</code> function when setting the proper compiler flags, however, making a function inline is something that a compiler may do but can not be forced.

Interesting question. So, what's going to happened ? Well if you debug with gdb you'll see something like 3 member variables (names are not accurate): <ul> <li> <code>_M_begin</code>: pointer to the first element of the dynamic array</li> <li> <code>_M_end</code>: pointer one past the last element of the dynamic array</li> <li> <code>_M_capacity</code>: pointer one past the last element that could be stored in the dynamic array</li> </ul> The implementation of <code>vector<T,Alloc>::size()</code> is thus usually reduced to: <pre class="prettyprint"><code>return _M_end - _M_begin; // Note: _Mylast - _Myfirst in VC 2008 </code></pre> Now, there are 2 things to consider when regarding the actual optimizations possible: <ul> <li>will this function be inlined ? Probably: I am no compiler writer, but it's a good bet since the overhead of a function call would dwarf the actual time here and since it's templated we have all the code available in the translation unit</li> <li>will the result be cached (ie sort of having an unnamed local variable): it could well be, but you won't know unless you disassemble the generated code</li> </ul> In other words: <ul> <li>If you store the <code>size</code> yourself, there is a good chance it will be as fast as the compiler could get it.</li> <li>If you do not, it will depend on whether the compiler can establish that nothing else is modifying the <code>vector</code>; if not, it cannot cache the variable, and will need to perform memory reads (L1) every time.</li> </ul> It's a micro-optimization. In general, it will be unnoticeable, either because the performance does not matter or because the compiler will perform it regardless. In a critical loop where the compiler does not apply the optimization, it can be a significant improvement.

Performance of vector::size() : is it as fast as reading a variable?

I have do an extensive calculation on a big vector of integers. The vector size is not changed during the calculation. The size of the vector is frequently accessed by the code. What is faster in general: using the vector::size() function or using helper constant vectorSize storing the size of the vector? I know that compilers usually able to inline the size() function when setting the proper compiler flags, however, making a function inline is something that a compiler may do but can not be forced.

Is std::vector fast?

A std::vector can never be faster than an array, as it has (a pointer to the first element of) an array as one of its data members. But the difference in run-time speed is slim and absent in any non-trivial program. One reason for this myth to persist, are examples that compare raw arrays with mis-used std::vectors.

Is vector faster than set C++?

The time complexity for the insertion of a new element is O(log N). Vector is faster for insertion and deletion of elements at the end of the container. Set is faster for insertion and deletion of elements at the middle of the container.

Does vector take more memory than array?

Vectors are efficient and flexible. They do require a little more memory than arrays, but this tradeoff is almost always worth the benefits.

What are the advantages of vector over arrays?

A vector is a dynamic array, whose size can be increased, whereas THE array size can not be changed. Reserve space can be given for vector, whereas for arrays you cannot give reserved space. A vector is a class whereas an array is a datatype.

Interesting question.

So, what's going to happened ? Well if you debug with gdb you'll see something like 3 member variables (names are not accurate):

_M_begin: pointer to the first element of the dynamic array
_M_end: pointer one past the last element of the dynamic array
_M_capacity: pointer one past the last element that could be stored in the dynamic array

The implementation of vector<T,Alloc>::size() is thus usually reduced to:

return _M_end - _M_begin;  // Note: _Mylast - _Myfirst in VC 2008

Now, there are 2 things to consider when regarding the actual optimizations possible:

will this function be inlined ? Probably: I am no compiler writer, but it's a good bet since the overhead of a function call would dwarf the actual time here and since it's templated we have all the code available in the translation unit
will the result be cached (ie sort of having an unnamed local variable): it could well be, but you won't know unless you disassemble the generated code

In other words:

If you store the size yourself, there is a good chance it will be as fast as the compiler could get it.
If you do not, it will depend on whether the compiler can establish that nothing else is modifying the vector; if not, it cannot cache the variable, and will need to perform memory reads (L1) every time.

It's a micro-optimization. In general, it will be unnoticeable, either because the performance does not matter or because the compiler will perform it regardless. In a critical loop where the compiler does not apply the optimization, it can be a significant improvement.

Performance of vector::size() : is it as fast as reading a variable?

Tags:

c++

gcc

stl

vector

zoli2k

People also ask

1 Answers

Matthieu M.

Recent Activity

Donate For Us

Performance of vector::size() : is it as fast as reading a variable?

Tags:

c++

gcc

stl

vector

zoli2k

People also ask

1 Answers

Matthieu M.

Related questions

Recent Activity

Donate For Us