Thread: Very slow processing of vectors?

Now instead of throwing guesses all over the place, time the different parts of the code. I would time it in some way like this:

Code:

int FindAllPlats() {

 __int64 freq, time0, time1;
 QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
 int x_pos, y_pos, MPR;
 char Ac[1];

 for(y_pos=1; y_pos <= 23; y_pos++)
  for(x_pos=1; x_pos <= 78; x_pos++) {
   QueryPerformanceCounter((LARGE_INTEGER*)&time0);
   Ac[0]=ReadPos(x_pos, y_pos);
   QueryPerformanceCounter((LARGE_INTEGER*)&time1);
   std::cout << ((float)time1-(float)time0)/(float)freq << endl;
   std::cin.get();
    if(Ac[0] == Wall8)
     MPR++;
   }

 return MPR;
}

And then keep doing that with all parts of the code until you find the bottleneck.

Instead of doing something like that, it might be simpler to just use a profiler. Dev-C++ integrates one, but I'm not sure about the Borland Compiler your using (does it include an IDE?)

Did you not read my post? When swapped with a static array the speed increased greatly. Grr, how many times do I have to say this?

I cant use a static array permenantly however. It ends up being alot of memory. (32kb + 66kb? not sure. * levels) I could declare them globaly, but it would end up taking up lots of memory no matter what. It would end up taking several mb's, for a console game, thats just retarded.

Once again, when the vector array was replaced to a static the speed increased. Its not a guess, I posted my code to prove it. Something is rotten in my code, its not how many times I called this ReadConsoleOutputCharacter function.

I know where my bottleneck is as I said, its the vector. When removed or replaced, the lag vanishes.

This doesnt make sence, vectors should not be this slow.

Code:

//Static:
 for(x=0; x < TotalPlats; x++)
   Plat[x] = FindPlatform();
//Takes about .2 seconds.

Code:

//<vector>
  for(x=0; x < TotalPlats; x++)
   Plat.push_back = FindPlatform();

And bubba, my class is built based around only one tile, so I dont really need id's. Its called Platform, but its refering to the '-' character. If I do add in more platforms, the class would become alot more complex.

I cant use a static array permenantly however. It ends up being alot of memory. (32kb + 66kb? not sure. * levels) I could declare them globaly, but it would end up taking up lots of memory no matter what.

Logically, if your vector will eventually reach that size, then it will take up (roughly) the same amount of memory as well.

Once again, when the vector array was replaced to a static the speed increased. Its not a guess, I posted my code to prove it. Something is rotten in my code, its not how many times I called this ReadConsoleOutputCharacter function.

I suggest writing the smallest and simplest program that demonstrates that swapping a vector for a static array leads to such a drastic speedup. I suspect that while writing this new program, you will find out a problem in your actual code that needs to be addressed, outside of the various suggestions that have been made in this thread.

So what happens when you reserve space in the vector and treat it like the static array instead of using push_back?

I just dont see how that will make much of a difference, the memory re-allocation cant possibly take so long.

Static array:

Code:

int blah() {
 int x, TotalPlats;
 Platform Plat[13];

 SetPos(0, 0);

 TotalPlats=12;

 for(x=0; x < TotalPlats; x++)
   Plat[x] = FindPlatform();
}

Vector:

Code:

int blah() {
 int x, TotalPlats;
 vector <Platform> Plat;

 TotalPlats=12;

 for(x=0; x < TotalPlats; x++)
   Plat.push_back(FindPlatform());
}

The static array is insanely faster. When actualy infused with my code, the results are the same. The static array is always about five seconds faster.

I'm not farmiliar with vector.reverse, but it sounds to me like it reverse a block of memory, I could reserve a block based on the amount of platforms I found, but how do I use this?

Once again, dont imply its other parts of my code. Its not. This is a problem somewhere with my use of vectors. When swapped with a static array, the speed increased by five seconds or so.

Lol you guys definantly stick to what you say for a very long time -,-.

Yes the vector is slower than a static array, simply because a vector will do more calls to copyconstructors and destructors and everything. Take this code example:

Code:

#include <iostream>
#include <vector>
#include <windows.h>

using namespace std;

class Foo
{
public:
	Foo() 
	{ 
		for(int i=0; i<10000; i++)
			for(int j=0; j<10000; j++);
	}
	Foo(const Foo &rhs)
	{
		for(int i=0; i<10000; i++)
			for(int j=0; j<10000; j++);
	}
};

Foo GetFoo()
{
	return Foo();
}

int main()
{
	int x, TotalPlats;
	Foo Plat[13];

	TotalPlats=12;

	__int64 freq, time0, time1;

	QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
	QueryPerformanceCounter((LARGE_INTEGER*)&time0);
	for(x=0; x < TotalPlats; x++)
		Plat[x] = GetFoo();

	QueryPerformanceCounter((LARGE_INTEGER*)&time1);

	cout << "time0: " << (time1-time0)/(float)freq << endl;

	vector<Foo> Plat2;

	QueryPerformanceCounter((LARGE_INTEGER*)&time0);
	for(x=0; x < TotalPlats; x++)
		Plat2.push_back(GetFoo());
	QueryPerformanceCounter((LARGE_INTEGER*)&time1);

	cout << "time1: " << (time1-time0)/(float)freq << endl;
}

On my machine the static array part will run in roughly 3.45 seconds, and the vector part will run in around 16.7 seconds. But if I comment out the copyconstructor and let the vector use the default one the vector part will actually run faster than the static array part. So yes, vectors can be very slow if you do lots of expensive stuff in the copyconstructor. Otherwise vectors can actually be faster than the static arrays, so dont go around blaming the vectors for being slow, look at your code and see what might cause the major slowdown.

I wouldnt be surprised if you actually have alot of stuff going on in the copyconstructor in the Platform class.

The static array is insanely faster. When actualy infused with my code, the results are the same. The static array is always about five seconds faster.

Well, a static array is usually faster than a std::vector, it is just that the speed increase should not be so drastic. Since you are certain that std::vector is too slow, try writing a dynamic array by hand, e.g.

Code:

int blah() {
	int TotalPlats = 12;
	Platform* Plat = new Platform[TotalPlats];
	for (int x = 0; x < TotalPlats; ++x) {
		Plat[x] = FindPlatform();
	}
	delete[] Plat;
	return 0;
}

Is the above still much faster than the equivalent using std::vector?

Once again, dont imply its other parts of my code. Its not.

After having seen you use 4 loops when 2 additions and assignments would suffice, I wouldnt bet on your claim.

Aha! When a call was made to vector.reserve, it made it speed up alot. The speed between static and vector is now totaly unnoticable!

Thank you guys!

Just for the record;

Code:

 vector <Platform> Plat;

 TotalPlats=12;
 Plat.reserve(TotalPlats);

 for(x=0; x < TotalPlats; x++)
   Plat.push_back(FindPlatform());