Aujourd’hui, j’ai procédé à un petit test afin de déterminer quel est le moyen le plus performant de mesurer le temps d’exécution d’un morceau de code.

Généralement pour mesurer des temps d’exécution, j’utilise la classe StopWatch du Framework DotNet mais j’ai l’impression qu’elle n’est pas très performante lorsqu’on l’utilise très très souvent.

J’ai donc réalisé un test qui compare le temps d’exécution d’une fonction mesuré avec le StopWatch et l’équivalent en utilisant directement un tickcount.

Tickcount plus performant que StopWatch

Voici le code utilisé:

Source code

Module Module1
 
    Sub Main()
        Const _nbLoop As Integer = 1000000000
        Dim s As New Stopwatch
        For i As Integer = 0 To _nbLoop
            s.Start()
            Dim z As Double = Test()
            s.Stop()
        Next
        Console.WriteLine("Stopwatch: " & s.ElapsedMilliseconds & "ms")
 
        Dim tke As Integer = 0
        For i As Integer = 0 To _nbLoop
            Dim tk1 As Integer = Environment.TickCount
            Dim z As Double = Test()
            tke += Environment.TickCount - tk1
        Next
        Console.WriteLine("Tickcount: " & tke & "ms")
 
        Console.ReadLine()
    End Sub
 
    Private Function Test() As Double
        Dim a As Integer = 10
        Dim b As Integer = 5
        Dim c As Integer = a * b
        Return c / 3
    End Function
End Module

Vous pouvez télécharger la solution complète ici.

Voici le résultat:

Stopwatch Vs Tickcount

Comme vous pouvez le constater, l’utilisation du tickcount est carrément plus rapide que celle du StopWatch. Notez toutefois que le StopWatch est plus précis puisque la granularité du tickcount est la milliseconde.

Related posts:

Résultat du concours CodinGame ASCII [.Net] Convertir un nombre dans un format lisible [.Net] Fonction de convertion d’un double dans le format Human Readable [VB.Net] Générateur de mots