Logicielsmoto.com

Nous sommes le 14 Déc 2019, 01:51

Heures au format UTC + 1 heure




Poster un nouveau sujet Répondre au sujet  [ 104 messages ]  Aller à la page Précédente  1, 2, 3, 4, 5, 6, 7  Suivante
Auteur Message
 Sujet du message:
MessagePosté: 29 Aoû 2006, 09:02 
Hors ligne

Inscription: 06 Juin 2004, 08:23
Messages: 443
Tomix3 a écrit:
Dans les modes d'adressages indexes, il y a aussi des modes non documentes. Je posterai la liste ce soir car je n'ai pas au taf la liste de ces modes.


Ca m'interresse ca. Y'a-t-il des modes d'adressage existant mais non documente pour certaines instructions, ou carement de nouveaux mode d'adressages ? T'as des infos (genre explication rapide) a partager avant ce soir ?


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 10:08 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1115
Localisation: Brest
Prehisto a écrit:
J'avoue moi-même rester interdit devant tant de rapidité à répondre à une question qui aurait mis beaucoup d'entre nous à l'étude pendant une semaine.


;) ouais.. mais en fait il se trouve que j'en ai besoin.. je suis en train d'essayer de porter l'algo basic des montagnes fractales en asm. Pour cela je commence par le faire en C pour trouver et debugger les algos et apres je reencode a la main en asm (j'ai defini un algo de trace de triangle rapide et la je regarde les fixed point pur savoir si un format 8.8 est suffisant).

Le C c'est pas mal en 1ere approximation pour se faire une idee d'un algo. A la louche c'est seulement E a 3 fois plus lent qu'a la main mais c'est bcp plus aise a manipuler.

En regardant le code C de crt0.o je m'appecrois qu'il y a une bonne optimisation pour calculer un pseudo "negd". Normalement on fait plutot:
Code:
coma
comb
addd #1
Or la crtO.o c'est bcp mieux:
Code:
nega
negb
sbca #0
et hop 2 octets et 2 (ou 3) cycles de gagnes! Chapeau.. j'ai toujours procede avec le "addd #1" mais le coup du sbca c'est bien vu!


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 10:27 
Hors ligne

Inscription: 13 Juin 2005, 21:50
Messages: 205
Localisation: Planete Zorg (31)
Samuel Devulder a écrit:
je m'appecrois qu'il y a une bonne optimisation pour calculer un pseudo "negd". Normalement on fait plutot:
Code:
coma
comb
addd #1
Or la crtO.o c'est bcp mieux:
Code:
nega
negb
sbca #0
et hop 2 octets et 2 (ou 3) cycles de gagnes! Chapeau.. j'ai toujours procede avec le "addd #1" mais le coup du sbca c'est bien vu!

Code:
COMA
NEGB

Hop! deux octets de plus et je ne parle pas des cycles cpu :sol: (sauf si B pointe sur #0 ;) )

Par contre, je ne connais pas l'instruction SBCx :oops: Cela prend en compte la retenue non?!

Au même titre que SUBX.B sur 68K si je ne m'abuse. :roll:


Dernière édition par jasz le 29 Aoû 2006, 10:51, édité 1 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 10:47 
Hors ligne

Inscription: 27 Avr 2006, 09:04
Messages: 101
@Yoann
Dans l'adressage indexe, je crois me souvenir qu'il y a des redondances.
Sinon, il y a effectivement 2 ou 3 modes en plus, sans aucun interet. Il y a aussi un mode d'adressage indexe equivalent au mode etendu. Enfin bon j'ai pas le detail la :)

Sinon, je suis entrain de me souvenir que pour le TFR et le EXG, il y a aussi des combinaisons non documentees a implementer.
J'ai fait tout ca dans mon emulateur mais je prefere garder mes sources. En revanche, ca ne me gene pas de partager l'information.
Je ferai un check up des sources pour voir toutes les bizarreries du 6809.

a+
Seg.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 11:01 
Hors ligne

Inscription: 13 Juin 2005, 21:50
Messages: 205
Localisation: Planete Zorg (31)
Tomix3 a écrit:
(...) mais je prefere garder mes sources.

Pourquoi? Tu as peur que l'Atariste que je suis s'en serve à mauvais escient :D


Dernière édition par jasz le 29 Aoû 2006, 11:06, édité 1 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 11:05 
Hors ligne

Inscription: 27 Avr 2006, 09:04
Messages: 101
@jasz
Mais non :) C'est juste que je prefere garder mon travail tant que le projet n'est pas fini. D'ailleurs, mon emulateur est au point mort depuis 2003, mais il est fonctionnel et il gobe des disquettes thomson sans soucis.
Je compte m'y remettre. Il n'a jamais ete mis au placard.

a+
Seg.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 11:15 
Hors ligne

Inscription: 13 Juin 2005, 21:50
Messages: 205
Localisation: Planete Zorg (31)
Bon, :) Si tu as besoin d'un coup de main, n'hésite pas alors. Ce sera une allience historique. ;)


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 12:21 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1115
Localisation: Brest
jasz a écrit:
Code:
COMA
NEGB

Hop! deux octets de plus et je ne parle pas des cycles cpu :sol: (sauf si B pointe sur #0 ;) )


en effet ce qui limite bcp son interet pratique :)

Citation:
Par contre, je ne connais pas l'instruction SBCx :oops: Cela prend en compte la retenue non?!

Au même titre que SUBX.B sur 68K si je ne m'abuse. :roll:


exact.. Il y a aussi adca et adcb.. addition avec carry.

Sur 68k le subx est pas mal utilise pour les optims bas niveau. Ca permet d'avoir facilement un registre avec -1 si c==1: subx.l d0,d0 ==> d0 contient 0 si c=0 ou 0xFFFFFFFF si c=1. En quelque sorte on a recopie la carry a tout le registre d0.

Su 6809e je me demande comment faire ca bien car on ne peut faire un sbc que par rapport a une constante. Il faudrait donc clearer le registre avant:
Code:
  .. instr positionnant C..
  clrb
  sbcb #0

Sauf que clrb force c=0. Bon evidemment si on peut le mettre avant l'isntruction positionnant C, c'est parfait.. mais sinon je vois pas trop sauf a faire des trucs pas super efficaces:
Code:
  .. instru positionnant la carry..
  rorb
  asrb \
  asrb  \ 7 fois
  ..    /
  asrb /

Pour du 16bits on peut par contre faire:
Code:
  rorb               
  sex
  tfr a,b


Dernière édition par Samuel Devulder le 29 Aoû 2006, 23:55, édité 1 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 12:42 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1115
Localisation: Brest
Code:
****** Division 8 bits ******
****** A:Divid B:Divis ******
DIVIS8  PSHS    B,X
            CLRB
            LDX     #8
DIVI81  ROLA
            ROLB
            SUBB    ,S
            BCC     DIVI82
            ADDB    ,S
DIVI82  LEAX    -1,X
            BNE     DIVI81
            ROLA
            COMA
            LEAS    1,S
            PULS    X,PC
****** Res:A    Rest:B ******

Oh que c'est beau... sisi.. pas une instruction de trop, meme les copies sur la pile sont utilisees. Mince si ca se trouve le code du sqrt() est pas le plus court.. J'suis jaloux ;). Ce genre de routines se trouve comment ? A partir d'un algo deja pas mal rapide et en reorganisant les instructions pour virer les trucs redondants ou pour utiliser a mieux les resultats partiels ? Il y a une bibliotheque de code arihmetiques optimisee pour 6809e quelque part ?

sam (oui je sais c'est pas desinterresse)


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 13:19 
Hors ligne

Inscription: 27 Avr 2006, 09:04
Messages: 101
@Sam
Je ne connais pas de bibliotheque arithmetique mais si tu veux commencer a collecter les routines dispersees sur le forum, ca peut faire un truc interessant.
De plus, en rendant public les sources, ca peut amener certains a trouver des optimisations que l'on n'aurait pas pense.

Pour la routine de racine carree, on va laisser tomber la version 8 bits qui n'a pas d'interet vu qu'une table de 256 valeurs fait l'affaire. On va plutot se concentrer sur la racine carree d'un nombre 16 bits.
J'en avais fait une qui me semble plus courte que la tienne (en ne deroulant pas la boucle) mais je la trouve pas tres optimisee aujourd'hui. Faut dire que elle aussi date d'il y a 15 ans (j'en connais un qui va encore en prendre un coup ;)). Donc, je peux la poster et on peut l'ameliorer ensemble... ou bien tu m'en proposes une autres plus courte :)

a+
Seg.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 13:26 
Hors ligne

Inscription: 27 Avr 2006, 09:04
Messages: 101
@Sam
Pour l'algo de div 8 bits, je suis parti de la methode de division en base 10 que j'ai applique au binaire. Evidemment, en binaire c'est beaucoup plus simple.
Apres, pour le code 6809, tu ponds une premiere version, puis tu optimises pour arriver au final a un code qui coule bien... enfin, du mieux que tu peux... en optimisant au max l'utilisation des registres.
J'ai aussi une routine de division 16 bits dans mes vieilles disquettes...

a+
Seg.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 17:41 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1115
Localisation: Brest
Tomix3 a écrit:
J'en avais fait une qui me semble plus courte que la tienne (en ne deroulant pas la boucle) mais je la trouve pas tres optimisee aujourd'hui.


Je suis tombe sur un algo en C tres interressant sur http://www.embedded.com/98/9802fe2.htm (ou ftp://ftp.embedded.com/pub/1998/cren98_2.txt):
Code:
uint16 sqrt(uint32 a) {
   uint16 rem = 0, root = 0;
   int i;
   for(i=16+1; --i;) {
      root <<= 1;
      rem = (rem << 2) + (a >> 30);
      a <<= 2;
      ++root;
      if(root<=rem) {
         rem -=root;
         ++root;
      } else --root;
   }
   return root>>1;
}


Ca doit se coder super efficacement en asm quand on voit que le a>>30 recupere les 2 bits du a<<=2 pour les inserer dans la partie basse de rem. Idem le root <<= 1 ... ++root c'est un ror avec la carry positionee a . Donc si pour du 16 bits on choisi de mettre rem dans regB, root dans regA, la valeur a sur la pile on a un code qui ressemble a:
Code:
lsl 1,s
rol ,s
rora
lsl 1,s
lsl ,s
rora
orcc #code_qui_met_bitc_a_1
rorb
La apres, on colle i dans le registre X, et voila l'algo est quasiment code. Il a plein de bonne propriete cet algo pour le 6809 finalement.
(il faut faire gaffe car root deborde d'1 bit le resultat donc il faudrait 9 bits.. le bit C peut peut-etre servir de 9eme bit si on choisi les instructions ne perturbant pas C.

C'est vrai que ca serait cool (enfin pour moi au moins) de creer un sujet sur les algos "arithmetiques" ou les algos "complexes" optimises pour 6809e.. Certes on gagne des cycles comme dans le sujet courant, sauf que la c'est au niveau de l'algo plus qu'au niveau des instructions elementaires... encore que.. l'optim d'instructions elementaire a un role non negligeable aussi.

Il y a l'air d'avoir des trucs interressants ici: http://www.embedded.com/code/master.htm

sam.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 17:50 
Hors ligne

Inscription: 27 Avr 2006, 09:04
Messages: 101
@Sam
Bien vu sam. C'est l'algo que j'utilise si ma memoire est bonne. Reste a voir l'implementation que tu en fais. Mon implementation n'est pas tip top mais si on peut en faire une qui depote, ca sera toujours ca de gagne.

a+
Seg.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 21:59 
Hors ligne

Inscription: 27 Avr 2006, 09:04
Messages: 101
Donc voici les modes indexes non documentes (codage binaire):
Citation:
%1RR10000 ~ [,R+] (5 cycles)
%1RR10010 ~ [,-R] (5 cycles)
%1RR00111 ~ A,R (1 cycle)
%1RR10111 ~ [A,R] (4 cycles)
%1RR01010 ~ (1,PC)|$00FF (4 cycles)
%1RR11010 ~ [(1,PC)|$00FF] (7 cycles)
%1RR01111 ~ n16 (~ mode étendu) (2 cycles)
%1RR01110 ~ $FFFF (5 cycles)
%1RR11110 ~ [$FFFF] (8 cycles)

Pour les instructions TFR et EXG maintenant:
On peut transferer un registre 8 bits dans un registre 16 bits. Ca se transforme en $ff00+Registre 8 bits.
Pour le registre CC, il se retrouve en poids fort et en poids faible quand on le transfert dans un registre 16 bits. Enfin c'est ce que dit mon code :) J'ai fait ca il y a longtemps alors je me rappelle plus des tests que j'avais effectue.
Idem pour le registre DP
Pour les transferts 16 bits vers 8 bits, seuls les poids faibles sont gardes.
Maintenant, si on specifie un registre qui n'existe pas en source, on retrouve un $FF ou un $FFFF (suivant la taille du registre) en destination.

Sinon je reviens sur les instructions non documentees "speciales" que j'avais range dans la categorie "exception", pour specifier l'increment PC constate apres execution de l'instruction:
Citation:
- 14 (1 cycle): PC mort
- 15 (1 cycle): PC mort
- 18 (3 cycles): PC=PC+1
- 1B (2 cycles): PC=PC+1
- 38 (4 cycles): PC=PC+2
- 87 (2 cycles): PC=PC+2
- 8F (3 cycles): PC=PC+3
- C7 (2 cycles): PC=PC+2
- CD (1 cycle): PC mort
- CF (1 cycle): PC mort

a+
Seg.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: 29 Aoû 2006, 22:24 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1115
Localisation: Brest
Tomix3 a écrit:
J'ai aussi une routine de division 16 bits dans mes vieilles disquettes...


j'suis preneur!

:)


Haut
 Profil  
Répondre en citant le message  
Afficher les messages postés depuis:  Trier par  
Poster un nouveau sujet Répondre au sujet  [ 104 messages ]  Aller à la page Précédente  1, 2, 3, 4, 5, 6, 7  Suivante

Heures au format UTC + 1 heure


Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 5 invités


Vous ne pouvez pas poster de nouveaux sujets
Vous ne pouvez pas répondre aux sujets
Vous ne pouvez pas éditer vos messages
Vous ne pouvez pas supprimer vos messages
Vous ne pouvez pas joindre des fichiers

Rechercher:
Aller à:  
cron
Développé par phpBB® Forum Software © phpBB Group
Traduction par phpBB-fr.com