为什么std::equal比两个小std::数组的手卷循环慢得多?

Question

我正在分析一小段代码，它是较大模拟的一部分，令我惊讶的是，STL函数equal (std::equal)比简单的for循环慢得多，它逐个比较两个数组的元素。我写了一个小的测试用例，我相信这是两者之间的一个公平的比较，而差异，使用Debian档案中的g++ 6.1.1不是微不足道的。我正在比较两个四元素的有符号整数数组。我测试了std::equal、operator==和一个小的for循环。我没有使用std::chrono来精确计时，但是可以通过time ./a.o out.

显式地看到差异。

我的问题是，给出下面的示例代码，为什么operator==和重载函数std::equal(我相信它调用了operator==)需要大约40秒才能完成，而手写的循环只需要8秒?我用的是最新款的英特尔笔记本电脑。for循环在所有优化级别(-O1、-O2、-O3和-Ofast)上都更快。我编译的代码g++ -std=c++14 -Ofast -march=native -mtune=native

运行代码

循环运行了很多次，只是为了让肉眼清楚地看到差异。模操作符表示对数组元素之一的廉价操作，用于防止编译器在循环之外进行优化。

#include<iostream>
#include<algorithm>
#include<array>
using namespace std;
using T = array<int32_t, 4>;
bool 
are_equal_manual(const T& L, const T& R)
noexcept {
    bool test{ true };
    for(uint32_t i{0}; i < 4; ++i) { test = test && (L[i] == R[i]); }
    return test;
}
bool
are_equal_alg(const T& L, const T& R)
noexcept {
    bool test{ equal(cbegin(L),cend(L),cbegin(R)) };
    return test;
}
int main(int argc, char** argv) {
    T left{ {0,1,2,3} };
    T right{ {0,1,2,3} };
    cout << boolalpha << are_equal_manual(left,right) << endl;
    cout << boolalpha << are_equal_alg(left,right) << endl;
    cout << boolalpha << (left == right) << endl;
    bool t{};
    const size_t N{ 5000000000 };
    for(size_t i{}; i < N; ++i) {
      //t = left == right; // SLOW
      //t = are_equal_manual(left,right); // FAST
        t = are_equal_alg(left,right);  // SLOW
      left[0] = i % 10;
      right[2] = i % 8;
    }
    cout<< boolalpha << t << endl;
    return(EXIT_SUCCESS);
}

Answer 1

使用are_equal_manual(left,right)函数时，main()中for循环生成的程序集:

.L21:
        xor     esi, esi
        test    eax, eax
        jne     .L20
        cmp     edx, 2
        sete    sil
.L20:
        mov     rax, rcx
        movzx   esi, sil
        mul     r8
        shr     rdx, 3
        lea     rax, [rdx+rdx*4]
        mov     edx, ecx
        add     rax, rax
        sub     edx, eax
        mov     eax, edx
        mov     edx, ecx
        add     rcx, 1
        and     edx, 7
        cmp     rcx, rdi

下面是使用are_equal_alg(left,right)函数时生成的内容:

.L20:
        lea     rsi, [rsp+16]
        mov     edx, 16
        mov     rdi, rsp
        call    memcmp
        mov     ecx, eax
        mov     rax, rbx
        mov     rdi, rbx
        mul     r12
        shr     rdx, 3
        lea     rax, [rdx+rdx*4]
        add     rax, rax
        sub     rdi, rax
        mov     eax, ebx
        add     rbx, 1
        and     eax, 7
        cmp     rbx, rbp
        mov     DWORD PTR [rsp], edi
        mov     DWORD PTR [rsp+24], eax
        jne     .L20

我不确定在第一种情况下生成的代码中发生了什么，但它显然没有调用memcmp()。它似乎根本没有比较数组的内容。虽然循环仍然迭代5000000000次，但它被优化为不做太多事情。但是，使用are_equal_alg(left,right)的循环仍然在执行比较。基本上，编译器仍然能够比std::equal模板更好地优化手动比较。