Performance comparison of C++ inline functions in different scenarios

Inline functions optimize performance by eliminating function call overhead: the compiler can inline functions into the call point to improve efficiency. Benchmarks show that inline functions are about 20% faster than non-inline functions. The compiler considers factors such as function size, complexity, and call frequency when deciding whether to inline.

C Performance comparison of inline functions in different scenarios

Inline functions are a kind of compiled code that replaces function call. It can improve performance in some cases by eliminating function call overhead.

Define inline functions

In C, use the inline keyword to declare a function as an inline function:

inline int sum(int a, int b) {
  return a + b;
}

Compiler Optimization

The compiler may or may not inline inline functions to the call site. Here are some factors the compiler may consider inlining a function:

• Function size: Smaller functions are more likely to be inlined.
• Function complexity: Complex functions are less likely to be inlined.
• Call frequency: Frequently called functions are more likely to be inlined.

Benchmark

To compare the performance of inline functions with non-inline functions, we perform a benchmark test:

#include <chrono>

// 内联版本
inline int inline_sum(int a, int b) {
  return a + b;
}

// 非内联版本
int non_inline_sum(int a, int b) {
  return a + b;
}

int main() {
  // 运行时间变量
  std::chrono::time_point<std::chrono::high_resolution_clock> start, stop;

  int sum1 = 0;

  // 内联版本
  start = std::chrono::high_resolution_clock::now();
  for (int i = 0; i < 10000000; i++) {
    sum1 += inline_sum(i, i);
  }
  stop = std::chrono::high_resolution_clock::now();

  int sum2 = 0;

  // 非内联版本
  start = std::chrono::high_resolution_clock::now();
  for (int i = 0; i < 10000000; i++) {
    sum2 += non_inline_sum(i, i);
  }
  stop = std::chrono::high_resolution_clock::now();

  std::cout << "内联版本： " << std::chrono::duration_cast<std::chrono::microseconds>(stop - start).count() << " 微秒" << std::endl;
  std::cout << "非内联版本： " << std::chrono::duration_cast<std::chrono::microseconds>(stop - start).count() << " 微秒" << std::endl;

  return 0;
}

Results

On the test computer, the benchmark results were as follows:

• Inline version: ~100 microseconds
• Non-inline version: ~ 120 microseconds

Conclusion

In our benchmarks, inline functions are about 20% faster than non-inline functions. However, please note that the actual performance improvement depends on the specific scenario and compiler optimization level.

The above is the detailed content of Performance comparison of C++ inline functions in different scenarios. For more information, please follow other related articles on the PHP Chinese website!