Obligement - L'Amiga au maximum

Vendredi 21 juillet 2017 - 08:43  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


Jeux Amiga

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


Trucs et astuces

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


Glossaire

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


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Contact

David Brunet

Courriel

 


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.


[Retour en haut] / [Retour aux articles] [Article précédent] / [Article suivant]