c++ - 为什么使用 'if' 语句可以提供更好的性能？

Question

在 VC++2015 中的 Release 模式下编译以下程序时，优化设置为 Ox(完全优化)，即使有额外的条件检查，我也能以某种方式获得更好的性能。

演示:http://coliru.stacked-crooked.com/a/a33b42a28548d3e4 (这并没有证明性能差异，因为 g++ 为两个版本生成了几乎相同的代码)。

运行此程序可以缩短 2. 的执行时间。这违反了我的常识，因为 2. 有一个 if 语句每次都要检查。

在我的机器上，1. 的平均时间为 105 毫秒，2. 的平均时间为 86 毫秒。该演示也显示了差异，但只有 5 毫秒的差异仍然有利于 2.；这是什么原因造成的？

---

这是完整的代码，它实际上给我带来了执行时间上的巨大差异。请注意，它实际上并没有使用两个函数。我只是注释掉了 operator++() 中的相关部分。

#include <iostream>
#include <thread>
#include <chrono>
#include <cstddef>
#include <atomic>
#include <limits>
#include <stdexcept>
#include <assert.h>

template <typename T = std::size_t>
class atomic_counter
{
public:
    using size_type = T;

    atomic_counter() : count_{ 0 }
    {
        assert( count_.is_lock_free() );
    }

    atomic_counter& operator++()
    {
        ++count_;                             // 1.
        //auto prev_count = ++count_;         // 2.
        //if ( prev_count == std::numeric_limits<size_type>::min() )
        //  throw std::overflow_error( "atomic_counter::operator++(): counter overflow" );

        return *this;
    }
    atomic_counter& operator--()
    {
        auto prev_count = --count_;
        if ( prev_count == std::numeric_limits<size_type>::max() )
            throw std::underflow_error( "atomic_counter::operator--() : counter underflow" );

        return *this;
    }

    size_type count() const
    {
        return count_.load();
    }

public:
    std::atomic<size_type> count_;
};

template
<
    typename Clock = std::chrono::high_resolution_clock,
    typename Unit = std::chrono::milliseconds,
    typename F,
    typename... FArgs
>
long long measure_execution_time( F&& f, FArgs&&... fargs )
{
    auto time_begin = Clock::now();
    f( std::forward<FArgs>( fargs )... );
    auto time_end = Clock::now();
    return std::chrono::duration_cast<Unit>( time_end - time_begin ).count();
}

int main()
{
    auto hardware_concurrency = std::thread::hardware_concurrency();
    std::size_t constexpr loop_count = 15'000'000;
    atomic_counter<> ac;

    auto lambda = [&] ( auto&& n )
    {
        for ( atomic_counter<>::size_type i{ 0 }; i < n; ++i )
            ++ac;
    };

    long long avg = 0;
    for ( std::size_t i{ 0 }; i < 20; ++i )
    {
        auto time = measure_execution_time<>( lambda, loop_count );
        std::cout << i + 1 << ".\t" << time << " ms\n";
        avg += time;
    }

    std::cout << "Avg:\t" << avg / 20 << " ms\n";
}

1. 的一致结果:

2. 的一致结果:

为 1. 生成的程序集:

000000013FA110F0  lea         rcx,[rsp+38h]  
000000013FA110F5  call        std::chrono::steady_clock::now (013FA11000h)+100000000h  
000000013FA110FA  mov         eax,2160EC0h  
000000013FA110FF  nop  
000000013FA11100 loopv1: mov    ecx,1  
000000013FA11105  lock xadd   qword ptr [ac],rcx  
000000013FA1110C  sub         rax,1  
000000013FA11110  jne    loopv1 ;   main+70h (013FA11100h)  
000000013FA11112  lea         rcx,[rsp+40h]  
000000013FA11117  call        std::chrono::steady_clock::now (013FA11000h)+100000000h

为 2. 生成的程序集:

long long measure_execution_time( F&& f, FArgs&&... fargs )
{
000000013F871230  mov         qword ptr [rsp+8],rbx  
000000013F871235  push        rdi  
000000013F871236  sub         rsp,50h  
000000013F87123A  mov         rdi,rcx  
000000013F87123D  mov         rbx,rdx  
    auto time_begin = Clock::now();
000000013F871240  lea         rcx,[rsp+70h]  
000000013F871245  call        std::chrono::steady_clock::now (013F871110h)  
    f( std::forward<FArgs>( fargs )... );
000000013F87124A  xor         r9d,r9d  
000000013F87124D  cmp         qword ptr [rbx],r9  
000000013F871250  jbe         measure_execution_time<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000> >,<lambda_fb2a7610a6d36531125f2c739fce673b> & __ptr64,unsigned __int64 const & __ptr64>+41h (013F871271h)  
000000013F871252 loopv2: mov    rax,qword ptr [rdi]   ; top of the inner loop
000000013F871255  mov         r8d,1  
000000013F87125B  lock xadd   qword ptr [rax],r8  
000000013F871260  lea         rax,[r8+1]  
000000013F871264  test        rax,rax  
000000013F871267  je          measure_execution_time<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000> >,<lambda_fb2a7610a6d36531125f2c739fce673b> & __ptr64,unsigned __int64 const & __ptr64>+7Bh (013F8712ABh)  
000000013F871269  inc         r9  
000000013F87126C  cmp         r9,qword ptr [rbx]   ; loop upper-bound in memory
000000013F87126F  jb  loopv2  ;         measure_execution_time<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000> >,<lambda_fb2a7610a6d36531125f2c739fce673b> & __ptr64,unsigned __int64 const & __ptr64>+22h (013F871252h)  
    auto time_end = Clock::now();
000000013F871271  lea         rcx,[time_end]  
000000013F871276  call        std::chrono::steady_clock::now (013F871110h)

Answer 1

有趣的 ordering of tests .

g++ -std=c++17 -O3 -Wall -pedantic -pthread main.cpp && ./a.outAverage 1: 159 msAverage 2: 165 ms

此处首先运行“Average 2”测试。

显然，它为接下来的“平均 1”测试准备了泵(准备东西)。