branchless min and max for integer (suggestion)

[RamonUnch]

I remember playing around a while back with min and max function that had to be used a lot. in the end I used branches because on modern CPU well predicted branches are often faster than branch-less equivalent. For min and max I remember using those old funcs I read somewhere...

inline int Imin(int a, int b) { return b ^ ((a ^ b) & -(a < b)); }
inline int Imax(int a, int b) { return a ^ ((a ^ b) & -(a < b)); }

On 386/486 the following will be maybe faster:

inline int Imin(int a, int b) { return b + ((a-b) & (a-b)>>31); }
inline int Imax(int a, int b) { return a - ((a-b) & (a-b)>>31); }

In Doom those min and max functions are not common, however with a bit of rewriting, branches can often be avoided like in the case of your last commit (just checked after having started to write) where the line:

     return dx + dy - ((dx < dy ? dx : dy) >> 1);
could be written:
     return dx + dy - (min(dx, dy) >> 1);

With a branchless min you get some potential benefit.

Of course you have to be careful because on 386/486 the branch is always assumed NOT to be taken which can lead to faster code. but for the cases where you have 50:50% odds then this kind of tricks are really worth it.

WC default min and max are just min(a,b) (((a) < (b)) ? (a) : (b)) and max(a,b) (((a) > (b)) ? (a) : (b)) in stdlib.h, like usual.
EDIT I just found a third version:

int min3(int a, int b) { return (-(a<=b) & a) | (-(b<=a) & b); }
int max3(int a, int b) { return (-(a>=b) & a) | (-(b>=a) & b); }

[RamonUnch]

Also a "manual" pre-i686 compatible cmove can be done like this:

/* cond HAS to be 0 or 1 */
#define Ternary(cond, a, b) ( ((a) & (-(cond))) | ((b) & (~(-(cond)))) )

Ternary(cond, a, b) is equivalent to cond? a : b if cond, a, b are all ints of the same size.

It can be slower than branches if the prediction is easy.
Actually I could never test this on old CPU.
On newer CPU like the Core2 I get very slightly better performances than a branch when the branch is hard to predict. I would be interested to know what one would get on older CPU where branch prediction magic did not exist.