Re: Z80 Vs 6502, FIGHT !

[Invité]

Bah moi elle me suffit pour mon p'tit jeu, elle est simple et assez rapide, je trouve

Oui mais elle ne traite que des box de collisions identiques pour tout les sprites ..
Mais bon effectivement si tu as ce type de cas dans ton jeu, c'est pas un problème, car effectivement c'est rapide .

a titre indicatif, le petit test sur 16 bits prend combien de cycles ??

[vingazole]

Je l'ai simplifiée pour 1 seul objet, en fait j'ai une hitbox "tueuse" et une hitbox "tuable" différente pour chaque ennemi (de façon à ne pas pénaliser le joueur).


Nombre de cycles de la comparaison 16 bits:

ld hl,(joueur_x1_16bits) : 5 cycles, 16 T-states
ld de,(objet_x1_16bits) : 6 cycles, 20 T-states
or a : 1 cycle, 4 T-states
sbc hl,de : 4 cycles, 15 T-states
jr c,tcol2 : 2/3 cycles, 7/12 T-states (selon que la condition est remplie ou pas)

Soit 19 cycles (ou 67 T-states) dans le cas le moins favorable.

[Invité]

C'est quoi des T-states ???

[nemokantio]

Ok pour les cycles.
Après faut voir combien de microsecondes ça prend, selon la fréquence du z80 concerné...
Je dis ça par rapport à la version 6502 que Touko va bientôt nous donner.

[Invité]

Code:


lda <x1 + 1  ;4 cycles partie haute
  cmp <x2 +1  ; 4 cycles
bne .fintest    ; 2/3 cycles

lda <x1    ;4 cycles partie basse
  cmp <x2  ; 4 cycles
bne .fintest  ; 2/3 cycles



Soit 11 cycles dans le meilleurs des cas, pas collision, 20 si collision, et 21 dans le pire si pas collision .

[vingazole]

Extrait de la doc officielle de Zilog :

Execution time (E.T.) for each instruction is given in microseconds for an assumed 4 MHz clock. Total machine cycles (M) are indicated with total clock periods (T States).
Also indicated are the number of T States for each M cycle. For example:

M Cycles: 2 T States: 7(4,3) 4 MHz E.T.: 1.75

indicates that the instruction consists of 2 machine cycles. The first cycle contains 4 clock periods (T States). The second cycle contains 3 clock periods for a total of 7 clock periods or T States. The instruction executes in 1.75 microseconds.

Donc la comparaison sur 16 bits que j'ai donnée prend 67/3,58=~18,715 microsecondes sur un z80 à 3,58 MHz (cas de la Sega Master System).

Ca doit prendre 67/4=16,75 microsecondes sur un Amstrad CPC 464 (à 4 MHz, si j'en crois Wikipédia).


PS: il me semblait plus pertinent de "sortir" dès qu'on est sûr qu'il n'y a pas de collision vu que c'est le cas le plus fréquent...

[Invité]

Ouai c'est aussi pourri que le 68000 quoi

Mais pourquoi parler de cycles, et de T states alors ???

[vingazole]

Ton exemple prend donc dans le pire des cas 21/1=21 microsecondes sur c64 et 21/7,6=~2,763 microsecondes sur PC-Engine, si je ne me trompe pas et que Wikipédia est juste (ça en fait des sources d'erreur potentielles )

[Invité]

Le CPU de la PCe c'est 7,16 pas 7,6 ..

[vingazole]

Ah bravo Wikipédia !
Alors ça fait 21/7,16=~2,933 microsecondes sur PCe, c'te fusée !!!

EDIT: ben non d'après ce que tu écris c'est 22 cycles dans le pire des cas, soit 22/7,16=~3,073 microsecondes (ce qui provoque toujours le même éblouissement, évidemment)

[nemokantio]

Mmm, si un cycle=1 microseconde (cas du 6502 à 1mhz je crois), c'est assez proche, avec un avantage au 6502 pour le meilleur des cas.
Mais c'est bien bne qu'il faudrait utiliser ?
C'est branch non equal ?

Merci à vous deux !
Je vous demande pas de le refaire avec des valeurs signées, vous allez me brûler !

[vingazole]

Je vous demande pas de le refaire avec des valeurs signées, vous allez me brûler !

c'est clair

[vingazole]

Mais c'est bien bne qu'il faudrait utiliser ?
C'est branch non equal ?

Ah non, si j'en crois ça :

BPL (Branch on PLus)
BMI (Branch on MInus)
BVC (Branch on oVerflow Clear)
BVS (Branch on oVerflow Set)
BCC (Branch on Carry Clear)
BCS (Branch on Carry Set)
BNE (Branch on Not Equal)
BEQ (Branch on EQual)

il faudrait plutôt un BPL (ou un BMI) ou un BCC (ou un BCS) !?
Je ne pense pas que ça change grand chose au nombre de cycles par contre...

[65c02]

Une comparaison 16 bits en 6502 qui chercherait à faire un <
donnerait

SEC
LDA joueur_x
SBC objet_x
LDA joueur_x+1
SBC objet_x+1
BCS test_ok ; si joueur_x < objet_x branche sur test_ok

En page zéro : ça fait 14 cycles si le test est faux et 15 cycles si le test est vrai
Et si les variables ne sont pas en page zéro on aurait 17 ou 18 cycles

Mais en lisant le code z80 je n'ai toutefois pas l'impression que ce soit des coordonnées en 16 bits mais plutôt les deux points extrêmes des box de collision en 8 bits

(edit arf, j'arrive après la bataille :) mais bon je laisse ce petit post inutile )

[vingazole]

Oui, ma routine est basée sur des coordonnées 8 bits (écran sms en 256x192 pixels), c'est nemokantio qui voulait une version 16 bits (écran 320x200)

Pour répondre à TOUKO :

Mais pourquoi parler de cycles, et de T states alors ???

encore un extrait de la doc Zilog :

All instructions are series of basic operations. Each of these operations can take from three to six clock periods to complete or they can be lengthened to synchronize the CPU to the speed of external devices. The clock periods are referred to as T (time) cycles and the operations are referred to as M (machine) cycles. Figure 4 illustrates how a typical instruction is series of specific M and T cycles. Notice that this instruction consists of three machine cycles (M1, M2, and M3). The first machine cycle of any instruction is a fetch cycle which is four, five, or six T cycles long (unless lengthened by the WAIT signal, which is described in the next section). The fetch cycle (M1) is used to fetch the opcode of the next instruction to be executed. Subsequent machine cycles move data between the CPU and memory or I/O devices, and they may have anywhere from three to five T cycles (again, they may be lengthened by wait states to synchronize the external devices to the CPU). The following paragraphs describe the timing which occurs within any of the basic machine cycles. During T2 and every subsequent Tw, the CPU samples the WAIT line with the falling edge of Clock. If the WAIT line is active at this time, another WAIT state is entered during the following cycle. Using this technique, the read can be lengthened to match the access time of any type of memory device.

et le petit schéma qui va avec : https://2img.net/r/ihimg/photo/my-images/12/mcycleststates.png/

[Invité]

Mmm, si un cycle=1 microseconde (cas du 6502 à 1mhz je crois), c'est assez proche, avec un avantage au 6502 pour le meilleur des cas.
Mais c'est bien bne qu'il faudrait utiliser ?
C'est branch non equal ?

Merci à vous deux !
Je vous demande pas de le refaire avec des valeurs signées, vous allez me brûler !

LOL, pour le bne j'ai mis ça un peu comme ça, mais que ce soit un brachement si inf, ou sup et egal, ça change rien niveau cycle ..

donc ce serai un bcc franchement si inferieur .

Code:

Une comparaison 16 bits en 6502 qui chercherait à faire un <
donnerait

    SEC     
    LDA joueur_x
    SBC objet_x
    LDA joueur_x+1
    SBC objet_x+1
    BCS test_ok ; si joueur_x < objet_x branche sur test_ok

euh je suis pas sur de ton compte de cycles .
En ZP ça donnerai
2
4
4
4
4
2/3 donc 20 min (faut compter le non banchement), et 21 max ..

[nemokantio]

Une comparaison 16 bits en 6502 qui chercherait à faire un <
donnerait

SEC
LDA joueur_x
SBC objet_x
LDA joueur_x+1
SBC objet_x+1
BCS test_ok ; si joueur_x < objet_x branche sur test_ok

En page zéro : ça fait 14 cycles si le test est faux et 15 cycles si le test est vrai
Et si les variables ne sont pas en page zéro on aurait 17 ou 18 cycles

Mais en lisant le code z80 je n'ai toutefois pas l'impression que ce soit des coordonnées en 16 bits mais plutôt les deux points extrêmes des box de collision en 8 bits

(edit arf, j'arrive après la bataille :) mais bon je laisse ce petit post inutile )

Ah oui, j'ai trouvé ça :
http://www.6502.org/tutorials/compare_beyond.html#4.1

Tu peux même faire (si j'ai bien compris):
LDA joueur_x
CMP objet_x
LDA joueur_x+1
SBC objet_x+1
BCS test_ok ; si joueur_x < objet_x branche sur test_ok

Mouais...
Non, je ne me mettrai pas au 6502 !


EDIT : t'inquiète Touko, je faisais exprès de chipoter !

[Invité]

Nan tu aurais tout à fait raison, t'es pas forcement sensé savoir que les branchements conditionnels prennent le même nb de cycles .

[65c02]

euh je suis pas sur de ton compte de cycles .
En ZP ça donnerai
2
4
4
4
4
2/3 donc 20 min (faut compter le non banchement), et 21 max ..

nop,
un LDA en absolue PZ c'est 3 cycles et pas 4

LDA Load Accumulator with Memory

M -> A N Z C I D V
+ + - - - -

addressing assembler opc bytes cyles
--------------------------------------------
immidiate LDA #oper A9 2 2
zeropage LDA oper A5 2 3
zeropage,X LDA oper,X B5 2 4
absolute LDA oper AD 3 4
absolute,X LDA oper,X BD 3 4*
absolute,Y LDA oper,Y B9 3 4*
(indirect,X) LDA (oper,X) A1 2 6
(indirect),Y LDA (oper),Y B1 2 5*


http://www.masswerk.at/6502/6502_instruction_set.html

[vingazole]

nop

$EA ?

[65c02]

nop

$EA ?

[Invité]

euh je suis pas sur de ton compte de cycles .
En ZP ça donnerai
2
4
4
4
4
2/3 donc 20 min (faut compter le non banchement), et 21 max ..

nop,
un LDA en absolue PZ c'est 3 cycles et pas 4

LDA Load Accumulator with Memory

M -> A N Z C I D V
+ + - - - -

addressing assembler opc bytes cyles
--------------------------------------------
immidiate LDA #oper A9 2 2
zeropage LDA oper A5 2 3
zeropage,X LDA oper,X B5 2 4
absolute LDA oper AD 3 4
absolute,X LDA oper,X BD 3 4*
absolute,Y LDA oper,Y B9 3 4*
(indirect,X) LDA (oper,X) A1 2 6
(indirect),Y LDA (oper),Y B1 2 5*


http://www.masswerk.at/6502/6502_instruction_set.html

ah bon, j'ai pris les cycles sur la doc 6280, et j'ai 4 cycles, elle est peut être fausse ..

Mais bon si j'ai des erreurs dans ma doc (ce qui semble être le cas), elles s'appliquent aussi à mon code qui prendra quand même moins de cycles

[65c02]

Sur VCS 2600, on passe notre temps à compter les cycles et l'émulateur stella désassemble le code en indiquant le nombre de cycles.

Intéressant, ça veut dire que ces deux processeurs sont plus différent qu'on ne le croit.
Mine de rien, c'est un joli piège pour les codeurs VCS qui voudraient passer sur PCE :)

si ta doc c'est ça
http://turbo.mindrec.com/tginternals/isa/
Je ne pense pas qu'il y ai d'erreur dans ta doc.
l'absolute zero page est 1 cycle plus rapide que l'absolute normal.
(ou alors y a deux erreurs :) )

[Invité]

Sur VCS 2600, on passe notre temps à compter les cycles et l'émulateur stella désassemble le code en indiquant le nombre de cycles.

Ca c'est excellent

Intéressant, ça veut dire que ces deux processeurs sont plus différent qu'on ne le croit.
Mine de rien, c'est un joli piège pour les codeurs VCS qui voudraient passer sur PCE :)

Je ne pense pas qu'il y ai d'erreur dans ta doc.
l'absolute zero page est 1 cycle plus rapide que l'absolute normal.
(ou alors y a deux erreurs :) )

Je sais pas je viens de comparer, avec le 6502 et 6510, et pas mal d'instructions ont 1 cycle en plus ..
C'est quand même étrange, faudrait que je vois ce qu'il en est avec le 65c02 ..

EDIT:je pense que ma doc est fausse, car c'est aussi 3 cycles sur 65c02 ..

EDIT 2: Je rectifie mon code .

Code:


lda x1 + 1  ;3 cycles partie haute
  cmp x2 +1  ; 3 cycles
bne .fintest    ; 2/3 cycles

lda x1    ;3 cycles partie basse
  cmp x2  ; 3 cycles
bne .fintest  ; 2/3 cycles


Donc 9 cycles dans le meilleurs des cas si pas collisions, 16 si collision, et 17 au pire si pas collision

[Invité]

Au fait sur Z80, un truc tout bête, comment vous calculez un score sur 10 chiffre ???

[Fabf]

Oh non il va nous faire le coup de l'ampli qui va jusqu'à 11 :lol:

https://www.youtube.com/watch?v=ll7rWiY5obI

[Invité]

LOL non du tout, c'est juste par curiosité, mais on peut s'arrêter à 9 si tu veux

[youki]

Pourquoi le Z80 , ne compte que jusqu'a 8 ? ... comme nous on compte sur nos doigts , lui il compte sur ses bits!.





heu...heureusement que nous l'ont fait pas ca... on compterait pas loin... :)

[Invité]

, non je voulais savoir comment ils font pour calculer le score dans un jeu en ASM Z80, parce que sur 6502 c'est simple et rapide avec le mode bcd .

Bon moi avec ma longueur je peux m'en servir de boulier(sur 24 bit), mais c'est vrai que pour toi ce serai un peu juste, sauf pour compter les états peut être (0 ou 1) .

[fzu2801]

Déjà de base :
AF: 8-bit accumulator (A) and flag bits (F) carry, zero, minus, parity/overflow, half-carry (used for BCD), and an Add/Subtract flag (usually called N) also for BCD

le BCD est facilement utilisable sur le Z80 ...

Detailed info DAA
Instruction Format:

OPCODE CYCLES
--------------------------------
27h 4


Description:
This instruction conditionally adjusts the accumulator for BCD addition
and subtraction operations. For addition (ADD, ADC, INC) or subtraction
(SUB, SBC, DEC, NEC), the following table indicates the operation performed:

--------------------------------------------------------------------------------
| | C Flag | HEX value in | H Flag | HEX value in | Number | C flag|
| Operation | Before | upper digit | Before | lower digit | added | After |
| | DAA | (bit 7-4) | DAA | (bit 3-0) | to byte | DAA |
|------------------------------------------------------------------------------|
| | 0 | 0-9 | 0 | 0-9 | 00 | 0 |
| ADD | 0 | 0-8 | 0 | A-F | 06 | 0 |
| | 0 | 0-9 | 1 | 0-3 | 06 | 0 |
| ADC | 0 | A-F | 0 | 0-9 | 60 | 1 |
| | 0 | 9-F | 0 | A-F | 66 | 1 |
| INC | 0 | A-F | 1 | 0-3 | 66 | 1 |
| | 1 | 0-2 | 0 | 0-9 | 60 | 1 |
| | 1 | 0-2 | 0 | A-F | 66 | 1 |
| | 1 | 0-3 | 1 | 0-3 | 66 | 1 |
|------------------------------------------------------------------------------|
| SUB | 0 | 0-9 | 0 | 0-9 | 00 | 0 |
| SBC | 0 | 0-8 | 1 | 6-F | FA | 0 |
| DEC | 1 | 7-F | 0 | 0-9 | A0 | 1 |
| NEG | 1 | 6-F | 1 | 6-F | 9A | 1 |
|------------------------------------------------------------------------------|

Flags:

C: See instruction.
N: Unaffected.
P/V: Set if Acc. is even parity after operation, reset otherwise.
H: See instruction.
Z: Set if Acc. is Zero after operation, reset otherwise.
S: Set if most significant bit of Acc. is 1 after operation, reset otherwise.
Example:

If an addition operation is performed between 15 (BCD) and 27 (BCD), simple decimal
arithmetic gives this result:

15
+27
----
42

But when the binary representations are added in the Accumulator according to
standard binary arithmetic:

0001 0101 15
+0010 0111 27
---------------
0011 1100 3C

The sum is ambiguous. The DAA instruction adjusts this result so that correct
BCD representation is obtained:

0011 1100 3C result
+0000 0110 06 +error
---------------
0100 0010 42 Correct BCD!

[youki]

Le compte est bon!!!