Re: Optimizing a function?
carl wrote:
I have a function that gets called for 512*512*350 times. In this functio=
n
there is a loop that gets run each time the function is called:
myFun(VectorType point) {
std::vector<MyObj> & myobjs =this->FindMyObjs(point);
int num = myobjs.size();
for (int i=0; i<num; i++) {
// Do stuff with each neighbor
}
}
Where FindMyObjs(point) is a function that looks up the point in:
std::map<int, std::vector<MyObj>> m_myMap;
which has been created before the program is run:
std::vector<MyObj> FindMyObjs(VectorType point) {
int key = computeKey(point);
return m_myMap[key];
}
The computeKey(point) looks like this:
unsigned int computeKey(VectorType location ) {
unsigned int key = 0;
int x_dir = floor((location[0]/m_cellSize[0]));
int y_dir = floor((location[1]/m_cellSize[1]))*m_split;
int z_dir = floor((location[2]/m_cellSize[2]))*m_split*m_spl=
it;
key = x_dir + y_dir + z_dir;
return key;
}
The number of elements in the std::vector<MyObj> is fixed. When the ve=
ctors
contains 216 elements the program takes around 50 seconds to complete (on=
a
3 GHZ machine with 6GB RAM and code compiled for release, using Visual
Studio 2008).
I have tried to remove the code from the while body but is has almost no
effect on the computation time.
Am I missing something very basic c++ optimization skills there or is the
program not meant to run faster on this machine?
I have made sure that only references to the already existing data
structures are used. Could it be the computeKey (3 floor operations) t=
hat
is expensive when called so many times?
It's time to profile your program. A profiler can find out the
bottleneck on a real machine, while a complexity analysis works on an
abstract one(and is a very old one).
For example, floor() could be expensive on some machine while cheap on
others. The current system loads also affects your program.
Furthermore, cache performance of your code affects the run time for
about 20% ~ 200%. It's relates to the layout of your program's data
and the pattern your program access the data in the memory.
The optimization setting of your compiler is also important. Read the
manual carefully.
Since you can't offer a compilable source code, I can't say nothing
for your code