我们正在开发一段代码，该代码将检查在一段时间内不应该允许用户进入某个扇区的时间，我的一位同事创建了一个函数，该函数在下面的代码中是isAllowed并包含多个比较，函数isAllowed2的不同方法是使用时间间隔之间的秒数。
最初，我们毫无疑问的是他的功能会更快，但是当实际运行代码并比较速度时，这是不正确的，即使这种差异是我们可以完全忽略的，我们也想知道为什么那是为什么实际上，“应该”更快。
考虑以下代码:
#include <iostream>
#include <chrono>
using namespace std;
using namespace std::chrono;
struct timing {
short hour;
short minute;
};
bool isAllowed(timing &from, timing &to, timing &actual) {
return !(((from.hour > to.hour && (actual.hour >= from.hour || actual.hour <= to.hour)) ||
(actual.hour >= from.hour && actual.hour <= to.hour)) &&
!(actual.minute > from.minute && actual.minute < to.minute));
}
long getSecs(short hour, short minutes) {
return (hour * 3600) + (minutes * 60);
}
bool isAllowed2(timing &from, timing &to, timing ¤t) {
long secsFrom = getSecs(from.hour, from.minute);
long secsTo = getSecs(to.hour, to.minute);
long secsCurrent = getSecs(current.hour, current.minute);
if (secsFrom > secsTo) secsTo += 24 * 60 * 60;
if (secsCurrent > secsFrom && secsCurrent < secsTo) {
return false;
}
return true;
}
int main() {
//debug messages
std::string okay = " - ok";
std::string error = " - er";
std::string receive = " - allowed";
std::string notReceive = " - denied";
//testing times
int const testDataCount = 5;
timing from[testDataCount] = {
{ 16, 30 },
{ 8, 30 },
{ 10, 30 },
{ 0, 30 },
{ 0, 0 }
};
timing to[testDataCount] = {
{ 8, 30 },
{ 20, 0 },
{ 20, 0 },
{ 6, 0 },
{ 7, 0 }
};
for (int i = 0; i < testDataCount; i++) {
std::cout << i + 1 << ": " << from[i].hour << ":" << from[i].minute << " to " << to[i].hour << ":"
<< to[i].minute << std::endl;
}
//test current times
timing current[5] = {
{ 12, 0 },
{ 23, 0 },
{ 17, 30 },
{ 15, 12 },
{ 0, 20 }
};
bool ergValues[][testDataCount] = {
{ true, false, false, true, true },
{ false, true, true, true, true },
{ false, false, false, true, true },
{ true, false, false, true, true },
{ false, true, true, true, false }
};
long totalNs1 = 0;
long totalNs2 = 0;
for (int i = 0; i < 4; i++) {
std::cout << std::endl << i + 1 << ". Test: " << current[i].hour << ":" << current[i].minute << std::endl;
for (int j = 0; j < testDataCount; j++) {
high_resolution_clock::time_point t1 = high_resolution_clock::now();
bool response = isAllowed(from[j], to[j], current[i]);
high_resolution_clock::time_point t2 = high_resolution_clock::now();
high_resolution_clock::time_point t3 = high_resolution_clock::now();
bool response2 = isAllowed2(from[j], to[j], current[i]);
high_resolution_clock::time_point t4 = high_resolution_clock::now();
long ns1 = duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
totalNs1 += ns1;
long ns2 = duration_cast<std::chrono::nanoseconds>(t4 - t3).count();
totalNs2 += ns2;
std::cout << j + 1 << "\t\t:1:" << ns1 << "ns: " << response << (response == ergValues[i][j] ? okay : error) << "\t\t:2:" << ns2 << "ms: " << response2 << (response2 == ergValues[i][j] ? okay : error) << "\t\t"
<< (ergValues[i][j] ? receive : notReceive) << std::endl;
}
}
std::cout << "\r\ntotalNs1 = " << totalNs1 << "\r\ntotalNs2 = " << totalNs2 << "\r\n\r\n";
return 0;
}
结果显然总是不同的，但是无论totalNs2总是小于totalNs1。
例如:
totalNs1 = 38796
totalNs2 = 25913
我在Windows 10和Debian 8上的AMD Phenom II X4和Intel i7-3770上进行了测试，结果非常相似。
所以最后一个问题是，为什么函数isAllowed2比isAllowed快？
注意:这主要是一个好奇心问题，如果有人认为标题或标签不是最合适的，请告诉我，我将相应地进行更改，请谅解任何最终的语法错误，因为英语不是我的母语。
编辑
同时，在了解了微基准测试的不精确性之后，我一直在基于所有建议和评论进行进一步研究，包括this令人难以置信的详细答案(非常感谢Baum mit Augen链接了this精彩演讲，这很有帮助)最终使用Google microbenchmark library获得了更多“准确”的结果，看来isAllowed函数实际上更快(如无优化编译)，如该库的输出所示。
Run on (8 X 2395 MHz CPU s)
-----------------------------------------------------------------------
Benchmark Time CPU Iterations
-----------------------------------------------------------------------
BM_isAllowed/2/min_time:2.000 22 ns 22 ns 128000000
BM_isAllowed/4/min_time:2.000 22 ns 22 ns 137846154
BM_isAllowed/8/min_time:2.000 22 ns 22 ns 128000000
BM_isAllowed/16/min_time:2.000 22 ns 22 ns 128000000
BM_isAllowed/22/min_time:2.000 22 ns 22 ns 137846154
BM_isAllowed2/2/min_time:2.000 24 ns 24 ns 112000000
BM_isAllowed2/4/min_time:2.000 24 ns 24 ns 119466667
BM_isAllowed2/8/min_time:2.000 24 ns 24 ns 119466667
BM_isAllowed2/16/min_time:2.000 24 ns 24 ns 119466667
BM_isAllowed2/22/min_time:2.000 24 ns 24 ns 119466667
注意:正如Martin Bonner所指出的那样，isAllowed函数似乎存在逻辑缺陷，请勿使用它的生产代码。
您可以在下面找到我用于执行此基准测试的代码，如果我不熟悉Google library，请告诉我其中是否存在任何缺陷。
重要的是，此代码是使用Visual Studio 2015编译的，对于我们要测试的部分，应禁用优化。
#include "benchmark/benchmark.h"
using namespace std;
using namespace benchmark;
#pragma optimize( "[optimization-list]", {on | off} )
volatile const long extraDay = 24 * 60 * 60;
#pragma optimize( "", off )
struct timing {
short hour;
short minute;
timing(short hour, short minute) : hour(hour), minute(minute) {}
};
static void BM_isAllowed(benchmark::State& state) {
while (state.KeepRunning())
{
timing from(state.range(0), state.range(0));
timing to(state.range(0), state.range(0));
timing current(state.range(0), state.range(0));
bool b = !(((from.hour > to.hour && (current.hour >= from.hour || current.hour <= to.hour)) ||
(current.hour >= from.hour && current.hour <= to.hour)) &&
!(current.minute > from.minute && current.minute < to.minute));
}
}
static void BM_isAllowed2(benchmark::State& state) {
while (state.KeepRunning())
{
timing from(state.range(0), state.range(0));
timing to(state.range(0), state.range(0));
timing current(state.range(0), state.range(0));
bool b;
long secsFrom = secsFrom = (from.hour * 3600) + (from.minute * 60);
long secsTo = (to.hour * 3600) + (to.minute * 60);
long secsCurrent = (current.hour * 3600) + (current.minute * 60);
if (secsFrom > secsTo)
secsTo += extraDay;
if (secsCurrent > secsFrom && secsCurrent < secsTo)
b = false;
else
b = true;
}
}
#pragma optimize( "", on )
BENCHMARK(BM_isAllowed)->RangeMultiplier(2)->Range(2, 22)->MinTime(2);
BENCHMARK(BM_isAllowed2)->RangeMultiplier(2)->Range(2, 22)->MinTime(2);
BENCHMARK_MAIN();
最佳答案
这没有黄金法则。不幸的是，众所周知，这样的代码的性能很难预测。最重要的是
衡量一切!
现在了解代码中的内容:正如其他人正确指出的那样，我们可以观察到isAllowed使用分支编译为函数，而isAllowed2最终变为无分支。
谈论性能时，分支很有趣:分支实际上介于免费和昂贵之间，包括端点。这是由于称为分支预测器的CPU组件引起的。它试图预测您的控制流将采用哪个分支，并使CPU推测性地执行它。如果猜测正确，则分支是免费的。如果猜错了，则分支是昂贵的。可以在this answer中找到对该概念的详尽详尽的解释。
因此，现在我们需要确定是要分支版本还是无分支版本。 通常，两个都不需要比另一个更快! 这实际上取决于 objective-c PU对分支的预测能力，当然这取决于实际输入。 (因此，对于编译器来说，选择是将函数编译为分支结果还是无分支结果是一个难题，因为编译器不知道二进制将在哪个CPU上运行，也不知道期望哪种输入数据。请参见this blogpost。 )
因此，如果您的基准测试实际上是正确的†，我们已确定在您的CPU上分支很难预测胜过相对便宜的整数算法。这也可能是由于测试用例数量很少，分支预测程序无法从如此少的调用中学习模式。但是同样，我们不能仅以一种或另一种方式调用，我们必须查看特定情况下的实际性能。
†如评论中所述，对于良好的测量而言，执行时间有点短，我发现机器上的偏差很大。有关微基准测试的信息，您可以看看this talk，这比人们想象的要难。
另外，由于Martin Bonner很有帮助noticed，您的两个函数做的不一样，因此您必须修复它才能获得正确的基准。