65 votes

Différence de performance entre Windows et Linux à l'aide du compilateur intel: examen de l'assemblage

Je suis en cours d'exécution d'un programme sur Windows et Linux (x86-64). Il a été compilé avec le même compilateur (Intel Parallel Studio XE 2017) avec les mêmes options, et la version de Windows est 3 fois plus rapide que le Linux. Le coupable est un appel à std::erf qui est résolu dans le Intel bibliothèque de mathématiques pour les deux cas (par défaut, elle est liée de façon dynamique sur Windows et statiquement sur Linux, mais à l'aide de la liaison dynamique sur Linux donne les mêmes performances).

Voici un programme simple à reproduire le problème.

#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);
}

Quand j'ai le profil de ce programme à l'aide de vTune, je trouve que le montage est un peu différent entre les Fenêtres et la version Linux. Voici le site d'appel (la boucle) sur Windows

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

Et le début de l'erf fonction appelée sur Windows

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"
...

Sur Linux, le code est un peu différent. Le site d'appel est:

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>

et le début de la fonction appelée (erf) est:

"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>
...

J'ai montré les 2 points où le temps est perdu sur Linux.

Personne ne comprends assemblée assez pour m'expliquer la différence entre les 2 codes et pourquoi la version Linux est 3 fois plus lent?

42voto

chill Points 9384

Dans les deux cas, les arguments et les résultats sont transmis uniquement dans les registres, comme par le respectifs des conventions d'appel sur Windows et GNU/Linux.

Dans le GNU/Linux variante, l' xmm1 est utilisé pour l'accumulation de la somme. Puisque c'est un appel tabassé registre (un.k.un appelant-enregistrés), il est stocké (et de restauration) dans le cadre de la pile de l'appelant sur chaque appel.

Dans le Windows variante, l' xmm6 est utilisé pour l'accumulation de la somme. Ce registre est callee-saved dans le Windows convention d'appel (mais pas dans le GNU/Linux one).

Donc, en résumé, la version GNU/Linux sauve/restaure à la fois xmm0 (dans le destinataire de l'appel[1]) et xmm1 (en l'appelant), tandis que la version Windows sauve/restaure uniquement xmm6 (dans le destinataire de l'appel).

[1] besoin de regarder l' std::errf de comprendre pourquoi.

3voto

rcgldr Points 1197

À l'aide de Visual Studio 2015, Win 7 64 bit de mode, je trouve le code suivant pour certaines des chemins utilisés dans l'erf() (tous les chemins indiqués). Chaque voie comporte jusqu'à 8 (peut-être plus pour les autres voies), les constantes de lecture de la mémoire, de sorte qu'un seul magasin / charger enregistrer un registre semble peu probable d'aboutir à un 3x la vitesse différentielle entre Linux et Windows. Aussi loin pour sauvegarder / restaurer, cet exemple sauvegarde et restaure xmm6 et xmm7. Car pour le moment, le programme dans le post original prend environ 0.86 secondes sur un processeur Intel 3770K (3.5 ghz cpu) (VS2015 / Win 7 64 bits). Mise à jour - plus tard, j'ai déterminé la surcharge pour une sauvegarde et de restauration d'un registre xmm est environ 0,03 secondes dans le cas des programmes de 10^8 boucles (environ 3 nanosecondes par boucle).

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  

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X