🔒 Locked

Object oriented slower??

Started by Floating Jul 16, 2003 at 9:55 PM 11 replies 1.6k views

Original Post

Jul 16, 2003 at 9:55 PM

Hi, I spent the last couple of days rewriting all my calculation routines (collision detection, dynamics, etc.) with dedicated classes for vectors and matrices. Now the code is much smaller, but it also runs 3-10 times slower!! I am very surprised about that. Here is what I did: Before, a vector was simply: float v[3] and a matrix: float m[4][4] all calculation routines were grouped in a static class clac with functions like:

void calc::multiply(float out[4][4],float m1[4][4],float m2[4][4])
{
	out[0][0]=m1[0][0]*m2[0][0]+m1[0][1]*m2[1][0]+m1[0][2]*m2[2][0]+m1[0][3]*m2[3][0];
	out[0][1]=m1[0][0]*m2[0][1]+m1[0][1]*m2[1][1]+m1[0][2]*m2[2][1]+m1[0][3]*m2[3][1];
	out[0][2]=m1[0][0]*m2[0][2]+m1[0][1]*m2[1][2]+m1[0][2]*m2[2][2]+m1[0][3]*m2[3][2];
	out[0][3]=m1[0][0]*m2[0][3]+m1[0][1]*m2[1][3]+m1[0][2]*m2[2][3]+m1[0][3]*m2[3][3];
	out[1][0]=m1[1][0]*m2[0][0]+m1[1][1]*m2[1][0]+m1[1][2]*m2[2][0]+m1[1][3]*m2[3][0];
	out[1][1]=m1[1][0]*m2[0][1]+m1[1][1]*m2[1][1]+m1[1][2]*m2[2][1]+m1[1][3]*m2[3][1];
	out[1][2]=m1[1][0]*m2[0][2]+m1[1][1]*m2[1][2]+m1[1][2]*m2[2][2]+m1[1][3]*m2[3][2];
	out[1][3]=m1[1][0]*m2[0][3]+m1[1][1]*m2[1][3]+m1[1][2]*m2[2][3]+m1[1][3]*m2[3][3];
	out[2][0]=m1[2][0]*m2[0][0]+m1[2][1]*m2[1][0]+m1[2][2]*m2[2][0]+m1[2][3]*m2[3][0];
	out[2][1]=m1[2][0]*m2[0][1]+m1[2][1]*m2[1][1]+m1[2][2]*m2[2][1]+m1[2][3]*m2[3][1];
	out[2][2]=m1[2][0]*m2[0][2]+m1[2][1]*m2[1][2]+m1[2][2]*m2[2][2]+m1[2][3]*m2[3][2];
	out[2][3]=m1[2][0]*m2[0][3]+m1[2][1]*m2[1][3]+m1[2][2]*m2[2][3]+m1[2][3]*m2[3][3];
	out[3][0]=m1[3][0]*m2[0][0]+m1[3][1]*m2[1][0]+m1[3][2]*m2[2][0]+m1[3][3]*m2[3][0];
	out[3][1]=m1[3][0]*m2[0][1]+m1[3][1]*m2[1][1]+m1[3][2]*m2[2][1]+m1[3][3]*m2[3][1];
	out[3][2]=m1[3][0]*m2[0][2]+m1[3][1]*m2[1][2]+m1[3][2]*m2[2][2]+m1[3][3]*m2[3][2];
	out[3][3]=m1[3][0]*m2[0][3]+m1[3][1]*m2[1][3]+m1[3][2]*m2[2][3]+m1[3][3]*m2[3][3];
}

for instance i did: calc::multiplyMatrices(matrixOut,matrixIn1,matrixIn2); calc::invertMatrix(matrix); calc::multiplyVector(matrix,vector); Now that I rewrote everything with classes:

class C3Vector  
{
public:
	C3Vector();
...
	float&	operator() (unsigned i);
	const float& operator() (unsigned i) const;
...
	C3Vector operator/ (float d);
	C3Vector operator* (float d);
	C3Vector operator+ (const C3Vector& v);
	C3Vector operator- (const C3Vector& v);
	C3Vector operator^ (const C3Vector& v);
	float operator* (const C3Vector& v);
	void operator= (const C3Vector& v);
	
	float data[3];
};

class C3X3Matrix  
{
public:
	C3X3Matrix();
...
	C3X3Matrix getTranspose();
	float&	operator() (unsigned i,unsigned j);
	const float& operator() (unsigned i,unsigned j) const;

	C3X3Matrix operator* (const C3X3Matrix& m);
	C3X3Matrix operator+ (const C3X3Matrix& m);
	C3X3Matrix operator* (const float f);
	C3Vector operator* (const C3Vector& v);
	void operator= (const C3X3Matrix& m);
	C3Vector axis[3];
};

class C4X4Matrix  
{
public:
	C4X4Matrix();
...
	C4X4Matrix getInverse();
...
	C4X4Matrix operator* (const C4X4Matrix& m);
	C4X4Matrix operator+ (const C4X4Matrix& m);
	C3Vector operator* (const C3Vector& v);
	void operator= (const C4X4Matrix& m);
		
	C3X3Matrix M;
	C3Vector X;
};

same operations as before: matrixOut=matrixIn1*matrixIn2; matrix=matrix.getInvert(); vector=matrix*vector; What went wrong? How come everything is soooo slowed down now. Thanks for your help

[edited by - Floating on July 16, 2003 10:59:34 PM]

civguy

Jul 17, 2003 at 1:37 AM

1. inline your vector/matrix operators. I.e. put the method definitions into header file and add "inline" before each member function declaration. Or alternatively, define the member functions inside the class:


class C4X4Matrix  {
  public:
  C4X4Matrix() {}
  
  C4X4Matrix& operator+=(const C4X4Matrix& m) {
    //do plus
    return *this;
  }
  //...
};

inline C4X4Matrix operator+(const C4X4Matrix& m1, const C4X4Matrix& m2) {
  C4X4Matrix tmp;
  //do plus
  return tmp;
}

That way you (probably) won't get function call overhead. But what's probably even more critical is:

2. Fix your math so that no temporaries are created. Currently you're doing:

matrixOut=matrixIn1*matrixIn2;
matrix=matrix.getInvert();
vector=matrix*vector;

Well, matrixIn1 * matrixIn2 returns a temporary. Fix it like this:
matrixOut = matrixIn1;
matrixOut *= matrixIn2;

Also, add operator*=() to do multiplication "in place". Now all calculation is done directly within matrixOut, and no temporaries are needed.

Similarly, add an operation so that you don't have to do:
matrix = matrix.getInvert();

but instead, you can do
matrix.invert();

Which inverts the matrix in place.

[edited by - civguy on July 17, 2003 2:40:14 AM]

Floating

Author

Floating

Jul 17, 2003 at 2:56 AM

Thanks Civguy!

I''ve already inlined some functions but there is no speed increase.
You are right with the temporary variables. But then if we don''t want to create any, the code becomes less readable and bigger and operator overloading loses a bit of its purpose.

Also when you say to do

matrixOut = matrixIn1;
matrixOut *= matrixIn2;

instead of

matrixOut=matrixIn1*matrixIn2;

you don''t create any temp variable. However you also have an assignement which is not needed. Am I right?

The first way does:
- assignement
- operation

the second does:
-create temp
-operation
-assignement

Creating a temp variable does only imply a stack shifting, no?

The best would to have a function which just does an operation like multiplyMatrices(out,in1,in2), but then what about OO?

Wildfire

Jul 17, 2003 at 4:04 AM

Have you tried release build? This can make quite the difference. Because if something is slower in debug mode, it doesn''t mean it''s necessarily slower in (optimized) release build.

Fredrik Dahlberg

Jul 17, 2003 at 7:11 AM

Wildfire is right, forget about optimizing temp variables and stuff and make sure you use release build.

Floating

Author

Floating

Jul 17, 2003 at 7:15 PM

Of course I have release built!

Shag

Jul 17, 2003 at 8:01 PM

Too drunk to think about this seriously ... but can''t you re-arrange the math to exclude out[][]? Therefore increasing both temporal and spacial locality?

If this makes no sense ... I appologise ... too many beers :-)

It just strikes me that all the assignments are unnecassary - just return a modified m1 or m2.

Neosmyle

Jul 17, 2003 at 11:28 PM

I''m not sure if the compiler would optimize this or not, but you should maybe have your copy ctors and assignment operators do a memcpy() instead of


m1[0][0] = m2[0][0];
m1[0][1] = m2[0][1];
etc...

Passing everything in and returning everything by reference would also be helpful.

Sailorstick

Jul 18, 2003 at 1:23 AM

IMO classes aren''t all they are cracked up to be. Your first method is easy enough to understand, and streamlined, with much less bloat than the class method. I''d switch back if I were you.
Besides, do you really need to subclass a matrix or a vector?
Probably not. So the only bonus you get is the fact that all matrix functions are in the one file. You could do that much yourself without classes...plus you get direct access if you needed it.
Your calc::multiply function would probably be better off like so:
void calc::multiply(float** out, float** m1, float** m2)
but I may be wrong.

Beer Hunter

122

Beer Hunter

Jul 18, 2003 at 3:41 AM

Some temporaries can be optimised away. Try it.

The trick is to write ''Foo a = b + c;'', and not ''Foo a; a = b + c;''.

Last Attacker

Jul 18, 2003 at 5:18 AM

There is a way to check if the compiler optimised something.
But you have to understand assembly to notice :

Make a break-point on the place you which to check in your code.
If you have Visual Studio''s C++, then compile and run in debug mode (to stop at the break-point) when you have reached the break point, open up the dissasebmly window (should be in the View Menu) and check it out.

Another way to optimise your code is to check how the compiler compiled it to assembly and if you think you can optimise it better (trust me you can, I''ve rewritten about 5-10 functions that perform better than what the compiler did) then you know how to, just include the asm{} and away you go. (It may sound simple but normally isn''t you need a whole lot of concentration to convert from C++ to assembly but code in C++ first before attemting ASM).

Well I hope this was helpfull.

Check yah guys later!

----------=Last Attacker=----------

E-mail: laextr@icqmail.com

jesterlecodeur

Jul 18, 2003 at 6:52 AM

http://www.flipcode.com/tutorials/tut_fastmath.shtml

Very fast but very complicate.

Topic Locked

This topic has been locked by a moderator. New replies are not allowed.