[[likely]] 与 [[unlikely]] 分支提示
什么是 likely 和 unlikely
[[likely]] 和 [[unlikely]] 是 C++20 引入的属性(attribute),用于告诉编译器某个分支路径更可能或更不可能被执行。编译器可以利用这个提示来优化代码布局,把更可能执行的代码放在连续的位置,减少指令缓存未命中和跳转开销。
if (error_code != 0) [[unlikely]] {
handle_error(); // 错误处理很少执行
} else [[likely]] {
process(); // 正常路径频繁执行
}这两个属性只是提示,不会改变程序的逻辑行为。编译器可以选择忽略它们。
基本示例
#include <iostream>
#include <vector>
#include <string>
#include <chrono>
#include <random>
#include <stdexcept>
// ============================
// 示例1:if-else 中使用
// ============================
int process_value(int value) {
if (value < 0) [[unlikely]] {
// 负值是异常情况,很少出现
throw std::invalid_argument("负值不允许");
} else [[likely]] {
// 正常情况,大部分时间走这条路径
return value * 2;
}
}
void if_else_demo() {
try {
std::cout << "process(42): " << process_value(42) << std::endl;
std::cout << "process(10): " << process_value(10) << std::endl;
process_value(-1);
} catch (const std::exception& e) {
std::cout << "异常: " << e.what() << std::endl;
}
}
// ============================
// 示例2:switch-case 中使用
// ============================
enum class RequestType { Normal, Priority, Admin, Error };
std::string handle_request(RequestType type) {
switch (type) {
[[likely]] case RequestType::Normal:
return "处理普通请求";
case RequestType::Priority:
return "处理优先请求";
[[unlikely]] case RequestType::Admin:
return "处理管理员请求";
[[unlikely]] case RequestType::Error:
return "处理错误请求";
}
return "未知";
}
void switch_demo() {
std::cout << handle_request(RequestType::Normal) << std::endl;
std::cout << handle_request(RequestType::Admin) << std::endl;
}
// ============================
// 示例3:循环中使用
// ============================
int find_negative(const std::vector<int>& data) {
for (size_t i = 0; i < data.size(); i++) {
if (data[i] < 0) [[unlikely]] {
// 负数很少出现
return static_cast<int>(i);
}
}
return -1;
}
void loop_demo() {
std::vector<int> data(1000, 1);
data[999] = -1; // 只有最后一个是负数
int pos = find_negative(data);
std::cout << "负数位置: " << pos << std::endl;
}
// ============================
// 示例4:错误检查模式
// ============================
struct Result {
bool success;
int value;
std::string error;
};
Result divide(int a, int b) {
if (b == 0) [[unlikely]] {
return {false, 0, "除数为零"};
}
if (a < 0 || b < 0) [[unlikely]] {
return {false, 0, "不支持负数"};
}
return {true, a / b, ""};
}
void error_check_demo() {
auto r1 = divide(100, 5);
if (r1.success) [[likely]] {
std::cout << "100/5 = " << r1.value << std::endl;
}
auto r2 = divide(10, 0);
if (!r2.success) [[likely]] {
std::cout << "错误: " << r2.error << std::endl;
}
}
// ============================
// 示例5:递归中使用
// ============================
constexpr double power(double x, long long n) noexcept {
if (n > 0) [[likely]] {
return x * power(x, n - 1);
} else [[unlikely]] {
return 1.0; // 基础情况只执行一次
}
}
void recursion_demo() {
std::cout << "2^10 = " << power(2.0, 10) << std::endl;
std::cout << "3^5 = " << power(3.0, 5) << std::endl;
}
// ============================
// 示例6:缓存命中优化
// ============================
int lookup_cache(int key,
const std::vector<std::pair<int, int>>& cache,
const std::vector<std::pair<int, int>>& database) {
// 先查缓存——大部分时候能命中
for (const auto& [k, v] : cache) {
if (k == key) [[likely]] {
return v; // 缓存命中
}
}
// 缓存未命中——回退到数据库
for (const auto& [k, v] : database) {
if (k == key) [[unlikely]] {
return v;
}
}
return -1;
}
void cache_demo() {
std::vector<std::pair<int, int>> cache = {{1, 100}, {2, 200}, {3, 300}};
std::vector<std::pair<int, int>> db = {{4, 400}, {5, 500}};
std::cout << "查找 key=2: " << lookup_cache(2, cache, db) << std::endl;
std::cout << "查找 key=5: " << lookup_cache(5, cache, db) << std::endl;
}
// ============================
// 示例7:性能对比测试
// ============================
void benchmark_demo() {
constexpr int iterations = 10'000'000;
// 生成测试数据:99% 的值大于0,1% 小于等于0
std::mt19937 rng(42);
std::uniform_int_distribution<int> dist(1, 100);
std::vector<int> data(iterations);
for (auto& v : data) {
v = dist(rng);
if (v == 1) v = -1; // 约 1% 的概率为负数
}
// 带 likely/unlikely
volatile long long sum1 = 0;
auto start = std::chrono::high_resolution_clock::now();
for (int v : data) {
if (v > 0) [[likely]] {
sum1 += v;
} else [[unlikely]] {
sum1 -= v;
}
}
auto end = std::chrono::high_resolution_clock::now();
auto ms1 = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
// 不带属性
volatile long long sum2 = 0;
start = std::chrono::high_resolution_clock::now();
for (int v : data) {
if (v > 0) {
sum2 += v;
} else {
sum2 -= v;
}
}
end = std::chrono::high_resolution_clock::now();
auto ms2 = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
std::cout << "带属性: " << ms1 << " us" << std::endl;
std::cout << "不带属性: " << ms2 << " us" << std::endl;
std::cout << "(效果取决于编译器和优化级别)" << std::endl;
}
int main() {
std::cout << "=== if-else ===" << std::endl;
if_else_demo();
std::cout << "\n=== switch-case ===" << std::endl;
switch_demo();
std::cout << "\n=== 循环 ===" << std::endl;
loop_demo();
std::cout << "\n=== 错误检查 ===" << std::endl;
error_check_demo();
std::cout << "\n=== 递归 ===" << std::endl;
recursion_demo();
std::cout << "\n=== 缓存 ===" << std::endl;
cache_demo();
std::cout << "\n=== 性能测试 ===" << std::endl;
benchmark_demo();
return 0;
}编译器如何利用这些提示
编译器拿到 likely/unlikely 提示后,可能做以下优化:
| 优化策略 | 说明 |
|---|---|
| 代码布局 | 把 likely 路径放在连续位置,unlikely 路径移到远处 |
| 跳转方向 | likely 路径不跳转(fallthrough),unlikely 路径跳转 |
| 指令缓存 | likely 路径更容易留在 L1 指令缓存中 |
| 分支预测 | 辅助 CPU 的静态分支预测(首次遇到时) |
likely/unlikely vs 编译器内建
| 方式 | 标准 | 语法 | 可移植性 |
|---|---|---|---|
[[likely]] / [[unlikely]] | C++20 | 标准属性 | 完全可移植 |
__builtin_expect(expr, val) | GCC/Clang 扩展 | 编译器内建 | 不可移植 |
__assume(expr) | MSVC 扩展 | 编译器内建 | 不可移植 |
| PGO(Profile-Guided Optimization) | 编译器功能 | 编译选项 | 依赖工具链 |
适用场景
- 错误处理路径(错误很少发生)
- 空指针检查(大部分时候不为空)
- 边界检查(越界极少发生)
- 缓存命中/未命中路径
- 热循环中的罕见条件分支
- 性能关键代码经过 profiling 确认的热路径
常见问题
likely/unlikely 能带来多大的性能提升?
通常很小(0-5%),在大多数情况下编译器和 CPU 的分支预测已经足够好。只有在高频执行的热路径、分支比例非常不均匀时才可能有明显效果。不要期望它能解决性能问题。
可以同时在两个分支都加 likely 吗?
不可以在同一个语句同时使用 [[likely]] 和 [[unlikely]]。但可以在 if 的两个分支分别标注不同的属性。
过度使用会有害吗?
C++ 标准草案明确指出:"过度使用这两个属性可能导致性能下降。"如果标注错误(比如把不常执行的路径标为 likely),反而会误导编译器。
constexpr 函数中可以使用吗?
可以。likely/unlikely 可以在 constexpr 函数中使用。
注意事项
- 只是提示,编译器可以忽略
- 过度使用或标注错误可能导致性能下降
- 应该基于 profiling 数据来决定标注哪些分支
- 不改变程序逻辑,只影响编译器优化
- 不能同时在一个语句上使用 likely 和 unlikely
- 大多数情况下编译器和 CPU 的自动预测就够了
编译器支持情况
| 编译器 | 支持 | 最低版本 |
|---|---|---|
| GCC | 支持 | 9.0 |
| Clang | 支持 | 12.0 |
| MSVC | 支持 | 19.26 (VS 2019 16.6) |
总结
[[likely]] 和 [[unlikely]] 是 C++20 引入的标准化分支预测提示,取代了以前各编译器的非标准扩展(如 __builtin_expect)。它们告诉编译器某条分支路径更可能或更不可能执行,编译器据此优化代码布局和跳转方向。实际性能提升通常很小,因为现代 CPU 的动态分支预测已经很强。最佳实践是只在经过 profiling 确认的热路径上使用,避免凭直觉大量标注。典型用法包括错误处理路径标 unlikely、正常处理路径标 likely。