
Cette page, en annexe du Chapitre XIV va nous permettre de voir comment il est possible "d'optimiser" légèrement un programme utilisant les niveaux de gris, pour qu'il prenne moins de place en mémoire :
Nous allons ici reprendre le premier exemple utilisé dans le Chapitre XIV, et nous allons essayer de le "modifier" très légèrement, afin qu'il prenne moins de mémoire. Étant donné que chaque programmeur à sa propre technique d'optimisation de ce type de programmes, il va être difficile d'expliquer exactement en quoi consiste chaque opération, mais nous allons tout de même essayer...
I:\ Si les étapes sont importantes :
Dans cette partie, nous allons nous intéresser au cas où toutes les étapes du programme sont intéressantes, et surtout importantes... A cause de cela, il sera dur d'optimiser véritablement le programme...
Dans le cas de ce programme, l'économie de mémoire réalisée est de 40octets :-(
Voici le code source du programme étudié en premier exemple du chapitre précédent, réécris pour se comporter exactement de la même façon, mais en occupant un petit peu moins de mémoire : (Les commentaires de ce programme ayant été faits dans le corps de ce chapitre, nous ne les avons pas retranscrit ici.).
#define
SAVE_SCREEN
#include <tigcclib.h>
short _ti92plus,
_ti89;
void _main(void)
{
short i=0;
if (!GrayOff())
return;
FontSetSys(F_4x6);
SetPlane (DARK_PLANE);
ClrScr();
DrawStrXY(20,
3, "Pas
de Plan actif", A_NORMAL);
SetPlane(LIGHT_PLANE);
ClrScr();
DrawStrXY(20,
3, "Pas
de Plan actif", A_NORMAL);
ngetchx();
for (i=11
; i<=20
; i++)
{
DrawLine(0,
i, 18,
i, A_NORMAL);
}
DrawStrXY(20,
14, "LIGHT_PLANE
actif", A_NORMAL);
ngetchx();
SetPlane (DARK_PLANE);
for (i=22
; i<=31
; i++)
{
DrawLine(0,
i, 18,
i, A_NORMAL);
}
DrawStrXY(20,
25, "DARK_PLANE
actif", A_NORMAL);
ngetchx();
for (i=33
; i<=42
; i++)
{
DrawLine(0,
i, 18,
i, A_NORMAL);
}
DrawStrXY(20,
36, "LIGHT_PLANE
et DARK_PLANE actifs",
A_NORMAL);
SetPlane (LIGHT_PLANE);
for (i=33
; i<=42
; i++)
{
DrawLine(0,
i, 18,
i, A_NORMAL);
}
DrawStrXY(20,
36, "LIGHT_PLANE
et DARK_PLANE actifs", A_NORMAL);
ngetchx();
GrayOff();
}
Comme vous avez sans doute pu le remarquer, on a ici
supprimé quelques instructions permettant de changer de plan actif. En effet,
on est souvent tenté de faire quelque chose ressemblant à ceci : (ce n'est
qu'un extrait de code !)
GrayOn();
SetPlane(LIGHT_PLANE);
ClrScr();
Setplane(DARK_PLANE);
ClrScr();
SetPlane(LIGHT_PLANE);
DrawStrXY(10,
10, "Niveaux
de gris", A_NORMAL);
SetPlane(DARK_PLANE);
DrawStrXY(20,
20, "Sur
TI-89 ou 92+", A_NORMAL);
SetPlane(LIGHT_PLANE);
DrawStrXY(30,
40, "Sous
TIGCC", A_NORMAL);
SetPlane(DARK_PLANE);
DrawStrXY(30,
40, "Sous
TIGCC", A_NORMAL);
GrayOff();
Cet extrait de code source écrira "Niveaux de
gris" en Gris clair, "Sur TI-89 et 92+" en gris foncé, et
"Sous TIGCC" en noir.
Cependant, il est possible d'utiliser ceci, qui a exactement
le même résultat, mais qui prendra moins de mémoire sur la TI :
GrayMode(GRAY_ON);
SetPlane(LIGHT_PLANE);
ClrScr();
DrawStrXY(10,10,"Niveaux
de gris",A_NORMAL);
DrawStrXY(30,40,"Sous
TIGCC",A_NORMAL);
SetPlane(DARK_PLANE);
ClrScr();
DrawStrXY(20,20,"Sur
TI-89 ou 92+",A_NORMAL);
DrawStrXY(30,40,"Sous
TIGCC",A_NORMAL);
GrayMode(GRAY_OFF);
Ainsi, on ne change qu'une seule fois de plan
actif... au lieu de 5 !!! ce qui permet d'économiser de la mémoire. (Et plus
le programme est long, plus la quantité de mémoire économisée est importante
!!!).
II:\ Si seul le résultat final est important :
Si on se moque des étapes intermédiaires, et que la seule chose qu'on souhaite, c'est obtenir l'écran final, il est possible de "sauter" certaines étapes, et donc de pouvoir utiliser la méthode proposée dans la première partie avec encore plus d'efficacité.
Dans le cas de ce programme, l'économie réalisée est de 174octets...
Cela nous donnera ce code source :
#define SAVE_SCREEN
#include <tigcclib.h>
short _ti92plus,
_ti89;
void efface_plan(short
plan)
{
SetPlane(plan);
ClrScr();
DrawStrXY(20,
3, "Pas
de Plan actif", A_NORMAL);
DrawStrXY(20,
36, "LIGHT_PLANE
et DARK_PLANE actifs", A_NORMAL);
}
void _main(void)
{
short i=0;
if (!GrayOn())
return;
FontSetSys(F_4x6);
efface_plan(DARK_PLANE);
for(i=22
; i<=31
; i++)
{
DrawLine(0,
i, 18,
i, A_NORMAL);
DrawLine(0,
i+11,
18, i+11,
A_NORMAL);
}
DrawStrXY(20,
25, "DARK_PLANE
actif", A_NORMAL);
efface_plan(LIGHT_PLANE);
for(i=11
; i<=20
; i++)
{
DrawLine(0,
i, 18,
i, A_NORMAL);
DrawLine(0,
i+22,
18, i+22,
A_NORMAL);
}
DrawStrXY(20,
14, "LIGHT_PLANE
actif", A_NORMAL);
ngetchx();
GrayOff();
}
Comme vous pouvez le remarquer, ce code est nettement plus
difficile à comprendre que le précédent !!! Cependant, si ce n'est que le
résultat final qui vous intéresse, et l'économie de mémoire, il est
largement plus avantageux (Il fait gagner 174 octets par apport à la version
étudiée dans le Chapitre
XIV, soit 13.5% de celui-ci !).
Pour parvenir à ce résultat, la manipulation la plus
important a été le fait de regrouper dans une seul fonction toutes celles qui
se répétaient plusieurs fois dans le programme (en l'occurrence, deux fois !).
J'espère que ce petit aparté vous aura appris quelque chose...
Copyright Squale92 & Verstand. Logo et sigle TCI® réservés. Développé pour MS Internet Explorer 5.0 en 1024x768 pixels. Page modifiée le