Quel est un exemple d'une fonction C simple qui est plus rapide implémentée dans l'assemblage en ligne?

Ma meilleure victoire sur un compilateur était sur une simple routine memcpy ... J'ai sauté beaucoup de choses de la configuration de base (par exemple, je n'avais pas besoin d'une grande image de pile, alors je sauve quelques cycles là-bas) et a fait quelques petites choses velues.

C'était il y a environ 6 ans, avec un compilateur propriétaire de qualité inconnue. Je vais devoir creuser le code que j'avais et l'essayer contre GCC maintenant; Je ne sais pas que cela pourrait être plus rapide, mais je ne l'excluais pas.

À la fin, même si mon memcpy était en moyenne environ 15 fois plus rapide que celui de notre bibliothèque C, je viens de le garder dans ma poche arrière au cas où j'en avais besoin. C'était un jouet pour moi de jouer avec l'Assemblée PPC et le boost de vitesse n'était pas nécessaire dans notre application.

Si vous voulez faire des trucs comme des opérations SIMD, vous pourrez peut-être battre un compilateur. Cela nécessitera une bonne connaissance de l'architecture et du jeu d'instructions cependant.

Si vous ne considérez pas la triche des opérations SIMD, vous pouvez généralement écrire une assemblée SIMD qui fonctionne beaucoup mieux que vos compilateurs AutoVectorisation Capacités (si elle a même une autocellation!)

Voici une SSE très basique (un des ensembles d'instructions SIMD de X86). C'est pour l'ensemble Visual C ++ en ligne. P>

Edit: Voici une petite paire de fonctions si vous voulez essayer pour vous-même. C'est le calcul d'un produit de points N longueur. L'une utilise des instructions SSE 2 en ligne (syntaxe en ligne GCC) L'autre est très basique C. P>

C'est très très simple et je serais très surpris si un bon compilateur ne pouvait pas vendre le Simple C boucle, mais si ce n'est pas, vous devriez voir une vitesse dans la SSE2. La version SSE 2 pourrait probablement être plus rapide si j'avais utilisé plus de registres, mais je ne veux pas étirer mes compétences SSE très faibles :). P>

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

sauf si vous êtes un gourou d'assemblage Les chances de battre le compilateur sont très faible .

Un fragment de la liaison ci-dessus,

Par exemple, l'orienté binaire "xor % EAX,% EAX "L'instruction était la moyen le plus rapide de définir un registre à zéro Dans les premières générations du X86, Mais la plupart du code est généré par compilateurs et compilateurs rarement Création d'une instruction XOR. Donc l'IA Les designers, ont décidé de déplacer le Compilateur fréquemment survenant Instructions générées jusqu'à l'avant de la logique de décodage combinante Faire le littéral "MOVL $ 0,% EAX" Les instructions exécutent plus vite que la XOR Instruction.