Rendimiento de las instrucciones x86 rep en procesadores modernos (pipeline/superscalar)

Question

he estado escribiendo en ensamblado x86 últimamente (por diversión) y me preguntaba si las instrucciones de cadena prefijadas rep tienen realmente una ventaja de rendimiento en procesadores modernos o si Recién implementado para compatibilidad con la espalda.

entiendo por qué Intel habría implementado originalmente las instrucciones de rep cuando los procesadores solo ejecutaron una instrucción a la vez, pero ¿hay alguna ventaja de usarlas ahora?

Con un bucle que compila más instrucciones, hay más para llenar la tubería y/o emitirse fuera de servicio. ¿Los procesadores modernos están diseñados para optimizar estas instrucciones con prefijo de rep, o las instrucciones de rep se utilizan tan raramente en el código moderno que no son importantes para los fabricantes?

Answer 1

En AMD y en las guías de optimización de Intel se da mucho espacio para preguntas como esta. Validez de los consejos que se dan en esta zona tiene una "vida media" - diferentes generaciones de CPU se comportan de manera diferente, por ejemplo:

• AMD Software Optimization Guide (Sep/2005), sección 8.3, pág. 167:
  Evite utilizar el prefijo REP al realizar operaciones de cadena, especialmente al copiar bloques de memoria.
• AMD Software Optimization Guide (Apr/2011), sección 9.3, pág. 148:
  Use el prefijo REP juiciosamente al realizar operaciones de cadena.

El Intel Architecture Optimization Manual da cifras de comparación de rendimiento para diversas técnicas de copia de bloque (incluyendo rep stosd) en la Tabla 7-2. Rendimiento relativo de rutinas de copia de memoria, pg. 7-37f., Para diferentes CPU, y nuevamente lo que es más rápido en uno podría no ser el más rápido en otros.

En muchos casos, las CPU x86 recientes (que tienen las operaciones de "cadena" SSE4.2) pueden realizar operaciones de cadena a través de la unidad SIMD, consulte this investigation.

Para realizar un seguimiento de todo esto (y/o mantenerse actualizado cuando las cosas cambian de nuevo, inevitablemente), lea Agner Fog's Optimization guides/blogs.

Answer 2

Además de la excelente respuesta de FrankH; Me gustaría señalar que el mejor método también depende de la longitud de la cadena, su alineación y si la longitud es fija o variable.

Para cadenas pequeñas (tal vez hasta aproximadamente 16 bytes) hacerlo manualmente con instrucciones simples es probablemente más rápido, ya que evita los costos de configuración de técnicas más complejas (y para cadenas de tamaño fijo se pueden desenrollar fácilmente). Para cadenas de tamaño medio (quizás de 16 bytes a 4 KiB), es probable que algo como "REP MOVSD" (con algunas instrucciones "MOVSB" incluidas si es posible una desalineación) sea lo mejor.

Para algo más grande que eso, algunas personas estarían tentadas de entrar en SSE/AVX y de captación previa, etc. Una mejor idea es arreglar la (s) llamada (s) para que no se copie (o strlen() o lo que sea) necesario en primer lugar. Si lo intentas lo suficiente, casi siempre encontrarás la manera. Nota: También tenga mucho cuidado con las "supuestas" rutinas rápidas de mempcy(); por lo general, se han probado en cadenas masivas y no se han probado en cadenas muy pequeñas/pequeñas/medianas.

También tenga en cuenta que (a los efectos de la optimización en lugar de conveniencia) debido a todas estas diferencias (probablemente longitud, alineación, fijo o variable tamaño, tipo de CPU, etc) la idea de tener una de usos múltiples "memcpy () "para todos los casos muy diferentes es miope.

Answer 3

Dado que nadie te ha dado ningún número, te daré algunos que he encontrado mediante la evaluación comparativa de mi recolector de basura que es muy pesado. Mis objetos para copiar son 60% 16 bytes de longitud y el resto 30% son 500 - 8000 bytes más o menos.

• Condición previa: Tanto dst, src y n son múltiplos de 8.
• Procesador: AMD Phenom (tm) II X6 1090T procesador de 64 bits/Linux

Aquí están mis tres memcpy variantes:

Hand-codificado bucle while:

if (n == 16) { 
    *dst++ = *src++; 
    *dst++ = *src++; 
} else { 
    size_t n_ptrs = n/sizeof(ptr); 
    ptr *end = dst + n_ptrs; 
    while (dst < end) { 
     *dst++ = *src++; 
    } 
} 

(ptr es un alias de uintptr_t). Tiempo: 101.16%

rep movsb

if (n == 16) { 
    *dst++ = *src++; 
    *dst++ = *src++; 
} else { 
    asm volatile("cld\n\t" 
       "rep ; movsb" 
       : "=D" (dst), "=S" (src) 
       : "c" (n), "D" (dst), "S" (src) 
       : "memory"); 
} 

tiempo: 103.22%

rep movsq

if (n == 16) { 
    *dst++ = *src++; 
    *dst++ = *src++; 
} else { 
    size_t n_ptrs = n/sizeof(ptr); 
    asm volatile("cld\n\t" 
       "rep ; movsq" 
       : "=D" (dst), "=S" (src) 
       : "c" (n_ptrs), "D" (dst), "S" (src) 
       : "memory"); 
} 

tiempo: 100.00%

req movsq gana por un pequeño margen.