Performance issues with simple computing

EDIT 2: Reduce program computation time by 16%! See bottom for calculation

I wrote an N-body simulator that implements the Barnes-Hut algorithm. Now I have an innocent function called CheckNode

. It's simple and doesn't take a lot of computation time, but the problem is that it is called millions of times, so it takes most of the computation time between each frame.

I have profiled the code and this function is responsible for 84.58%

the total computation time, and this is only with 10K particles, when I do it with 10x precision, this function uses more and more percentage.

Now here's a function, with the percentage of time spent on the right in red.

Now, there are some disturbing things here. As a simple if statement taking 9.17%

, and another if statement is over 20% of the computation time! Is there even the slightest optimization that can be done here that will be multiplied by millions of function calls to make my program run faster?

EDIT:

Here's the function CalculateForceNode

:

void CalculateForceNode(Body* bi, Node* bj)  //bi is being attracted to bj. 15 flops of calculation
{
    //vector from the body to the center of mass
    double vectorx = bj->CenterOfMassx - bi->posX;
    double vectory = bj->CenterOfMassy - bi->posY;

    //c^2 = a^2 + b^2 + softener^2
    double distSqr = vectorx * vectorx + vectory * vectory + Softener * Softener;

    // ivnDistCube = 1/distSqr^(3/2)
    double distSixth = distSqr * distSqr * distSqr;
    double invDistCube = 1.0f / (sqrt(distSixth));

    double Accel = (bj->TotalMass * invDistCube * _GRAV_CONST);

    bi->AccelX += vectorx * Accel;
    bi->AccelY += vectory * Accel;
}

      

        
        
        
      

    

EDIT 2:

Optimization results

Now the function CheckNode

takes 82.03%

all the computation time (measured during 1 min. 37 s of the sample), in contrast to the previously taken one 84.58%

.

Now the logic says that the remaining 15%

computation time coincides with the remaining computation time of the 18%

second program. Thus, these identical periods (the same code) took the 15%

first program and the 18%

second program. Allowing time for this other code to complete x

, the first program took 1/0.15

= 6.666x

and the second took 1/0.18

= 5.555x

. Then you can find the fraction that 5.555x

has 6.666x

, which is calculated as ~0.83

, and for that there was ( 1 - 0.83 = 0.16

) 16% reduction in program calculation time!