1

J'ai tenté de faire une fonction en C pour effacer un buffer (bon ici c'est l'écran) histoire de voir comment je pouvais optimiser au maximum (je pense que ça ne sert pas à grand chose de dérouler encore la boucle) ça et voilà ce que ça donne :

__attribute__((regparm))void clrbuff()
{
short i=0;
unsigned long long *screen_long = (long long*)LCD_MEM;


while(i<750) // 750 = 3000 / 32
{


*screen_long++=0x00000000;
*screen_long++=0x00000000;
*screen_long++=0x00000000;
*screen_long++=0x00000000;
*screen_long++=0x00000000;
*screen_long++=0x00000000;
*screen_long++=0x00000000;
*screen_long++=0x00000000;


i=i+16;

}
}


Je serais curieux de savoir comment on peut faire pour l'optimiser encore plus (si possible) en C.... enfin ça ne me dérange pas si il y a de l'asm non plus.

En asm ça donne :

move.w #19456,%a0
move.w #736,%d0
.L8:
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
clr.l (%a0)+
add.w #-16,%d0
jbpl .L8
Ca ne doit pas vraiment être ce qu'il y a de plus rapide. Je crois que movem.l va est bcp plus rapide mais je ne sais pas comment l'utiliser.
www.wikio.fr/user1921&info=comments

2

Bon déjà n'utilise pas les long long si tu n'en as pas besoin (ce qui est le cas ici), parce que GTC ne les supporte pas, et TIGCC génère en général du code assez moyen (même si là ça va à peu près, encore que je soupçonne que le fait qu'il utilise clr.l (a0)+ et pas move.l d1,(a0)+ soit lié à ça...). Et comme le processeur ne les supporte pas en hardware, ça ne te fera rien gagner de les utiliser.

Accessoirement, je rajouterais que tu débordes de ton buffer, donc ça pourrait théoriquement foirer. Bon, dans ce cas précis, c'est pas grave, puisque c'est sur 89 et que le fait de déborder un peu n'est pas grave, et puisque sur 92, le même code adapté à l'écran ne débordera pas parce que la taille de l'écran est multiple de 64. Mais fait quand même très attention à ce genre de choses embarrassed

Sinon, pour optimiser tout ça, tu peux initialiser d1 à 0, et remplacer clr.l (a0)+ par move.l d1,(a0)+ (ce sera quasiment 2x plus rapide). Ensuite, tu n'as pas besoin de dérouler ta boucle tant que ça. (j'ajouterais que ces deux choses là sont déjà implémentées dans memset, donc si tu l'utilises ton prog sera plus petit et en plus tu as la garantie qu'il ne débordera pas du buffer happy).

Et si tu avais vraiment besoin d'encore plus de vitesse (mais je ne suis pas sûr que ça vaille vraiment le coup), tu peux utiliser movem.l, le gain en vitesse sera d'un peu moins de 30%. Mais tu es obligé de passer par de l'ASM, dans ce cas-là (et je crois qu'il y a des libs qui ont des routines faites pour ça, cf. extgraph, xlib ou graphx).

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

3

Bon déjà n'utilise pas les long long si tu n'en as pas besoin (ce qui est le cas ici),

C'était juste pour voir le code généré par TIGCC.
encore que je soupçonne que le fait qu'il utilise clr.l (a0)+ et pas move.l d1,(a0)+ soit lié à ça

Non c'est pas lié à ça. Je ne comprends pas pourquoi TIGCC ne l'optimise pas... peut-être qu'il faut écrire le code C d'une autre manière ? Ou que TIGCC ne le supporte pas. C'est dur à implémenter ce genre d'optimisation ? Et GTC le fais ?
Accessoirement, je rajouterais que tu débordes de ton buffer, donc ça pourrait théoriquement foirer.

Oui je sais mais je ne déborde pas du buffer d'une 92 ou V200 : ça reste toujours dans le buffer de 3840.

Sinon, pour optimiser tout ça, tu peux initialiser d1 à 0, et remplacer clr.l (a0)+ par move.l d1,(a0)+ (ce sera quasiment 2x plus rapide).

Ah oui en effet !

void clr()
{
short i=0;
unsigned long long int *screen_long = (long long int*)LCD_MEM;
asm("move.l #0, %d1");
while(i<750)
{


asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
asm("move.l %d1,(%a0)+");
*screen_long++=0x00000000; // là je suis obligé de faire ça sinon il y a un divide by 0 ! Je ne comprends pas pourquoi.


i=i+16;

}
}
Mais tu es obligé de passer par de l'ASM

C'est pas possible de remplacer move.l par movem.l ? C'est quoi la différence ? Franchement ça serait cool qu'un jour TIGCC la suppporte cette instrcution.
et je crois qu'il y a des libs qui ont des routines faites pour ça, cf. extgraph, xlib ou graphx).

Bah oui je sais et quand j'en ai besoin je m'en sers mais j'ai envie d'avoir un niveau de programmation un peu plus poussé.


www.wikio.fr/user1921&info=comments

4

C'est pas possible de remplacer move.l par movem.l ? C'est quoi la différence ? Franchement ça serait cool qu'un jour TIGCC la suppporte cette instrcution.
Ces instructions ne sont pas du tout pareilles. movem permet de copier plusieurs registres vers/à partir de la mémoire alors que move copie de registre/mémoire vers registre/mémoire. Si tu regardes le listing asm produit par gcc pour certaines fonctions, tu verras qu'il utilise movem pour sauvegarder/restaurer les registres qu'il utilise wink
avatar
Le scénario de notre univers a été rédigée par un bataillon de singes savants. Tout s'explique enfin.
T'as un problème ? Tu veux un bonbon ?
[CrystalMPQ] C# MPQ Library/Tools - [CrystalBoy] C# GB Emulator - [Monoxide] C# OSX library - M68k Opcodes

5

Ah bon. Bah je ne savais pas.

Par contre je ne comprend pas pourquoi TIGCC sort des clr.l (%a0)+ lorsque l'on attribut la valeur 0. Avec 1, ça à l'air d'être mieux optimiser par exemple.
J'ai fais un test et c'est vrai en plus ! grin
Kevin, ton optimisation de taille elle est pas génial ! grin En -O3, ça devrait être "débridé".
Voilà avec 5 au lieu de 0 :

moveq.l #5,%d2
move.l %d2,(%a0)+
#L2790
move.l %d2,(%a0)+
#L2796
move.l %d2,(%a0)+
#L2802
move.l %d2,(%a0)+
#L2808
move.l %d2,(%a0)+
#L2814
move.l %d2,(%a0)+
#L2820
move.l %d2,(%a0)+
#L2826
move.l %d2,(%a0)+
#L2832
move.l %d2,(%a0)+
#L2838
move.l %d2,(%a0)+
....
www.wikio.fr/user1921&info=comments

6

C'est dur à implémenter ce genre d'optimisation ?

Le problème c'est que c'est une optimisation qui est délicate puisque dans certains cas elle est assez efficace, par exemple dans ton cas (mais ça reste toujours une perte de taille pour un gain de vitesse), mais dans d'autres elles ne l'est pas. De toutes façons, ce genre d'optimisations augmente le temps de compilation.
Et GTC le fais ?

Pas la version on-calc, et la version PC le fera certainement avec le nouveau générateur de code que je suis en train d'écrire (pour mon école smile je fais d'une pierre deux coups).
Par contre je ne comprend pas pourquoi TIGCC sort des clr.l (%a0)+ lorsque l'on attribut la valeur 0. Avec 1, ça à l'air d'être mieux optimiser par exemple. J'ai fais un test et c'est vrai en plus !

Oui, c'est normal (enfin, presque wink). Ce n'est pas si évident que ça à implémenter, et on est plus ou moins obligé de générer les deux codes et voir ce qu'il y a de mieux (je ne suis pas sûr qu'il y ait d'heuristique très efficace pour ça). Mais dans ton cas, le compilo ne se rendra compte que c'est très rentable qu'en testant cette méthode sur tout ton bloc, ce qui peut être assez gourmand en temps de compil.

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

7

Pas la version on-calc, et la version PC le fera certainement avec le nouveau générateur de code que je suis en train d'écrire (pour mon école je fais d'une pierre deux coups).

Ah comme ça tu aura du temps pour bosser sur ton compilateur ? smile Tiens c'est pas mal ça ! smile T'as trouvé le bon truc là ! grin

Mais dans ton cas, le compilo ne se rendra compte que c'est très rentable qu'en testant cette méthode sur tout ton bloc, ce qui peut être assez gourmand en temps de compil.


Bah ouais mais pourquoi ce n'est pas pareil pour 0 ? La valeur 0 n'est pas traité ici comme une autre valeur parce-qu'il y a l'instruction clr.l qui permet de gagner de la place plutôt, non ?
Il n'y a pas une option de compilation qui permet de modifier ça.
www.wikio.fr/user1921&info=comments

8

Ca y est j'ai trouvé l'astuce ! grin :
void clr()
{
short i=0;
register unsigned long int *screen_long asm("a0") = (long *)LCD_MEM;

register long zero asm("%d1");
zero =0;
while(i<750)
{
*screen_long++=zero;
*screen_long++=zero;
*screen_long++=zero;
*screen_long++=zero;
*screen_long++=zero;
*screen_long++=zero;
*screen_long++=zero;
*screen_long++=zero;
i=i+8;

}
}
Là au moins le compilateur n'a plus le choix.
www.wikio.fr/user1921&info=comments

9

Ah comme ça tu aura du temps pour bosser sur ton compilateur ? smile Tiens c'est pas mal ça ! smile T'as trouvé le bon truc là ! grin

Ouais gni On a un projet de compilo, et en principe on est censé faire un compilo d'un sous-ensemble de CAML en CAML, mais c'est pas obligatoire donc je fais un compilo C en C++ tongue (mais je suis obligé de refaire le parser pour que le code soit entièrement de moi, même si GTC n'utilisera pas ce parser) Par contre ça avancera pas la première beta embarrassed (d'ailleurs, faudrait que je m'y remette sérieusement et que j'installe tout sur mon nouvel ordi...)
Bah ouais mais pourquoi ce n'est pas pareil pour 0 ? La valeur 0 n'est pas traité ici comme une autre valeur parce-qu'il y a l'instruction clr.l qui permet de gagner de la place plutôt, non ?

Oui, donc si le générateur de code utilisait des move #0 au lieu de clr, le code serait moins bon (cf TIFS qui n'utilise pas clr gol). Une autre solution serait de rajouter une passe après avoir alloué les move #0 pour voir si c'est rentable de garder move #0 ou s'il faut passer aux clr, mais ça peut nécessiter une passe supplémentaire d'allocation de registre...

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

10

OK, alors étant donné que c'est un bug-fix spécifique à TI-GCC, je te conseille vivement de faire :
#ifdef __GNUC__
#define asm_tigcc_fix(reg) asm(reg)
#else
#define asm_tigcc_fix(reg)
#endif

et de remplacer tes asm(...) par des asm_tigcc_fix(...) puisqu'ils ne sont pas nécessaires pour que le code compile correctement.

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

11

Raphaël :
Kevin, ton optimisation de taille elle est pas génial ! grin En -O3, ça devrait être "débridé".

Ce n'est pas notre patch qui fait ça. C'est dans le code FSF.
Pollux
: OK, alors étant donné que c'est un bug-fix

Je l'appellerais plutôt un workaround pour une limitation. Ce n'est pas vraiment un bogue.
spécifique à TI-GCC, je te conseille vivement de faire :
#ifdef __GNUC__
#define asm_tigcc_fix(reg) asm(reg)
#else
#define asm_tigcc_fix(reg)
#endif
et de remplacer tes asm(...) par des asm_tigcc_fix(...) puisqu'ils ne sont pas nécessaires pour que le code compile correctement.

Franchement:
#ifndef __GNUC__
#error Your compiler is not supported. Use GCC.
#endif

me paraît plus approprié.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

12

"Plus" ? on peut savoir pourquoi ?
Ca me paraît moins approprié : la compilation échoue avec ton truc !
avatar
Un site complet sur lequel vous trouverez des programmes et des jeux pour votre calculatrice TI 89 / Titanium / 92+ / Voyage 200 : www.ti-fr.com.
Quelques idées personnelles ici.

13

Pas si on utilise le compilateur pour lequel le programme est prévu. roll
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

14

Et pourquoi il te paraît "plus approprié" de limiter les programmes à TIGCC? roll

« The biggest civil liberty of all is not to be killed by a terrorist. » (Geoff Hoon, ministre des transports anglais)

15

Parce qu'il te paraît "plus approprié" à toi de les limiter à ton compilateur à toi. roll Sinon, tu n'aurais pas rajouté des extensions incompatibles, ni changé la syntaxe de l'assembleur inline.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

16

de vrais gamins... pas de débat tigcc vs gtc ici merci
avatar
Que cache le pays des Dieux ? - Forum Ghibli - Forum Littéraire

La fin d'un monde souillé est venue. L'oiseau blanc plane dans le ciel annonçant le début d'une longue ère de purification. Détachons-nous à jamais de notre vie dans ce monde de souffrance. Ô toi l'oiseau blanc, l'être vêtu de bleu, guide nous vers ce monde de pureté. - Sutra originel dork.