1

Quelqu'un aurai une routine ultra rapide d'affichage de pixel en ASM? (si ce sujet n'a pas déjà etait traité...)

2

ben non, ce sujet est déjà traîté tongue
In many respects the Yoshi is like a beautiful woman. A man can come so enamoured that he bestows on her all his time, his energy and his fortune.
- Fred whipple, 1960

*** Ne sous-estimez pas la puissance de la Marmotte ***
© Marmotte Team : LaMarmotte, sBibi, Vark & Sabrina

3

mais je retrouve plus le topic sad
il est quelque part dans cette section du forum...
In many respects the Yoshi is like a beautiful woman. A man can come so enamoured that he bestows on her all his time, his energy and his fortune.
- Fred whipple, 1960

*** Ne sous-estimez pas la puissance de la Marmotte ***
© Marmotte Team : LaMarmotte, sBibi, Vark & Sabrina

4

Désolé mais je n'ai pas trouver le fameux topic alors si qqn pouvait me donner une reponse (ou le topic wink)

5

Dans un topic du mois de mai dans /asm, il y avait (désolé, le copier/coller a tué les tabulations):
PutPixel_DePollux:
move.w          d0,-(a7)           ; 8          Sauvegarde des registres. Avec leur
move.w          d1,-(a7)           ; 8          petit nombre, et leur différence de
pea             (a0)               ; 12         taille, il est plus rapide de le faire 1 par 1
add.w           d1,d1              ; 4
move.w          d1,a0              ; 4          a0 = d1
lsl.w           #4,d1              ; 6+2*4=14   d1 = 32*d1
sub.w           a0,d1              ; 4          d1 = 30*le numéro de ligne
move.w          d1,a0              ; 4          a0 pointe sur cette ligne
lea             $4C00(a0),a0       ; 8          d1 = ligne en VM du pixel
move.w          d0,d1              ; 4          d0 = d1
lsr.w           #3,d0              ; 6+2*3=12   d0 = numéro de l'octet contenant le pixel
not.b           d1                 ; 4          équivalent à eor.b #7,d1, bref on soustrait 7 à d1
bset.b          d1,0(a0,d0.w)      ; 10+8=18   
move.l          (a7)+,a0           ; 12         Restaurations
move.w          (a7)+,d1           ; 8
move.w          (a7)+,d0           ; 8
rts                                ; 16         148 cycles au total. Par Pollux le 30/04/2001
PutPixel_DePpHd:
move.w        d0,-(a7)
move.w        d1,-(a7)
move.l        a0,-(a7)
add.w         d1,d1
movea.w       Screen(Pc,d1.w),a0
move.w        d0,d1
lsr.w         #3,d1
not.w         d0
bset.b        d0,0(a0,d1.w)
move.l        (a7)+,a0
move.w        (a7)+,d1
move.w        (a7)+,d0
rts
Screen:
dc.w           $4C00+0*30
dc.w           $4C00+1*30
dc.w           $4C00+2*30
dc.w           $4C00+3*30
dc.w           $4C00+4*30
dc.w           $4C00+5*30
...

[edit]Edité par ExtendeD le 21-10-2001 à 21:13:48[/edit]

6

merci smile

7

Heu, move.l a0,-(a7) ===> pea (a0) comme Pollux.

8

Extended : Tu as censuré une information dans ton copier-coller... La routine "de Pollux" est en fait co-écrite par lui et moi. Il a optimisé à fond une de mes routines.
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.

9

Ben moi aussi je me suis inspire de celle de Pollux smile

10

C'est vrai, on t'avait sollicité pour participer au concours wink
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.

11

Thibaut : ah oui excuse moi, g oublié de préciser grin

12

héhé, oubli ? grin

13

pour plus de rapidité, virer la sauvegarde des registres, car souvent on en a plus besoin après
:D

14

oui oui, bien sûr, mais là les sources proviennent d'un défi, et la sauvegarde des registres était dans les règles, pour le comptage du nombre de cycles.

15

bieeeen wink
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.

16

Question: le concour continue, on a le droit de proposer ses routines?
Si oui ca m'interesserai un ptit peut quand memewink
XLib v1.00 Powerrrrrrrrrrrrrrrrrrrr!

17

Aucun problème JS, donnes smile

Mais je me demande comment tu as pu faire plus rapide que PpHd ?
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.

18

Bein pour cela faut me donner qqs info:
Quels registres utiliser on les choisit?
Quels sont les paramettres d'entrée?
Quels sont les restrictions (vs etc... pc...)?

Au fait pour la maniere de verifier la rapidite d'une routine, il faut faire un bench, car rien que entre ces 2 routines cidessus, il y a deja 4 shifts de differences...
XLib v1.00 Powerrrrrrrrrrrrrrrrrrrr!

19

d0.w : X
d1.w : Y

Les registres doivent êtres inchangés au retour.

Restriction : aucune si je me souvient bien.
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.

20

bon voila une routine plus rapide que celle de pphd... mais bon ca reprend le meme principe...
PutPixel_DeTiMad:
  move.w  #1,%d0
  move.w  #1,%d1
  move.w  %d1,-(%a7)
  move.l   %a0,-(%a7)
  add.w     %d1,%d1
  movea.w Screen(%pc,%d1.w),%a0
  move.w   %d0,%d1
  lsr.w        #3,%d1
  add.w	%d1,%a0
  move.w	%d0,%d1
  not.w       %d1
  bset.b      %d1,(%a0)
  move.l     (%a7)+,%a0
  move.w    (%a7)+,%d1
  rts

PutPixel_DePpHd:
	move.w				#3,%d0
	move.w				#3,%d1
  move.w        %d0,-(%a7)
  move.w        %d1,-(%a7)
  move.l        %a0,-(%a7)
  add.w         %d1,%d1
  movea.w       Screen(%pc,%d1.w),%a0
  move.w        %d0,%d1
  lsr.w         #3,%d1
  not.w         %d0
  bset.b        %d0,0(%a0,%d1.w)
  move.l        (%a7)+,%a0
  move.w        (%a7)+,%d1
  move.w        (%a7)+,%d0
  rts



PutPixel_DePollux:
	move.w					#2,%d0							 /* x.w */
	move.w					#2,%d1							 /* y.w */
  move.w          %d0,-(%a7)           /*; 8          Sauvegarde des registres. Avec leur */
  move.w          %d1,-(%a7)           /*; 8          petit nombre, et leur différence de */
  pea             (%a0)                /*; 12         taille, il est plus rapide de le faire 1 par 1 */
  add.w           %d1,%d1              /*; 4 																												*/
  move.w          %d1,%a0              /*; 4          a0 = d1 */
  lsl.w           #4,%d1               /*; 6+2*4=14   d1 = 32*d1 */
  sub.w           %a0,%d1              /*; 4          d1 = 30*le numéro de ligne */
  move.w          %d1,%a0              /*; 4          a0 pointe sur cette ligne */
  lea             0x4c00(%a0),%a0     /*; 8          d1 = ligne en VM du pixel */
  move.w          %d0,%d1              /*; 4          d0 = d1 */
  lsr.w           #3,%d0               /*; 6+2*3=12   d0 = numéro de l'octet contenant le pixel */
  not.b           %d1                  /*; 4          équivalent à eor.b #7,d1, bref on soustrait 7 à d1 */
  bset.b          %d1,0(%a0,%d0.w)     /*; 10+8=18  																								 */
  move.l          (%a7)+,%a0           /*; 12         Restaurations */
  move.w          (%a7)+,%d1           /*; 8 */
  move.w          (%a7)+,%d0           /*; 8 */
  rts                    


resultat bench:
1: TiMad: 28622 c/S
2: PpHd: 26206 c/S
3: Pollux: 24702 c/S

NB: la routine que je propose n'est qu'une routine de pphd optimiseewink donc c'est un peut de la gruge mais bon l'idee est de faire du precalcule... ce qui n'est pas qqc de tres complique a pensewink
[edit]Edité par TiMad le 29-10-2001 à 23:55:56[/edit]
XLib v1.00 Powerrrrrrrrrrrrrrrrrrrr!

21

Bouuh tu peux mettre entre pre stp ?
Sinon bravo smilesmile

Qu'en dit PpHd ?
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.

22

on peut faire encore plus rapide et atteindre les 30000 c/S ... mais apres on rentre dans un contexte de librairie graphique du meme genre que genlib...
c'ad une fonction qui initialise les plan et qui evite de repointer a chaque fois sur un plan undef... puis on peut encore plus pouse le precalculer...
XLib v1.00 Powerrrrrrrrrrrrrrrrrrrr!

23

Tu écrases d0 et d1 !
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.

24

Non justement si tu regarde bien je n'utilise que 2 registres en ecriture et 3 en lecture...
a0 et d1 en ecriture/lecture et d0 en lecture seulement.. conclusion ,ca suprime:
move.w %d1,-(%a7) (8 cycles environs)
move.w (%a7)+,%d1 (idem)

et ils sont remplacer par:
move.w %d0,%d1 (4 cycles environs) *2
donc le gain est de: 2*8-2*4= 8 cycles environs

mais on peut toujours faire mieux...
XLib v1.00 Powerrrrrrrrrrrrrrrrrrrr!

25

ove.w #1,%d0 move.w #1,%d1 Attend, au point d'entrée je vois : m
confus
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.

26

bein oui ce sont les coordonnées du points... qui ecrases les registre... tout comme dans la routine de pollux et pphd..
quand tu fais:
move.w #1,d0
move.w #1,d1
bsr BlackPxl

tu ecrases bien les registres d0 et d1.. mais c'est pas la fonction elle meme qui les ecrase car avant et apres l'appele de la fonctions, tous les registres ont garder le meme etat...
XLib v1.00 Powerrrrrrrrrrrrrrrrrrrr!

27

Encore plus rapide (inspiré fortement de PpHd wink) :

PutPixel_DePollux2:
  move.w	#3,%d0
  move.w	#3,%d1
  move.w        %d1,-(%a7)
  move.l        %a0,-(%a7)
  add.w         %d1,%d1
  movea.w       Screen(%pc,%d1.w),%a0
  move.w        %d0,%d1
  lsr.w         #3,%d1
  not.w         %d0
  bset.b        %d0,0(%a0,%d1.w)
  not.w         %d0
  move.l        (%a7)+,%a0
  move.w        (%a7)+,%d1
  rts


Ca m'étonnerait qu'on puisse aller plus vite...

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

28

erf surment que si.. il suffit de cherche un peutwink
XLib v1.00 Powerrrrrrrrrrrrrrrrrrrr!

29

Resultat dernier bench:
pollux2: 28874 c/S
TiMad: 28622 c/S

pollux a pris la tete de la course mais pour combien de tmpswink

Enfin, on peut faire legerement mieux:
PutPixel_pphd_modif_timad_modif_pollux_modif_timad;):
    move.w	#3,%d0   /* on a pas le droit d'optimiser les deux premieres lignes... */
    move.w	#3,%d1
    move.b        %d1,-(%a7)
    pea (%a0)
    add.b         %d1,%d1
    movea.w       Screen(%pc,%d1.w),%a0
    move.b        %d0,%d1
    lsr.w         #3,%d1
    not.w         %d0
    bset.b        %d0,0(%a0,%d1.w)
    not.w         %d0
    move.l        (%a7)+,%a0
    move.w        (%a7)+,%d1
    rts


resultat bench:
28947 c/S
[edit]Edité par TiMad le 31-10-2001 à 15:24:29[/edit]
XLib v1.00 Powerrrrrrrrrrrrrrrrrrrr!

30

tiens, on apprend des choses smile va falloir faire un Replace All dans tous mes progs grin (et corriger GTC au passage smile)

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