Modern C++——使用分支预测优化代码性能

大纲

• [[likely]]
• [[unlikely]]
• 样例
• 应用场景
• 题外
• 参考代码
• 参考资料

在C++20中，新引入了一对属性关键字[[likely]]和[[unlikely]]，它们用于为编译器提供关于代码分支执行概率的额外信息，以帮助编译器进行更好的优化。这对属性是基于长期实践中开发人员对程序执行路径的深入理解而设计的，特别是在面对复杂逻辑和频繁分支的情况下。

[[likely]]

[[likely]]属性用于标记某个分支条件在运行时更有可能为真。当编译器遇到这种标记时，它会尝试优化与该分支相关的代码，以提高整体的执行效率。具体来说，编译器可能会重新组织指令序列，使更可能执行的路径在缓存中更频繁地命中，从而减少对主内存的访问，并降低指令的等待时间。

[[unlikely]]

相反，[[unlikely]]属性用于标记某个分支条件在运行时不太可能为真。编译器在处理这样的分支时，会考虑优化与该分支相关联的代码的加载和执行，以便减少对处理器资源的占用，特别是当这个不太可能发生的分支实际上未执行时。通过减少对不太可能执行的路径的优化投资，编译器可以集中资源来优化更常执行的代码部分。

样例

#include <chrono>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <random>
#include <functional>
 
namespace with_attributes {
    constexpr double pow(double x, long long n) noexcept {
        if (n <= 0) [[unlikely]]
            return 1;
        else [[likely]]
            return x * pow(x, n - 1);
    }
} // namespace with_attributes
 
namespace no_attributes {
    constexpr double pow(double x, long long n) noexcept {
        if (n <= 0)
            return 1;
        else
            return x * pow(x, n - 1);
    }
} // namespace no_attributes

double calc(double x, std::function<double(double, long long)> f) noexcept {
    constexpr long long precision{16LL};
    double y{};
    for (auto n{0LL}; n < precision; n += 2LL)
        y += f(x, n);
    return y;
}

double gen_random() noexcept {
    static std::random_device rd;
    static std::mt19937 gen(rd());
    static std::uniform_real_distribution<double> dis(-1.0, 1.0);
    return dis(gen);
}
 
volatile double sink{}; // ensures a side effect
 
int main() {
    auto benchmark = [](auto fun, auto rem)
    {
        const auto start = std::chrono::high_resolution_clock::now();
        for (auto y{1ULL}; y != 500'000'000ULL; ++y)
            sink = calc(gen_random(), fun);
        const std::chrono::duration<double> diff =
            std::chrono::high_resolution_clock::now() - start;
        std::cout << "Time: " << std::fixed << std::setprecision(6) << diff.count()
                  << " sec " << rem << std::endl; 
    };
 
    benchmark(with_attributes::pow, "(with attributes)");
    benchmark(no_attributes::pow, "(without attributes)");
    benchmark(with_attributes::pow, "(with attributes)");
    benchmark(no_attributes::pow, "(without attributes)");
    benchmark(with_attributes::pow, "(with attributes)");
    benchmark(no_attributes::pow, "(without attributes)");
}

上面代码的pow函数中n的值大部分时候大于0，于是我们在with_attributes::pow的else部分标记为[[likely]]；而很少出现的小于等于0的时候，使用[[unlikely]]标记。这样编译器就会根据我们的标记来优化代码。

作为对照组，no_attributes::pow除了没有标记外和with_attributes::pow完全一致。

我们看下对比结果。

可以发现使用了分支预测标记的代码效率更高（本例提升了约20%性能）。

应用场景

这些属性的应用可以帮助提升在复杂分支结构下的程序性能。特别是在性能敏感的应用中，如实时系统、高性能计算和科学计算，合理使用[[likely]]和[[unlikely]]属性可以显著提升执行效率。然而，它们并不是万能的，开发者需要基于程序的实际执行路径和统计数据来谨慎选择使用。

题外

在研究这个专题时，我最开始预计编译器会优化分支顺序，于是设计了如下的代码

    if (value == 0) [[unlikely]] {
        sum += value.get_value();
    } else if (value == 1) [[unlikely]] {
        sum += value.get_value();
    } else if (value == 2) [[unlikely]] {
        sum += value.get_value();
    } else if (value == 3) [[unlikely]] {
        sum += value.get_value();
    } else if (value == 4) [[unlikely]] {
        sum += value.get_value();
    } else if (value == 5) [[unlikely]] {
        sum += value.get_value();
    } else if (value == 6) [[likely]] {
        sum += value.get_value();
    } 

如果我们的设想成立，则编译器进入如下编译优化：先对比value==6这个条件，然后再对比其他条件。这样经常执行的value==6的分支只要执行一次对比，而省去了多余的其他5次对比。但是我在Linux和Windows两个平台上都做了实验，发现编译器并没有因为我们的标记而优化条件对比的顺序。所以这优化类还需要我们程序员自己来做。

如果没有做顺序调优，那么编译器对本例进行了什么优化导致优20%的性能提升呢？这个问题我们会在《从汇编层看64位程序运行——likely提示编译器的优化案例》中解答。

参考代码

https://github.com/f304646673/cpulsplus/tree/master/likely

参考资料

• https://en.cppreference.com/w/cpp/language/attributes/likely