¿Cuál es un ejemplo de una simple función C que se implementa más rápidamente en el ensamblaje en línea?

Question

Estoy teniendo dificultades para superar mi compilador mediante el ensamblaje en línea.

¿Qué ejemplos son buenos y no artificiales de una función que el compilador tiene dificultades para hacer realmente, muy rápido y simple? Pero eso es relativamente simple de hacer con el ensamblaje en línea.

Answer 1

Como está relacionado con el iPhone y el código de ensamblaje, daré un ejemplo que sería relevante en el mundo del iPhone (y no en algunos asse sse o x86). Si alguien decide escribir código de ensamblaje para alguna aplicación del mundo real, lo más probable es que se trate de algún tipo de procesamiento de señal digital o manipulación de imágenes. Ejemplos: conversión de espacio de color de píxeles RGB, codificación de imágenes al formato jpeg/png o codificación de sonido a mp3, amr o g729 para aplicaciones de voip. En caso de codificación de sonido hay muchas rutinas que no pueden ser traducidas por el compilador a código asm eficiente, simplemente no tienen equivalente en C. Ejemplos de las cosas comúnmente utilizadas en el procesamiento de sonido: matemática saturada, rutinas de acumulación múltiple, multiplicación de matrices .

Ejemplo de saturado agregar: 32-bit firm int tiene rango: 0x8000 0000 < = int32 < = 0x7fff ffff. Si agrega dos entradas, el resultado podría desbordarse, pero esto podría ser inaceptable en ciertos casos en el procesamiento de señales digitales. Básicamente, si el resultado se desborda o desborda saturada, add debe devolver 0x8000 0000 o 0x7fff ffff. Esa sería una función c completa para verificar eso. una versión optimizada del complemento saturada podría ser:

 
int saturated_add(int a, int b) 
{ 
    int result = a + b; 

    if (((a^b) & 0x80000000) == 0) 
    { 
     if ((result^a) & 0x80000000) 
     { 
      result = (a < 0) ? 0x80000000 : 0x7fffffff; 
     } 
    } 
    return result; 
} 

es posible que también se consiguen múltiples if/else para comprobar si hay desbordamiento o en x86 puede comprobar indicador de desbordamiento (que también requiere el uso de ASM). iPhone usa las CPU armv6 o v7 que tienen dsp asm. Por lo tanto, la función saturated_add con múltiples brunches (sentencias if/else) y 2 constantes de 32 bits podría ser una instrucción asm simple que utiliza solo un ciclo de CPU. Por lo tanto, simplemente haciendo que la instrucción saturada use asm podría hacer que el algoritmo completo sea dos o tres veces más rápido (y de menor tamaño). Aquí está el manual QADD: otros QADD

ejemplos de código que a menudo ejecutan en bucles largos son

 
res1 = a + b1*c1; 
res2 = a + b2*c2; 
res3 = a + b3*c3; 

parece que nada no puede ser optimizado aquí, pero en la CPU ARM puede utilizar instrucciones DSP específicos que ¡toma menos ciclos que para hacer una simple multiplicación! Así es, a + b * c con instrucciones específicas podría ejecutar más rápido que simple a * b. Para este tipo de casos, los compiladores simplemente no pueden entender la lógica de su código y no pueden usar estas instrucciones dsp directamente y es por eso que necesita escribir asm manualmente para optimizar el código, PERO solo debe escribir manualmente algunas partes del código que no necesitan ser optimizado ¡Si comienza a escribir bucles simples manualmente, es casi seguro que no le ganará al compilador! Hay varios documentos buenos en la web para el ensamblaje en línea para codificar filtros de abeto, codificación/descodificación de amr, etc.

Answer 2

Mi mejor triunfo sobre un compilador fue en una rutina de memcpy simple ... Me salteé muchas cosas de la configuración básica (por ejemplo, no necesitaba mucho de un marco de pila, así que guardo unos ciclos allí), e hizo algunas cosas bastante peludas.

Eso fue hace unos 6 años, con algún compilador propietario de calidad desconocida. Tendré que desenterrar el código que tenía y probarlo contra GCC ahora; No sé si podría ser más rápido, pero no lo descartaría.

Al final, aunque mi memcpy era en promedio aproximadamente 15 veces más rápido que el de nuestra biblioteca C, simplemente lo guardé en mi bolsillo trasero en caso de que lo necesitara. Para mí era un juguete jugar con el ensamblaje de PPC, y el aumento de velocidad no era necesario en nuestra aplicación.

Answer 3

Si desea hacer cosas como las operaciones SIMD, es posible que pueda vencer a un compilador. Sin embargo, esto requerirá un buen conocimiento de la arquitectura y del conjunto de instrucciones.

Answer 4

Si no tenemos en cuenta las operaciones SIMD trampa, por lo general, puede escribir el montaje SIMD que rinde mucho mejor que sus habilidades compiladores autovectorization (si es que tiene autovectorization!)

Here's un SSE muy básico (Uno de los x86 Tutoriales de juegos SIMD). Es para el ensamblado en línea de Visual C++.

Editar: Aquí hay un pequeño par de funciones si quieres probarlo por ti mismo. Es el cálculo de un producto de punto de longitud n. Uno está usando instrucciones SSE 2 en línea (sintaxis en línea GCC) el otro es muy básico C.

Es muy muy simple y me sorprendería mucho si un buen compilador no pudiera vectorizar el simple C loop , pero si no lo hace, debería ver una aceleración en el SSE2. La versión SSE 2 probablemente podría ser más rápida si utilizara más registros, pero no quiero extender mis habilidades SSE muy débiles :).

float dot_asm(float *a, float*b, int n) 
{ 
    float ans = 0; 
    int i; 
    // I'm not doing checking for size % 8 != 0 arrays. 
    while(n > 0) { 
    float tmp[4] __attribute__ ((aligned(16))); 

    __asm__ __volatile__(
      "xorps  %%xmm0, %%xmm0\n\t" 
      "movups  (%0), %%xmm1\n\t" 
      "movups  16(%0), %%xmm2\n\t" 
      "movups  (%1), %%xmm3\n\t" 
      "movups  16(%1), %%xmm4\n\t" 
      "add  $32,%0\n\t" 
      "add  $32,%1\n\t" 
      "mulps  %%xmm3, %%xmm1\n\t" 
      "mulps  %%xmm4, %%xmm2\n\t" 
      "addps  %%xmm2, %%xmm1\n\t" 
      "addps  %%xmm1, %%xmm0" 
      :"+r" (a), "+r" (b) 
      : 
      :"xmm0", "xmm1", "xmm2", "xmm3", "xmm4"); 

    __asm__ __volatile__(
     "movaps  %%xmm0, %0" 
     : "=m" (tmp) 
     : 
     :"xmm0", "memory");    

    for(i = 0; i < 4; i++) { 
     ans += tmp[i]; 
    } 
    n -= 8; 
    } 
    return ans; 
} 

float dot_c(float *a, float *b, int n) { 

    float ans = 0; 
    int i; 
    for(i = 0;i < n; i++) { 
    ans += a[i]*b[i]; 
    } 
    return ans; 
} 

Answer 5

menos que sea un assembly guru las probabilidades de golpear el compilador son muy bajo.

Un fragmento desde el enlace anterior,

Por ejemplo, el orientado a bits "XOR % EAX,% EAX" instrucción era la forma más rápido para establecer un registro a cero en las primeras generaciones del x86, pero la mayoría del código es generado por compiladores y compiladores rara vez genera instrucción XOR. Por lo que los diseñadores IA, decidió trasladar la que aparecen con frecuencia compilador instrucciones generadas hasta el frente de la lógica combinatoria decodificación haciendo que el literal "MOVL $ 0,% EAX" instrucción ejecutan más rápidamente que la instrucción XOR.

Answer 6

Implementé una simple correlación cruzada utilizando una implementación genérica de "Estrecho C". Y ENTONCES cuando tomó más tiempo que el timeslice que tenía disponible, recurrí a la paralelización explícita del algoritmo y al uso del procesador intrínseco para forzar las instrucciones específicas que se utilizarán en los cálculos. Para este caso particular, el tiempo de cálculo se redujo de> 30 ms a poco más de 4 ms. Tenía una ventana de 15 ms para completar el procesamiento antes de que ocurriera la siguiente adquisición de datos.

Esta fue una optimización de tipo SIMD en un procesador VLWI. Esto solo requiere 4 o menos de los intrínsecos del procesador, que son básicamente instrucciones de lenguaje ensamblador que dan la apariencia de una llamada a función en el código fuente. Podría hacer lo mismo con el ensamblaje en línea, pero la sintaxis y la administración de registros son un poco más agradables con los intrínsecos del procesador.

Aparte de eso, si el tamaño importa, el ensamblador es el rey. Fui a la escuela con un tipo que escribió un editor de texto de pantalla completa en menos de 512 bytes.

Answer 7

Tengo un algoritmo de suma de comprobación que requiere que las palabras giren en una cierta cantidad de bits. Para ponerlo en práctica, Tengo esta macro:

//rotate word n right by b bits 
#define ROR16(n,b) (((n)>>(b))|(((n)<<(16-(b)))&0xFFFF)) 

//... and inside the inner loop: 
sum ^= ROR16(val, pos); 

liberación VisualStudio acumulación expande a esto: (val es de hacha, pos está en dx, sum está en BX)

mov   ecx,10h 
sub   ecx,edx 
mov   ebp,eax 
shl   ebp,cl 
mov   cx,dx 
sar   ax,cl 
add   esi,2 
or   bp,ax 
xor   bx,bp 

Cuanto más ensamblador generado a mano equivalente eficiente sería:

mov  cl,dx 
ror  ax,cl 
xor  bx,ax 

no he encontrado la manera de emitir la instrucción ror de 'c' pura código. Sin embargo ...
Mientras escribía esto, recordé los intrínsecos del compilador. Puedo generar el segundo conjunto de instrucciones con:

sum ^= _rotr16(val,pos); 

Así que mi respuesta es: Incluso si usted piensa que puede vencer el compilador C puro, compruebe las características intrínsecas antes de recurrir a inline montaje.