c++ Reemplazar un contador de bucle de 32 bits con 64 bits introduce desviaciones de rendimiento increíbles





4 Answers

Codifiqué un programa de C equivalente para experimentar, y puedo confirmar este extraño comportamiento. Además, gcc cree que el entero de 64 bits (que probablemente debería ser un size_t todos modos) es mejor, ya que el uso de uint_fast32_t hace que gcc use un uint de 64 bits.

Hice un poco de bromear con la asamblea:
Simplemente tome la versión de 32 bits, reemplace todas las instrucciones / registros de 32 bits con la versión de 64 bits en el bucle de popcount interno del programa. Observación: ¡el código es tan rápido como la versión de 32 bits!

Esto es obviamente un pirateo, ya que el tamaño de la variable no es realmente de 64 bits, ya que otras partes del programa aún usan la versión de 32 bits, pero mientras el bucle de popcount interno domine el rendimiento, este es un buen comienzo .

Luego copié el código de bucle interno de la versión de 32 bits del programa, lo hackeé para que fuera de 64 bits, jugué con los registros para convertirlo en un reemplazo del bucle interno de la versión de 64 bits. Este código también se ejecuta tan rápido como la versión de 32 bits.

Mi conclusión es que esta es una mala programación de instrucciones por parte del compilador, no una ventaja real de velocidad / latencia de las instrucciones de 32 bits.

(Advertencia: he pirateado el ensamblaje, podría haber roto algo sin darme cuenta. No lo creo).

c++ performance optimization assembly compiler-optimization

Estaba buscando la forma más rápida de hacer popcount grandes conjuntos de datos. Encontré un efecto muy extraño : cambiar la variable de bucle de unsigned a uint64_t hizo que el rendimiento cayera en un 50% en mi PC.

El punto de referencia

#include <iostream>
#include <chrono>
#include <x86intrin.h>

int main(int argc, char* argv[]) {

    using namespace std;
    if (argc != 2) {
       cerr << "usage: array_size in MB" << endl;
       return -1;
    }

    uint64_t size = atol(argv[1])<<20;
    uint64_t* buffer = new uint64_t[size/8];
    char* charbuffer = reinterpret_cast<char*>(buffer);
    for (unsigned i=0; i<size; ++i)
        charbuffer[i] = rand()%256;

    uint64_t count,duration;
    chrono::time_point<chrono::system_clock> startP,endP;
    {
        startP = chrono::system_clock::now();
        count = 0;
        for( unsigned k = 0; k < 10000; k++){
            // Tight unrolled loop with unsigned
            for (unsigned i=0; i<size/8; i+=4) {
                count += _mm_popcnt_u64(buffer[i]);
                count += _mm_popcnt_u64(buffer[i+1]);
                count += _mm_popcnt_u64(buffer[i+2]);
                count += _mm_popcnt_u64(buffer[i+3]);
            }
        }
        endP = chrono::system_clock::now();
        duration = chrono::duration_cast<std::chrono::nanoseconds>(endP-startP).count();
        cout << "unsigned\t" << count << '\t' << (duration/1.0E9) << " sec \t"
             << (10000.0*size)/(duration) << " GB/s" << endl;
    }
    {
        startP = chrono::system_clock::now();
        count=0;
        for( unsigned k = 0; k < 10000; k++){
            // Tight unrolled loop with uint64_t
            for (uint64_t i=0;i<size/8;i+=4) {
                count += _mm_popcnt_u64(buffer[i]);
                count += _mm_popcnt_u64(buffer[i+1]);
                count += _mm_popcnt_u64(buffer[i+2]);
                count += _mm_popcnt_u64(buffer[i+3]);
            }
        }
        endP = chrono::system_clock::now();
        duration = chrono::duration_cast<std::chrono::nanoseconds>(endP-startP).count();
        cout << "uint64_t\t"  << count << '\t' << (duration/1.0E9) << " sec \t"
             << (10000.0*size)/(duration) << " GB/s" << endl;
    }

    free(charbuffer);
}

Como puede ver, creamos un búfer de datos aleatorios, con un tamaño de x megabytes donde x se lee desde la línea de comandos. Luego, iteramos sobre el búfer y utilizamos una versión desenrollada del intrínseco de popcount x86 para realizar el popcount. Para obtener un resultado más preciso, hacemos el popcount 10.000 veces. Medimos los tiempos para el popcount. En mayúsculas, la variable de bucle interno unsigned está unsigned , en minúscula, la variable de bucle interno es uint64_t . Pensé que esto no debería hacer ninguna diferencia, pero lo contrario es el caso.

Los resultados (absolutamente locos)

Lo compilo así (versión g ++: Ubuntu 4.8.2-19ubuntu1):

g++ -O3 -march=native -std=c++11 test.cpp -o test

Aquí están los resultados en mi CPU Haswell Core i7-4770K a 3.50 GHz, ejecutando la test 1 (por lo que 1 MB de datos aleatorios):

  • sin firma 41959360000 0.401554 sec 26.113 GB / s
  • uint64_t 41959360000 0.759822 sec 13.8003 GB / s

Como puede ver, el rendimiento de la versión uint64_t es solo la mitad de la versión unsigned . El problema parece ser que se genera un ensamblaje diferente, pero ¿por qué? Primero, pensé en un error del compilador, así que probé clang++ (Ubuntu Clang versión 3.4-1ubuntu3):

clang++ -O3 -march=native -std=c++11 teest.cpp -o test

Resultado: test 1

  • sin firma 41959360000 0.398293 sec 26.3267 GB / s
  • uint64_t 41959360000 0.680954 sec 15.3986 GB / s

Entonces, es casi el mismo resultado y aún es extraño. Pero ahora se pone súper extraño. Reemplazo el tamaño del búfer que se leyó desde la entrada con una constante 1 , así que cambio:

uint64_t size = atol(argv[1]) << 20;

a

uint64_t size = 1 << 20;

Por lo tanto, el compilador ahora sabe el tamaño del búfer en tiempo de compilación. ¡Tal vez pueda agregar algunas optimizaciones! Aquí están los números para g++ :

  • sin firma 41959360000 0.509156 sec 20.5944 GB / s
  • uint64_t 41959360000 0.508673 sec 20.6139 GB / s

Ahora, ambas versiones son igualmente rápidas. Sin embargo, los unsigned volvieron aún más lentos ! Disminuyó de 26 a 20 GB/s , reemplazando así una no constante por un valor constante que conduce a una desoptimización . En serio, no tengo ni idea de lo que está pasando aquí! Pero ahora para clang++ con la nueva versión:

  • sin firma 41959360000 0.677009 sec 15.4884 GB / s
  • uint64_t 41959360000 0.676909 sec 15.4906 GB / s

¿Esperar lo? Ahora, ambas versiones se redujeron a un número lento de 15 GB / s. Por lo tanto, reemplazar un valor no constante por un valor constante, incluso puede llevar a código lento en ambos casos para Clang!

Le pregunté a un colega con una CPU Ivy Bridge para compilar mi punto de referencia. Obtuvo resultados similares, por lo que no parece ser Haswell. Debido a que dos compiladores producen resultados extraños aquí, tampoco parece ser un error de compilación. Aquí no tenemos una CPU AMD, por lo que solo pudimos probar con Intel.

¡Más locura, por favor!

Tome el primer ejemplo (el que tiene un atol(argv[1]) ) y ponga una static antes de la variable, es decir:

static uint64_t size=atol(argv[1])<<20;

Aquí están mis resultados en g ++:

  • sin firma 41959360000 0.396728 sec 26.4306 GB / s
  • uint64_t 41959360000 0.509484 sec 20.5811 GB / s

Yay, otra alternativa más . Todavía tenemos los 26 GB / s u32 con u32 , pero logramos obtener u64 al menos desde los 13 GB / s hasta la versión de 20 GB / s. En la PC de mi u64 , la versión u64 llegó a ser incluso más rápida que la versión u32 , lo que u32 el resultado más rápido de todos. Lamentablemente, esto solo funciona para g++ , clang++ no parece preocuparse por la static .

Mi pregunta

¿Puedes explicar estos resultados? Especialmente:

  • ¿Cómo puede haber tal diferencia entre u32 y u64 ?
  • ¿Cómo puede reemplazar un código menos óptimo la sustitución de una no constante por un tamaño de búfer constante?
  • ¿Cómo puede la inserción de la palabra clave static hacer que el bucle u64 más rápido? ¡Incluso más rápido que el código original en la computadora de mi colega!

Sé que la optimización es un territorio difícil, sin embargo, nunca pensé que cambios tan pequeños pueden llevar a una diferencia del 100% en el tiempo de ejecución y que pequeños factores como un tamaño de búfer constante pueden mezclar los resultados nuevamente. Por supuesto, siempre quiero tener una versión que pueda cargar 26 GB / s. La única forma confiable en que puedo pensar es copiar y pegar el ensamblaje para este caso y usar el ensamblaje en línea. Esta es la única forma en que puedo deshacerme de los compiladores que parecen volverse locos con pequeños cambios. ¿Qué piensas? ¿Hay otra forma de obtener el código de forma confiable con la mayor parte del rendimiento?

El desmontaje

Aquí está el desmontaje de los diversos resultados:

Versión de 26 GB / s desde g ++ / u32 / non-const bufsize :

0x400af8:
lea 0x1(%rdx),%eax
popcnt (%rbx,%rax,8),%r9
lea 0x2(%rdx),%edi
popcnt (%rbx,%rcx,8),%rax
lea 0x3(%rdx),%esi
add %r9,%rax
popcnt (%rbx,%rdi,8),%rcx
add $0x4,%edx
add %rcx,%rax
popcnt (%rbx,%rsi,8),%rcx
add %rcx,%rax
mov %edx,%ecx
add %rax,%r14
cmp %rbp,%rcx
jb 0x400af8

Versión de 13 GB / s desde g ++ / u64 / non-const bufsize :

0x400c00:
popcnt 0x8(%rbx,%rdx,8),%rcx
popcnt (%rbx,%rdx,8),%rax
add %rcx,%rax
popcnt 0x10(%rbx,%rdx,8),%rcx
add %rcx,%rax
popcnt 0x18(%rbx,%rdx,8),%rcx
add $0x4,%rdx
add %rcx,%rax
add %rax,%r12
cmp %rbp,%rdx
jb 0x400c00

Versión de 15 GB / s desde clang ++ / u64 / non-const bufsize :

0x400e50:
popcnt (%r15,%rcx,8),%rdx
add %rbx,%rdx
popcnt 0x8(%r15,%rcx,8),%rsi
add %rdx,%rsi
popcnt 0x10(%r15,%rcx,8),%rdx
add %rsi,%rdx
popcnt 0x18(%r15,%rcx,8),%rbx
add %rdx,%rbx
add $0x4,%rcx
cmp %rbp,%rcx
jb 0x400e50

Versión de 20 GB / s de g ++ / u32 & u64 / const bufsize :

0x400a68:
popcnt (%rbx,%rdx,1),%rax
popcnt 0x8(%rbx,%rdx,1),%rcx
add %rax,%rcx
popcnt 0x10(%rbx,%rdx,1),%rax
add %rax,%rcx
popcnt 0x18(%rbx,%rdx,1),%rsi
add $0x20,%rdx
add %rsi,%rcx
add %rcx,%rbp
cmp $0x100000,%rdx
jne 0x400a68

Versión de 15 GB / s desde clang ++ / u32 & u64 / const bufsize :

0x400dd0:
popcnt (%r14,%rcx,8),%rdx
add %rbx,%rdx
popcnt 0x8(%r14,%rcx,8),%rsi
add %rdx,%rsi
popcnt 0x10(%r14,%rcx,8),%rdx
add %rsi,%rdx
popcnt 0x18(%r14,%rcx,8),%rbx
add %rdx,%rbx
add $0x4,%rcx
cmp $0x20000,%rcx
jb 0x400dd0

Curiosamente, la versión más rápida (26 GB / s) también es la más larga. Parece ser la única solución que utiliza lea . Algunas versiones usan jb para saltar, otras usan jne . Pero aparte de eso, todas las versiones parecen ser comparables. No veo de dónde podría originarse una brecha de rendimiento del 100%, pero no soy demasiado experto en descifrar el ensamblaje. La versión más lenta (13 GB / s) parece incluso muy corta y buena. ¿Alguien puede explicar esto?

Lecciones aprendidas

No importa cuál sea la respuesta a esta pregunta será; He aprendido que en los bucles realmente calientes todos los detalles pueden importar, incluso los detalles que no parecen tener ninguna asociación con el código activo . Nunca he pensado qué tipo usar para una variable de bucle, pero como ves, un cambio tan pequeño puede hacer una diferencia del 100% . ¡Incluso el tipo de almacenamiento de un búfer puede hacer una gran diferencia, como vimos con la inserción de la palabra clave static delante de la variable de tamaño! En el futuro, siempre probaré varias alternativas en varios compiladores cuando escribo bucles realmente precisos y cruciales que son cruciales para el rendimiento del sistema.

Lo interesante también es que la diferencia de rendimiento sigue siendo tan alta, aunque ya he desenrollado el bucle cuatro veces. Por lo tanto, incluso si se desenrolla, puede verse afectado por importantes desviaciones de rendimiento. Bastante interesante.




No puedo dar una respuesta autorizada, pero ofrezco una visión general de una causa probable. Esta referencia muestra claramente que para las instrucciones en el cuerpo de su bucle hay una relación de 3: 1 entre la latencia y el rendimiento. También muestra los efectos del envío múltiple. Dado que hay (dar o tomar) tres unidades enteras en los procesadores x86 modernos, generalmente es posible enviar tres instrucciones por ciclo.

Por lo tanto, entre el rendimiento máximo de la tubería y el despacho múltiple y la falla de estos mecanismos, tenemos un factor de seis en el desempeño. Es bien sabido que la complejidad del conjunto de instrucciones x86 hace que sea bastante fácil que ocurran roturas extravagantes. El documento de arriba tiene un gran ejemplo:

El rendimiento del Pentium 4 para los cambios a la derecha de 64 bits es realmente pobre. El desplazamiento a la izquierda de 64 bits, así como los desplazamientos de 32 bits, tienen un rendimiento aceptable. Parece que la ruta de datos desde los 32 bits superiores hasta los 32 bits inferiores de la ALU no está bien diseñada.

Personalmente, me encontré con un caso extraño en el que un bucle caliente se ejecutó considerablemente más lento en un núcleo específico de un chip de cuatro núcleos (AMD, si recuerdo). De hecho, obtuvimos un mejor rendimiento en un cálculo de reducción de mapa desactivando ese núcleo.

Aquí, mi conjetura es la contención de unidades enteras: que los popcnt , contador de bucle y dirección apenas pueden ejecutarse a toda velocidad con el contador de 32 bits de ancho, pero el contador de 64 bits provoca la contención y las paradas de la tubería. Como solo hay alrededor de 12 ciclos en total, potencialmente 4 ciclos con múltiples despachos, ejecución por cuerpo de bucle, un solo bloqueo podría afectar razonablemente el tiempo de ejecución en un factor de 2.

El cambio inducido por el uso de una variable estática, que supongo que solo provoca un pequeño reordenamiento de las instrucciones, es otra pista de que el código de 32 bits se encuentra en algún punto de inflexión para la contención.

Sé que este no es un análisis riguroso, pero es una explicación plausible.




¿Ha intentado pasar -funroll-loops -fprefetch-loop-arrays a GCC?

Obtengo los siguientes resultados con estas optimizaciones adicionales:

[1829] /tmp/so_25078285 $ cat /proc/cpuinfo |grep CPU|head -n1
model name      : Intel(R) Core(TM) i3-3225 CPU @ 3.30GHz
[1829] /tmp/so_25078285 $ g++ --version|head -n1
g++ (Ubuntu/Linaro 4.7.3-1ubuntu1) 4.7.3

[1829] /tmp/so_25078285 $ g++ -O3 -march=native -std=c++11 test.cpp -o test_o3
[1829] /tmp/so_25078285 $ g++ -O3 -march=native -funroll-loops -fprefetch-loop-arrays -std=c++11     test.cpp -o test_o3_unroll_loops__and__prefetch_loop_arrays

[1829] /tmp/so_25078285 $ ./test_o3 1
unsigned        41959360000     0.595 sec       17.6231 GB/s
uint64_t        41959360000     0.898626 sec    11.6687 GB/s

[1829] /tmp/so_25078285 $ ./test_o3_unroll_loops__and__prefetch_loop_arrays 1
unsigned        41959360000     0.618222 sec    16.9612 GB/s
uint64_t        41959360000     0.407304 sec    25.7443 GB/s



TL; DR: use __builtin intrinsics en su lugar.

Pude hacer que gcc 4.8.4 (e incluso 4.7.3 en gcc.godbolt.org) genere un código óptimo para esto usando __builtin_popcountll que usa la misma instrucción de ensamblaje, pero no tiene ese error de dependencia falso.

No estoy 100% seguro de mi código de evaluación comparativa, pero la salida de objdump parece compartir mis puntos de vista. Uso algunos otros trucos ( ++i vs i++ ) para hacer que el compilador se desenrolle en bucle sin ninguna instrucción de movl (comportamiento extraño, debo decir).

Resultados:

Count: 20318230000  Elapsed: 0.411156 seconds   Speed: 25.503118 GB/s

Código de referencia:

#include <stdint.h>
#include <stddef.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>

uint64_t builtin_popcnt(const uint64_t* buf, size_t len){
  uint64_t cnt = 0;
  for(size_t i = 0; i < len; ++i){
    cnt += __builtin_popcountll(buf[i]);
  }
  return cnt;
}

int main(int argc, char** argv){
  if(argc != 2){
    printf("Usage: %s <buffer size in MB>\n", argv[0]);
    return -1;
  }
  uint64_t size = atol(argv[1]) << 20;
  uint64_t* buffer = (uint64_t*)malloc((size/8)*sizeof(*buffer));

  // Spoil copy-on-write memory allocation on *nix
  for (size_t i = 0; i < (size / 8); i++) {
    buffer[i] = random();
  }
  uint64_t count = 0;
  clock_t tic = clock();
  for(size_t i = 0; i < 10000; ++i){
    count += builtin_popcnt(buffer, size/8);
  }
  clock_t toc = clock();
  printf("Count: %lu\tElapsed: %f seconds\tSpeed: %f GB/s\n", count, (double)(toc - tic) / CLOCKS_PER_SEC, ((10000.0*size)/(((double)(toc - tic)*1e+9) / CLOCKS_PER_SEC)));
  return 0;
}

Opciones de compilación:

gcc --std=gnu99 -mpopcnt -O3 -funroll-loops -march=native bench.c -o bench

Versión GCC:

gcc (Ubuntu 4.8.4-2ubuntu1~14.04.1) 4.8.4

Versión del kernel de Linux:

3.19.0-58-generic

Información de la CPU:

processor   : 0
vendor_id   : GenuineIntel
cpu family  : 6
model       : 70
model name  : Intel(R) Core(TM) i7-4870HQ CPU @ 2.50 GHz
stepping    : 1
microcode   : 0xf
cpu MHz     : 2494.226
cache size  : 6144 KB
physical id : 0
siblings    : 1
core id     : 0
cpu cores   : 1
apicid      : 0
initial apicid  : 0
fpu     : yes
fpu_exception   : yes
cpuid level : 13
wp      : yes
flags       : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx rdtscp lm constant_tsc nopl xtopology nonstop_tsc eagerfpu pni pclmulqdq ssse3 fma cx16 pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand hypervisor lahf_lm abm arat pln pts dtherm fsgsbase tsc_adjust bmi1 hle avx2 smep bmi2 invpcid xsaveopt
bugs        :
bogomips    : 4988.45
clflush size    : 64
cache_alignment : 64
address sizes   : 36 bits physical, 48 bits virtual
power management:



Related