Re: Optimizing a function?

I have a function that gets called for 512*512*350 times. In this
function 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_split;
    key = x_dir + y_dir + z_dir;
    return key;
  }

The number of elements in the std::vector<MyObj> is fixed. When the
vectors 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)
that is expensive when called so many times?