Instruction optimale ?

Réponse acceptée !
Salut,


Tout comme ToutEnMasm, je conseille le test pour ce genre question.
J'ai réalisé un prog en C avec asm inline :

===========================================
#include <stdio.h>
#include <stdlib.h>

unsigned int timing_test1[1024];
unsigned int timing_test2[1024];

void *ptr1, *ptr2;
char _ptr1[16+16];
char _ptr2[16+16];

inline void test1()
{
    __asm(
        "mov    (%0),%%ebx    \n"
        "mov    (%1),%%ecx    \n"
        "movdqa    (%%ebx),%%xmm1    \n"
        "addps    (%%ecx),%%xmm1    \n"
        :: "m" (ptr1) , "m" (ptr2)
        : "ebx", "ecx");
}

inline void test2()
{
    __asm(
        "mov    (%0),%%ebx    \n"
        "mov    (%1),%%ecx    \n"
        "movdqa    (%%ebx),%%xmm1    \n"
        "movdqa    (%%ecx),%%xmm2    \n"
        "addps    %%xmm2,%%xmm1    \n"
        :: "m" (ptr1) , "m" (ptr2)
        : "ebx", "ecx");
}


int main(int argc, char **argv)
{
    int loop;
   
    ptr1 = (void *)((unsigned long)(_ptr1+15)&(~0x0F));
    ptr2 = (void *)((unsigned long)(_ptr2+15)&(~0x0F));
   
    unsigned int result_test1=0, result_test2=0;
    unsigned int debut,fin;
    // boucles de test ...
    __asm__ volatile ("rdtsc":"=A" (debut));
    for(loop=0;loop<4096;loop++) test1();
    __asm__ volatile ("rdtsc":"=A" (fin));
    result_test1 = ((debut<fin)?(fin-debut):(debut-fin))/4096;
   
    __asm__ volatile ("rdtsc":"=A" (debut));
    for(loop=0;loop<4096;loop++) test2();
    __asm__ volatile ("rdtsc":"=A" (fin));
    result_test2 = ((debut<fin)?(fin-debut):(debut-fin))/4096;
    // affichage du résultat ...
    printf("Test1 : %u cycles d'horloge et Test2 : %d cycles d'horloge\n",result_test1,result_test2);
    return EXIT_SUCCESS;
}
===========================================

Et le résultat chez moi me donne :
Test1 : 34 cycles d'horloge et Test2 : 32 cycles d'horloge

de manière répétitif.

On peut donc déduire que utiliser 2x movdqa + 1x addps est plus rapide.

Celà est surement dû au fait que les 2 méthodes ont une contrainte sur les 2 opérandes (que ce soit sur xmm2 ou sur le chargement des 128bits). Mais movdqa est à priori mieux géré en terme de cycles cpu que addps pour le chargement des données alignées sur 128bits.
Addps doit gaspiller de precieux cycles cpu en considérant le chargement pas forcément aligné.

Dune2.

Gentoo... que du bonheur ...