Thibaut (./3) :

Martial Demolins (./2) :
Un modulo n avec n==x^2 (x entier évidemment) peut être très rapide en assembleur, mais je sais pas si gcc sait optimiser ça.

Bien sûr que si Ce serait grave sinon. Il suffit que l'opérande de gauche soit non signée.

Attention, cette limitation (nombre non signé (unsigned)!) est importante, c'est moins efficace avec des nombres signés (il y a des opérations en plus à faire, parce que le modulo d'un nombre négatif par un nombre positif est toujours négatif ou nul en C). Donc je conseille de toujours écrire &(x-1) pour les modulos par une puissance de 2 (x=2^k étant la puissance de 2). Dans beaucoup de cas (routines de sprites par exemple), &(x-1) (et >>k pour la division qui va avec) a des chances d'être ce que tu veux réellement d'ailleurs, la définition C du modulo est un peu bizarre.

djflex (./1) :
4) La longueur d'un bloc de code influe-elle sur la vitesse du programme à squizzer ce code

Il y a 3 longueurs de saut possibles: <128 octets (.s), >=128 et <32768 octets (.w) et >=32768 octets (.l). Entre .s et .w, la différence est minime: pour un branchement effectué ou pour un appel de fonction (bsr), ça n'a aucune importance (10 cycles pour le branchement effectué dans les 2 cas, 18 pour le bsr), pour un branchement conditionnel qui n'est pas effectué (condition non satisfaite), le .s prend 8 cycles, le .w 12. Les sauts .l sont plus coûteux: jmp (saut non conditionnel) prend 12 cycles, jsr (appel de fonction) prend 20 cycles et les sauts conditionnels sont particulièrement coûteux parce qu'il faut un saut conditionnel .s + un jmp, ce qui fait 20 cycles pour un branchement effectué (le bra.s ne sera pas effectué, le jmp le sera) et 10 pour un branchement non effectué (bra.s effectué, jmp sauté).

En taille de code, un saut .s prend 2 octets, un saut .w prend 4 octets, un saut non conditionnel .l prend 6 octets + 1 relogement et un saut conditionnel .l prend un saut .s + un saut non conditionnel .l, donc 8 octets + 1 relogement.