For...Next / Do...Loop while

Merci pour ces renseignements.

Voici les résultats que j'obtiens avec ce test de boucles folles : (Athlon
2000)

Dim Depart As String
Dim I As Long
Dim J As Long
Dim K As Long
Dim L As Long
Depart = Timer

For I = 0 To 254
For J = 0 To 254
For K = 0 To 254
For L = 0 To 100
Next L
Next K
Next J
Next I

Form1.Cls
Print Int(Timer - Depart)
End Sub

Résultats :

' 46 avec Byte
' 38 avec Integer
' 37 avec Long
' 53 Single
' 52 Double
' 71 Variant

Merci et ...
Bonne réception.
andre.araste@wanadoo.fr
http://perso.wanadoo.fr/andre.araste/
Membre du Club Win's: http://www.clubwins.org
Avertissement: Je ne vends rien.

"Zoury" <yanick_lefebvre at hotmail dot com> a écrit dans le message de
news:uhuHDaH$DHA.1452@TK2MSFTNGP09.phx.gbl...

Resalut!

> Une variable de type Byte est codée sur un seul octet dans l'intervalle

de

> valeurs de 0 à 255

On ne peut plus d'accord! :O)


> ... mais la boucle va tourner à une vitesse folle car elle n'explore

qu'un

> seul octet. Avec un type Long elle mettrait 4 fois plus de temps. Avec

un

> type Double elle mettrait 8 fois plus de temps.
>
> D'accord ?

Nope!

Dans un système 32bits, comme c'est le cas pour la majorité des logiciels
(et matériels) actuels (NT4, 2000, XP, 95, 98, Me, VB6, etc.), le CPU

traite

les données en bloc de 32bits (et les bus aussi).
Si on lui passe une données de type Long qui est stockée sur 32 bits, il
traite la valeur tel quelle sans aucune modification supplémentaire. Si
toutefois on lui passe une variable de Byte qui est stockée sur 8 bits, le
système devra masquer les 24bits qui sont inutilisé par ce format de
variable avant d'envoyé la valeur au CPU, ce qui demande évidemment des
intructions supplémentaires. Le nombres d'instructions effectuées sur les
données afin de les formattés correctement pour le CPU peuvent varier d'un
type à l'autre, mais une chose est sûre, c'est que d'utiliser un type dont
la taille est identique à celle utilisé par le matériel/logiciel du

système

demande moins de ressources.

--
Cordialement
Yanick Lefebvre - MVP pour Visual Basic
http://faq.vb.free.fr/?rubrique=0 - http://www.mvps.org/vbnet/
http://www.mentalis.org/agnet/apiguide.shtml - http://www.mztools.com/

Merci de poster les réponses au groupe afin d'en faire profiter à tous

J'obtiens des résultats ayant des proportions semblable.. :O)

je te conseilles fortement de jeter un oeil à l'article qui suit :
http://www.mvps.org/vb/index2.html?tips/benchmarks.htm

Voici le benchmark que j'ai utilisé pour vérifier les résultats en suivant
les conseilles de l'article :
'***
Option Explicit

Private Sub Main()

Const NUM_LOOP As Long = 5000000
Dim by As Byte
Dim i As Integer
Dim l As Long
Dim d As Double
Dim j As Long
Dim sw As CStopWatch
Dim tLoop As Long
Dim t1 As Long
Dim t2 As Long
Dim t3 As Long
Dim t4 As Long

Set sw = New CStopWatch

Call Randomize

sw.Reset
For j = 1 To NUM_LOOP
Next j
tLoop = sw.Elapsed

sw.Reset
For j = 1 To NUM_LOOP
by = TestByte
Next j
t1 = sw.Elapsed

sw.Reset
For j = 1 To NUM_LOOP
i = TestInteger
Next j
t2 = sw.Elapsed

sw.Reset
For j = 1 To NUM_LOOP
l = TestLong
Next j
t3 = sw.Elapsed

sw.Reset
For j = 1 To NUM_LOOP
d = TestDouble
Next j
t4 = sw.Elapsed

Debug.Print "Nombre de boucles : " & NUM_LOOP
Debug.Print "Temps de la boucle : " & tLoop & " ms"
Debug.Print "Byte : " & t1 - tLoop & " ms"
Debug.Print "Integer : " & t2 - tLoop & " ms"
Debug.Print "Long : " & t3 - tLoop & " ms"
Debug.Print "Double : " & t4 - tLoop & " ms"

End Sub

Private Function TestByte() As Byte
TestByte = Rnd * &HFF
End Function

Private Function TestInteger() As Integer
TestInteger = Rnd * &HFFFF
End Function

Private Function TestLong() As Long
TestLong = Rnd * &H7FFFFFFF
End Function

Private Function TestDouble() As Double
TestDouble = Rnd * 1.79769313486231E+308
End Function
'***

j'obtiens ces résultats sur un Athlon 1200 Mhz :
---
Nombre de boucles : 5000000
Temps de la boucle : 196 ms
Byte : 3865 ms
Integer : 3481 ms
Long : 3155 ms
Double : 4168 ms
--

--
Cordialement
Yanick Lefebvre - MVP pour Visual Basic
http://faq.vb.free.fr/?rubrique=0 - http://www.mvps.org/vbnet/
http://www.mentalis.org/agnet/apiguide.shtml - http://www.mztools.com/

Merci de poster les réponses au groupe afin d'en faire profiter à tous

A titre d'information, voici le code généré par :

Sub Main()
Dim j&
Dim b As Byte, i As Integer, l As Long
Beep
For b = 0 To 100
j = j + 1
Next
For i = 0 To 10000
j = j + 1
Next
For l = 0 To 100000
j = j + 1
Next
End Sub


sur P4, avec VB 6 Sp5 avec les options de compil std (optimiser la rapidité
du code)


00401580 53 push ebx
00401581 56 push esi
00401582 57 push edi
00401583 33 F6 xor esi,esi ' j est mis à zéro, même
si on ne le précise pas
00401585 FF 15 40 10 40 00 call dword ptr ds:[401040h] ' Beep
0040158B 8B 3D 28 10 40 00 mov edi,dword ptr
ds:[401028h]------------+
00401591 B9 64 00 00 00 mov ecx,64h
'
00401596 FF D7 call edi
'
00401598 33 C9 xor ecx,ecx
' intro de la boucle avec Byte !
0040159A 8A D8 mov bl,al
' pour controler que 64H est bien
0040159C FF D7 call edi
' un Byte !...
0040159E 3A C3 cmp al,bl
'
004015A0 77 0D ja 004015AF
'
004015A2 83 C6 01 add
esi,1 - - - - - - - - - - - - - - - ------------- +
004015A5 70 32 jo 004015D9
'
004015A7 04 01 add al,1
' boucle avec Byte
004015A9 72 2E jb 004015D9
'
004015AB 3A C3 cmp al,bl
'
004015AD 76 F3 jbe
004015A2-----------------------------------+
004015AF 33 C0 xor
eax,eax-------------------------------+
004015B1 83 C6 01 add esi,1
'
004015B4 70 23 jo 004015D9
' boucle avec Integer
004015B6 66 05 01 00 add ax,1
'
004015BA 70 1D jo 004015D9
'
004015BC 66 3D 10 27 cmp ax,2710h
'
004015C0 7E EF jle
004015B1------------------------------+
004015C2 33 C0 xor
eax,eax-------------------------------+
004015C4 83 C6 01 add esi,1
'
004015C7 70 10 jo 004015D9
' boucle avec Long
004015C9 83 C0 01 add eax,1
'
004015CC 70 0B jo 004015D9
'
004015CE 3D A0 86 01 00 cmp eax,186A0h
'
004015D3 7E EF jle
004015C4------------------------------+
004015D5 5F pop edi
004015D6 5E pop esi
004015D7 5B pop ebx
004015D8 C3 ret
004015D9 FF 15 48 10 40 00 call dword ptr ds:[401048h]


Pour la boucle avec Byte, le compilateur appelle une fonction pré-définie
pour s'assurer que la donnée est bien un BYTE. Ce qui nous rappelle que sous
VB3 le type BYTE n'existait pas et que Microsoft a gentiment bricolé pour
implémenter le type ! Alors que pour Integer et Long il génère directement
le code ! Car, en 'optimisant la rapidité du code' on aurait pu imaginer un
truc du genre :

DEBUT xor al,al
add esi,1
jo 004015D9
add al,1
jo 004015D9
cmp al,64h
jle DEBUT



Dis Monsieur Microsoft, tu pourrais nous donner la description de tes
stratégies de compilation ?
Enfin, si tu les as...