GammaLib

• GSkyDir implements the actual dist computation
• GSkyDir2 implements a precomputation cache and the methods sin_dec and cos_dec
• GSkyDir3 implements a precomputation cache and the cache computations are directly performed in the relevant class
• GSkyDir4 implements a dynamic allocation of a precomputation cache, and the cache computations are directly performed in the relevant class

The main difference between GSkyDir2 and GSkyDir3 is that no overhead in calling sin_dec and cos_dec is needed in the latter, while the former needs function calls, although the sin_dec and cos_dec methods have been declared inline.

Computations have been done using the nested loop

    // Loop
    double sum = 0.0;
    for (int outer = 0; outer < nouter; ++outer) {
        GSkyDir crab( 83.6331,  22.0145);
        GSkyDir vela(128.8361, -45.1764);
        for (int inner = 0; inner < ninner; ++inner) {
            double dist = crab.dist(vela);
            sum += dist;
        }
    }

Here a CPU benchmark on Mac OS X for 10000000 / ninner iterations, where ninner was selected to be 1, 2, 3, 10, 100 and 1000:

GSkyDir is obviously fastest when the dist computation is never reused (ninner=1). GSkyDir3 comes closets to the results, since only little overhead is involved with testing the existence of precomputed values. GSkyDir4 is worst, as the dynamic allocation of the cache memory takes some time. The dynamic allocation penalty is only recovered after a few reuses of the values.

If the precomputed values are reused (ninner>1), GSkyDir3 works best, taking only 45% of the time needed for the original method for (ninner>100). The drawback of this method is that the memory held by the class is essentially doubled with respect to the original class. If precomputed values are dynamically allocated, about 50% of the time is needed for (ninner>100).

For comparison, here the same table on galileo (32 Bit Linux system):

The general behavior is similar, yet the dynamic memory allocation penalty is considerably smaller. With a single reuse of the cache, the GSkyDir4::dist method becomes faster than the GSkyDir::dist method. For (ninner>100), the speed penalty for dynamic memory allocation completely vanished.

And finally the same table for kepler (64 Bit Linux system):

Here the dynamic memory allocation penalty is larger, but the code is still faster than the original code for (ninner>1). The computation time for large ninner is 40% of the original time.

Conclusion: The implementation of a cache should be considered. Using additional members roughly doubles the size of GSkyDir, but reduces the computing time to 40-45% of the actual duration on all tested systems. Using a dynamically allocated cache will slow down significantly the computations if the values are never reused, hence this approach should not be pursued.

The pre computation cache has been implemented. Still need to check the impact on the result.

Here the actual speed change (including also modifications in the matrix stack, vector and model access):