Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Amiga E - E et assembleur
(Article écrit par Pierre Girard et extrait d'Amiga News - mai 1996)
|
|
Avis aux amateurs de vitesse ! Le but de l'article de ce mois-ci est de doper vos programmes à grands coups d'assembleur.
Cela passe, malheureusement pour vous, par une explication plus théorique que le mois dernier.
Ne vous endormez pas ! Amis débutants, n'ayez pas peur. Cet article ne s'adresse pas aux programmeurs chevronnés de démos qui
codent des animations texturées à raisons de 50 images/seconde. Non, il s'agit simplement d'introduire dans des programmes en
E quelques lignes d'assembleur pour accélérer vos routines.
Le cas le plus fréquent est, bien entendu, la gestion des opérations répétitives (comme les boucles) qui ont tendance à prendre
beaucoup de temps machine. Prenons un exemple inutile, mais simple : nous avons 10 millions de multiplications à effectuer.
En Amiga E, cela donne :
FOR I:=1 TO 10000000
resultat:=a*2
ENDFOR
|
En assembleur, la structure change un peu :
MOVE.L #4,D1
MOVE.L #10000000,D0
label:
MULU #2,D1 ; (ou LSL.L #1,D1)
SUBQ.L #1,D0
BPL label
|
J'ai réalisé ce petit test sur ma machine (68020 à 28 MHz), en utilisant l'assembleur en ligne du compilateur E. Les résultats
obtenus grâce au profileur fourni avec le E sont significatifs. L'exécution du programme en E met 19,85 secondes, alors que
si l'on adapte la routine de multiplication en assembleur, l'exécution ne prend plus que 15,35 secondes :
AmigaE : 19,85 s
Assembleur avec MULU (compilateur=EC) : 15,35 s
Assembleur avec LSL.L (EC) : 6,83 s
Assembleur avec LSL.L (Devpac) : 4,43 s
Bon, c'est vrai que le test n'est pas valable parce qu'on n'utilise qu'une seule instruction (MULU) qui n'est pas représentative.
Mais en règle générale, je pense qu'on peut obtenir au moins une diminution de 50% du temps machine en mettant de l'assembleur
"in line". On aurait pu optimiser encore en utilisant un LSL (décalage logique vers la gauche), mais dans ce cas précis,
on ne gagne que 50 millisecondes.
L'utilisation
Celle-ci est simple mais il faut quand même avoir quelques bases en assembleur. Voici deux ou trois principes préalables à connaître.
Vous pouvez utiliser directement les variables du E dans la source en assembleur que vous insérez. Exemple :
PROC main()
DEF variable
variable:=25
MOVE.L variable,D0
/* Copie la valeur de "variable" dans le registre D0 */
ADD.L #5,D0
MOVE.L D0,variable
WriteF('Variable + 5= \d\n',variable)
ENDPROC
|
Ceci est aussi valable pour les constantes, mais elles doivent être précédées de "#".
CONST CONSTANTE=23
PROC main()
DEF x
MOVE.L #CONSTANTE,D0
/*Copie la constante CONSTANTE dans le registre D0*/
ADD.L #2,D0
MOVE.L D0,x
WriteF('Constante + 2= \d\n',x)
ENDPROC
|
Les labels et les procédures sont aussi directement accessibles en assembleur, mais elles sont relatives au compteur d'adresse
ou PC-relatives (PC=Program Counter) et doivent donc être utilisées comme telles.
PROC main()
LEA main(PC),A0 /* Copie l'adresse de main dans le registre A0 */
label:
LEA label(PC),A1 /* Copie l'adresse de label dans le registre A1 */
ENDPROC
|
En ce qui concerne les appels de fonctions des bibliothèques, ils se font d'une manière tout à fait classique. Il convient tout
d'abord de stocker l'adresse de base de la bibliothèque dans le registre A6. Ensuite, il faut remplir les différents registres
dont la fonction appelée a besoin, et enfin faire un JSR nom_de_la_fonction.
PROC main()
MOVE.L #0,A0
MOVE.L intuitionbase,A6
JSR DisplayBeep(A6)
ENDPROC
|
Quelques règles à respecter
Ces quelques conseils pour éviter les déboires et rechercher pendant des heures pourquoi votre superbe programme ne marche pas
sont tirés du "beginner guide" de Jason Hulance, qui est dorénavant fourni avec le paquetage du E (me semble-t-il).
- Tous les codes mnémoniques (DBRA, MOVE...) et les registres (D0.., A0...) doivent impérativement être en majuscule.
- La plupart des assembleurs utilisent le ";" pour signaler que le reste de la ligne est un commentaire. En E, vous pouvez utiliser
"->" ou les classiques "/*" et */".
- Les registres A4 et A5 sont utilisés en interne par le E, donc il est fortement conseillé de les éviter si vous incluez une
routine en assembleur. Mais vous pouvez utilisé les autres registres, surtout si vous utilisez le mot-clé "REG" en option du
compilateur ou comme définition (voir le manuel du E). Attention, si votre code assembleur peut être appelé par du code utilisant
l'option "REG", vous devez sauvé les registres D3-D7. MOVEM.L D3-D7,-(A7); /* source en assembleur */; MOVEM.L (A7)+,D3-D7
- Des fonctions comme WriteF() affectent certains registres. Alors, lisez la documentation du E pour vérifier quels registres
il faut utiliser !
Avantages et inconvénients
Il faut bien avoir à l'esprit que l'assembleur en ligne du E ne se substitue pas à un macro assembleur évolué. D'ailleurs, ce
n'est pas le but. Cependant, il est un outil vraiment très pratique pour faire la "routine qui tue", tout en profitant des
facilités du E pour le reste du programme. Ainsi, ne vous attendez pas à profiter de macro-commandes directement pour
l'assembleur mais le E peut palier à ce manque. La puissance réside en fait dans la possibilité d'échanger les données entre
le E et l'assembleur sans avoir à se casser la tête. Pour être honnête, la première fois que j'ai utilisé le E, je n'arrivais
pas à croire qu'on puisse faire un MOVE.L pour stocker la valeur d'un registre directement dans une variable du E !
Conclusion
Le E est vraiment LE langage de l'Amiga à l'heure actuelle. Il suffit de regarder la production du domaine public et bientôt
commerciale (il me semble que Photogenics a été programmé en E ?) pour s'en persuader. L'ajout d'assembleur va vous ouvrir de
nouveaux horizons, notamment au point de vue de la rapidité.
Mais il faut aussi savoir qu'il y a des tâches plus faciles à réaliser en assembleur qu'en E. Si vous n'avez jamais fait
d'assembleur, je vous invite à vous y mettre en commençant par acheter un ouvrage de référence sur le processeur MC68000.
J'attends vos réactions par courrier à la rédaction d'Amiga News ou via l'adresse électronique de Yann. A bientôt.
|
