Discussion :

[mathk]

Bonjour voila je comprend pas trés bien le principe de l'instruction loop
qulqu'un pourai m'aider

Et au fait qu'es ce que veut dir cette instruction :

Code :

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

1
2
3
 
source BYTE "dndndndnd"
target  BYTE SIZEOF source DUP(0), 0

[Nono40]

L'instruction LOOP est exactement la même chose que :

Code :

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

1
2
DEC ECX  ; ou CX en mode 16 bits
JNE xxx

[2PluS4]

Vi sauf que loop est plus lent que

Code :

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

1
2
dec ecx
jne truc

donc il est à éviter

Et puis il ne fait tt à fait la meme chose: il ne modifie pas les flags

[Selenite]

Pour la rapidité de LOOP ou de DEC/JNZ, ça dépend du processeur. Sur certains, la première options est plus rapide que la seconde, sur d'autre c'est l'inverse.

[mathk]

o ok merci mais juste un détail elle s'arret quant ta boucle DEC ECX JNE

[TangiX]

Code :

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

1
2
3
4
5
6
mov CX, iterations
etiq:
...
dec ecx
jne etiq
...

c plus clair là ?
quand ECX = 0 on sort de la boucle

bon dev'

[Nono40]

Il est vrai que je n'avais jamais fait attention au fait que LOOP ne modifie pas les flags

Par contre pour la vitesse, j'avais déjà noté cette différence sur les processeurs récents. Et je ne l'utilisait plus.

[2PluS4]

Sur certains, la première options est plus rapide que la seconde, sur d'autre c'est l'inverse.

oui sur les 8086 c plus rapide mais ca existe plus depuis 15 ans et on s'en fout.

[Selenite]

C'est ce qu'il parait...

[Invité]

Précision sur LOOP. L'UNIQUE processeur sur lequel elle est plus rapide que DEC/JNZ est le P4. Sur TOUS les
autres, Y COMPRIS L'ANTIQUE 8086, c'est plus lent. AUCUN compilateur n'utilise plus cette instruction depuis bien longtemps...
Encore un mystère du P4.

A+

[Selenite]

Voilà ce que dit la doc de MASM32:

LOOP is faster and smaller on 8088-286. On 386+ DEC/JNZ is much faster. On the Pentium the DEC/JNZ instructions pair taking only 1 cycle.

[Blustuff]

moi je remettrais pas en doute AMILIN, surtout pour une doc faite par des Mrcrosoftiens.

[Selenite]

Je ne remets rien en doute. Je ne me serais pas permis étant donné que je n'ai pas d'avis dessus.
J'ai juste mis cet extrait à titre d'information. Le lecteur eventuel remets ensuite en doute ce qu'il veut.

[Invité]

moi je remettrais pas en doute AMILIN, surtout pour une doc faite par des Mrcrosoftiens

Mais si mais si !!! J'ai été un peu trop catégorique...

Pour clore le débat, sur le papier LOOP est effectivement légérement plus rapide (en comptant les cycles dans le cas optimal) que DEC/JNZ sur 8086/286.
Toutefois, même sur ces processeurs, il y a bien longtemps que l'on a appris à utiliser plutôt DEC/JNZ. Sur les proc > et autre que le P4, c'est à ABOLIR.

Par exemple, sur Athlon, DEC/JNZ prend (cas optimal) 1 cycle. De plus, ce sont deux instrutions 'simple' (DirectPath dans le jargon AMD). LOOP prend 8 cycles et est une instruction complexe (VectorPath).

Le cas du P4 est plus nuancé: DEC/INC doivent être évité car, apparemment, CF n'est pas renommé séparemment ce qui fait que ces instructions dépendent de TOUTES les modifications de flags précédentes (je rappelle que CF n'est pas modifié par DEC/INC et que les processeurs récent font du renommage de registre). Et ceci n'est pas indiqué si l'on consulte les cycles sur le papier... Donc, selon les boucles, LOOP est plus rapide sur ce proc !

A+

[Juju_41]

Et au fait qu'es ce que veut dir cette instruction :

Code :

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

1
2
source BYTE "dndndndnd"
target  BYTE SIZEOF source DUP(0), 0

Je pense que c'est la 2ème ligne qui pose problème
SIZEOF source correspond à la taille de "source" ce qui serait je pense 9 octets ... mais source représentant en théorie un emplacement mémoire je ne trouve pas cela très rigoureux ...
Enfin au final tu auras en mémoire :

Code :

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

1
2
       d n d n d n d n d 0 0 0 0 0 0 0 0 0 0
source ^          target ^                 ^ zéro "supplémentaire"

[Blustuff]

et

Code :

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

1
2
sub ecx, 1
jnz ...

??

[Selenite]

Sauter à ... si ECX vaut zéro après avoir été décrémenté.

En C.

Code :

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

1
2
3
4
5
6
 
int ecx = MA_VAR
do 
{
    // code...
} while (--ecx)

En ASM.

Code :

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

1
2
3
4
5
6
 
mov ecx, MA_VAR
label:
;code...
dec ecx
jnz label

dec a et sub a, 1 sont equivalent à la difference près que sub modifie CF.[/b]

[Invité]

dec a et sub a, 1 sont equivalent à la difference près que sub modifie CF

Mais différence importante Blawk. Si tu fais des calculs en chaîne avec propagation de retenue il est important de ne pas détruire CF (exemple l'addition en multi-précision en base 2^32: un cas ou le passage par l'ASM est obligatoire avec l'instruction ADC)

Mais je pense que Blustuff voulait savoir si sub .,1 est mieux que dec sur P4 et c'est bien le cas !!!! Le problème, comme tu l'as noté, est CF.

A+

[Chris_hks]

Mais alors c'est quoi le mieux sur P4 ?
sub, jnz ou loop ??

[Nono40]

Petit essai rapide pour répondre, boucle simple faite avec LOOP ou DEC/JNE

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
procedure TForm1.Button3Click(Sender: TObject);
Var i,t:Integer;
    h:DWord;
begin
  t:=0;
  H:=GetTickCount;
  For i:=1 To 10000 Do
  Asm
    MOV ECX,10000
    XOR EAX,EAX
@@L1:
    ADD EAX,i
    DEC ECX
    JNE @@L1
    ADD T,EAX
  End;
  ShowMessage(IntToStr(GetTickCount-h));
end;

Sur PIII : 930 ms avec LOOP, 440 ms avec DEC/JNE
Sur PIV : 109 ms dans les deux cas.

Si ces résultats se confirmes, ( si tu essayes... ) alors au pire tu ne gagne rien avec DEC/JNE mais dans les autres cas tu gagnes beaucoup. J'avais déjà noté cette différence en faisant des essais d'optimisation en ASM de procédures sur un PIII.