Re: Array vs Vector performance
krisprad@yahoo.co.uk wrote:
I am experimenting with array and vector speeds using the following
code snippets on Windows Visual Studio. The code accesses all elements
of vector/array iterating several times.
...
There appears to be significant performance difference between the
array and the vector.
...
Is this difference expected or am I missing something?
As you found out already, this depends on several factors
in Visual Studio. I tried to make some sense out of this
and made the arrays into a structure:
...
struct Testinf {
size_t size;
int a[SIZE];
std::vector<int> v;
Testinf() : size(SIZE), v(SIZE) {}
};
...
In Visual C++ 9, the element that comes first
in the struct "determines" which testing function
will be faster (the effect will be more pronounced
if you use smaller arrays w/more iterations.)
"array first" (as above), SIZE=1000000, MAX_ITER=1000:
TestArray 4.734 sec
TestVector 4.984 sec
"vector first", SIZE=1000000, MAX_ITER=1000:
TestArray 5.016 sec
TestVector 4.844 sec
(did three runs, took best result of each, Athlon-64/3200+, WinXP)
In gcc (Cygwin gcc 3.4.4, Linux gcc 4.3.2)
and Intel C++ (icc 10.1-32 Linux), there's not
much of a difference to be seen. I changed the
array sizes to *1000000* and the iteration count
to *1000*. Otherwise, the arrays would be too
small to get meaningful results (imho).
Cygwin gcc 3.4.4 (-O3, XP, Athlon 64/3200+):
TestArray 4.703 sec
TestVector 4.625 sec
Intel C++ 10.1 (-O3, Linux, P4/2666MHz)
TestArray 3.56 sec
TestVector 3.58 sec
GCC 4.3.2 (-O3, Linux, P4/2666MHz)
TestArray 3.6 sec
TestVector 3.6 sec
I'd think that memory alignment issues are
of much more importance here (compared to
vector<> vs. array considerations).
I would also like to know if this code could be further simplified
for instrumentation, by eliminating cout-s for example.
Out of curiosity, I tried to apply a well known "Perl-idiom"
to this problem ;-) See appendix.
Regards
Mirco
---- 8< ----
#define _SECURE_SCL 0
#include <ctime>
#include <vector>
#include <iostream>
int const SIZE = 1000000, MAX_ITER = 1000; // size of vector/array and ...
struct Testinf {
size_t size;
int a[SIZE];
std::vector<int> v;
Testinf() : size(SIZE), v(SIZE) {}
};
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int TestArray(Testinf& t, size_t maxiter) // accessing array
{
t.a[0] = 3;
int r = 0;
for(size_t c=0; c<maxiter; ++c) {
for(size_t i=1; i<t.size; ++i) {
t.a[i] = t.a[i-1] + i;
r += t.a[i];
}
}
return r;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int TestVector(Testinf& t, size_t maxiter) // accessing vector
{
t.v[0] = 3;
int r = 0;
for(size_t c=0; c<maxiter; ++c) {
for(size_t i=1; i<t.size; ++i) {
t.v[i] = t.v[i-1] + i;
r += t.v[i];
}
}
return r;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
struct Fu {
const char *t; // a literal name
int (*PTestF)(Testinf&, size_t); // and a function, set by ctor
Fu(int(*f)(Testinf&, size_t), const char *name) : t(name), PTestF(f) {}
};
void timethese(size_t maxiter, Fu f[], Testinf& t, size_t n); // tests an array of Fu
int main()
{
static Testinf t; // static in order to avert stack problems
Fu f[] = {
Fu(TestArray, "TestArray"),
Fu(TestVector, "TestVector")
};
size_t n = sizeof(f)/sizeof(*f);
timethese(MAX_ITER, f, t, n);
return 0;
}
double timethis(Fu f, Testinf& t, size_t maxiter)
{
time_t time = clock();
int x = 1 & (f.PTestF(t, maxiter) & ~0x1); // fool optimizer,
return double(clock()-time-x) / CLOCKS_PER_SEC; // x will be always 0
}
void timethese(size_t maxiter, Fu f[], Testinf& t, size_t n)
{
for(size_t i=0; i<n; i++)
std::cout << f[i].t << "\t"
<< timethis(f[i], t, maxiter) << " sec"
<< std::endl;
}
---- 8< ----
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]