* Victor Bazarov:
Alf said:
* Victor Bazarov:
(e-mail address removed) wrote:
[..]
In my case the structure is a POD, and zeroing it is what I want.
Also the structure is in a C library and not defined by me, so I
can't add a constructor. For memcpy(), the reason I am using it is
performance is important and the compiler I'm using inlines a
memcpy() call to a rep stos instruction on my Intel machine. I'm
only using the std::vectorto make memory management more
convenient.
Memset() rather. Also the resize() is done elsewhere, and I need to
0 all of the data repeatedly, even if the size didn't actually
change. I did not know that resize() 0'd the new elements be
default, though -- I always assumed it just used the default
constructors for objects. I'll file that away for future reference.
In such dire circumstances (3rd party struct with no access, POD for
sure, repeated need to zero it out), you should be able to get away
with memset. Most of the caution warnings you get from us are very
relevant in *general cases* when you have the entire source in your
possession, and while the struct is POD now, it might lose its
PODness somehow in the future; the use of 'memset' in such case is
a maintenance nightmare. So don't take our comments personally, do
make a mental note of them and follow the right development practices
and you're going to be alright.
Uhm, well my point was the memset is entirely superfluous.
It's not superfluous when you have to do it repeatedly.
Right. But it's superfluous in the original context of this thread, the OP's code
vector<TheStructure> s;
s.resize(100);
memset(&(s[0]), 0, sizeof(TheStructure) * s.size());
What's the
other way of setting all elements of a vector to some initial state
(like zeroing it out) that would be as fast as memset if you have to
do it many times over?
Don't know.
It seems that in practice memset is the fastest way to zero a vector of POD's:
<code>
#include <iostream>
#include <ostream>
#include <vector>
#include <algorithm>
#include <ctime>
#include <memory.h>
struct S
{
char filler[100];
};
typedef std::vector<S> SVec;
inline void clearUsingResize( SVec& v )
{
size_t const oldSize = v.size();
v.clear();
v.resize( oldSize );
}
inline void clearUsingCopy( SVec& v )
{
std::fill( v.begin(), v.end(), S() );
}
inline void clearUsingMemset( SVec& v )
{
memset( &v[0], 0, v.size()*sizeof(S) );
}
template< void(*clear)(SVec&) >
void test( char const testName[] )
{
SVec v( 1000 );
clock_t const startTime = clock();
for( int i = 1; i <= 10000; ++i )
{
clear( v );
}
clock_t const endTime = clock();
std::cout << "Testing " << testName << ":";
std::cout << double(endTime - startTime)/CLOCKS_PER_SEC << " sec.";
std::cout << std::endl;
std::cout << std::endl;
}
#define TEST( f ) test<f>( #f )
int main()
{
TEST( clearUsingResize );
TEST( clearUsingCopy );
TEST( clearUsingMemset );
}
</code>
<output>
V:\> gnuc vc_project.cpp -O2
V:\> a
Testing clearUsingResize:0.937 sec.
Testing clearUsingCopy:0.906 sec.
Testing clearUsingMemset:0.531 sec.
V:\> msvc vc_project.cpp -O2 -o b
vc_project.cpp
V:\> b
Testing clearUsingResize:0.828 sec.
Testing clearUsingCopy:0.75 sec.
Testing clearUsingMemset:0.593 sec.
V:\> _
</output>
Disclaimer: I just took the optimization option for speed from memory, might be
wrong.
However, it's not very big difference from safe way of doing it, so it's a
question whether it's really worth it.
As always in cases of optimization, measure measure measure, and identify where
optimization is really needed, and whether the trade-off is really worth it.
Cheers, & hth.,
- Alf
