Fast pixel routine - Page 1

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

ben non, ce sujet est déjà traîté

mais je retrouve plus le topic
il est quelque part dans cette section du forum...

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

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]

merci

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

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.

Ben moi aussi je me suis inspire de celle de Pollux

C'est vrai, on t'avait sollicité pour participer au concours

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

héhé, oubli ?

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

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.

bieeeen

Question: le concour continue, on a le droit de proposer ses routines?
Si oui ca m'interesserai un ptit peut quand meme

Aucun problème JS, donnes

Mais je me demande comment tu as pu faire plus rapide que PpHd ?

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

d0.w : X
d1.w : Y

Les registres doivent êtres inchangés au retour.

Restriction : aucune si je me souvient bien.

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 optimisee 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 pense
[edit]Edité par TiMad le 29-10-2001 à 23:55:56[/edit]

Bouuh tu peux mettre entre pre stp ?
Sinon bravo

Qu'en dit PpHd ?

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

Tu écrases d0 et d1 !

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

ove.w #1,%d0 move.w #1,%d1 Attend, au point d'entrée je vois : m

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

Encore plus rapide (inspiré fortement de PpHd ) :

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

erf surment que si.. il suffit de cherche un peut

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

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

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]

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