C++ `__attribute__((hot))` / `cold`：引导编译器进行函数热/冷路径优化

好的，各位朋友，欢迎来到“C++编译器行为艺术：热的烫手，冷的冰牙”讲座！今天咱们聊点刺激的，C++里头那些隐藏的“小纸条”，让编译器听咱们的指挥，优化函数的热路径和冷路径。

开场白：编译器也需要“人生导师”

各位可能觉得，编译器嘛，冷冰冰的机器，懂什么优化？但实际上，编译器就像一个努力工作的实习生，它会按照规则优化代码，但如果你能给它一些提示，它就能事半功倍，做出更棒的优化。__attribute__((hot)) 和 __attribute__((cold))，就是我们给编译器的“人生导师”小纸条。

什么是热路径？什么是冷路径？

咱们先搞清楚两个概念：

热路径 (Hot Path): 代码中执行频率非常高的部分。比如，一个游戏引擎的主循环，或者一个数据库查询的核心算法。优化热路径，能显著提升程序的整体性能。
冷路径 (Cold Path): 代码中执行频率很低的部分。比如，错误处理代码、罕见的边界条件处理、或者程序的初始化代码。优化冷路径，对整体性能影响不大，但可以减少代码体积，提升缓存利用率。

说白了，热路径就是“香饽饽”，编译器要重点照顾；冷路径就是“边角料”，编译器可以稍微放一放。

__attribute__((hot))：告诉编译器，“这个函数很重要！”

__attribute__((hot))，顾名思义，就是告诉编译器：“这个函数很重要，要像对待亲儿子一样对待它！”。编译器会尽一切努力优化这个函数，比如：

内联 (Inlining): 尽可能把这个函数直接嵌入到调用它的地方，避免函数调用的开销。
指令调度 (Instruction Scheduling): 优化指令的执行顺序，充分利用CPU的流水线。
寄存器分配 (Register Allocation): 尽可能把函数中常用的变量放到寄存器里，避免访存开销。
代码对齐 (Code Alignment): 将函数代码放置在cache line的起始位置，减少cache的抖动。

代码示例：__attribute__((hot)) 的威力

假设我们有一个计算密集型的函数，它在程序的关键路径上：

#include <iostream>
#include <chrono>

__attribute__((hot))
double calculate_something_important(double x) {
  double result = x;
  for (int i = 0; i < 1000000; ++i) {
    result = result * x + 1.0 / (x + 1.0);
  }
  return result;
}

int main() {
  auto start = std::chrono::high_resolution_clock::now();
  double result = calculate_something_important(2.0);
  auto end = std::chrono::high_resolution_clock::now();

  std::chrono::duration<double> duration = end - start;

  std::cout << "Result: " << result << std::endl;
  std::cout << "Time taken: " << duration.count() << " seconds" << std::endl;

  return 0;
}

编译时，加上 -O3 优化选项，再对比加上 __attribute__((hot)) 和不加的情况，你会发现，加上之后，运行时间会有明显的减少。

注意事项：__attribute__((hot)) 不是万能的

过度使用： 不要把所有的函数都标记为 __attribute__((hot))。编译器资源有限，如果过度使用，反而可能导致性能下降。
内联膨胀： 内联虽然能减少函数调用开销，但也会增加代码体积，导致缓存利用率下降。
适用场景： __attribute__((hot)) 最适合那些计算密集型、调用频繁、并且代码体积不大的函数。

__attribute__((cold))：告诉编译器，“这个函数不太重要”

__attribute__((cold)) 和 __attribute__((hot)) 相反，它是告诉编译器：“这个函数不太重要，可以稍微放一放”。编译器会对冷路径函数进行一些“特殊照顾”，比如：

不内联 (No Inlining): 避免把冷路径函数内联到热路径代码中，减少热路径代码的体积。
代码分离 (Code Separation): 把冷路径函数放到单独的代码段中，减少热路径代码的缓存污染。
优化等级降低 (Lower Optimization Level): 对冷路径函数使用较低的优化等级，减少编译时间。

代码示例：__attribute__((cold)) 的妙用

#include <iostream>
#include <stdexcept>

double divide(double a, double b) {
  if (b == 0.0) {
    [[gnu::cold]]
    throw std::runtime_error("Division by zero!");
  }
  return a / b;
}

int main() {
  try {
    double result = divide(10.0, 0.0);
    std::cout << "Result: " << result << std::endl;
  } catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

在这个例子中，除数为零的情况非常罕见，所以我们用 __attribute__((cold)) 标记了 throw std::runtime_error("Division by zero!"); 这行代码。编译器会将这部分代码放到单独的代码段中，避免影响 divide 函数的性能。

[[gnu::cold]] 和 [[likely]], [[unlikely]]

C++17 引入了 [[likely]] 和 [[unlikely]] 属性，C++23引入了[[assume(expression)]]。虽然他们不是完全等同于 __attribute__((hot)) 和 __attribute__((cold))，但它们可以用来指导编译器进行分支预测优化。

[[likely]]: 告诉编译器，这个分支很可能被执行。
[[unlikely]]: 告诉编译器，这个分支不太可能被执行。
[[assume(expression)]] : 告诉编译器，表达式总是真的。

[[gnu::cold]] 的作用和 __attribute__((cold)) 类似，都是告诉编译器，这部分代码不太可能被执行。

代码示例：[[likely]] 和 [[unlikely]] 的应用

#include <iostream>

int main() {
  int value = 10;
  if (value > 5) [[likely]] {
    std::cout << "Value is greater than 5" << std::endl;
  } else [[unlikely]] {
    std::cout << "Value is not greater than 5" << std::endl;
  }
  return 0;
}

在这个例子中，value > 5 的概率很高，所以我们用 [[likely]] 标记了这个分支。编译器会优化代码，使得执行 value > 5 分支的效率更高。

[[assume(expression)]]的应用

#include <iostream>

int main() {
  int size = 10;
  int* arr = new int[size];

  for (int i = 0; i < size; ++i) {
    [[assume(i >= 0 && i < size)]] // 假设 i 在有效范围内
    arr[i] = i * 2;
  }

  // 使用数组...

  delete[] arr;
  return 0;
}

编译器可以利用 [[assume(i >= 0 && i < size)]] 来优化循环，例如，它可以消除循环内的边界检查。需要非常谨慎地使用 [[assume]]，因为如果假设不成立，程序的行为将是未定义的。

对比表格：__attribute__((hot/cold)) vs. [[likely/unlikely]] vs. [[gnu::cold]] vs. [[assume]]

特性	`__attribute__((hot))`	`__attribute__((cold))`	`[[likely]]`	`[[unlikely]]`	`[[gnu::cold]]`	`[[assume]]`
目的	优化热路径函数	优化冷路径函数	分支预测优化	分支预测优化	优化冷路径代码	表达式假设
适用对象	函数	函数	`if`, `switch`	`if`, `switch`	代码块	表达式
编译器行为	积极优化	降低优化等级	优化真分支	优化假分支	代码分离	代码优化
C++ 标准	GNU 扩展	GNU 扩展	C++17	C++17	GNU 扩展	C++23

实战案例：一个日志系统的优化

假设我们有一个日志系统，大部分时间都在记录正常信息，只有在发生错误时才会记录错误信息。

#include <iostream>
#include <fstream>
#include <string>

void log_message(const std::string& message, bool is_error) {
  std::ofstream log_file("log.txt", std::ios::app);
  if (is_error) [[unlikely]] {
    log_file << "[ERROR] " << message << std::endl;
  } else [[likely]] {
    log_file << "[INFO] " << message << std::endl;
  }
}

int main() {
  log_message("Application started", false);
  // ... 一些代码 ...
  log_message("An unexpected error occurred", true);
  // ... 更多代码 ...
  log_message("Application finished", false);
  return 0;
}

在这个例子中，is_error 为 true 的概率很低，所以我们用 [[unlikely]] 标记了错误处理分支。编译器会优化代码，使得记录正常信息的效率更高。

更高级的优化技巧：Profile-Guided Optimization (PGO)

__attribute__((hot)) 和 __attribute__((cold)) 只能告诉编译器一些静态的信息。更高级的优化技巧是 Profile-Guided Optimization (PGO)。PGO 通过实际运行程序，收集程序的运行数据，然后利用这些数据来指导编译器进行优化。

PGO 的步骤如下：

编译： 使用 -fprofile-generate 选项编译程序，生成带有 profiling 代码的可执行文件。
运行： 运行程序，让程序执行一段时间，收集程序的运行数据。
编译： 使用 -fprofile-use 选项再次编译程序，利用收集到的运行数据来指导编译器进行优化。

PGO 可以比 __attribute__((hot)) 和 __attribute__((cold)) 更加精确地识别热路径和冷路径，从而实现更好的优化效果。但是，PGO 也需要更多的编译和运行时间。

总结：让编译器成为你的盟友

__attribute__((hot))、__attribute__((cold))、[[likely]]、[[unlikely]]，还有 PGO，都是我们引导编译器进行优化的工具。掌握这些工具，可以让编译器成为我们的盟友，共同打造高性能的 C++ 程序。当然，代码优化是一个复杂的过程，需要根据实际情况进行选择和调整。

最后，给大家留个思考题：

在多线程环境中，__attribute__((hot)) 和 __attribute__((cold)) 应该如何使用？线程锁争用的处理应该标记为 hot 还是 cold?

希望今天的讲座对大家有所帮助！谢谢大家！

C++ `attribute((hot))` / `cold`：引导编译器进行函数热/冷路径优化

发表回复取消回复

发表回复 取消回复

发表回复取消回复