Relying on compiler optimizations with C++

Question

Question: is it OK to rely on compiler optimizations while coding?

Let's say I need to calculate calculateF and calcuateG which both depend on another value returned by getValue. Sometimes I need both values, some other times I only need one of those values.

// some function
double getValue(double value)
{
    double val(0.0);
    // do some math with value
    return val;
}

// calculateF depends on getValue
double calculateF(double value)
{
    double f(0.0);
    auto val = getValue(value);
    // calculate f which depends on val (and value)
    return f;
}

// calculateG depends on getValue
double calculateG(double value)
{
    double g(0.0);
    auto val = getValue(value);
    // calculate g which depends on val (and value)
    return g;
}

Now, I could write this more elegantly:

std::pair<double,double> calculateFG(double value)
{
    auto val = getValue(value);
    double f(0.0), g(0.0);
    // calculate f and g which depend on val (and value)
    return {f,g};
}

If I want both values:

double value(5.3);
auto [f,g] = calculateFG(value); // since C++17
// do things with f and g

If I want only 1 value, say f, I just don't use g and it will be optimized out. So, the performance of calculateFG is exactly the same as calculateF if I don't use g. Furthermore, if I need both f and g, I only need to call getValue once instead of twice.

The code is cleaner (only 1 function calculateFG instead of calculateF and calculateG), and faster if both f and g are required. But is relying on the compiler optimization a wise choice?

Answer 1

It is hard to say if it is wise or not. It depends on compiler optimization - function inlining.

• If calculateFG is inlined, the complier can optimize out the unused one. Once inlined, g is unused so all the code for generating g is dead code^[1]. (It may not be able, for example, if the calculation code has some side effects)

• If not, I don't think the optimization can be applied(Always calc f and g).

Now you may wonder if it is possible to always inline specific functions.

Please note that giving inline keyword does not force the compiler to inline that function. It is just a hint. With or without the keyword, it is the compiler's call. It seems like there is non-standard way though - How do I force gcc to inline a function?

^{[1]_{Relavent compiler options : -fdce -fdse -ftree-dce -ftree-dse}}

Answer 2

Modern C++ compilers are pretty good at optimization choices, given the chance.

That is to say, if you declare a function inline, that does not mean the optimizer will actually ilnine it 100% of the time. The effect is more subtle: inline means you avoid the One Definition Rule, so the function definition can go into header files. That makes it a lot easier for the optimizer.

Now with your examples of double [f,g], optimizers are very good at tracking the use of simple scalar values, and will be able to eliminate write-only operations. Inlining allows the optimizer to eliminate unnecessary writes in called functions too. For you, that means the optimizer can eliminate writes to f in calculateFG when the calling code does not use f later on.

Answer 3

Perhaps it is best to turn the logic inside-out. Instead of computing a value (getValue()), passing it to both calculateF() and calculateG(), and passing the results to another place, you can change the code to pass the functions instead of computed values.

This way, if the client code does not need calculateF's value, it won't call it. The same with calculateG. If getValue is also expensive, you can call it once and bind or capture the value.

These are concepts used extensively in functional programming paradigm.

You could rewrite your calculateFG() function more or less like this:

auto getFG(double value)
{
    auto val = getValue(value);
    return {
        [val]{ return calculateF(val); },
        [val]{ return calculateG(val); }};
}

Answer 4

It sounds like your goal is to only perform the (potentially expensive) calculations of getValue(), f, and g as few times as possible given the caller's needs -- i.e. you don't want to perform any computations that the caller isn't going to use the results of.

In that case, it might be simplest to just implement a little class that does the necessary on-demand computations and caching, something like this:

#include <stdio.h>
#include <math.h>

class MyCalc
{
public:
   MyCalc(double inputValue)
      : _inputValue(inputValue), _vCalculated(false), _fCalculated(false), _gCalculated(false)
   {
      /* empty */
   }

   double getF() const
   {
      if (_fCalculated == false)
      {
         _f = calculateF();
         _fCalculated = true;
      }
      return _f;
   }

   double getG() const
   {
      if (_gCalculated == false)
      {
         _g = calculateG();
         _gCalculated = true;
      }
      return _g;
   }

private:
   const double _inputValue;

   double getV() const
   {
      if (_vCalculated == false)
      {
         _v = calculateV();
         _vCalculated = true;
      }
      return _v;
   }

   mutable bool _vCalculated;
   mutable double _v;

   mutable bool _fCalculated;
   mutable double _f;

   mutable bool _gCalculated;
   mutable double _g;

   // Expensive math routines below; we only want to call these (at most) one time
   double calculateV() const {printf("calculateV called!\n"); return _inputValue*sin(2.14159);}
   double calculateF() const {printf("calculateF called!\n"); return getV()*cos(2.14159);}
   double calculateG() const {printf("calculateG called!\n"); return getV()*tan(2.14159);}
};

// unit test/demo
int main()
{
   {
      printf("\nTest 1:  Calling only getF()\n");
      MyCalc c(1.5555);
      printf("f=%f\n", c.getF());
   }

   {
      printf("\nTest 2:  Calling only getG()\n");
      MyCalc c(1.5555);
      printf("g=%f\n", c.getG());
   }

   {
      printf("\nTest 3:  Calling both getF and getG()\n");
      MyCalc c(1.5555);
      printf("f=%f g=%f\n", c.getF(), c.getG());
   }
   return 0;
}

Answer 5

I think that it's best to write your code in a way that expresses what you are trying to accomplish.

If your goal is to make sure that certain calculations are only done once, use something like Jeremy's answer.

Answer 6

A good function should do only one thing. I would design like below.

class Calc {
    public:
    Calc(double value) : value{value}, val{getValue(value)} {
    }
    double calculateF() const;
    double calculateG() const;
    //If it is really a common usecase to call both together
    std::pair<double, double> calculateFG() const {
        return {calculateF(), calculateG()};
    }
    static double getValue(double value);
    private:
    double value;
    double val;
};

To know whether compiler will optimize will depend on the rest of the code. For example, if there was a debug message like log_debug(...), that could affect dead code removal. Compiler can only get rid of the dead code if it can prove that the code has no side effects in compile time (Even if you force inline).

Other option is, you can mark the getValue function with special compiler specific attributes like pure or const. This can force the compiler to optimize the second call of getValue. https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-g_t_0040code_007bpure_007d-function-attribute-3348