Speed Test: std::Vector vs Array

March 12, 2010
by hevi

Most recently I have been working on a multithreaded ray tracer in order to port it to CUDA so I am not using any recursion. The first step is implementing the ray tracer without using any acceleration structure. So I simply test a ray with all the objects in a scene thus I needed to decide using whether an array or a vector.
As the current code strongly relies on the data structure I am using, I wanted to test the iteration speed of std::vector versus array.

Here is the code I used for testing.

#include 
#include 
#include 
#include 
#include 
#include 
#include 
typedef DWORD TIME_TYPE;


#define BEGIN_TIMING(repeat)	 TIME_TYPE dwStartTime = timeGetTime(); 	for(int __i = 0; __i < repeat; __i++){
#define END_TIMING		}; TIME_TYPE __ret = (timeGetTime() - dwStartTime); cout<< __FUNCTION__ << "\t\t: elapsed time =\t"<<__ret<* classAVector;
ClassA** classAArray;

TIME_TYPE testFillInArray()
{
	BEGIN_TIMING(1)
		classAArray = new ClassA*[g_uiTestSize];
		for(int i =0; i < g_uiTestSize; i++)
		{
			classAArray[i] = new ClassA();
		}
	END_TIMING
}

TIME_TYPE testFillInVector()
{
	BEGIN_TIMING(1)
		classAVector = new vector();
		for(int i =0; i < g_uiTestSize; i++)
		{
			classAVector->push_back(new ClassA());
		}
	END_TIMING
}

TIME_TYPE testDestroyArray()
{
	BEGIN_TIMING(1)
		for (int i = 0; i < g_uiTestSize; i++)
		{
			delete classAArray[i];
		}
		delete [] classAArray;
	END_TIMING
}

TIME_TYPE testDestroyVector()
{
	BEGIN_TIMING(1)
		for  (int i = 0; i < g_uiTestSize; i++)
		{
			delete (*classAVector)[i];
		}
		delete classAVector;

	END_TIMING
}

TIME_TYPE testIterateVector(void)
{
	BEGIN_TIMING(g_uiRepeatCount)
	ClassA *pClassA;

/*
	const int sz = classAVector->size();
	for (int i = 0; i < sz; i++)
	{
		pClassA = (*classAVector)[i];		
		pClassA->a++;
		pClassA->b++;
		pClassA->c++;
		pClassA->d++;
	}*/



	vector::iterator it = classAVector->begin();
		const vector::iterator endIt = classAVector->end();
		while(it != endIt)
		{
			pClassA = (*it);
			pClassA->a++;
			pClassA->b++;
			pClassA->c++;
			pClassA->d++;
			it++;
		}

	END_TIMING
}

TIME_TYPE testIterateArray(void)
{
	BEGIN_TIMING(g_uiRepeatCount)
	ClassA *pClassA;
	for (int i =0; i < g_uiTestSize; i++)
	{
		pClassA = classAArray[i];
		pClassA->a++;
		pClassA->b++;
		pClassA->c++;
		pClassA->d++;

	}
	END_TIMING
}

void verify()
{
	cout<<"verifying"<at(i)->a )
		{
			cout << "error!:" << i <
Here is the code to download
Results

Results are striking indeed. If you compiling the code in Release mode without any run-time error checking and disabled exection support iterating a Vector by using std::vector<>::iterator is almost as fast as using array.
However testing them on debug mode shows the difference, iteration time is terribly slow on std::vector ; about 60 times slower.
Conclusion

std::vector is almost as fast as using a static array on release mode (using Visual Studio 2008) but terribly slow on debug mode. So if your code is running slow on the debug mode, don't give up std::vector and give a go on the release mode.