[Axe] Optimisation d'un code pour la compilation !

Si vous n'avez pas envie de tout lire, j'ai mis des balises codes afin de repérer plus rapidement les codes à optimiser. Dans tout mes exemples, j'utiliserai la variable A. Bien entendu vous pouvez faire ces optimisations avec n'importe quelles autres variables.

Partie I : les trucs basic
Quelques astuces que nous avons appris en TI-Basic peuvent être également appliquées à Axe. Jetons un coup d'oeil:
Les opérations booléennes comme celle-ci :

Code:

If A≠0

Peuvent être optimisées comme ceci :

Code:

!If A

Mieux encore, le calcul If (A≠0) and (B≠0) se simplifie donc par If A and B.

Toutefois, il faut faire attention : les calculs en Axe se font sans règles de priorités. Le calcul If A=1 and B=2 sera lu par la calculatrice If (A=1 and B)=2. Ce calcul étant toujours égal à 0, le code de la condition ne sera jamais exécuté. Pour remédier à cela, il faut placer les parenthèses avant le deuxième calcul booléen : If A=1 and (B=2.

Partie II : Général
Vérifier l'égalité :

Code:

If A=EXP

s'optimise en

Code:

!If A-EXP

De même que

Code:

If A=EXP and (B=EXP)

s'optimise en

Code:

!If A-EXP + (B-EXP)

Où + est le comparateur 'or' pour les variables de 2 octets.

Maintenant, si vous vérifiez la même variable par plusieurs expression :

Code:

If A=EXP1 or (A=EXP2)

on simplifiera par

Code:

If inData(A,Data(EXP1,EXP2,0))

Il ne faudra surtout pas oublier le 0 à la fin, où sinon la commande inData( ne se terminera jamais. Les points faibles de ce code sont que les valeurs testées sont forcément des constantes d'un octet chacune.

Truc de math
Si vous le pouvez, mettez toujours les constantes à la fin d'une expression :

Code:

CONST+A

ce code peut être simplifié comme ceci :

Code:

A+CONST

En effet, il est plus rapide d'additionner deux octets à un octet voir à un bit, que l'inverse. La différence est faible, mais peut être utile.
Autre chose : mettez le moins de parenthèses dans vos code, et utilisez les calculs sans priorités à votre avantage.

Partie III : utilisez la variable Ans
Comme en TI-Basic, l'Axe possède une variable Ans possédant régulièrement la valeur du dernier calcul effectué. Si on ne la réinitialise pas en début d'expression par un nombre ou une variable, on peut l'utiliser très facilement. Tout les calculs passent par Ans.
Par exemple, si on utilise deux fois le même argument :

Code:

Text(0,0,PTR)

On peut simplifier en

Code:

Text(0,,PTR)

Le deuxième 0 disparaît car il n'est plus utile : la variable Ans possède la même valeur.

A partir de cela, on peut améliorer grandement la vitesse de nos programmes, en combinant les calculs booléen à la variable Ans :

Code:

If A>3:1→B

devient

Code:

If A>3:→B

Ou encore :

Code:

0→B: 0→A

devient

Code:

0→B→A

Et même :

Code:

0→A: 1→B: 3→C

devient

Code:

0→A+1→B+2→C

On peut également utiliser le même système dans les fonctions :

Code:

sub(LBL,EXP).....Lbl LBL: EXP*2→{L1}

devient

Code:

sub(LBL,EXP).....Lbl LBL: *2→{L1}

Si l'on veut exécuter une boucle un nombre n de fois :

Code:

n
While
-1→A
:.Code
A
End

On peut également recréer une boucle Do...While (pour les connaisseurs) à l'aide d'un Lbl, rendant la boucle encore plus rapide :

Code:

n
Lbl L
  →A
  ;Code
!If A-1
  Goto L
End

Bien sûr, on ne peut pas parler de toutes les optimisations possible avec la variable Ans, mais je suis sûr que vous en trouverez d'autres.

Partie IV : fonctions
C'est avec les fonctions que vous réduirez le plus la taille de votre code. Elles sont très facile à utiliser ; il faut juste savoir quand les utilisez :

• Si vous réécrivez un même code plusieurs fois dans votre programme, faites une fonction !
  
• Ou sinon, si votre code n'apparaît qu'une fois, n'en faites pas.
  

Les commandes sub( prennent entre 3 et 5 octets sur votre programme, en fonction de la longueur de son nom. Il faut rajouter 3 octets à chaque argument que vous mettez sub(LBL,ARGUMENT,ARGUMENT,...) (6 maximum). A chaque fois que vous mettrez un argument sauvé (sub(LBL,ARGr,...)), cela vous coûtera 15 octets par arguments en plus.

Si vous faites appelle à une fonction dans une fonction, et que vous mettez un Return juste après comme ici :

Code:

Lbl A
:.Code
:sub(B)
:Return

Il sera judicieux d'utiliser la commande Goto :

Code:

Lbl A
:.Code
:Goto B

Le Return de l'autre fonction effectuant un retour vers le programme principale.

Un autre truc, si vous mettez en fin de programme une fonction quelconque :

Code:

Lbl A
:.Code
:Return

La fin du programme étant lui même un Return, on peut simplifier comme cela :

Code:

Lbl A
:.Code

Partie V: La vitesse ou la taille
Les optimisations qui vont suivre permettent toutes de rendre le programme plus rapide, au détriment de la taille du programme.

Mettre le plus de condition possible augmente la vitesse considérablement :

Code:

If EXP1 and EXP2

est plus lent que

Code:

If EXP1 : If EXP2

Cependant, le deuxième code prend plus de mémoire sur l'exécutable.

Lors de simple calcul, on peut gagner de la vitesse en multipliant par les puissances de 2 les plus petites.

Code:

EXP*96

Le code ci dessus prend moins de place, mais est plus lent que le code ci dessous.

Code:

EXP*2*2*2*2*2*3

Partie VI : divers
Toutes les choses qui n'appartiennent à aucune catégorie...

Si vous avez besoin de faire des lignes horizontales ou verticales :

Code:

Line(0,,20,0)

Il est mieux de créer un rectangle d'épaisseur 1 :

Code:

Rect(0,,20,1)

Cela améliore la vitesse et la taille je crois.

Utilisez les ElseIf et les DS <( si vous le pouvez. Ils ne sont pas là pour rien, et ils sont très utiles.

Les commandes text( et Bitmap( sont lentes parce ce sont des fonctions de TI. Evitez-les si possible. (je sais, il est difficile de ne pas utiliser de text(... mais faites de votre mieux)

La nouvelle commande DispGraphClrDraw revient à la même chose que DispGraph: ClrDraw, mais en deux fois plus vite.

Rappelez-vous chaque nouvelle commande que vous utilisez en Axe créée ses propres fonctions dans votre exécutable. Ainsi, (pour des raisons de taille) il est mieux d'éviter d'utiliser Rect( si vous avez déjà utilisé la commande line( de même pour la commande Pt-On( si vous avez déjà utilisé Pt-Change(.

One major optimization that usually gets ignored is recycling large axe commands. Axe is not like BASIC and so each command needs its own subroutine to add to your program. For instance, lets say you use Pt-On() and Pt-Mask() in your code. Each one has to bring its own 100+ byte subroutine into your program. But you can probably get away with having just a Pt-Mask routine, recycling it to act like Pt-On by simply adding a 2nd layer to your sprite which is only 8 bytes extra instead of 100ish. Or you could do the opposite too and only have Pt-On() and Pt-Change() to manually change both buffers at once. This generally reduces the overall size of the program by a lot when you use the routines only once or very rarely in your code. And I don't mean calling it rarely, it could be the most used routine in your code, I just mean rarely appears in your source.

kindermoumoute a écrit:Mieux encore, le calcul If (A≠0) and (B≠0) se simplifie donc par !If A and B.