CODEWITHSUNDEEP
performancelanguage-agnosticprogramming-languages
Si_plus_plus
Si_plus_plus

Reputation: 7

Are boolean operations slower than mathematical operations in loops?

I really tried to find something about this kind of operations but I don't find specific information about my question... It's simple: Are boolean operations slower than typical math operations in loops?

For example, this can be seen when working with some kind of sorting. The method will make an iteration and compare X with Y... But is this slower than a summatory or substraction loop?

Example: Boolean comparisons

for(int i=1; i<Vector.Length; i++) if(Vector[i-1] < Vector[i])

Versus summation:

Double sum = 0;

for(int i=0; i<Vector.Length; i++) sum += Vector[i];

(Talking about big length loops)

Which is faster for the processor to complete? Do booleans require more operations in order to return "true" or "false" ?

Upvotes: 0

Views: 368

Answers (1)

Julien Guertault
Julien Guertault

Reputation: 1334

Short version

There is no correct answer because your question is not specific enough (the two examples of code you give don't achieve the same purpose).

If your question is:

Is bool isGreater = (a > b); slower or faster than int sum = a + b;?

Then the answer would be: It's about the same unless you're very very very very very concerned about how many cycles you spend, in which case it depends on your processor and you need to read its documentation.

If your question is:

Is the first example I gave going to iterate slower or faster than the second example?

Then the answer is: It's going to depend primarily on the values the array contains, but also on the compiler, the processor, and plenty of other factors.

Longer version

On most processors a boolean operation has no reason to significantly be slower or faster than an addition: both are basic instructions, even though comparison may take two of them (subtracting, then comparing to zero). The number of cycles it takes to decode the instruction depends on the processor and might be different, but a few cycles won't make a lot of difference unless you're in a critical loop.

In the example you give though, the if condition could potentially be harmful, because of instruction pipelining. Modern processors try very hard to guess what the next bunch of instructions are going to be so they can pre-fetch them and treat them in parallel. If there is branching, the processor doesn't know if it will have to execute the then or the else part, so it guesses based on the previous times.

If the result of your condition is the same most of the time, the processor will likely guess it right and this will go well. But if the result of the condition keeps changing, then the processor won't guess correctly. When such a branch misprediction happens, it means it can just throw away the content of the pipeline and do it all over again because it just realized it was moot. That. does. hurt.

You can try it yourself: measure the time it takes to run your loop over a million elements when they are of same, increasing, decreasing, alternating, or random value.

Which leads me to the conclusion: processors have become some seriously complex beasts and there is no golden answers, just rules of thumb, so you need to measure and profile. You can read what other people did measure though to get an idea of what you should or should not do.

Have fun experimenting. :)

Upvotes: 3

Related Questions