请考虑以下代码：
void error_handling();
bool method_impl();
bool method()
{
const bool res = method_impl();
if (res == false) {
error_handling();
return false;
}
return true;
}
我知道method_impl()将返回true 99.999％（是的，三位小数）的时间，但我的编译器没有。 method()在时间消耗方面具有部分关键性。
method()（并使其不太可读）以确保只有在method_impl()返回false时才会跳转？如果是，怎么样？答案 0 :(得分：6)
您可以建议编译器method_impl()将返回true：
void error_handling();
bool method_impl();
bool method()
{
const bool res = method_impl();
if (__builtin_expect (res, 0) == false) {
error_handling();
return false;
}
return true;
}
这将在GCC中有效。
答案 1 :(得分：4)
底层硬件已经执行了此优化。它将“失败”第一次预测它，但在它将点击正确的选项en.wikipedia.org/wiki/Branch_predictor。
您可以尝试应用GCC扩展程序并检查它是否更快，但我认为您几乎看不到它与它没有任何区别。始终应用分支预测，它不是您启用的
答案 2 :(得分：4)
根据其他答案＆＃39;建议，我对解决方案进行了基准测试如果您考虑提出这个答案，请另外投票给其他人。
#include <iostream>
#include <iomanip>
#include <string>
// solutions
#include <ctime>
// benchmak
#include <limits>
#include <random>
#include <chrono>
#include <algorithm>
#include <functional>
//
// Solutions
//
namespace
{
volatile std::time_t near_futur = -1;
void error_handling() { std::cerr << "error\n"; }
bool method_impl() { return std::time(NULL) != near_futur; }
bool method_no_builtin()
{
const bool res = method_impl();
if (res == false) {
error_handling();
return false;
}
return true;
}
bool method_builtin()
{
const bool res = method_impl();
if (__builtin_expect(res, 1) == false) {
error_handling();
return false;
}
return true;
}
bool method_builtin_incorrect()
{
const bool res = method_impl();
if (__builtin_expect(res, 0) == false) {
error_handling();
return false;
}
return true;
}
bool method_rewritten()
{
const bool res = method_impl();
if (res == true) {
return true;
} else {
error_handling();
return false;
}
}
}
//
// benchmark
//
constexpr std::size_t BENCHSIZE = 10'000'000;
class Clock
{
std::chrono::time_point<std::chrono::steady_clock> _start;
public:
static inline std::chrono::time_point<std::chrono::steady_clock> now() { return std::chrono::steady_clock::now(); }
Clock() : _start(now())
{
}
template<class DurationUnit>
std::size_t end()
{
return std::chrono::duration_cast<DurationUnit>(now() - _start).count();
}
};
//
// Entry point
//
int main()
{
{
Clock clock;
bool result = true;
for (std::size_t i = 0 ; i < BENCHSIZE ; ++i)
{
result &= method_no_builtin();
result &= method_no_builtin();
result &= method_no_builtin();
result &= method_no_builtin();
result &= method_no_builtin();
result &= method_no_builtin();
result &= method_no_builtin();
result &= method_no_builtin();
result &= method_no_builtin();
result &= method_no_builtin();
}
const double unit_time = clock.end<std::chrono::nanoseconds>() / static_cast<double>(BENCHSIZE);
std::cout << std::setw(40) << "method_no_builtin(): " << std::setprecision(3) << unit_time << " ns\n";
}
{
Clock clock;
bool result = true;
for (std::size_t i = 0 ; i < BENCHSIZE ; ++i)
{
result &= method_builtin();
result &= method_builtin();
result &= method_builtin();
result &= method_builtin();
result &= method_builtin();
result &= method_builtin();
result &= method_builtin();
result &= method_builtin();
result &= method_builtin();
result &= method_builtin();
}
const double unit_time = clock.end<std::chrono::nanoseconds>() / static_cast<double>(BENCHSIZE);
std::cout << std::setw(40) << "method_builtin(): " << std::setprecision(3) << unit_time << " ns\n";
}
{
Clock clock;
bool result = true;
for (std::size_t i = 0 ; i < BENCHSIZE ; ++i)
{
result &= method_builtin_incorrect();
result &= method_builtin_incorrect();
result &= method_builtin_incorrect();
result &= method_builtin_incorrect();
result &= method_builtin_incorrect();
result &= method_builtin_incorrect();
result &= method_builtin_incorrect();
result &= method_builtin_incorrect();
result &= method_builtin_incorrect();
result &= method_builtin_incorrect();
}
const double unit_time = clock.end<std::chrono::nanoseconds>() / static_cast<double>(BENCHSIZE);
std::cout << std::setw(40) << "method_builtin_incorrect(): " << std::setprecision(3) << unit_time << " ns\n";
}
{
Clock clock;
bool result = true;
for (std::size_t i = 0 ; i < BENCHSIZE ; ++i)
{
result &= method_rewritten();
result &= method_rewritten();
result &= method_rewritten();
result &= method_rewritten();
result &= method_rewritten();
result &= method_rewritten();
result &= method_rewritten();
result &= method_rewritten();
result &= method_rewritten();
result &= method_rewritten();
}
const double unit_time = clock.end<std::chrono::nanoseconds>() / static_cast<double>(BENCHSIZE);
std::cout << std::setw(40) << "method_rewritten(): " << std::setprecision(3) << unit_time << " ns\n";
}
}
g++ -std=c++14 -O2 -Wall -Wextra -Werror main.cpp method_no_builtin(): 42.8 ns
method_builtin(): 44.4 ns
method_builtin_incorrect(): 51.4 ns
method_rewritten(): 39.3 ns
http://jsfiddle.net/toj5wyt6/24/
g++ -std=c++14 -O3 -Wall -Wextra -Werror main.cpp method_no_builtin(): 32.3 ns
method_builtin(): 31.1 ns
method_builtin_incorrect(): 35.6 ns
method_rewritten(): 30.5 ns
这些优化之间的差异太小而不能得出任何结论：如果在为已知的更常见路径优化分支时找到性能增益，则此增益太小而不值得麻烦并且可读性的损失。
答案 3 :(得分：1)
在不知道std :: time（）的实现的情况下，我不会总结 从这个测试。从你自己的结果来看，它似乎占据了循环中的时间。
FWIW，我在调优代码时自己使用了很可能（）/不可能（）。我不想改变代码的结构，但是在阅读程序集时，我希望看到公共路径是一条直线的未分支的分支。这里的关键（对我来说）是组件的可读性。这也是最快的事实是次要的（最快的分支是正确预测的未分支分支）。