If and else, were should I put the more likely part?

Question

I was wondering if there is a big performance difference in languages, whether you should put the more likely to be executed code in the if or in the else clause. Here is an example:

// x is a random number, or some key code from the user
if(!somespecific_keycode)
   do the general stuff
else
   do specific stuff

and the other solution

if(somespecific_keycode)
   do the specific stuff
else
   do general stuff

That depends heavily on the compiler, the compiler version, the optimizing options you chose and sometimes just the weather. But in 99.999% of all real-world cases I can think of you will most probably notice no difference. — Doc Brown, Aug 01 '12 at 16:41
There will be a performance difference... on the scale of **NANOSECONDS!** That won't be noticeable to anyone except superman. — Marlon, Aug 01 '12 at 16:48

pb2q · Accepted Answer · 2012-08-01T21:46:35.380

10

Prefer to put them in the order that makes the code clearer, which is usually having the more likely to be executed first.

edited Aug 01 '12 at 21:46

answered Aug 01 '12 at 16:41

pb2q

58,613
19
146
147

2

Fully supporting this answer. Good organizations with elaborate coding conventions would include this into rules – Roman Saveljev Aug 01 '12 at 16:49

score 8 · Answer 2 · answered Aug 01 '12 at 16:42

8

As others said: in terms of performance you should best rely on your compiler and your hardware (branch prediction, speculative execution) to do the right thing.

In case you are really concerned that these two don't help you enough, GCC provides a builtin (__builtin_expect) with which you can explicitly indicate the expected outcome of a branch.

In terms of code readability, I personally like the more likely case to be on top.

answered Aug 01 '12 at 16:42

BjoernD

4,720
27
32

I voted up this answer, and it would be better if you explained how to use __builtin_expect and gave an example. – Eric Postpischil Aug 01 '12 at 16:57
that only counts, when the compiler knows which one is more probable, when it comes to user input, the programmer knows best whats the most likely option the user will choose – Bartlomiej Lewandowski Aug 01 '12 at 17:23
An example for __builtin_expect() can be found in the documentation I linked to. – BjoernD Aug 01 '12 at 21:04

score 4 · Answer 3 · answered Aug 01 '12 at 16:39

4

Unless you experience a performance problem, don't worry about it.

If you do experience a performance problem, try switching them around and measure which variant is faster, if any of them.

answered Aug 01 '12 at 16:39

Sebastian Paaske Tørholm

49,493
11
100
118

Danil Speransky · Answer 4 · 2017-07-17T10:49:22.267

2

The common rule is to put more likely case first, it's considered to be more readable.

edited Jul 17 '17 at 10:49

answered Aug 01 '12 at 16:40

Danil Speransky

29,891
5
68
79

score 1 · Answer 5 · answered Aug 01 '12 at 16:39

1

branch prediction will cause one of those to be more likely and it will cause a performance difference if inside a loop. But mostly you can ignore that if you are not thinking at assembler level.

answered Aug 01 '12 at 16:39

Markus Mikkolainen

3,397
18
21

score 1 · Answer 6 · answered Aug 01 '12 at 16:43

This isn't necessarily a performance concern, but I usually go from specific to general to prevent cases like this:

int i = 15;

if(i % 3 == 0)
   System.out.println("fizz");
else if(i % 5 == 0)
   System.out.println("buzz");
else if(i % 3 == 0 && i % 5 == 0)
   System.out.println("fizzbuzz");

Here the above code will never say 'fizzbuzz', because 15 matches both the i % 3 == 0 and i % 5 == 0 conditions. If you re-order into something more specific:

int i = 15;

if(i % 3 == 0 && i % 5 == 0)
   System.out.println("fizzbuzz");
else if(i % 3 == 0)
   System.out.println("fizz");
else if(i % 5 == 0)
   System.out.println("buzz");

Now the above code will reach "fizzbuzz" before getting stopped by the more general conditions

score 1 · Answer 7 · answered Jul 17 '17 at 10:58

All answers have valid points. Here is an additional one:

Avoid double negations: if not this, then that, else something tends to be confusing for the reader. Hence for the example given, I would favor:
```
if (somespecific_keycode) {
    do_the_specific_stuff();
} else {
    do_general_stuff();
}
```

score 0 · Answer 8 · answered Aug 01 '12 at 16:41

0

It mostly doesn't make a difference but sometimes it is easier to read and debug if your ifs are checking if something is true or equal and the else handles when that isn't the case.

answered Aug 01 '12 at 16:41

edhedges

2,722
2
28
61

score 0 · Answer 9 · answered Aug 01 '12 at 16:42

As the others have said, it's not going to make a huge difference unless you are using this many many times (in a loop for example). In that case, put the most likely condition first as it will have the earliest opportunity to break out of the condition checking.

It become more apparent when you start having many 'else if's .

score 0 · Answer 10 · answered Aug 01 '12 at 16:42

Any difference that may arise is more related to the context than inherently with if-else constructions. So the best you can do here is develop your own tests to detect any difference.

Unless you are optimizing an already finished system or software, what I'd recommend you is avoid premature optimizations. Probably you've already heard they are evil.

score 0 · Answer 11 · answered Aug 01 '12 at 16:43

AFAIK with modern optimizing C compilers there is no direct relation between how you organize your if or loop and actual branching instructions in generated code. Moreover different CPUs have different branch prediction algorithms.

Therefore:

Don't optimize until you see bad performance related to this code
If you do optimize, measure and compare different versions
Use realistic data of varied characteristics for performance measurement
Look at assembly code generated by your compiler in both cases.

If and else, were should I put the more likely part?

11 Answers11