[c++] Reemplazar una variable de recuento de bucles de 32 bits con 64 bits introduce desviaciones de rendimiento locas


3 Answers

Codifiqué un programa 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 usar uint_fast32_t hace que gcc use un uint de 64 bits.

Hice un poco de burla 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 cuenta interno del programa. Observación: ¡el código es tan rápido como la versión de 32 bits!

Esto es obviamente un hack, 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 cuenta interno domine el rendimiento, este es un buen comienzo .

Luego copié el código del bucle interno de la versión de 32 bits del programa, lo pirateé para que fuera de 64 bits, jugueteé con los registros para reemplazarlo por el 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 el compilador, no la velocidad real / latencia de las instrucciones de 32 bits.

(Advertencia: Corté el montaje, podría haber roto algo sin darme cuenta. No lo creo).

Question

Estaba buscando la forma más rápida de popcount grandes conjuntos de datos. Encontré un efecto muy extraño : al cambiar la variable de bucle de unsigned a uint64_t el rendimiento disminuyó 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 ve, creamos un búfer de datos aleatorios, con un tamaño de x megabytes donde x se lee desde la línea de comando. Después, iteramos sobre el búfer y usamos una versión desenrollada de la cuenta x86 intrínseca para realizar la cuenta. Para obtener un resultado más preciso, hacemos la cuenta 10 000 veces. Medimos los tiempos para el popcount. En la parte superior, la variable de ciclo interno unsigned está unsigned , en la minúscula, la variable de ciclo 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 de 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 (tan 1 MB de datos aleatorios):

  • sin signo 41959360000 0.401554 seg 26.113 GB / s
  • uint64_t 41959360000 0.759822 seg 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 de compilación, 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 signo 41959360000 0.398293 sec 26.3267 GB / s
  • uint64_t 41959360000 0.680954 sec 15.3986 GB / s

Por lo tanto, es casi el mismo resultado y todavía es extraño. Pero ahora se vuelve súper extraño. Sustituyo el tamaño del búfer que se leyó de 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 conoce 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 firmar 41959360000 0.509156 sec 20.5944 GB / s
  • uint64_t 41959360000 0.508673 seg 20.6139 GB / s

Ahora, ambas versiones son igualmente rápidas. Sin embargo, ¡el unsigned hizo aún más lento ! Se redujo de 26 a 20 GB/s , por lo que el reemplazo de un valor no constante por un valor constante conduce a una desoptimización . En serio, no tengo idea de lo que está pasando aquí! Pero ahora para clang++ con la nueva versión:

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

¿Esperar lo? Ahora, ambas versiones cayeron a la lenta cantidad de 15 GB / s. Por lo tanto, reemplazar un valor no constante por un valor constante incluso lleva a un código lento en ambos casos para Clang.

Le pedí a un colega con una CPU de Ivy Bridge que compilara mi punto de referencia. Obtuvo resultados similares, así que no parece ser Haswell. Debido a que dos compiladores producen resultados extraños aquí, tampoco parece ser un error del compilador. No tenemos una CPU AMD aquí, así que solo pudimos probar con Intel.

Más locura, por favor!

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

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

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

  • sin signo 41959360000 0.396728 seg 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 de la versión de 13 GB / s a ​​la 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 , obteniendo el resultado más rápido de todos. Lamentablemente, esto solo funciona para g++ , a clang++ no parece importarle la static .

Mi pregunta

¿Puedes explicar estos resultados? Especialmente:

  • ¿Cómo puede haber tal diferencia entre u32 y u64 ?
  • ¿Cómo se puede reemplazar un elemento no constante por un tamaño de búfer constante, desencadenar un código menos óptimo ?
  • ¿Cómo puede la inserción de la palabra clave static hacer que el ciclo 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 complicado, sin embargo, nunca pensé que cambios tan pequeños pudieran llevar a una diferencia del 100% en el tiempo de ejecución y que factores pequeños como un tamaño de búfer constante puedan volver a mezclar los resultados totalmente. Por supuesto, siempre quiero tener la versión que es capaz de popcount 26 GB / s. La única manera 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 enloquecer por pequeños cambios. ¿Qué piensas? ¿Hay alguna otra forma de obtener de manera confiable el código con más rendimiento?

El Desmontaje

Aquí está el desmontaje para los diversos resultados:

26 GB / s versión de 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

13 GB / s versión de 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

15 GB / s versión de 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 y 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

15 GB / s versión de 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 usa 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 hábil para 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; Aprendí 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 de acceso . Nunca pensé en 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 marcar una gran diferencia, como vimos con la inserción de la palabra clave static en frente de la variable de tamaño. En el futuro, siempre probaré varias alternativas en varios compiladores cuando escribo bucles realmente cerrados y calientes que son cruciales para el rendimiento del sistema.

Lo interesante es también que la diferencia en el rendimiento sigue siendo tan alta, aunque ya he desenrollado el circuito cuatro veces. Entonces, incluso si se desenrolla, aún puede ser golpeado por las principales desviaciones de rendimiento. Bastante interesante.




No puedo dar una respuesta autorizada, pero proporciono una descripción de una posible causa. Esta referencia muestra bastante claramente que para las instrucciones en el cuerpo de su ciclo hay una relación 3: 1 entre latencia y rendimiento. También muestra los efectos del despacho múltiple. Como hay tres unidades enteras (dar o recibir) en los procesadores modernos x86, generalmente es posible enviar tres instrucciones por ciclo.

Entonces, entre el pipeline máximo y el rendimiento de despacho múltiple y el fallo de estos mecanismos, tenemos un factor de seis en el rendimiento. Es bastante conocido que la complejidad del conjunto de instrucciones x86 hace que sea bastante fácil que se produzca una rotura peculiar. El documento anterior 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 todos los cambios de 32 bits tienen un rendimiento aceptable. Parece que la ruta de datos desde los 32 bits superiores a los 32 bits inferiores de la ALU no está bien diseñada.

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

Aquí mi suposición es contienda para unidades enteras: que el popcnt , el contador de bucles y los cálculos de direcciones apenas pueden ejecutarse a toda velocidad con el contador de 32 bits de ancho, pero el contador de 64 bits causa contención y bloqueos de tuberías. Como solo hay aproximadamente 12 ciclos en total, posiblemente 4 ciclos con despacho múltiple, por ejecución del cuerpo del bucle, un solo bloqueo podría afectar razonablemente el tiempo de ejecución por un factor de 2.

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

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




Intenté esto con Visual Studio 2013 Express , usando un puntero en lugar de un índice, lo que aceleró un poco el proceso. Sospecho que esto es porque el direccionamiento es offset + register, en lugar de offset + register + (register << 3). Código C ++

   uint64_t* bfrend = buffer+(size/8);
   uint64_t* bfrptr;

// ...

   {
      startP = chrono::system_clock::now();
      count = 0;
      for (unsigned k = 0; k < 10000; k++){
         // Tight unrolled loop with uint64_t
         for (bfrptr = buffer; bfrptr < bfrend;){
            count += __popcnt64(*bfrptr++);
            count += __popcnt64(*bfrptr++);
            count += __popcnt64(*bfrptr++);
            count += __popcnt64(*bfrptr++);
         }
      }
      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;
   }

código de ensamblado: r10 = bfrptr, r15 = bfrend, rsi = conteo, rdi = buffer, r13 = k:

$LL5@main:
        mov     r10, rdi
        cmp     rdi, r15
        jae     SHORT $LN4@main
        npad    4
$LL2@main:
        mov     rax, QWORD PTR [r10+24]
        mov     rcx, QWORD PTR [r10+16]
        mov     r8, QWORD PTR [r10+8]
        mov     r9, QWORD PTR [r10]
        popcnt  rdx, rax
        popcnt  rax, rcx
        add     rdx, rax
        popcnt  rax, r8
        add     r10, 32
        add     rdx, rax
        popcnt  rax, r9
        add     rsi, rax
        add     rsi, rdx
        cmp     r10, r15
        jb      SHORT $LL2@main
$LN4@main:
        dec     r13
        jne     SHORT $LL5@main



TL; DR: Use __builtin intrinsics en su lugar.

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

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

Resultados:

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

Código de Benchmarking:

#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 de 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 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