Routine asm (exg) - Page 1

Je voulais faire une routine asm pour échanger des variables plus vite qu'en C, malheureusement je ne sais pas trop comment faire. J'ai essayé en faissant comme cela mais ça marche pas:

inline void swap_var(register int var1 asm("d0"),register int var_1 asm("d1"),register int var2 asm("d2"),register int var_2 asm("d3"))
{
asm("exg %d1,%d0
exg %d2,%d3");

}

Il n'y a pas d'erreur à la compilation mais les variables ne sont pas échangées. Peut-être qu'ensuite il faut que les variables chargent les registres mais je ne sais pas comment faire.
Quelqu'un aurait une idée ?

C'est parce que tu passes le contenu de la variable, et non son adresse à la fonction.
De toute façon, c'est très lente de faire une fonction juste pour ça. Tu ferais mieux de faire une macro.

La fonction est inlinée de toute façon.

C'est surtout que le fait de le mettre en fonction sauve les registres, c'est normal qu'au retour de la fonction on ne voit pas que les registres ont été échangés.

Ah oui, j'avais pas fait gaffe au inline.

le coup du truc pr échanger les variables (je sais plus trop, mais c quelque chose du style a^=b^=a^=b ) est pas bien optimisé ?

Non je n'ai pas l'impression.

Par rapport à un exg pas vraiment je pense.

croisé

carrement pas meme...

eh ben, sur ce coup, au moins, voila une réponse claire, nette, et précise
merci.

enfin ca depend comment tigcc optimise ca ms bon... un exg sera tjrs plus rapide que trois eor...

Ouais en C j'utiliserais pas les 3 xor pour échanger 2 variables.
Je ferais plutôt:
void echange (int *a, int *b)
{
  int temp;
  temp = *a;
  *a = *b;
  *b = temp;
}

Mais là dans la question de Raphaël il y a 4 variables à échanger et il voudrait le faire en ASM. Je pense que tu peux laisser la routine en C, je pense pas que ça sera si lent que ça.

Oui en fait je fais bien comme ça en C:

void echange (int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}

...sauf que je ne fais pas de fonction.

On dirati que la solution la plus rapide sans tomber dans l'ASM est celle que propose squale92

#define EXCH(a,b) ((a)^=(b)^=(a)^=(b))

Sinon bien sur avec une variable auxiliaire

#define EXCH(a,b) \
{\
int tmp;\
\
tmp=a;\
a=b;\
b=tmp;\
}

Reste à savoir laquelle est meilleure après l'optimisation du compilateur

En tout cas, une fct avec des pointers c'est hors question, car on rajoute l'overhead des indirections.

J'ai essayer la méthode de squale92 mais même avec des test assez poussés je n'ai vu aucune différence avec cet méthode :
#define EXCH(a,b) \
{\
int tmp;\
\
tmp=a;\
a=b;\
b=tmp;\
}

je suppose que ça dépend des options de compilation, ou du compilateur...

a^=b^=a^=b n'est en général pas optimisé du tout par rapport à d'autres méthodes. Mais je crois que GCC est cependant assez fin pour optimiser dans certains cas bien particuliers, notamment:
unsigned long long x,z;
x=(unsigned long long)0x0123456789ABCDEF;
z=(unsigned long long)0xFEDCBA9876543210;

x^=z^=x^=z;

printf_xy(0,0,"%lu",x);
printf_xy(0,10,"%lu",z);
[x et z ne sont utilisées nulle part aillleurs].

bah l'echange avec la variable temporaire serait logiquement plus rapide si un registre est utilise en temps que var temporaire...
ms je c pas si gcc le fait sans qu'on mette register dans la declaration de la var... ca depend aussi surement des options de compilation...

Une possibilité est:
#define EXCH(a,b) asm("exg.l %0,%1":"=r"(a),"=r"(b):"0"(a),"1"(b))

À essayer aussi:
#define EXCH(a,b) asm("":"=g"(a),"=g"(b):"0"(b),"1"(a))

Kevin Kofler a écrit :
Une possibilité est:
#define EXCH(a,b) asm("exg.l %0,%1":"=r"(a),"=r"(b):"0"(a),"1"(b))

Voilà. C'est la ligne que je cherchais .
Je n'arrive pas du tout à me familiariser avec cette extension GNU (si c'en est bien une) qui permet d'utiliser de l'asm dans les sources C.

À essayer aussi:
#define EXCH(a,b) asm("":"=g"(a),"=g"(b):"0"(b),"1"(a))

Par contre, là je ne comprends pas du tout.
Il faut remettre ce que tu as mis dans la première ligne en changeant juste les =r en =g ?
Je suis pas sûr.

Non, l'astuce est d'échanger l'ordre des opérandes input et des opérandes output. Je n'ai pas testé, mais ça devrait échanger les variables rapidement.

J'ai essayé les deux routines qui marchent bien d'ailleurs, et celle là est déjà sûrement plus rapide que d'utiliser une variable temporaire en C : #define EXCH(a,b) asm("":"=g"(a),"=g"(b):"0"(b),"1"(a))
Dans mon moteur je passe de 23-24 à 24 images/s et c'est pas rien vu la proportion que ça tient dans le programme !
Merci bien pour ces deux routines même si je n'y comprends pas encore grand chose.
Je vais faire des tests plus poussés pour la plaisir.

Ah, bah non finalement en refaisant des tests je constate aucune différence entre toutes les routines... bizarre.
Par contre en utilisant ClearGrayScreen2B();, j'ai gagné 1 Fps (avant j'utilisais memset() ).

bof, sur 23-24 fps voir une difference c'un fps c pas top top...
vo mieux que tu fasse des benchs separes pour chacune de tes routines d'abord, et qu'apres tu les integre a ton moteur, et apres, tu compte le temps que ca met de faire chaque bout pour reperer les goulots d'etranglements et les parties de ton code qui bouffent le + de temps... l'histoire des exg c insignifiant par rapport a ce que tu peux accelerer avec le reste (a moins que tu fasse un exg par pixel dessine )

Raphaël
a écrit : Ah, bah non finalement en refaisant des tests je constate aucune différence entre toutes les routines... bizarre.

Tu ne constates aucune différence de vitesse parce que la différence n'est pas mesurable. C'est dans l'ordre du centième de milliseconde. Regarde la différence de taille, là tu devrais pouvoir mesurer quelques octets, et ici (contrairement à beaucoup d'autres domaines d'optimisation où elles sont plutôt inversement proportionnelles) taille et vitesse sont à peu près proportionnelles. Moins d'octets = moins d'instructions = moins de cycles = moins de microsecondes.

La routine je l'utilise uniquement pour le remplissage des triangles. Et justement c'est après en faisant un bench qui contenait une boucle où j' exécutais cette routine plus de 10 000 fois par fps, où j'ai vu que finalement aucune routine n'est plus rapide que l'autre... pourtant on ne dirait pas comme ça. Et pour la taille je n'ai pas regardé.

10000 fois par fps? ca veut dire koi?
10000 fois par frame?
10000 fois par sec?

J'ai vu ca un coup sur un forum pour un echange:

a+=b;  [i]//les deux (a+b) dans a[/i]
b=a-b; [i]//retire b de (a+b) reste a[/i]
a=a-b; [i]//retire a de (a+b) reste b[/i]

C'est le même principe que pour les XOR.
Et je te déconseille de faire ça avec des variables signées, parce qu'en cas de débordement, le standard C ne garantit que ça marche comme prévu que pour les variables non signées. Pour les variables signées, le compilateur peut faire ce qu'il veut.