gcc -O0在2的幂（矩阵换位）矩阵大小上表现优于-O3

时间：2014-02-18 01:04:51

标签： c++ gcc linear-algebra compiler-optimization execution-time

（出于测试目的）我编写了一个简单的方法来计算nxn矩阵的转置

void transpose(const size_t _n, double* _A) {
    for(uint i=0; i < _n; ++i) {
        for(uint j=i+1; j < _n; ++j) {
            double tmp  = _A[i*_n+j];
            _A[i*_n+j] = _A[j*_n+i];
            _A[j*_n+i] = tmp;
        }
    }
}

当使用优化级别O3或Ofast时，我期望编译器展开一些循环，这将导致更高的性能，尤其是当矩阵大小是2的倍数（即，每次迭代可以执行双循环体）或类似时。相反，我测量的恰恰相反。 2的权力实际上表明执行时间显着增加。

这些尖峰也是64的固定间隔，间隔128更明显，依此类推。每个尖峰都延伸到相邻的矩阵大小，如下表所示

size n  time(us)
1020    2649
1021    2815
1022    3100
1023    5428
1024    15791
1025    6778
1026    3106
1027    2847
1028    2660
1029    3038
1030    2613

我使用gcc版本4.8.2编译但是同样的事情发生在clang 3.5上，所以这可能是一些通用的东西？

  

所以我的问题基本上是：为什么执行时间周期性增加？是否有一些通用的东西与任何优化选项一起出现（就像clang和gcc一样）？如果是这样的优化选项导致了这个？

     

这怎么可能如此重要，即使O0版本的程序在512的倍数时优于03版本？

execution time vs matrix size for O0 and O3

编辑：请注意此（对数）图中峰值的大小。转换具有优化的1024x1024矩阵实际上需要花费与转换1300x1300矩阵而无需优化一样多的时间。如果这是一个缓存故障/页面错误问题，那么有人需要向我解释为什么内存布局对于程序的优化版本来说是如此显着不同，它失败了2的权限，只是为了恢复高性能稍大的矩阵。缓存故障是否应该创建更多类似步骤的模式？为什么执行时间会再次下降？ （为什么优化会创建之前没有的缓存故障？）

编辑：以下内容应该是gcc制作的汇编代码

无优化（O0）：

_Z9transposemRPd:
.LFB0:
    .cfi_startproc
    push    rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    mov rbp, rsp
    .cfi_def_cfa_register 6
    mov QWORD PTR [rbp-24], rdi
    mov QWORD PTR [rbp-32], rsi
    mov DWORD PTR [rbp-4], 0
    jmp .L2
.L5:
    mov eax, DWORD PTR [rbp-4]
    add eax, 1
    mov DWORD PTR [rbp-8], eax
    jmp .L3
.L4:
    mov rax, QWORD PTR [rbp-32]
    mov rdx, QWORD PTR [rax]
    mov eax, DWORD PTR [rbp-4]
    imul    rax, QWORD PTR [rbp-24]
    mov rcx, rax
    mov eax, DWORD PTR [rbp-8]
    add rax, rcx
    sal rax, 3
    add rax, rdx
    mov rax, QWORD PTR [rax]
    mov QWORD PTR [rbp-16], rax
    mov rax, QWORD PTR [rbp-32]
    mov rdx, QWORD PTR [rax]
    mov eax, DWORD PTR [rbp-4]
    imul    rax, QWORD PTR [rbp-24]
    mov rcx, rax
    mov eax, DWORD PTR [rbp-8]
    add rax, rcx
    sal rax, 3
    add rdx, rax
    mov rax, QWORD PTR [rbp-32]
    mov rcx, QWORD PTR [rax]
    mov eax, DWORD PTR [rbp-8]
    imul    rax, QWORD PTR [rbp-24]
    mov rsi, rax
    mov eax, DWORD PTR [rbp-4]
    add rax, rsi
    sal rax, 3
    add rax, rcx
    mov rax, QWORD PTR [rax]
    mov QWORD PTR [rdx], rax
    mov rax, QWORD PTR [rbp-32]
    mov rdx, QWORD PTR [rax]
    mov eax, DWORD PTR [rbp-8]
    imul    rax, QWORD PTR [rbp-24]
    mov rcx, rax
    mov eax, DWORD PTR [rbp-4]
    add rax, rcx
    sal rax, 3
    add rdx, rax
    mov rax, QWORD PTR [rbp-16]
    mov QWORD PTR [rdx], rax
    add DWORD PTR [rbp-8], 1
.L3:
    mov eax, DWORD PTR [rbp-8]
    cmp rax, QWORD PTR [rbp-24]
    jb  .L4
    add DWORD PTR [rbp-4], 1
.L2:
    mov eax, DWORD PTR [rbp-4]
    cmp rax, QWORD PTR [rbp-24]
    jb  .L5
    pop rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE0:
    .size   _Z9transposemRPd, .-_Z9transposemRPd
    .ident  "GCC: (Debian 4.8.2-15) 4.8.2"
    .section    .note.GNU-stack,"",@progbits

优化（O3）

_Z9transposemRPd:
.LFB0:
    .cfi_startproc
    push    rbx
    .cfi_def_cfa_offset 16
    .cfi_offset 3, -16
    xor r11d, r11d
    xor ebx, ebx
.L2:
    cmp r11, rdi
    mov r9, r11
    jae .L10
    .p2align 4,,10
    .p2align 3
.L7:
    add ebx, 1
    mov r11d, ebx
    cmp rdi, r11
    mov rax, r11
    jbe .L2
    mov r10, r9
    mov r8, QWORD PTR [rsi]
    mov edx, ebx
    imul    r10, rdi
    .p2align 4,,10
    .p2align 3
.L6:
    lea rcx, [rax+r10]
    add edx, 1
    imul    rax, rdi
    lea rcx, [r8+rcx*8]
    movsd   xmm0, QWORD PTR [rcx]
    add rax, r9
    lea rax, [r8+rax*8]
    movsd   xmm1, QWORD PTR [rax]
    movsd   QWORD PTR [rcx], xmm1
    movsd   QWORD PTR [rax], xmm0
    mov eax, edx
    cmp rdi, rax
    ja  .L6
    cmp r11, rdi
    mov r9, r11
    jb  .L7
.L10:
    pop rbx
    .cfi_def_cfa_offset 8
    ret
    .cfi_endproc
.LFE0:
    .size   _Z9transposemRPd, .-_Z9transposemRPd
    .ident  "GCC: (Debian 4.8.2-15) 4.8.2"
    .section    .note.GNU-stack,"",@progbits

4 个答案:

答案 0 :(得分：7)

执行时间的周期性增加必须归因于缓存只是N路关联而不是完全关联。您正在目睹与缓存行选择算法相关的哈希冲突。

最快的L1缓存具有比下一级L2更少的缓存行数。在每个级别中，每个缓存行只能从一组有限的源中填充。

高速缓存行选择算法的典型硬件实现只使用存储器地址中的少量位来确定应在哪个高速缓存插槽中写入数据 - 在HW位移位是免费的。

这导致记忆范围之间的竞争，例如地址0x300010和0x341010之间。 在完全顺序算法中，这无关紧要 - 对于实际上所有形式的算法，N足够大：

 for (i=0;i<1000;i++) a[i] += b[i] * c[i] + d[i];

但是当输入（或输出）的数量变大时，这会在算法优化时在内部发生，在缓存中有一个输入会强制另一个输出进入缓存。

 // one possible method of optimization with 2 outputs and 6 inputs
 // with two unrelated execution paths -- should be faster, but maybe it isn't
 for (i=0;i<500;i++) { 
       a[i]     += b[i]     * c[i]     + d[i];
       a[i+500] += b[i+500] * c[i+500] + d[i+500];
 }

Example 5: Cache Associativity中的图表说明矩阵行之间的512字节偏移是特定系统的全局最坏情况维度。如果知道这一点，那么工作缓解就是将矩阵水平过度分配到其他维度char matrix[512][512 + 64]。

答案 1 :(得分：0)

性能的提升可能与CPU / RAM缓存有关。

当数据不是2的幂时，高速缓存行负载（如16,32或64个字）传输的内容比捆绑总线所需的数据多 - 实际上无用。对于2的幂的数据集，使用所有预取数据。

我敢打赌，如果你要禁用L1和L2缓存，性能将是完全平滑和可预测的。但它会慢得多。缓存真的有助于提高性能！

答案 2 :(得分：0)

使用代码进行注释：在-O3情况下，使用

#include <cstdlib>

extern void transpose(const size_t n, double* a)
{
    for (size_t i = 0; i < n; ++i) {
        for (size_t j = i + 1; j < n; ++j) {
            std::swap(a[i * n + j], a[j * n + i]); // or your expanded version.
        }
    }
}

使用

进行编译 
$ g++ --version
g++ (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
...
$ g++ -g1 -std=c++11 -Wall -o test.S -S test.cpp -O3

我得到了

_Z9transposemPd:
.LFB68:
    .cfi_startproc
.LBB2:
    testq   %rdi, %rdi
    je  .L1
    leaq    8(,%rdi,8), %r10
    xorl    %r8d, %r8d
.LBB3:
    addq    $1, %r8
    leaq    -8(%r10), %rcx
    cmpq    %rdi, %r8
    leaq    (%rsi,%rcx), %r9
    je  .L1
    .p2align 4,,10
    .p2align 3
.L10:
    movq    %r9, %rdx
    movq    %r8, %rax
    .p2align 4,,10
    .p2align 3
.L5:
.LBB4:
    movsd   (%rdx), %xmm1
    movsd   (%rsi,%rax,8), %xmm0
    movsd   %xmm1, (%rsi,%rax,8)
.LBE4:
    addq    $1, %rax
.LBB5:
    movsd   %xmm0, (%rdx)
    addq    %rcx, %rdx
.LBE5:
    cmpq    %rdi, %rax
    jne .L5
    addq    $1, %r8
    addq    %r10, %r9
    addq    %rcx, %rsi
    cmpq    %rdi, %r8
    jne .L10
.L1:
    rep ret
.LBE3:
.LBE2:
    .cfi_endproc

如果我添加-m32，那就完全不同了。

（注意：无论我使用std :: swap还是你的变体，它对程序集都没有区别）

为了理解导致峰值的原因，您可能希望可视化正在进行的内存操作。

答案 3 :(得分：0)

要添加到其他人：g++ -std=c++11 -march=core2 -O3 -c -S - gcc版本4.8.2（MacPorts gcc48 4.8.2_0） - x86_64-apple-darwin13.0.0：

__Z9transposemPd:
LFB0:
        testq   %rdi, %rdi
        je      L1
        leaq    8(,%rdi,8), %r10
        xorl    %r8d, %r8d
        leaq    -8(%r10), %rcx
        addq    $1, %r8
        leaq    (%rsi,%rcx), %r9
        cmpq    %rdi, %r8
        je      L1
        .align 4,0x90
L10:
        movq    %r9, %rdx
        movq    %r8, %rax
        .align 4,0x90
L5:
        movsd   (%rdx), %xmm0
        movsd   (%rsi,%rax,8), %xmm1
        movsd   %xmm0, (%rsi,%rax,8)
        addq    $1, %rax
        movsd   %xmm1, (%rdx)
        addq    %rcx, %rdx
        cmpq    %rdi, %rax
        jne     L5
        addq    $1, %r8
        addq    %r10, %r9
        addq    %rcx, %rsi
        cmpq    %rdi, %r8
        jne     L10
L1:
        rep; ret

基本上与@ ksfone的代码相同，用于：

#include <cstddef>

void transpose(const size_t _n, double* _A) {
    for(size_t i=0; i < _n; ++i) {
        for(size_t j=i+1; j < _n; ++j) {
            double tmp  = _A[i*_n+j];
            _A[i*_n+j] = _A[j*_n+i];
            _A[j*_n+i] = tmp;
        }
    }
}

除了Mach-O'作为'差异（额外的下划线，对齐和DWARF位置），它也是一样的。但与OP的装配输出有很大不同。一个更“紧密”的内循环。

相关问题
最新问题