Discussion :

[kuntagp]

Bonjour je dois évaluer le temps d'exécution de ce programme et je présume qu'il exécutera "Boucle : ADD AX , -1" 257 fois et "JNE Boucle" 257 fois. par contre sachant que la boucle sans saut vaut 4 cycles cela devrait me donner 258*4+256*16 pour le nombre de cycles.
Quelqu'un pourrait me le confirmer s'il vous plait?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
         ASSUME CS:Code, DS:Data
 
Data     SEGMENT
Tempo    DW   0100H
Data     ENDS
 
Code     SEGMENT
Debut:   MOV  AX, Data
         MOV  DS, AX
         MOV  AX, Tempo
Boucle:  ADD  AX, -1
         JNE  Boucle
         MOV  AH, 4CH
         INT  21H
Code     ENDS
         END  Debut

[DomDA91]

Bonjour

Le décompte de bouclage est une difficulté pour un non spécialiste.
Le plus simple (et le plus sûr) est de prendre un papier et un crayon et de décomposer l'exécution "à la main", en prenant bien sûr une petite valeur pour le compteur de boucle.
Par exemple si on prend 3 comme valeur initiale on aura:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Ligne
10          MOV AX, Tempo (Initialisation du compteur AX à 3)
11 Boucle: (1er passage), AX passe à 2
12          AX non à 0, on saute ligne 11
11 Boucle: (2ème passage), AX passe à 1
12          AX non à 0, on saute ligne 11
11 Boucle: (3ème passage), AX passe à 0
12          AX à 0, pas de saut, on continue ligne 13
13          MOV ... etc.

Conclusion pour Tempo = 3 on aura 3 passages ligne 11 et trois passages ligne 12 dont 2 fois avec saut réalisé et la troisième fois avec saut non réalisé.
On constatera que, pour ces deux lignes, le nombre d'exécutions est égal à la valeur initiale du compteur et que pour la ligne 12, tous les sauts sont réalisés sauf le dernier qui est un saut non réalisé.

Sachant que l'on a 4 cycles pour l'addition, 16 cycles pour un saut réalisé et 4 cycles pour un saut non réalisé, je te laisse le soin de faire le calcul pour une valeur initiale de 256.

Je ne sais pas si tu effectue ce travail à titre de simple exercice ou dans le cadre d'une activité professionelle concrète, mais dans le second cas, sache que ce genre de calcul ne vaut que pour les microprocesseurs ancien comme le 8086 ou 8088.
Les techniques utilisées dans les processeurs modernes, telles que exécution parallelisée, pipelinage, prédiction de branchement, et j'en passe, influent considérablement sur les performances.
D'ailleurs dans ces processeurs d'architecture RISC, la plupart des instructions de base s'exécutent en un seul cycle d'horloge (interne), ce qui donne prépondérance à d'autres considérations telles que proportion de cycles d'accès mémoire, alignement des données, etc.
Par conséquent le calcul du temps d'exécution par décompte de cycles risque de s'écarter considérablement de la réalité et doit plutot être considéré comme un exercice d'école.

[kuntagp]

Bonjour

Le décompte de bouclage est une difficulté pour un non spécialiste.
Le plus simple (et le plus sûr) est de prendre un papier et un crayon et de décomposer l'exécution "à la main", en prenant bien sûr une petite valeur pour le compteur de boucle.
Par exemple si on prend 3 comme valeur initiale on aura:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Ligne
10          MOV AX, Tempo (Initialisation du compteur AX à 3)
11 Boucle: (1er passage), AX passe à 2
12          AX non à 0, on saute ligne 11
11 Boucle: (2ème passage), AX passe à 1
12          AX non à 0, on saute ligne 11
11 Boucle: (3ème passage), AX passe à 0
12          AX à 0, pas de saut, on continue ligne 13
13          MOV ... etc.

Conclusion pour Tempo = 3 on aura 3 passages ligne 11 et trois passages ligne 12 dont 2 fois avec saut réalisé et la troisième fois avec saut non réalisé.
On constatera que, pour ces deux lignes, le nombre d'exécutions est égal à la valeur initiale du compteur et que pour la ligne 12, tous les sauts sont réalisés sauf le dernier qui est un saut non réalisé.

Sachant que l'on a 4 cycles pour l'addition, 16 cycles pour un saut réalisé et 4 cycles pour un saut non réalisé, je te laisse le soin de faire le calcul pour une valeur initiale de 256.

Je ne sais pas si tu effectue ce travail à titre de simple exercice ou dans le cadre d'une activité professionelle concrète, mais dans le second cas, sache que ce genre de calcul ne vaut que pour les microprocesseurs ancien comme le 8086 ou 8088.
Les techniques utilisées dans les processeurs modernes, telles que exécution parallelisée, pipelinage, prédiction de branchement, et j'en passe, influent considérablement sur les performances.
D'ailleurs dans ces processeurs d'architecture RISC, la plupart des instructions de base s'exécutent en un seul cycle d'horloge (interne), ce qui donne prépondérance à d'autres considérations telles que proportion de cycles d'accès mémoire, alignement des données, etc.
Par conséquent le calcul du temps d'exécution par décompte de cycles risque de s'écarter considérablement de la réalité et doit plutot être considéré comme un exercice d'école.

C'est pour un exercice sur le 8086, d'ailleurs l'énoncé stipule que:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
Debut:  MOV AX, Data  ; 10
        MOV DS, AX    ; 2
        MOV AX, Tempo ; 10
Boucle: ADD AX, -1    ; 4 x 257
        JNE Boucle    ; 16 x 256 + 4
        MOV AH, 4CH   ; 4
        INT 21H       ; 52

soit un Total = 10+2+10+4*256+16*255+4+4+52 = 5186
Et je pense que la formule serait (considérant x=Tempo)

10+2+10+4x+16(x-1)+4+4+52
soit 20x+66

[DomDA91]

soit un Total = 10+2+10+4*256+16*255+4+4+52 = 5186
Et je pense que la formule serait (considérant x=Tempo)

10+2+10+4x+16(x-1)+4+4+52
soit 20x+66

D'accord avec toi pour ce décompte.