c++ - recursos - Diferencia de rendimiento entre Windows y Linux usando el compilador de Intel: mirando el ensamblado

windows 7 vs windows 10 rendimiento 2017

Question

Estoy ejecutando un programa en Windows y Linux (x86-64). Se ha compilado con el mismo compilador (Intel Parallel Studio XE 2017) con las mismas opciones, y la versión de Windows es 3 veces más rápida que la de Linux. El culpable es una llamada a std::erf que se resuelve en la biblioteca matemática de Intel para ambos casos (de forma predeterminada, está vinculado dinámicamente en Windows y estáticamente en Linux, pero el uso del enlace dinámico en Linux ofrece el mismo rendimiento).

Aquí hay un programa simple para reproducir el problema.

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

Cuando perfilo este programa usando vTune, encuentro que el ensamblaje es un poco diferente entre Windows y la versión de Linux. Aquí está el sitio de llamadas (el bucle) en Windows

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

Y el comienzo de la función erf llamada en 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"
...

En Linux, el código es un poco diferente. El sitio de la llamada es:

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>

y el comienzo de la función llamada (erf) es:

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

He mostrado los 2 puntos donde se pierde el tiempo en Linux.

¿Alguien entiende el ensamblaje lo suficiente como para explicarme la diferencia de los 2 códigos y por qué la versión de Linux es 3 veces más lenta?

Answer 1

En ambos casos, los argumentos y resultados se pasan solo en registros, según las convenciones de llamada respectivas en Windows y GNU / Linux.

En la variante GNU / Linux, el xmm1 se usa para acumular la suma. Dado que se trata de un registro de capa de llamada (también conocido como guardado por la persona que llama), se almacena (y restaura) en el marco de la pila de la persona que llama en cada llamada.

En la variante de Windows, el xmm6 se usa para acumular la suma. Este registro se guarda en la convención de llamadas de Windows ( pero no en la de GNU / Linux ).

En resumen, la versión GNU / Linux guarda / restaura tanto xmm0 (en la llamada [1]) como xmm1 (en la llamada), mientras que la versión de Windows guarda / restaura solo xmm6 (en la llamada).

[1] necesita mirar std::errf para descubrir por qué.

Answer 2

Usando Visual Studio 2015, modo Win 7 de 64 bits, encuentro el siguiente código para algunas de las rutas utilizadas en erf () (no se muestran todas las rutas). Cada ruta implica hasta 8 (tal vez más para otras rutas) constantes leídas de la memoria, por lo que una sola tienda / carga para guardar un registro parece poco probable que dé como resultado un diferencial de velocidad 3x entre Linux y Windows. En cuanto a guardar / restaurar, este ejemplo guarda y restaura xmm6 y xmm7. En cuanto al tiempo, el programa en la publicación original tarda aproximadamente 0,86 segundos en un Intel 3770K (CPU de 3,5 ghz) (VS2015 / Win 7 64 bit). Actualización: más tarde determiné que la sobrecarga para guardar y restaurar un registro xmm es de aproximadamente 0.03 segundos en el caso de los programas 10 ^ 8 bucles (aproximadamente 3 nanosegundos por bucle).

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