webentwicklung-frage-antwort-db.com.de

Leistungsunterschied zwischen Windows und Linux mit Intel Compiler: Betrachten Sie die Assembly

Ich führe ein Programm unter Windows und Linux (x86-64) aus. Es wurde mit demselben Compiler (Intel Parallel Studio XE 2017) mit denselben Optionen kompiliert, und die Windows-Version ist dreimal schneller als die Linux-Version. Der Täter ist ein Aufruf von std :: erf , der in beiden Fällen in der Intel-Mathematikbibliothek aufgelöst wird (standardmäßig wird er unter Windows dynamisch und unter Linux statisch verknüpft, aber die Verwendung der dynamischen Verknüpfung unter Linux ergibt das gleiche Leistung).

Hier ist ein einfaches Programm, um das Problem zu reproduzieren.

#include <cmath>
#include <cstdio>

int main() {
  int n = 100000000;
  float sum = 1.0f;

  for (int k = 0; k < n; k++) {
    sum += std::erf(sum);
  }

  std::printf("%7.2f\n", sum);
}

Wenn ich dieses Programm mit vTune profiliere, stelle ich fest, dass sich die Assembly zwischen der Windows- und der Linux-Version etwas unterscheidet. Hier ist die Aufrufstelle (die Schleife) unter Windows

Block 3:
"vmovaps xmm0, xmm6"
call 0x1400023e0 <erff>
Block 4:
inc ebx
"vaddss xmm6, xmm6, xmm0"
"cmp ebx, 0x5f5e100"
jl 0x14000103f <Block 3>

Und der Beginn der erf-Funktion ruft Windows auf

Block 1:
Push rbp
"sub rsp, 0x40"
"lea rbp, ptr [rsp+0x20]"
"lea rcx, ptr [rip-0xa6c81]"
"movd edx, xmm0"
"movups xmmword ptr [rbp+0x10], xmm6"
"movss dword ptr [rbp+0x30], xmm0"
"mov eax, edx"
"and edx, 0x7fffffff"
"and eax, 0x80000000"
"add eax, 0x3f800000"
"mov dword ptr [rbp], eax"
"movss xmm6, dword ptr [rbp]"
"cmp edx, 0x7f800000"
...

Unter Linux ist der Code etwas anders. Die Aufrufstelle ist:

Block 3
"vmovaps %xmm1, %xmm0"
"vmovssl  %xmm1, (%rsp)"
callq  0x400bc0 <erff>
Block 4
inc %r12d
"vmovssl  (%rsp), %xmm1"
"vaddss %xmm0, %xmm1, %xmm1"   <-------- hotspot here
"cmp $0x5f5e100, %r12d"
jl 0x400b6b <Block 3>

und der anfang der aufgerufenen funktion (erf) ist:

"movd %xmm0, %edx"
"movssl  %xmm0, -0x10(%rsp)"   <-------- hotspot here
"mov %edx, %eax"
"and $0x7fffffff, %edx"
"and $0x80000000, %eax"
"add $0x3f800000, %eax"
"movl  %eax, -0x18(%rsp)"
"movssl  -0x18(%rsp), %xmm0"
"cmp $0x7f800000, %edx"
jnl 0x400dac <Block 8>
...

Ich habe die 2 Punkte gezeigt, bei denen die Zeit unter Linux verloren geht.

Versteht jemand Assembly genug, um mir den Unterschied der beiden Codes zu erklären und warum die Linux-Version dreimal langsamer ist?

65
InsideLoop

In beiden Fällen werden die Argumente und Ergebnisse nur in Registern gemäß den jeweiligen Aufrufkonventionen unter Windows und GNU/Linux übergeben.

In der GNU/Linux-Variante wird die Summe mit xmm1 Akkumuliert. Da es sich um ein von Anrufen überlastetes Register handelt (das von einem Anrufer gespeichert wurde), wird es bei jedem Anruf im Stack-Frame des Anrufers gespeichert (und wiederhergestellt).

In der Windows-Variante wird die Summe mit xmm6 Akkumuliert. Dieses Register wird in der Windows-Aufrufkonvention (aber nicht in der GNU/Linux-Konvention) gespeichert.

Zusammenfassend gesagt, speichert die GNU/Linux-Version sowohl xmm0 (Im Aufrufer [1]) als auch xmm1 (Im Aufrufer), während die Windows-Version nur xmm6 (In der Angerufenen).

[1] müssen sich std::errf Ansehen, um herauszufinden, warum.

42
chill

Unter Verwendung von Visual Studio 2015, Win 7 64-Bit-Modus, finde ich den folgenden Code für einige der in erf () verwendeten Pfade (nicht alle Pfade werden angezeigt). Jeder Pfad enthält bis zu 8 (möglicherweise mehr für andere Pfade) Konstanten, die aus dem Speicher gelesen werden. Daher ist es unwahrscheinlich, dass ein einzelnes Speichern/Laden zum Speichern eines Registers zu einem dreifachen Geschwindigkeitsunterschied zwischen Linux und Windows führt. Was das Speichern/Wiederherstellen betrifft, werden in diesem Beispiel xmm6 und xmm7 gespeichert und wiederhergestellt. Wie für die Zeit, das Programm in der ursprünglichen Veröffentlichung dauert etwa 0,86 Sekunden auf einem Intel 3770K (3,5 GHz CPU) (VS2015/Win 7 64 Bit). Update - Ich habe später festgestellt, dass der Overhead für das Speichern und Wiederherstellen eines xmm-Registers bei den Programmen 10 ^ 8 Schleifen (ca. 3 Nanosekunden pro Schleife) ca. 0,03 Sekunden beträgt.

000007FEEE25CF90  mov         rax,rsp  
000007FEEE25CF93  movss       dword ptr [rax+8],xmm0  
000007FEEE25CF98  sub         rsp,48h  
000007FEEE25CF9C  movaps      xmmword ptr [rax-18h],xmm6  
000007FEEE25CFA0  lea         rcx,[rax+8]  
000007FEEE25CFA4  movaps      xmmword ptr [rax-28h],xmm7  
000007FEEE25CFA8  movaps      xmm6,xmm0  
000007FEEE25CFAB  call        000007FEEE266370  
000007FEEE25CFB0  movsx       ecx,ax  
000007FEEE25CFB3  test        ecx,ecx  
000007FEEE25CFB5  je          000007FEEE25D0AF  
000007FEEE25CFBB  sub         ecx,1  
000007FEEE25CFBE  je          000007FEEE25D08F  
000007FEEE25CFC4  cmp         ecx,1  
000007FEEE25CFC7  je          000007FEEE25D0AF  
000007FEEE25CFCD  xorps       xmm7,xmm7  
000007FEEE25CFD0  movaps      xmm2,xmm6  
000007FEEE25CFD3  comiss      xmm7,xmm6  
000007FEEE25CFD6  jbe         000007FEEE25CFDF  
000007FEEE25CFD8  xorps       xmm2,xmmword ptr [7FEEE2991E0h]  
000007FEEE25CFDF  movss       xmm0,dword ptr [7FEEE298E50h]  
000007FEEE25CFE7  comiss      xmm0,xmm2  
000007FEEE25CFEA  jbe         000007FEEE25D053  
000007FEEE25CFEC  movaps      xmm2,xmm6  
000007FEEE25CFEF  mulss       xmm2,xmm6  
000007FEEE25CFF3  movaps      xmm0,xmm2  
000007FEEE25CFF6  movaps      xmm1,xmm2  
000007FEEE25CFF9  mulss       xmm0,dword ptr [7FEEE298B34h]  
000007FEEE25D001  mulss       xmm1,dword ptr [7FEEE298B5Ch]  
000007FEEE25D009  addss       xmm0,dword ptr [7FEEE298B8Ch]  
000007FEEE25D011  addss       xmm1,dword ptr [7FEEE298B9Ch]  
000007FEEE25D019  mulss       xmm0,xmm2  
000007FEEE25D01D  mulss       xmm1,xmm2  
000007FEEE25D021  addss       xmm0,dword ptr [7FEEE298BB8h]  
000007FEEE25D029  addss       xmm1,dword ptr [7FEEE298C88h]  
000007FEEE25D031  mulss       xmm0,xmm2  
000007FEEE25D035  mulss       xmm1,xmm2  
000007FEEE25D039  addss       xmm0,dword ptr [7FEEE298DC8h]  
000007FEEE25D041  addss       xmm1,dword ptr [7FEEE298D8Ch]  
000007FEEE25D049  divss       xmm0,xmm1  
000007FEEE25D04D  mulss       xmm0,xmm6  
000007FEEE25D051  jmp         000007FEEE25D0B2  
000007FEEE25D053  movss       xmm1,dword ptr [7FEEE299028h]  
000007FEEE25D05B  comiss      xmm1,xmm2  
000007FEEE25D05E  jbe         000007FEEE25D076  
000007FEEE25D060  movaps      xmm0,xmm2  
000007FEEE25D063  call        000007FEEE25CF04  
000007FEEE25D068  movss       xmm1,dword ptr [7FEEE298D8Ch]  
000007FEEE25D070  subss       xmm1,xmm0  
000007FEEE25D074  jmp         000007FEEE25D07E  
000007FEEE25D076  movss       xmm1,dword ptr [7FEEE298D8Ch]  
000007FEEE25D07E  comiss      xmm7,xmm6  
000007FEEE25D081  jbe         000007FEEE25D08A  
000007FEEE25D083  xorps       xmm1,xmmword ptr [7FEEE2991E0h]  
000007FEEE25D08A  movaps      xmm0,xmm1  
000007FEEE25D08D  jmp         000007FEEE25D0B2  
000007FEEE25D08F  mov         eax,8000h  
000007FEEE25D094  test        Word ptr [rsp+52h],ax  
000007FEEE25D099  je          000007FEEE25D0A5  
000007FEEE25D09B  movss       xmm0,dword ptr [7FEEE2990DCh]  
000007FEEE25D0A3  jmp         000007FEEE25D0B2  
000007FEEE25D0A5  movss       xmm0,dword ptr [7FEEE298D8Ch]  
000007FEEE25D0AD  jmp         000007FEEE25D0B2  
000007FEEE25D0AF  movaps      xmm0,xmm6  
000007FEEE25D0B2  movaps      xmm6,xmmword ptr [rsp+30h]  
000007FEEE25D0B7  movaps      xmm7,xmmword ptr [rsp+20h]  
000007FEEE25D0BC  add         rsp,48h  
000007FEEE25D0C0  ret  
3
rcgldr