Bonjour,
VB.NET propose différentes façon de faire les choses... qu'est-ce qui est le plus rapide ?
J'ai fait un benchmark maison et les résultats sont très instructifs.
J'ai ensuite optimisé quelques uns de mes programmes (déjà optimisés du point de vue algo et mathématiques) qui se sont alors montrés entre 5 et 25 fois plus rapide ... c'est super mais ça veut dire aussi qu'avant je codais en VB.NET comme une merde
Mon programme de benchmark est ici en pièce jointe avec le code source : VB-NET-BENCH.zip
Qu'en pensez-vous ? Avez-vous des autres idées de fonction VB à tester ?
Voici le résultat du benchmark :
NB : les tests ont été réalisés avec le fichier .EXE release ; dans le projet Option Explicit est à ON et Option Strict est à ON également
=== VERIF CHAINE NULLE ===
Nombre de tests : 30.000.000
106ms : If s <> ""
158ms : If s <> vbNullString
24ms : If len(s) <> 0
33ms : If Not String.IsNullOrEmpty(s)
16ms : If s.Length <> 0
=== CRÉATION CHAINE NULLE ===
Nombre de tests : 60.000.000
47ms : s = ""
33ms : s = vbNullString
33ms : s = String.Empty
=== CONCATENATION CHAINE ===
Nombre de tests : 50.000
442ms : s1 = s1 & "a"
426ms : s1 &= "a"
0ms : s2.Append("a") : s1 = s2.ToString
Nombre de tests : 5.000
0ms : s2.Append("a" & "b" & "c" & "d" & "e" & "f" & "g" & "h" & "i" & "j") : s1 = s2.ToString
=== COMPARAISON CHAINE avec s1 = s2 ===
Nombre de tests : 2.000.000
11ms : s1 = s2
184ms : String.Compare(s1, s2) = 0
5ms : String.CompareOrdinal(s1, s2) = 0
4ms : String.Equals(s1, s2)
=== COMPARAISON CHAINE avec s1 <> s2 ; len(s1) = len(s2) ===
Nombre de tests : 2.000.000
50ms : s1 = s2
174ms : String.Compare(s1, s2) = 0
18ms : String.CompareOrdinal(s1, s2) = 0
13ms : String.Equals(s1, s2)
=== COMPARAISON CHAINE avec s1 <> s2 ; len(s1) <> len(s2) ===
Nombre de tests : 2.000.000
41ms : s1 = s2
178ms : String.Compare(s1, s2) = 0
17ms : String.CompareOrdinal(s1, s2) = 0
4ms : String.Equals(s1, s2)
=== COMPARAISON CHAINE IGNORER CASSE avec s1 = s2 ===
Nombre de tests : 2.000.000
445ms : UCase(s1) = UCase(s2)
416ms : s1.ToUpper = s2.ToUpper
225ms : UCase(s1) = s2
181ms : String.Compare(s1, s2, True) = 0
6ms : String.Equals(s1, s2, StringComparison.OrdinalIgnoreCase)
=== COMPARAISON CHAINE IGNORER CASSE avec s1 <> s2 ; len(s1) = len(s2) ===
Nombre de tests : 2.000.000
454ms : UCase(s1) = UCase(s2)
417ms : s1.ToUpper = s2.ToUpper
224ms : UCase(s1) = s2
175ms : String.Compare(s1, s2, True) = 0
65ms : String.Equals(s1, s2, StringComparison.OrdinalIgnoreCase)
=== COMPARAISON CHAINE IGNORER CASSE avec s1 <> s2 ; len(s1) <> len(s2) ===
Nombre de tests : 2.000.000
455ms : UCase(s1) = UCase(s2)
420ms : s1.ToUpper = s2.ToUpper
224ms : UCase(s1) = s2
183ms : String.Compare(s1, s2, True) = 0
8ms : String.Equals(s1, s2, StringComparison.OrdinalIgnoreCase)
=== APPELS BYVAL BYREF - VALEURS DANS CALL ===
Nombre de tests : 100.000.000
78ms : Call Sub1(A As Integer, B As Double, C As String)
55ms : Call Sub2(ByVal A As Integer, ByVal B As Double, ByVal C As String)
55ms : Call Sub3(ByRef A As Integer, ByRef B As Double, ByRef C As String)
55ms : Call Sub4(ByVal A As Integer, ByVal B As Double, ByRef C As String)
=== APPELS BYVAL BYREF - VARIABLES ===
Nombre de tests : 100.000.000
70ms : Call Sub1(A As Integer, B As Double, C As String)
55ms : Call Sub2(ByVal A As Integer, ByVal B As Double, ByVal C As String)
55ms : Call Sub3(ByRef A As Integer, ByRef B As Double, ByRef C As String)
55ms : Call Sub4(ByVal A As Integer, ByVal B As Double, ByRef C As String)
=== COLLECTION VS LIST(OF ) / FOR EACH ===
Nombre de tests : 1.000.000
213ms : Collection - Construction et For Each
94ms : List(Of ) - Construction et For Each
=== COLLECTION VS LIST(OF ) / .ITEM(I) ===
Nombre de tests : 10.000
200ms : Collection - Construction et For i
0ms : List(Of ) - Construction et For i
=== LIST(OF ) : FOR EACH / FOR I .ITEM(I) ===
Nombre de tests : 10.000.000
58ms : For Each
15ms : For i
=== OPÉRATEURS += ===
Nombre de tests : 50.000.000
56ms : x = x + 1
41ms : x += 1
=== OPÉRATEURS -= ===
Nombre de tests : 50.000.000
62ms : x = x - 1
41ms : x -= 1
=== OPÉRATEURS *= ===
Nombre de tests : 50.000.000
72ms : x = x * 3
55ms : x *= 3
=== OPÉRATEURS /= ===
Nombre de tests : 50.000.000
45ms : x = x / 3
29ms : x /= 3
=== / CTE VS * CTE ===
Nombre de tests : 100.000.000
72ms : z = x / 2
55ms : z = x * 0.5
=== / VAR VS * VAR ===
Nombre de tests : 100.000.000
78ms : z = x / y
54ms : z = x * y
=== / VAR VS * VAR II ===
Nombre de tests : 10.000.000
208ms : zi = xi / y avec y = i
61ms : zi = xi * y avec y = 1/i
=== FONCTIONS MATHÉMATIQUES ===
Nombre de tests : 80.000.000
15ms : +
15ms : -
10ms : *
112ms : /
100ms : SQRT
528ms : SIN
624ms : COS
776ms : TAN
476ms : LOG
416ms : ASIN
452ms : ACOS
872ms : ATAN
A +
Partager