la boucle magique - Page 1

C-1.A RTNC
P=C.0 CSR.A C-1.A SKC
{ A=DAT1.W D1+16 DAT0=A.W D0+16
C-1.B UPNC C-1.XS UPNC C+1.X C-1.A UPNC }
A=DAT1.WP DAT0=A.WP
CD0EX C+P+1 CD0EX CD1EX C+P+1 CD1EX
P=0 RTN
[edit]Edité par Quenalma le 02-11-2001 à 12:17:04[/edit]

J'comprend pa

blblblblblblblblblblblblblblblblblblblblblblblblblbllblblblblblblblblblblblblbllblblblblblblblbllblblblblblblblblblblblblbllb

Ca ressemble au saturn...

Je pense bien que c'est du Saturn. Donc si quelqu'un qui connaît le Saturn pourrait nous traduire cela...

c du saturn , c le gars qui a la hp49G

mais, on a beau pas connaitre le language, c pas clair du tout !

pas clair...
Je comprends que sur saturn il y ait eu beaucoup de daubes...

Sur le saturn il y a surment moind de merde que sur la ti.. mais bon certain newbees qui ne savent ni programmer en asm sur ti ni sur hp trouverons certainement des faux argument pour defendre les phrases completement debiles de ben...

moi j connais..., mais je sais pas travailler avec P, ni avec SKC (que'ce?) ni avec les boucles { ... }

A et C sont des variable (d0,d1 sur 64bits)
D0 et D1 sont des pointeurs (a0,a1, avec accès sur 64 bits)
P: en général utilisé comme compteur mais peux permettre de faire des opérations élémentaires à partir du Pième quartet (ou Pième bit, je sais plus, mais je crois que 0<=P<=15 donc plutot quartet)

A, W, B, XS, X (, WP?) sont les équivalents des .b, .w et .l
RTN = RTS
RTNC = bcs exit (ou bcc, je sais plus)

alors maintenant démerdez vous à comprendre ce codes avec ces notions...

Et les + et -, c'est comme les += ou -= en C (les add et sub dans la plupart des langages assembleur)?

Ouais je crois, mais à mon époque on écrivait C = C - 1, donc il y avait une redondance, mais les compiilateurs créés sur HP permettent beaucoup plus de souplesse

si tu pouvais expliquer :
1) csr
2) skc
3) les { ... }
4) upnc/unpc

apparemment, le {...}, c pour les boucles...

CSR : "C Shift Right" decalage de C d'un quartet a droite (division par 16)

{ ... } c'est une structure. A la compilation ca ne genere aucun code.

SKC : "SKip if Carry" saute la struct apres si carry est arme. C'est un GOC en fait mais la structure evite de mettre un label

UPNC : "UP if Not Carry"
UPC : "UP if Carry" : remonte en haut de la structure si carry est arme/desarme. Pareil : c'est compile en un GOC/GONC mais pas besoin d'un label, le compilo gere tout ca.

dc ça permet de faire des boucles en clair?

Bon, voilà ce que ça donne en pseudo-C. Ne reste plus qu'à savoir les valeurs des extensions, le sens de CD?EX et ce que donne C+P+1 en vrai C. (Je suppose que UNPC devrait être UPNC...) Je n'ai toujours pas compris ce que fait cette boucle.

if (!(C.A--)) return;
P=C.0;
C.A >> 4;
while (C.A--)
{
A=DAT1.W;
D1+=16;
DAT0=A.W;
D0+=16;
if(C.B--) continue;
if(C.XS--) continue;
C.X++;
}
A=DAT1.WP;
DAT0=A.WP;
CD0EX;
++(C+P);
CD0EX;
CD1EX;
++(C+P);
P=0;
return;

CD?EX exhange la variable C avec l'adresse du pointeur D?, mais c'était évident...

Avec les GOC et les GONC, je me situe déjà mieux...
Les extensions sont assez compliquée en Saturn...
A équivant aux 5 premiers quartets: ca définit une adresse dans la mémoire (il faut 3 quartets de plus pour la TI)
X correspond aux trois premiers quartets. En général, on utilise X pour les boucles
W, si je m'abuse, donne les 16 quartes, c'est à dire les 64 bits de la variable.
B c'est 2 quartes, évidement.
XS c'est le 3è quartet
WP, là je sèche...
C+P+1 doit surement modifier C

[edit]Edité par Paxal le 02-11-2001 à 11:23:58[/edit]

Oula, c'est très bizarre comme langage assembleur... Le 68k est beaucoup plus simple à programmer. Et tout ce discours ne nous explique toujours ni ce que fait cette boucle, ni ce qu'elle vient faire dans ce forum. À part nous montrer à tous comme le Saturn est compliqué...
[edit]Edité par Kevin Kofler le 02-11-2001 à 01:39:56[/edit]

La complexité du Saturn lui permet des algorithmes d'autant plus bizarres qu'ils sont rapides!!!

Ca s'appelle memcpy

En pseudo-C, si on considère que les int font 5 bits :

[i]	long long *d0,*d1;
	int c; quartet p;

	if (!c--) return;	// rien à copier
	p=c&15;		// reste
	c>>=4;		// dividende
	if (c--) do {	// boucle principale
		*d0++=*d1++;	// on copie...
		if (((unsigned char)c)--) continue;	// plus rapide qu'avec int :)
		if (xs--) continue;	// partie haute...
		x++;
	} while (c--);	// suite de la partie basse
	*(quartet[p+1])d0++=*(quartet[p+1])d1++;	// on copie le reste
	p=0; return;	// et on nettoie P
[/i]

[edit]Edité par Pollux le 02-11-2001 à 15:37:35[/edit]

Bravo

Quoi? Tout ça pour un memcpy???

Comparez à cela:

 subq.w #1,d0
boucle: move.b (a0)+,(a1)+
 dbra.w d0,boucle

...

c un memcpy optimisé... (cf memcpy de TI, c bcp plus compliqué que ce que tu as écrit)

on pourrait aussi bien faire :

C-1.A
RTNC
P=0
{
 A=DAT1.P
 DAT0=A.P
 D0+1
 D1+1
 C-1.A
 UPNC
}
RTNC

mais c pas optimisé

on peut raccourcir:

{
C-1.A
RTNC
A=DAT1.P DAT0=A.P
D0+1 D1+1
UP
}

On en apprend un peu plus chaque jour sur ce forum

Même raccourci, le code Saturn est plus long que le code 68k.

subq.w #1,d0
boucle: move.b (a0)+,(a1)+
dbra.w d0,boucle

=> 49 caracteres

{ C-1.A RTNC
A=DAT1.P DAT0=A.P
D0+1 D1+1 UP }

=> 37 caracteres

49 caractères, ca me parait énorme...
sub -> 4 quartets
move -> 4 quartets
bra -> 2 + 2/4/6 quartets

soit en tout au maximum 16 quartes, donc 8 caractères...

caracteres de source...
mais j'avoue que le saturn est tout pourri. mais il est rigolo a programmer!