Discussion :

[zizoufoot]

Bonjour. Il y a quelques jours, je me suis posé la question de savoir laquelle de ces deux instructions étaient la plus rapide pour n'importe quels processeurs aceptants ces instructions :
mov bx, dx
mov ecx, edx
La première instruction déplace moins de données (16 bits), cependant elle est plus longue (taille) que la deuxième : (valeur hexadecimale) 66:8BDA
La deuxième instruction déplace plus de données (32 bits), cependant elle est moins longue (taille) que la première : (valeur hexadecimale) 8BDA

Pour répondre à ma question, j'ai fais un bout de code pour voir laquelle prennait le plus de cycle du processeur :

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
17
18
19
20
21
22
23
MOV ECX,-1
label1:LOOPDNE label1    ;//Juste un petit échauffement
 
RDTSC                    ;//Récupère le nombre de cycles écoulés jusqu'à appel de cet instruction
MOV ECX,1000
label2:MOV BX,DX
LOOPDNE label2           ;//On fait digèrer 1000 fois l'instruction [MOV BX,DX] -> une fois ne m'aurait pas donné une marge de différence entre les deux instructions
MOV ECX,EAX
RDTSC
SUB EAX,ECX              ;//On récupère le nombre de cycle écoulés entre les deux RDTSC.
PUSH EAX
 
MOV ECX,-1
label3:LOOPDNE label3    ;//Encore un échauffement, puis comme en haut...
 
RDTSC
MOV ECX,1000
label4:MOV EBX,EDX
LOOPDNE label4
MOV ECX,EAX
RDTSC
SUB EAX,ECX
PUSH EAX

J'ai utilisé cette procédure 5 fois et voici les résultats :
Première :
Boucle du [MOV BX,DX] : 2121 (cycles)
Boucle du [MOV EBX,EDX] : 210B
(16h cycles de différence)
Deuxième :
Boucle du [MOV BX,DX] : 2121 (cycles)
Boucle du [MOV EBX,EDX] : 2100
(21h cycles de différence)
Troisième :
Boucle du [MOV BX,DX] : 2116 (cycles)
Boucle du [MOV EBX,EDX] : 2100
(16h cycles de différence)
Quatrième :
Boucle du [MOV BX,DX] : 2116 (cycles)
Boucle du [MOV EBX,EDX] : 210B
(0Bh cycles de différence)
Cinquième:
Boucle du [MOV BX,DX] : 210B (cycles)
Boucle du [MOV EBX,EDX] : 2100
(0Bh cycles de différence)

J'en tire les conclusions : Bien que l'instruction [MOV EBX,EDX] déplace plus de données elle est plus rapide que l'instruction [MOV BX,DX].
Ma question : POURQUOI? (qu'est-ce qui joue exactement?)
(Je me serais attendu à l'inverse...)

Merci

[ALT]

Il me semble que l'explication tient dans l'adressage :
En 16 bits, le processeur doit charger des demi-données. Il est obligé de se caler sur des "demi-cases" mémoires.
En 32 bits, il travaille sur des adresses entières, qu'il sait manipuler avec efficacité.
Bref, il est plus rapide pour un processeur 32 bits d'incrémenter le pointeur d'adresses de 4 octets que de deux.

Le problème était différent sur les processeurs 16 bits Intel, qui avaient un registre d'adresses sur 20 bits...

Voilà. J'espère avoir été clair.

[zizoufoot]

Merci.
J'étais parti sur cette piste également. Cependant, je pensais que le déplacement mémoire influait plus que l'addressage.

[Blustuff]

En fait, la taille des données importe peu. Le bus fait de toute façon 32 bits sur une architecture intel 32. Ca coûte rien pour le proc d'utiliser que la moitié du bus. On peut utiliser des instructions comme movz r32, r8, où directement des instructions 8 bits.

Mais en fait, il y a le préfixe d'opérande qui est pénible. le "66:" que vous avez écrit plus haut. Il oblige le processeur à passer en mode d'opérande 16 bits.

Quoiqu'il en soit, le problème dépend du processeur. Certains indiquent clairement une pénalité d'un cycle pour chaque préfixe d'opérande avalé.

Le problème de l'alignement est très compliqué. Pour exemple, certains procs ont des pénalités lorsqu'on accède deux fois au même mot mémoire.