Question

I have this sort of C function — that is being called a zillion times:

void foo ()
{
    if (/*condition*/)
    {

    }
    else if(/*another_condition*/)
    {

    }
    else if (/*another_condition_2*/)
    {

    } 
          /*And so on, I have 4 of them, but we can generalize it*/
    else
    {

    }
 }

I have a good test-case that calls this function, causing certain if-branches to be called more than the others.

My goal is to figure the best way to arrange the if statements to minimize the branching.

The only way I can think of is to do write to a file for every if condition branched to, thereby creating a histogram. This seems to be a tedious way. Is there a better way, better tools?

I am building it on AS3 Linux, using gcc 3.4; using oprofile (opcontrol) for profiling.

Answer 1

It’s not portable, but many versions of GCC support a function called __builtin_expect() that can be used to tell the compiler what we expect a value to be:

if(__builtin_expect(condition, 0)) {
  // We expect condition to be false (0), so we're less likely to get here
} else {
  // We expect to get here more often, so GCC produces better code
}

The Linux kernel uses these as macros to make them more intuitive, cleaner, and more portable (i.e. redefine the macros on non-GCC systems):

#ifdef __GNUC__
#  define likely(x)   __builtin_expect((x), 1)
#  define unlikely(x) __builtin_expect((x), 0)
#else
#  define likely(x)   (x)
#  define unlikely(x) (x)
#endif

With this, we can rewrite the above:

if(unlikely(condition)) {
  // we're less likely to get here
} else {
  // we expect to get here more often
}

Of course, this is probably unnecessary unless you’re aiming for raw speed and/or you’ve profiled and found that this is a problem.