小贝子编程

C 的性能11现代风格的循环与老式循环



这是我在这里发布的第一个问题，所以我希望我不会做错任何事情。

我的问题涉及现代风格的C 11循环（std::for_each，基于范围的）与老式的C 循环（for (...; ...; ...)）。据我所知，在我看来，现代C 的座右铭是"表现不佳，没有对性能的妥协"。现代C 样式可导致安全，干净和快速代码，几乎没有性能惩罚，并且可能具有与老式的C 相比的性能。

现在，我已经进行了一些测试，以评估这种增益与 loops 有关的大小。首先，我写了以下三个功能：

using namespace std;
void foo(vector<double>& v)
{
    for (size_t i = 0; i < v.size(); i++)
    {
        v[i] /= 42;
    }
}
void bar(vector<double>& v)
{
    for (auto& x : v)
    {
        x /= 42;
    }
}
void wee(vector<double>& v)
{
    for_each(begin(v), end(v), [] (double& x)
    {
        x /= 42;
    });
}

然后，我通过以这种方式打电话来比较他们的性能（正确评论/删除main()的循环中的三行：

vector<double> make_vector()
{
    vector<double> v;
    for (int i = 0; i < 30000; i++) { v.push_back(i); }
    return v;
}
int main()
{
    time_t start = clock();
    auto v = make_vector();
    for (int i = 0; i <= 50000; i++) 
    { 
        // UNCOMMENT THE FUNCTION CALL TO BE TESTED, COMMENT THE OTHERS
        foo(v);
        // bar(v); 
        // wee(v);
    }
    time_t end = clock();
    cout << (end - start) << endl;
    return 0;
}

通过评论/删除main()的循环中的线，并使用旧式循环作为基线来平均每个版本的程序的10个执行基于std::for_each和Lambdas的循环的性能差约2.3倍。

我使用clang 3.2来编译此问题，但我没有尝试过MS VC11（我正在使用WinxP）。

考虑到我希望获得可比执行时间的期望，我的问题是：

  1. 我有明显的事情做错了吗？
  2. 如果不是，那么2倍的表现罚款难道不接受现代循环是一个很好的理由吗？

我想说的是，我确实相信，以现代C 样式编写的代码的清晰度和安全性可获得可能的性能损失，但我不同意以下陈述，即清晰度/一侧的安全性和另一侧的性能。

我想念什么吗？

看起来只有在不启用编译器中的优化时出现的差异。

使用clang，您可以使用-O[0-3]标志启用优化。

mankaress是正确的 - 很可能您没有启用优化。

实际上在clang上，它们在主循环中几乎产生了相同的结果ASM代码，而PRE/POST代码的差异很小。

我已经测试了四个版本：hand_loop_index，hand_loop_iterator，range_based_for，for_each_algorithm

hand_loop_iterator， range_based_for和 for_each_algorithm-这三个都会产生完全相同的结果asm 用于完整功能的主体，只有标签的名称。

即。用迭代器编写循环的手编写会导致与基于范围的for和std :: for_each。

完全相同的ASM代码。

带有索引版本的索引和循环之间有一些差异。

在两种情况下，

主循环几乎相同。唯一的次要不同是使用迭代器版本rdx寄存器而不是rsi。

。

索引版本：

.LBB0_7:                                # %vector.body
                                        # =>This Inner Loop Header: Depth=1
    movupd  -48(%rsi), %xmm1
    movupd  -32(%rsi), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -48(%rsi)
    movupd  %xmm2, -32(%rsi)
    movupd  -16(%rsi), %xmm1
    movupd  (%rsi), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -16(%rsi)
    movupd  %xmm2, (%rsi)
    addq    $64, %rsi
    addq    $-8, %rdi
    jne .LBB0_7

迭代版本：

.LBB1_6:                                # %vector.body
                                        # =>This Inner Loop Header: Depth=1
    movupd  -48(%rdx), %xmm1
    movupd  -32(%rdx), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -48(%rdx)
    movupd  %xmm2, -32(%rdx)
    movupd  -16(%rdx), %xmm1
    movupd  (%rdx), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -16(%rdx)
    movupd  %xmm2, (%rdx)
    addq    $64, %rdx
    addq    $-8, %rsi
    jne .LBB1_6

索引与迭代器版本的pre/post代码有很多差异，但不应影响足够大数组的总结果计时。

在ASM输出

的Coliru上实时演示 
#include <algorithm>
#include <iterator>
#include <vector>
using namespace std;
void hand_loop_index(vector<double> &v)
{
    for (size_t i = 0; i < v.size(); ++i)
    {
        v[i] /= 42;
    }
}
void hand_loop_iterator(vector<double> &v)
{
    for (auto first = begin(v), last = end(v); first!=last; ++first)
    {
        *first /= 42;
    }
}
void range_based_for(vector<double> &v)
{
    for (auto &x : v)
    {
        x /= 42;
    }
}
void for_each_algorithm(vector<double> &v)
{
    for_each(begin(v), end(v), [] (double &x)
    {
        x /= 42;
    });
}

结果ASM：

# clang++ -std=c++1z -O3 -Wall -pedantic -pthread main.cpp -S
    .text
    .file   "main.cpp"
    .section    .rodata.cst16,"aM",@progbits,16
    .align  16
.LCPI0_0:
    .quad   4631107791820423168     # double 4.200000e+01
    .quad   4631107791820423168     # double 4.200000e+01
    .section    .rodata.cst8,"aM",@progbits,8
    .align  8
.LCPI0_1:
    .quad   4631107791820423168     # double 42
    .text
    .globl  _Z15hand_loop_indexRSt6vectorIdSaIdEE
    .align  16, 0x90
    .type   _Z15hand_loop_indexRSt6vectorIdSaIdEE,@function
_Z15hand_loop_indexRSt6vectorIdSaIdEE:  # @_Z15hand_loop_indexRSt6vectorIdSaIdEE
    .cfi_startproc
# BB#0:
    movq    (%rdi), %rax
    movq    8(%rdi), %rcx
    subq    %rax, %rcx
    je  .LBB0_11
# BB#1:                                 # %.lr.ph
    sarq    $3, %rcx
    cmpq    $1, %rcx
    movl    $1, %edx
    cmovaq  %rcx, %rdx
    xorl    %edi, %edi
    testq   %rdx, %rdx
    je  .LBB0_10
# BB#2:                                 # %overflow.checked
    xorl    %edi, %edi
    movq    %rdx, %r8
    andq    $-4, %r8
    je  .LBB0_9
# BB#3:                                 # %vector.body.preheader
    cmpq    $1, %rcx
    movl    $1, %edi
    cmovaq  %rcx, %rdi
    addq    $-4, %rdi
    movq    %rdi, %rsi
    shrq    $2, %rsi
    xorl    %r9d, %r9d
    btq $2, %rdi
    jb  .LBB0_5
# BB#4:                                 # %vector.body.prol
    movupd  (%rax), %xmm0
    movupd  16(%rax), %xmm1
    movapd  .LCPI0_0(%rip), %xmm2   # xmm2 = [4.200000e+01,4.200000e+01]
    divpd   %xmm2, %xmm0
    divpd   %xmm2, %xmm1
    movupd  %xmm0, (%rax)
    movupd  %xmm1, 16(%rax)
    movl    $4, %r9d
.LBB0_5:                                # %vector.body.preheader.split
    testq   %rsi, %rsi
    je  .LBB0_8
# BB#6:                                 # %vector.body.preheader.split.split
    cmpq    $1, %rcx
    movl    $1, %edi
    cmovaq  %rcx, %rdi
    andq    $-4, %rdi
    subq    %r9, %rdi
    leaq    48(%rax,%r9,8), %rsi
    movapd  .LCPI0_0(%rip), %xmm0   # xmm0 = [4.200000e+01,4.200000e+01]
    .align  16, 0x90
.LBB0_7:                                # %vector.body
                                        # =>This Inner Loop Header: Depth=1
    movupd  -48(%rsi), %xmm1
    movupd  -32(%rsi), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -48(%rsi)
    movupd  %xmm2, -32(%rsi)
    movupd  -16(%rsi), %xmm1
    movupd  (%rsi), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -16(%rsi)
    movupd  %xmm2, (%rsi)
    addq    $64, %rsi
    addq    $-8, %rdi
    jne .LBB0_7
.LBB0_8:
    movq    %r8, %rdi
.LBB0_9:                                # %middle.block
    cmpq    %rdi, %rdx
    je  .LBB0_11
    .align  16, 0x90
.LBB0_10:                               # %scalar.ph
                                        # =>This Inner Loop Header: Depth=1
    movsd   (%rax,%rdi,8), %xmm0    # xmm0 = mem[0],zero
    divsd   .LCPI0_1(%rip), %xmm0
    movsd   %xmm0, (%rax,%rdi,8)
    incq    %rdi
    cmpq    %rcx, %rdi
    jb  .LBB0_10
.LBB0_11:                               # %._crit_edge
    retq
.Lfunc_end0:
    .size   _Z15hand_loop_indexRSt6vectorIdSaIdEE, .Lfunc_end0-_Z15hand_loop_indexRSt6vectorIdSaIdEE
    .cfi_endproc
.section    .rodata.cst16,"aM",@progbits,16
    .align  16
.LCPI1_0:
    .quad   4631107791820423168     # double 4.200000e+01
    .quad   4631107791820423168     # double 4.200000e+01
    .section    .rodata.cst8,"aM",@progbits,8
    .align  8
.LCPI1_1:
    .quad   4631107791820423168     # double 42
    .text
    .globl  _Z18hand_loop_iteratorRSt6vectorIdSaIdEE
    .align  16, 0x90
    .type   _Z18hand_loop_iteratorRSt6vectorIdSaIdEE,@function
_Z18hand_loop_iteratorRSt6vectorIdSaIdEE: # @_Z18hand_loop_iteratorRSt6vectorIdSaIdEE
    .cfi_startproc
# BB#0:
    movq    (%rdi), %rdx
    movq    8(%rdi), %rax
    cmpq    %rax, %rdx
    je  .LBB1_11
# BB#1:                                 # %.lr.ph.preheader
    movabsq $4611686018427387900, %rsi # imm = 0x3FFFFFFFFFFFFFFC
    leaq    -8(%rax), %rcx
    subq    %rdx, %rcx
    shrq    $3, %rcx
    incq    %rcx
    xorl    %edi, %edi
    movq    %rcx, %r9
    andq    %rsi, %r9
    je  .LBB1_8
# BB#2:                                 # %vector.body.preheader
    andq    %rcx, %rsi
    leaq    -4(%rsi), %rdi
    movq    %rdi, %r11
    shrq    $2, %r11
    xorl    %r10d, %r10d
    btq $2, %rdi
    jb  .LBB1_4
# BB#3:                                 # %vector.body.prol
    movupd  (%rdx), %xmm0
    movupd  16(%rdx), %xmm1
    movapd  .LCPI1_0(%rip), %xmm2   # xmm2 = [4.200000e+01,4.200000e+01]
    divpd   %xmm2, %xmm0
    divpd   %xmm2, %xmm1
    movupd  %xmm0, (%rdx)
    movupd  %xmm1, 16(%rdx)
    movl    $4, %r10d
.LBB1_4:                                # %vector.body.preheader.split
    leaq    (%rdx,%r9,8), %r8
    testq   %r11, %r11
    je  .LBB1_7
# BB#5:                                 # %vector.body.preheader.split.split
    subq    %r10, %rsi
    leaq    48(%rdx,%r10,8), %rdx
    movapd  .LCPI1_0(%rip), %xmm0   # xmm0 = [4.200000e+01,4.200000e+01]
    .align  16, 0x90
.LBB1_6:                                # %vector.body
                                        # =>This Inner Loop Header: Depth=1
    movupd  -48(%rdx), %xmm1
    movupd  -32(%rdx), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -48(%rdx)
    movupd  %xmm2, -32(%rdx)
    movupd  -16(%rdx), %xmm1
    movupd  (%rdx), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -16(%rdx)
    movupd  %xmm2, (%rdx)
    addq    $64, %rdx
    addq    $-8, %rsi
    jne .LBB1_6
.LBB1_7:
    movq    %r8, %rdx
    movq    %r9, %rdi
.LBB1_8:                                # %middle.block
    cmpq    %rdi, %rcx
    je  .LBB1_11
# BB#9:
    movsd   .LCPI1_1(%rip), %xmm0   # xmm0 = mem[0],zero
    .align  16, 0x90
.LBB1_10:                               # %.lr.ph
                                        # =>This Inner Loop Header: Depth=1
    movsd   (%rdx), %xmm1           # xmm1 = mem[0],zero
    divsd   %xmm0, %xmm1
    movsd   %xmm1, (%rdx)
    addq    $8, %rdx
    cmpq    %rdx, %rax
    jne .LBB1_10
.LBB1_11:                               # %._crit_edge
    retq
.Lfunc_end1:
    .size   _Z18hand_loop_iteratorRSt6vectorIdSaIdEE, .Lfunc_end1-_Z18hand_loop_iteratorRSt6vectorIdSaIdEE
    .cfi_endproc
.section    .rodata.cst16,"aM",@progbits,16
    .align  16
.LCPI2_0:
    .quad   4631107791820423168     # double 4.200000e+01
    .quad   4631107791820423168     # double 4.200000e+01
    .section    .rodata.cst8,"aM",@progbits,8
    .align  8
.LCPI2_1:
    .quad   4631107791820423168     # double 42
    .text
    .globl  _Z15range_based_forRSt6vectorIdSaIdEE
    .align  16, 0x90
    .type   _Z15range_based_forRSt6vectorIdSaIdEE,@function
_Z15range_based_forRSt6vectorIdSaIdEE:  # @_Z15range_based_forRSt6vectorIdSaIdEE
    .cfi_startproc
# BB#0:
    movq    (%rdi), %rdx
    movq    8(%rdi), %rax
    cmpq    %rax, %rdx
    je  .LBB2_11
# BB#1:                                 # %.lr.ph.preheader
    movabsq $4611686018427387900, %rsi # imm = 0x3FFFFFFFFFFFFFFC
    leaq    -8(%rax), %rcx
    subq    %rdx, %rcx
    shrq    $3, %rcx
    incq    %rcx
    xorl    %edi, %edi
    movq    %rcx, %r9
    andq    %rsi, %r9
    je  .LBB2_8
# BB#2:                                 # %vector.body.preheader
    andq    %rcx, %rsi
    leaq    -4(%rsi), %rdi
    movq    %rdi, %r11
    shrq    $2, %r11
    xorl    %r10d, %r10d
    btq $2, %rdi
    jb  .LBB2_4
# BB#3:                                 # %vector.body.prol
    movupd  (%rdx), %xmm0
    movupd  16(%rdx), %xmm1
    movapd  .LCPI2_0(%rip), %xmm2   # xmm2 = [4.200000e+01,4.200000e+01]
    divpd   %xmm2, %xmm0
    divpd   %xmm2, %xmm1
    movupd  %xmm0, (%rdx)
    movupd  %xmm1, 16(%rdx)
    movl    $4, %r10d
.LBB2_4:                                # %vector.body.preheader.split
    leaq    (%rdx,%r9,8), %r8
    testq   %r11, %r11
    je  .LBB2_7
# BB#5:                                 # %vector.body.preheader.split.split
    subq    %r10, %rsi
    leaq    48(%rdx,%r10,8), %rdx
    movapd  .LCPI2_0(%rip), %xmm0   # xmm0 = [4.200000e+01,4.200000e+01]
    .align  16, 0x90
.LBB2_6:                                # %vector.body
                                        # =>This Inner Loop Header: Depth=1
    movupd  -48(%rdx), %xmm1
    movupd  -32(%rdx), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -48(%rdx)
    movupd  %xmm2, -32(%rdx)
    movupd  -16(%rdx), %xmm1
    movupd  (%rdx), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -16(%rdx)
    movupd  %xmm2, (%rdx)
    addq    $64, %rdx
    addq    $-8, %rsi
    jne .LBB2_6
.LBB2_7:
    movq    %r8, %rdx
    movq    %r9, %rdi
.LBB2_8:                                # %middle.block
    cmpq    %rdi, %rcx
    je  .LBB2_11
# BB#9:
    movsd   .LCPI2_1(%rip), %xmm0   # xmm0 = mem[0],zero
    .align  16, 0x90
.LBB2_10:                               # %.lr.ph
                                        # =>This Inner Loop Header: Depth=1
    movsd   (%rdx), %xmm1           # xmm1 = mem[0],zero
    divsd   %xmm0, %xmm1
    movsd   %xmm1, (%rdx)
    addq    $8, %rdx
    cmpq    %rdx, %rax
    jne .LBB2_10
.LBB2_11:                               # %._crit_edge
    retq
.Lfunc_end2:
    .size   _Z15range_based_forRSt6vectorIdSaIdEE, .Lfunc_end2-_Z15range_based_forRSt6vectorIdSaIdEE
    .cfi_endproc
.section    .rodata.cst16,"aM",@progbits,16
    .align  16
.LCPI3_0:
    .quad   4631107791820423168     # double 4.200000e+01
    .quad   4631107791820423168     # double 4.200000e+01
    .section    .rodata.cst8,"aM",@progbits,8
    .align  8
.LCPI3_1:
    .quad   4631107791820423168     # double 42
    .text
    .globl  _Z18for_each_algorithmRSt6vectorIdSaIdEE
    .align  16, 0x90
    .type   _Z18for_each_algorithmRSt6vectorIdSaIdEE,@function
_Z18for_each_algorithmRSt6vectorIdSaIdEE: # @_Z18for_each_algorithmRSt6vectorIdSaIdEE
    .cfi_startproc
# BB#0:
    movq    (%rdi), %rdx
    movq    8(%rdi), %rax
    cmpq    %rax, %rdx
    je  .LBB3_11
# BB#1:                                 # %.lr.ph.i.preheader
    movabsq $4611686018427387900, %rsi # imm = 0x3FFFFFFFFFFFFFFC
    leaq    -8(%rax), %rcx
    subq    %rdx, %rcx
    shrq    $3, %rcx
    incq    %rcx
    xorl    %edi, %edi
    movq    %rcx, %r9
    andq    %rsi, %r9
    je  .LBB3_8
# BB#2:                                 # %vector.body.preheader
    andq    %rcx, %rsi
    leaq    -4(%rsi), %rdi
    movq    %rdi, %r11
    shrq    $2, %r11
    xorl    %r10d, %r10d
    btq $2, %rdi
    jb  .LBB3_4
# BB#3:                                 # %vector.body.prol
    movupd  (%rdx), %xmm0
    movupd  16(%rdx), %xmm1
    movapd  .LCPI3_0(%rip), %xmm2   # xmm2 = [4.200000e+01,4.200000e+01]
    divpd   %xmm2, %xmm0
    divpd   %xmm2, %xmm1
    movupd  %xmm0, (%rdx)
    movupd  %xmm1, 16(%rdx)
    movl    $4, %r10d
.LBB3_4:                                # %vector.body.preheader.split
    leaq    (%rdx,%r9,8), %r8
    testq   %r11, %r11
    je  .LBB3_7
# BB#5:                                 # %vector.body.preheader.split.split
    subq    %r10, %rsi
    leaq    48(%rdx,%r10,8), %rdx
    movapd  .LCPI3_0(%rip), %xmm0   # xmm0 = [4.200000e+01,4.200000e+01]
    .align  16, 0x90
.LBB3_6:                                # %vector.body
                                        # =>This Inner Loop Header: Depth=1
    movupd  -48(%rdx), %xmm1
    movupd  -32(%rdx), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -48(%rdx)
    movupd  %xmm2, -32(%rdx)
    movupd  -16(%rdx), %xmm1
    movupd  (%rdx), %xmm2
    divpd   %xmm0, %xmm1
    divpd   %xmm0, %xmm2
    movupd  %xmm1, -16(%rdx)
    movupd  %xmm2, (%rdx)
    addq    $64, %rdx
    addq    $-8, %rsi
    jne .LBB3_6
.LBB3_7:
    movq    %r8, %rdx
    movq    %r9, %rdi
.LBB3_8:                                # %middle.block
    cmpq    %rdi, %rcx
    je  .LBB3_11
# BB#9:
    movsd   .LCPI3_1(%rip), %xmm0   # xmm0 = mem[0],zero
    .align  16, 0x90
.LBB3_10:                               # %.lr.ph.i
                                        # =>This Inner Loop Header: Depth=1
    movsd   (%rdx), %xmm1           # xmm1 = mem[0],zero
    divsd   %xmm0, %xmm1
    movsd   %xmm1, (%rdx)
    addq    $8, %rdx
    cmpq    %rdx, %rax
    jne .LBB3_10
.LBB3_11:                               # %_ZSt8for_eachIN9__gnu_cxx17__normal_iteratorIPdSt6vectorIdSaIdEEEEZ18for_each_algorithmR5_E3$_0ET0_T_SA_S9_.exit
    retq
.Lfunc_end3:
    .size   _Z18for_each_algorithmRSt6vectorIdSaIdEE, .Lfunc_end3-_Z18for_each_algorithmRSt6vectorIdSaIdEE
    .cfi_endproc
    .ident  "clang version 3.7.0 (tags/RELEASE_370/final 246979)"
    .section    ".note.GNU-stack","",@progbits

相关内容

最新更新


热门标签：

javascript python java c# php android html jquery c++ css ios sql mysql arrays asp.net json python-3.x ruby-on-rails .net sql-server django objective-c excel regex ruby linux ajax iphone xml vba spring asp.net-mvc database wordpress string postgresql wpf windows xcode bash git oracle list vb.net multithreading eclipse algorithm macos powershell visual-studio image forms numpy scala function api selenium