c++ - Visual Studio 2012 不同的值发布/调试模式

Question

在调试和发布模式之间切换时，此代码在 MSVS 2012、Windows 7 中产生不同的值：

#include <iostream>
using namespace std;

int A[20000];

int main() {

    int shift = 0;
    int Period = 30;
    //Fill array
    for(int i = 0; i < 20000; i++) {
        A[i] = i * 2 + 123;
    }

    int sumTotal = 0;
    int sum = 0;

    for(int bars = Period + 10; bars < 1000; bars++) {
        sum = 0;
        for(int i = 0; i< Period; i++) {
            sum += A[bars - i];
        }
        sumTotal += sum;
    }
    cout << sumTotal << endl;
}

你能重现或找到原因吗？我一直在测试项目属性的各种设置。

调试（正确结果）：32630400
发布：32814720

/GS /GL /analyze- /W3 /Gy /Zc:wchar_t /I"C:\Program Files (x86)\Visual Leak Detector\include" /Z7 /Gm- /O2 /Fd"Release\vc110.pdb" /fp:precise /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /Gd /Oy- /Oi /MD /Fa"Release\" /EHsc /nologo /Fo"Release\" /Fp"Release\Testing.pch"

score 18 · Accepted Answer

我使用 VS2012 C 编译器测试了代码的“简化”版本

int main()
{
  int A[12] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };

  int sum = 0;
  int i;

  for (i = 0; i < 12; ++i)
     sum += A[11 - i];

  printf("%d\n", sum);

  return 0;
}

我在 x64 模式下编译它发布配置为速度优化。该错误仍然存在，但取决于其他优化和代码生成设置，它会以不同的方式显示自己。一个版本的代码生成“随机”结果，而另一个版本始终生成8sum（而不是正确的12）。

这就是始终生成的版本的生成代码的样子8

000000013FC81DF0  mov         rax,rsp  
000000013FC81DF3  sub         rsp,68h  
000000013FC81DF7  movd        xmm1,dword ptr [rax-18h]  
000000013FC81DFC  movd        xmm2,dword ptr [rax-10h]  
000000013FC81E01  movd        xmm5,dword ptr [rax-0Ch]  
000000013FC81E06  xorps       xmm0,xmm0  
000000013FC81E09  xorps       xmm3,xmm3  

for (i = 0; i < 12; ++i)
000000013FC81E0C  xor         ecx,ecx  
000000013FC81E0E  mov         dword ptr [rax-48h],1  
000000013FC81E15  mov         dword ptr [rax-44h],1  
000000013FC81E1C  mov         dword ptr [rax-40h],1  
000000013FC81E23  punpckldq   xmm2,xmm1  
000000013FC81E27  mov         dword ptr [rax-3Ch],1  
000000013FC81E2E  mov         dword ptr [rax-38h],1  
000000013FC81E35  mov         dword ptr [rax-34h],1  
{
     sum += A[11 - i];
000000013FC81E3C  movdqa      xmm4,xmmword ptr [__xmm@00000001000000010000000100000001 (013FC83360h)]  
000000013FC81E44  paddd       xmm4,xmm0  
000000013FC81E48  movd        xmm0,dword ptr [rax-14h]  
000000013FC81E4D  mov         dword ptr [rax-30h],1  
000000013FC81E54  mov         dword ptr [rax-2Ch],1  
000000013FC81E5B  mov         dword ptr [rax-28h],1  
000000013FC81E62  mov         dword ptr [rax-24h],1  
000000013FC81E69  punpckldq   xmm5,xmm0  
000000013FC81E6D  punpckldq   xmm5,xmm2  
000000013FC81E71  paddd       xmm5,xmm3  
000000013FC81E75  paddd       xmm5,xmm4  
000000013FC81E79  mov         dword ptr [rax-20h],1  
000000013FC81E80  mov         dword ptr [rax-1Ch],1  
000000013FC81E87  mov         r8d,ecx  
000000013FC81E8A  movdqa      xmm0,xmm5  
000000013FC81E8E  psrldq      xmm0,8  
000000013FC81E93  paddd       xmm5,xmm0  
000000013FC81E97  movdqa      xmm0,xmm5  
000000013FC81E9B  lea         rax,[rax-40h]  
000000013FC81E9F  mov         r9d,2  
000000013FC81EA5  psrldq      xmm0,4  
000000013FC81EAA  paddd       xmm5,xmm0  
000000013FC81EAE  movd        edx,xmm5  
000000013FC81EB2  nop         word ptr [rax+rax]  
{
     sum += A[11 - i];
000000013FC81EC0  add         ecx,dword ptr [rax+4]  
000000013FC81EC3  add         r8d,dword ptr [rax]  
000000013FC81EC6  lea         rax,[rax-8]  
000000013FC81ECA  dec         r9  
000000013FC81ECD  jne         main+0D0h (013FC81EC0h)  
}

printf("%d\n", sum);
000000013FC81ECF  lea         eax,[r8+rcx]  
000000013FC81ED3  lea         rcx,[__security_cookie_complement+8h (013FC84040h)]  
000000013FC81EDA  add         edx,eax  
000000013FC81EDC  call        qword ptr [__imp_printf (013FC83140h)]  

return 0;
000000013FC81EE2  xor         eax,eax  
}
000000013FC81EE4  add         rsp,68h  
000000013FC81EE8  ret

代码生成器和优化器留下了很多奇怪的、看似不必要的 mumbo-jumbo，但这段代码的作用可以简要描述如下。

有两个独立的算法用来产生最终的和，显然应该处理数组的不同部分。我猜想两个处理流程（非 SSE 和 SSE）用于通过指令流水线促进并行性。

一种算法是一个简单的循环，它对数组元素求和，每次迭代处理两个元素。可以从上面的“交错”代码中提取如下

; Initialization
000000013F1E1E0C  xor         ecx,ecx                 ; ecx - odd element sum
000000013F1E1E87  mov         r8d,ecx                 ; r8 - even element sum
000000013F1E1E9B  lea         rax,[rax-40h]           ; start from i = 2
000000013F1E1E9F  mov         r9d,2                   ; do 2 iterations

; The cycle
000000013F1E1EC0  add         ecx,dword ptr [rax+4]   ; ecx += A[i + 1]
000000013F1E1EC3  add         r8d,dword ptr [rax]     ; r8d += A[i]
000000013F1E1EC6  lea         rax,[rax-8]             ; i -= 2
000000013F1E1ECA  dec         r9                      
000000013F1E1ECD  jne         main+0D0h (013F1E1EC0h) ; loop again if r9 is not zero

该算法从 address 开始添加元素rax - 40h，在我的实验中，它等于并向&A[2]后跳过两个元素进行两次迭代。这将累加寄存器中和的总和A[0]以及A[2]寄存器中和r8的总和。因此，这部分算法处理数组的 4 个元素，并在和中正确生成值。A[1]A[3]ecx2r8ecx

该算法的另一部分是使用 SSE 指令编写的，显然负责对数组的剩余部分求和。可以从代码中提取如下

; Initially xmm5 is zero
000000013F1E1E3C  movdqa      xmm4,xmmword ptr [__xmm@00000001000000010000000100000001 (013F1E3360h)]  
000000013F1E1E75  paddd       xmm5,xmm4  

000000013F1E1E8A  movdqa      xmm0,xmm5               ; copy
000000013F1E1E8E  psrldq      xmm0,8                  ; shift
000000013F1E1E93  paddd       xmm5,xmm0               ; and add

000000013F1E1E8A  movdqa      xmm0,xmm5               ; copy
000000013F1E1E8E  psrldq      xmm0,4                  ; shift
000000013F1E1E93  paddd       xmm5,xmm0               ; and add

000000013F1E1EAE  movd        edx,xmm5                ; edx - the sum

该部分使用的通用算法很简单：它将值0x00000001000000010000000100000001放入 128 位寄存器xmm5中，然后将其向右移动 8 个字节（0x00000000000000000000000100000001）并将其与原始值相加，产生0x00000001000000010000000200000002。这再次向右移动 4 个字节 ( 0x00000000000000010000000100000002) 并再次添加到前一个值，产生0x00000001000000020000000300000004. 的最后一个 32 位字0x00000004作为xmm5结果并放入寄存器edx。因此，该算法产生4作为其最终结果。很明显，该算法只是在 128 位寄存器中执行连续 32 位字的“并行”加法。请注意，顺便说一句，该算法甚至没有尝试访问A，它从编译器/优化器生成的嵌入式常量开始求和。

现在，最后的值r8 + ecx + edx被报告为最终总和。显然，这只是8，而不是正确的12。看起来这两种算法之一忘记了做一些工作。我不知道是哪一个，但从大量的“冗余”指令来看，看起来应该是 SSE 算法8而edx不是4. 一个可疑的指令是这个

000000013FC81E71  paddd       xmm5,xmm3

在那一刻xmm3总是包含零。所以，这条指令看起来完全是多余的和不必要的。但是，如果xmm3实际上包含另一个表示数组的另外 4 个元素的“魔术”常数（就像xmm4做的那样），那么该算法将正常工作并产生正确的总和。

如果对数组元素使用独特的初始值

int A[12] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

可以清楚地看到，第一个（非SSE）算法成功求和1, 2, 3, 4，而第二个（SSE）算法求和9, 10, 11, 12。5, 6, 7, 8仍然被排除在考虑之外，导致52作为最终总和而不是正确的78.

这绝对是一个编译器/优化器错误。

PS 导入到 VS2013 Update 2 的相同设置的同一个项目似乎没有受到这个 bug 的影响。

score 15 · Accepted Answer

我相信您在优化器中发现了一个错误。cout << "hi"您可以通过禁用优化或通过在最内层for循环中添加具有无法优化的副作用（例如）的额外代码来获得发布版本以提供与调试版本相同（正确）的输出（这可能会阻止任何优化）否则执行不正确）。我建议将其报告给 Microsoft。

更新：微软确认这是一个与自动矢量化相关的错误，并已在 VS2013 更新 2 中修复。其他版本的解决方法是通过在循环前加上#pragma loop(no_vector).

此外，他们描述了两种可以触发错误的不同循环结构。我将引用它们：

有两种情况会出现错误：

1）正如用户burzvingion所提到的，得到向量化形式的循环：

for (int i=0; ...) { sum = A[...] - sum; }

2) 得到以下形式矢量化的循环：

for (int i=0; ...) { sum = sum + A[ - i]; }

他们还为定位易受攻击的代码提供了以下建议：

如果您正在查看源代码以尝试查找这些情况，我建议您首先抛出 /Qvec-report:1 以查找所有已矢量化的循环，然后从那里开始。要解决这些错误，请将 #pragma loop(no_vector) 放在 for 循环之上。

score 5 · Accepted Answer

产生优化错误的代码可以简化为以下内容：

#include <iostream>
using namespace std;

#define SIZE 12

int main()
{
    int A[SIZE] = {0};

    int sum = 0;
    for (int i=0; i<SIZE; i++)
        sum += A[SIZE-1-i];
    cout << sum << endl;

    return 0;
}

可以通过应用以下任一更改来消除优化错误：

将的定义更改为SIZE小于 12 的值
将表达式更改A[SIZE-1-i]为A[SIZE-i-1]
将操作cout << sum << endl移入循环

因此，为了诊断问题，我们可以简单地应用这些更改中的任何一个，然后在更改之前的代码反汇编和更改之后的代码反汇编之间进行比较。

score 4 · Accepted Answer

我比较了两种情况的 asm 代码（在 VC++ 2013 express 中），在发布版本中，for 循环的发布版本中的 asm 代码

for (int i = 0; i< Period; i++)

在下面，它与调试版本中的非常不同

$LL6@main:

; 23   :        sum = 0;
; 24   :        for (int i = 0; i< Period; i++){

    xorps   xmm5, xmm5
    lea eax, DWORD PTR [edi+88]
    xorps   xmm4, xmm4
    mov ecx, 3
    npad    2
$LL3@main:

; 25   :            //cout << "hi";
; 26   :            sum += A[bars - i];

    movd    xmm2, DWORD PTR [eax-4]
    lea eax, DWORD PTR [eax-32]
    movd    xmm0, DWORD PTR [eax+32]
    movd    xmm1, DWORD PTR [eax+36]
    movd    xmm3, DWORD PTR [eax+40]
    punpckldq xmm3, xmm0
    movd    xmm0, DWORD PTR [eax+48]
    punpckldq xmm1, xmm2
    movd    xmm2, DWORD PTR [eax+44]
    punpckldq xmm3, xmm1
    movd    xmm1, DWORD PTR [eax+52]
    paddd   xmm5, xmm3
    movd    xmm3, DWORD PTR [eax+56]
    punpckldq xmm3, xmm0
    punpckldq xmm1, xmm2
    punpckldq xmm3, xmm1
    paddd   xmm4, xmm3
    dec ecx
    jne SHORT $LL3@main

; 23   :        sum = 0;
; 24   :        for (int i = 0; i< Period; i++){

    paddd   xmm4, xmm5
    xor edx, edx
    movdqa  xmm0, xmm4
    mov eax, edi
    psrldq  xmm0, 8
    mov esi, 3
    paddd   xmm4, xmm0
    movdqa  xmm0, xmm4
    psrldq  xmm0, 4
    paddd   xmm4, xmm0
    movd    ebx, xmm4
    npad    7
$LL30@main:

; 25   :            //cout << "hi";
; 26   :            sum += A[bars - i];

    add ecx, DWORD PTR [eax]
    lea eax, DWORD PTR [eax-8]
    add edx, DWORD PTR [eax+4]
    dec esi
    jne SHORT $LL30@main

; 27   :    

}

从 asm 代码中可以看出，这里使用了 SSE 指令。所以我检查了VC++ 中 SSE 指令的编译器选项，然后我指定 /arch:IA32 以在发布版本中禁用 x86 处理器的 SSE 和 SSE2 指令的生成，然后我得到与调试版本相同的结果。

我对SSE不熟悉，希望有人可以根据我的发现进行更多解释。

c++ - Visual Studio 2012 不同的值发布/调试模式

4 回答 4

Related

Reference