问题一：调用函数的执行时间

Question

If most of the calls to function foo() below pass one of 10 particular values, which method will significantly reduce the execution time of calling the function?

which choices are correct? I think Choice D but I am uncertain. Experts. Thoughts?

A. Replace * with an if-else block testing for the 10 values, assigning r accordingly
B. Remove inline
C. Delete foo() and move the time-consuming operation to its caller
D. Replace * with code performing a table lookup, with the 10 values and corresponding values of r
E. Replace * with swtich ?

1 inline int foo (int x) {
2   int r;
3 
4   * // time-consuming operation on x, result stored in r
5 
6   return r;    
7 }

Answer 1

B will not have any effect. inline only suppresses the one-definition rule; it does not force the compiler to inline the function.

C is unlikely to have any impact; if the compiler determines that the function is a good candidate to be inlined, it will do so. Manually inlining it could make performance worse.

The other three options (A, D, and E) may all perform better or worse than each other depending on many factors. The biggest factor in all of this is the compiler. Modern compilers are very good at optimization. A, D, and E could all be trivially transformed into each other. Therefore, they might all be just as fast as each other.

The answer is therefore highly dependent on the specific compiler (and version of that compiler) as well as the compilation flags being used. Given a specific compiler, I would need to properly benchmark each option with optimizations turned all the way up in order to determine the correct answer.

If I were taking this test, I would refuse to answer this question and send a note to the proctor/author indicating that the question is defective.

---

Now that I have that out of the way, if we assume all compiler optimizations are disabled , D is likely to be the fastest simply because it is branchless. A and E both involve branching, and a failed branch prediction is costly.

I would expect D to be the fastest. A and E should perform about the same.

---

In my tests on gcc with -O3 , E is optimized to a lookup table (like D) but A remains a series of conditional jumps. So in this particular test, D and E are both the correct answer.

Switching to clang with -O3 , it optimizes both A and E to use a lookup table (like D). It generates equivalent assembly for all options.