Compile-time with mixed const/non-const ternary operator

Question

Consider the following example :

template<int X> class MyClass
{
    public:
        MyClass(int x) {_ncx = x;}
        void test() 
        {
            for (unsigned int i = 0; i < 1000000; ++i) {
                if ((X < 0) ? (_cx > 5) : (_ncx > 5)) {
                    /* SOMETHING */
                } else {
                    /* SOMETHING */
                }
            }
        }
    protected:
        static const int _cx = (X < 0) ? (-X) : (X);
        int _ncx;
};

My question is : will MyClass<-6>::test() and MyClass<6>::test() have a different speed ?

I hope so because in case of a negative template parameter, the if in test function can be evaluated at compile-time, but I'm not sure what is the behaviour of a compiler if there is a compile-time thing and a non-compile-time thing in a ternary operator (which is the case here).

Note : it's a pure "theoretical" question. If there is a non-null probability of "yes", I will implement some class for my code with such compile-time template parameters, and if not, I will only provide runtime versions.

The whole point is when you pass a negative template parameter, we don't care about ncx. — Vincent, Sep 25 '12 at 23:45
Check also this answer: http://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-an-unsorted-array/11227902#11227902 — ABu, Feb 14 '14 at 14:33

score 2 · Answer 1 · answered Sep 26 '12 at 00:34

2

Move the conditional outside the loop:

        ...
        if ((X < 0) ? (_cx > 5) : (_ncx > 5)) {
            for (unsigned int i = 0; i < 1000000; ++i) {
                /* SOMETHING */
            }
        } else {
            for (unsigned int i = 0; i < 1000000; ++i) {
                /* SOMETHING */
            }
        }
        ...

That way you don't depend on the compiler optimization to remove unused code; if the unused part of the conditional is not removed by the compiler you just pay for a conditional branch once, and not every time around the loop.

answered Sep 26 '12 at 00:34

DanielKO

4,422
19
29

Of course, but this is only an example to illustrate a "theoretical" question. The functions I want to optimize are far more complicated, and I need to know if a compiler can optimize const/non-const ternary operators. – Vincent Sep 26 '12 at 00:38
2

I supplied a practical answer, if speed of utmost importance and a "depends on the compiler" response is not acceptable, the next thing to do is to avoid depending on the compiler to do this. There is nothing in the standard mandating or restricting how a compiler may do optimizations to the code, as long as it produces the correct output. – DanielKO Sep 26 '12 at 00:52
That being the case, The theoretical answer is: Given this example, a compiler can likely make up for the engineer's design short-comings when it comes to placement of the conditional in the first place. Only a detailed examination of the produced ASM will suffice to determined said-same for functions that are far-more-complicated. – WhozCraig Sep 26 '12 at 02:24

Michael Anderson · Accepted Answer · 2012-09-26T01:54:47.910

For my compiler ( clang++ v2.9 on OS X ) compiling this similar but not identical code:

void foo();
void bar();

template<int N>
void do_something( int arg ) {
  if ( N<0 && arg<0 ) { foo(); }
  else { bar(); }
}

// Some functions to instantiate the templates.
void one_fn(int arg) {
  do_something<1>(arg);
}

void neg_one_fn(int arg) {
  do_something<-1>(arg);
}

This generates the following assembly with clang++ -S -O3.

one_fn = do_something<1>

The first functions assembly clearly only has the call to bar.

    .globl  __Z6one_fni
    .align  4, 0x90
__Z6one_fni:                            ## @_Z6one_fni
Leh_func_begin0:
    pushl   %ebp
    movl    %esp, %ebp
    popl    %ebp
    jmp __Z3barv                ## TAILCALL
Leh_func_end0:

neg_one_fn = do_something<-1>

The second function has been reduced to a simple if to call either bar or foo.

    .globl  __Z10neg_one_fni
    .align  4, 0x90
__Z10neg_one_fni:                       ## @_Z10neg_one_fni
Leh_func_begin1:
    pushl   %ebp
    movl    %esp, %ebp
    cmpl    $0, 8(%ebp)
    jns LBB1_2                  ## %if.else.i
    popl    %ebp
    jmp __Z3foov                ## TAILCALL
LBB1_2:                                 ## %if.else.i
    popl    %ebp
    jmp __Z3barv                ## TAILCALL
Leh_func_end1:

Summary

So you can see that the compiler inlined the template, then optimised away the branch when it could. So the kind of transformation you are hoping for does occur in current compilers. I got similar results (but less clear assembly) from an old g++ 4.0.1 compiler too.

Addendum:

I decided this example wasn't quite similar enough to your initial case (as it didnt' involve the ternary operator) so I changed it to this: (Getting the same kind of results)

template<int X>
void do_something_else( int _ncx ) {
  static const int _cx = (X<0) ? (-X) : (X);
  if ( (X < 0) ? (_cx > 5) : (_ncx > 5)) {
    foo();
  } else {
    bar();
  }
}

void a(int arg) {
  do_something_else<1>(arg);
}

void b(int arg) {
  do_something_else<-1>(arg);
}

This generates the assembly

a() = do_something_else<1>

This still contains the branch.

__Z1ai:                                 ## @_Z1ai
Leh_func_begin2:
    pushl   %ebp
    movl    %esp, %ebp
    cmpl    $6, 8(%ebp)
    jl  LBB2_2                  ## %if.then.i
    popl    %ebp
    jmp __Z3foov                ## TAILCALL
LBB2_2:                                 ## %if.else.i
    popl    %ebp
    jmp __Z3barv                ## TAILCALL
Leh_func_end2:

b() = do_something_else<-1>

Branch is optimised away.

__Z1bi:                                 ## @_Z1bi
Leh_func_begin3:
    pushl   %ebp
    movl    %esp, %ebp
    popl    %ebp
    jmp __Z3barv                ## TAILCALL
Leh_func_end3:

score 0 · Answer 3 · answered Sep 25 '12 at 23:37

0

It probably depends on how smart your compiler is. I recommend you write a little benchmark program to test it out yourself in your environment to find out for sure.

answered Sep 25 '12 at 23:37

CXJ

4,301
3
32
62