in c is there any way specialise a function template for specific values of arguments-CodePudding

I have a broadly used function foo(int a, int b) and I want to provide a special version of foo that performs differently if a is say 1.

a) I don't want to go through the whole code base and change all occurrences of foo(1, b) to foo1(b) because the rules on arguments may change and I dont want to keep going through the code base whenever the rules on arguments change.

b) I don't want to burden function foo with an "if (a == 1)" test because of performance issues.

It seems to me to be a fundamental skill of the compiler to call the right code based on what it can see in front of it. Or is this a possible missing feature of C that requires macros or something to handle currently.

CodePudding user response：

Simply write

inline int foo(int a, int b)
{
   if (a==1) {
      // skip complex code and call easy code
     call_easy(b);
   } else {
      // complex code here
     do_complex(a, b);
   }
}

When you call

foo(1, 10);

the optimizer will/should simply insert a call_easy(b).

Any decent optimizer will inline the function and detect if the function has been called with a==1. Also I think that the entire constexpr mentioned in other posts is nice, but not really necessary in your case. constexpr is very useful, if you want to resolve values at compile time. But you simply asked to switch code paths based on a value at runtime. The optimizer should be able to detect that.

In order to detect that, the optimizer needs to see your function definition at all places where your function is called. Hence the inline requirement - although compilers such as Visual Studio have a "generate code at link time" feature, that reduces this requirement somewhat.

Finally you might want to look at C attributes [[likely]] (I think). I haven't worked with them yet, but they are supposed to tell the compiler which execution path is likely and give a hint to the optimizer.

And why don't you experiment a little and look at the generated code in the debugger/disassemble. That will give you a feel for the optimizer. Don't forget that the optimizer is likely only active in Release Builds :)

CodePudding user response：

Templates work in compile time and you want to decide in runtime which is never possible. If and only if you really can call your function with constexpr values, than you can change to a template, but the call becomes foo<1,2>() instead of foo(1,2); "performance issues"... that's really funny! If that single compare assembler instruction is the performance problem... yes, than you have done everything super perfect :-)

BTW: If you already call with constexpr values and the function is visible in the compilation unit, you can be sure the compiler already knows to optimize it away...

But there is another way to handle such things if you really have constexpr values sometimes and your algorithm inside the function can be constexpr evaluated. In that case, you can decide inside the function if your function was called in a constexpr context. If that is the case, you can do a full compile time algorithm which also can contain your if ( a== 1) which will be fully evaluated in compile time. If the function is not called in constexpr context, the function is running as before without any additional overhead.

To do such decision in compile time we need the actual C standard ( C 20 )!

constexpr int foo( int a, int)
{
    if (std::is_constant_evaluated() )
    { // this part is fully evaluated in compile time!  
        if ( a == 1 ) 
        {
            return 1;
        }
        else
        {
            return 2;
        }
    }   
    else
    {   // and the rest runs as before in runtime
        if ( a == 0 )
        {
           return 3;
        }
        else
        {
           return 4;
        }
    }   
}

int main()
{
    constexpr int res1 = foo( 1,0 ); // fully evaluated during compile time
    constexpr int res2 = foo( 2,0 ); // also full compile time
    std::cout << res1 << std::endl;
    std::cout << res2 << std::endl;
    std::cout << foo( 5, 0) << std::endl; // here we go in runtime
    std::cout << foo( 0, 0) << std::endl; // here we go in runtime
}

That code will return:

So we do not need to go with classic templates, no need to change the rest of the code but have full compile time optimization if possible.

CodePudding user response：

@Sebastian's suggestion works at least in the simple case with all optimisation levels except -O0 in g 9.3.0 on Ubuntu 20.04 in c 20 mode. Thanks again.

See below disassembly always calling directly the correct subfunction func1 or func2 instead of the top function func(). A similar disassembly after -O0 shows only the top level func() being called leaving the decision to run-time which is not desired.

I hope this will work in production code and perhaps with multiple hard coded arguments.

Breakpoint 1, main () at p1.cpp:24
24      int main() {
(gdb) disass /m
Dump of assembler code for function main():
6       inline void func(int a, int b) {

7
8                       if (a == 1)

9                               func1(b);

10                      else
11                              func2(a,b);

12              }
13
14      void func1(int b) {
15              std::cout << "func1 " << " " << " " << b << std::endl;
16      }
17
18      void func2(int a, int b) {
19              std::cout << "func2 " << a << " " << b << std::endl;
20      }
21
22      };
23
24      int main() {
=> 0x0000555555555286 < 0>:     endbr64 
   0x000055555555528a < 4>:     push   %rbp
   0x000055555555528b < 5>:     push   %rbx
   0x000055555555528c < 6>:     sub    $0x18,%rsp
   0x0000555555555290 < 10>:    mov    $0x28,