Forum TI-Planet.org

A l'aide d'un petit programme en asm (de ma conception) , je suis parvenu à mesurer très précisément le temps d'éxecution de (presque) chacune des instructions eZ80 (il reste 10% que je ne peux mesurer : les formes d'instructions de sortie OUT car celles-ci font planter la TI83PCE)
Comment ai-je fait ? Hé bien grâce à l'utilisation du cpu-clock-timer !
À noter que les tests ont été effectués en mode ADL=1, et que les adressages-mémoire ne sortaient pas de la zone RAM-VRAM (de $D40000 à $D657FF) afin d'avoir en permanence les même temps d'accès-mémoire en écriture ou lecture.
(voir http://wikiti.brandonw.net/index.php?ti ... ait_States pour plus d'infos)

Je vous dévoile donc cette liste en 2 versions : par ordre alphabétique, puis selon le temps d'exécution (ordre croissant)
Et tout ça en format ODS, HTML, PDF

J'espère que cela vous sera utile dans vos optimisations

https://tiplanet.org/forum/archives_voir.php?id=469451 et disponible ici aussi : https://wiki.tiplanet.org/Timings_des_instructions_eZ80

Ah! encore une précision sur la légende:
n = valeur 8bits
Mmn = valeur 24bits
r = registre 8bits

Merci pour le copié collé de la description
Revenons à nos moutons, bravo à toi, je pense que cela va en aider plus d'un

Bah ouais, j'avais la flemme, quoi ! Ha ha
Après ce dur labeur, fallait s'y attendre =D

Je viens de mettre à jour le ZIP : il contient maintenant 3 formats: ODS, HTML et PDF et en 2 versions (l'une classée par ordre alphabétique, l'autre selon le temps d'exécution)

Intéressant. Par contre, je crains que le temps mis par les instructions soit un peu plus complexe en fonction des instructions attenantes. Je m'explique :

Le ez80 fetch les instructions pendant la phase décode-execute de la précédente. Théoriquement, cela permet de supprimer le besoin de dépenser des cycles pour fetcher l'instruction. Cependant, à cause des waits-states rajoutés sur le read (3+1 effectif), le nombre de cycle nécessaires pour accéder à la RAM dépasse le nombre de cycles maskables par le fetch en même temps que le décode; MAIS ça reste dépendant de l'instruction, puisque certaines possèdent un temps d'éxecution long.

Par exemple, l'instruction add hl,de, en considérant le cache de fetch vide (après un jp par exmple) sera découpé de cette manière :

FETCH : 1 read + 3 wait states : 4 TStates
DECODE&EXEC : 1 TState

Soit 5 TStates pour add hl, de

Par contre, si on considère qu'il y a une instruction avant, de 1 TState d'éxecution :
FETCH 1 read + 3 wait states : 4 TStates -1 (provenant du chargement du système pendant l'execute de l'instruction précédante)
DECODE&EXECUTE : 1 TStates

Soit 4 TStates !

Pourrait tu tester de timer ce code :

Code: Select all

mlt hl
add hl,de


mlt étant une instruction à longue latence d'éxecute, add hl,de devrait paraitre comme une instruction à 1 TState.

Bref, tout cela est compliquer, et le meilleur moyen c'est quand même de tester

EDIT : en me relisant, je remarque que j'ai combiner Execute&décode mais je crois que ce n'est même pas le cas sur ez80; aucune idée sur ce que ça change par contre (+1TStates ?)

Geygey, ça a du prendre du temps. Personnellement je comptais faire la même chose mais avec les instructions Ti-Basic. Genre quel est le plus rapide entre :

Code: Select all

If A=5
Then
End

Code: Select all

If A=5

Bon là c'est évident mais vous avez compris le principe

Par contre, comme le dit TheMachine42, c'est très complexe et dépend beaucoup de la configuration de la calculatrice, enfin ça peut toujours être utile pour avoir une idée du temps de chacune des instructions

Tout d'abord, merci pour votre intérêt

C'est vrai qu'avec son traitement des instructions en parallèle ("pipeline") j'avais des doutes sur l'efficacité de mon programme!
Je vais expliquer brièvement le fonctionnement de mon programme:
L'instruction (ou le groupe d'instructions) est mesurée 256 fois d'affilée
Puis le programme ne retient que la valeur la plus basse (car il arrive bien souvent que l'instruction et le cpuclock-timer ne soient pas synchronisés: l'idéal étant le timer qui incrémente , et ce, juste au moment où l'instruction est traitée)

Code: Select all

.nolist
#include "ti84pce.inc"
.list
.org userMem-2
.db tExtTok,tAsm84CeCmp
.assume ADL=1

      di
      ld hl,$f20030
      ld a,(hl)
      and %11000000
      ld (hl),a
      inc l
      set 1,(hl)

      ld b,0

loop:   push bc
      ld hl,$f20000
      ld de,0
      ld (hl),e
      inc l
      ld (hl),de
      ld l,$30
      set 0,(hl)
      push hl
   ld hl,EnRam
   ld bc,EnRam
   ld de,EnRam
   ld ix,EnRam
;-------------------------------

      mlt hl

;-------------------------------
      pop hl
      res 0,(hl)
      ld l,h
      ld hl,(hl)
      ld a,(data)
      cp l
      jr c,pass
      ld a,l
      ld (data),a
pass:   pop bc
      djnz loop
      ld hl,(data)
      ld de,-109
      add hl,de
      jp _DispHL
data:   .db 255,0,0
EnRam:   .db 0,0,0,0,0,0,0,0

Je viens de mesurer le temps que prend le code

Code: Select all

mlt hl
add hl,de

Le programme me donne 16 comme résultat

PS: et si on ne met rien à mesurer, le programme affiche bien 0

EDIT: j'ai aussi testé ce mélange:

Code: Select all

mlt hl
      mlt hl
      add hl,de
      mlt hl
      mlt hl
      add hl,de
      add hl,de

Ce qui nous donne bien 60 ;)

Très bon boulot

Je suggère de créer une page dédiée sur notre wiki, histoire que ce soit accessible d'autant plus facilement (et plus collaboratif?)
Par exemple: https://wiki.tiplanet.org/Timings_des_instructions_eZ80 ?

Tu peux t'inspirer d'autres pages (par exemple ici) pour la syntaxe des tableaux, ou n'hésite pas à demander de l'aide sinon.


( Edit: BTW, tu devrais venir sur IRC, sur le channel #ez80-dev des serveurs EFNet )

Merci Adriweb

Oui ! Bonne idée la page "Timings des instructions eZ80"
Par contre , je ne sais pas comment créer une page de ce genre

Ce qui m'embête un peu , c'est que le timing de bon nombre d'instructions peut légèrement changer si l'on travaille avec des adressages hors de l'espace-mémoire RAM+VRAM...
C'est pour cela que ma liste est (pour l'instant) "généraliste"
Je réfléchis quant à une solution d'affichage plus détaillée, mais en même temps pas trop "lourde" (il ne faut pas que l'on s'y perde !)

J'ai commencé une conversion pour toi

https://wiki.tiplanet.org/Timings_des_instructions_eZ80

(j'ai converti ton fichier .ods en .csv, puis utilisé http://area23.brightbyte.de/csv2wp.php )

Super !!! =D

EDIT :
Par contre, je n'ai encore parlé des quelques valeurs comme par exemple "13,8" pour JR cc',d
dans ce cas-précis, si la condition cc' est remplie, le saut relatif est effectué (alors le temps=13)
sinon, le temps=8

Je m'étais dit que si j'utilisais une fraction"13/8", le tri n'aurait pas fonctionné,..Si ?