Discussion :

[toubib]

Bonjour.
Problème récurrent : je veux comparer la rapidité de deux routines, j'utilise Stopwatch et le code qui suit avec mes deux routines à tester. C'est pour voir si les calculs avec des Integers, des longs, des short est plus ou moins rapide (Les articles sur le web datent un peu) . Ici j'ai la comparaison d'addition d'un integer ou d' un Short.

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
24
25
26
27
 
        Dim b As Integer
        Dim c As Integer
        Dim i As Integer
        Dim s As Short
        Dim sw As New Stopwatch
        sw.Start()
        ' Ici  routine 1
        For c = 1 To 30000
            i = 1
            For b = 0 To 250
                i = i + 1
            Next
        Next
        sw.Stop()
        Label1.Text = sw.ElapsedTicks.ToString()
        Dim sw1 = New Stopwatch
        sw1.Start()
        ' Ici  routine 2
        For c = 1 To 30000
            s = 1
            For b = 0 To 250
                s = s + 1
            Next
        Next
        sw1.Stop()
        Label2.Text = sw1.ElapsedTicks.ToString()

Le résultat est n'importe quoi!!
Même si les 2 routines sont identiques et utilisent par exemple toutes les 2 des integers. La première routine est systématiquement plus longue.
J'ai pris soin d'être en mode Release, de faire tourner le code plusieurs fois (la première fois cela 'devrait être plus longue' puisqu'il y a compilation JIT.
J'ai bien compris la cause de cela, mais comment y remédier?
Il est dit sur un forum de mesurer les processus, comment?
Je voulais aussi utiliser un thread avec une priorité importante mais je ne sais pas récupérer les temps à la fin de la routine.
Y a t-il un moyen sur de mesurer? Le Framework fournit il d'autres méthodes?
Merci de votre aide

[DotNetMatt]

Je pense que tu devrais te tourner vers les "Performance Counters". Ce n'est pas forcément simple à utiliser au début, mais tu peux mesurer pas mal de choses avec.

Voici une introduction, et une autre.

[abd75web]

peut être tu ferais mieux d'utiliser

Code :

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

.ElapsedMilliseconds()

au lieu

Code :

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

.ElapsedTicks

[Pol63]

avec ellapsed ms j'ai peu de variation en général (hormis le 1er tour)
après le type de variable ne fera pas gagner des masses je pense, sinon tu peux te tourner vers du c si tu veux gagner des nanosecondes ^^

si le temps total est moins de 50ms c'est moins fiable aussi je pense, il faut des durée assez longues et donc augmenter la boucle si nécessaire (mais tu ne précises pas les temps ...)

[rv26t]

Bonjour,

Bonjour.
Problème récurrent : je veux comparer la rapidité de deux routines, j'utilise Stopwatch et le code qui suit avec mes deux routines à tester. C'est pour voir si les calculs avec des Integers, des longs, des short est plus ou moins rapide (Les articles sur le web datent un peu)

Effectivement, les conseils microsoft sont de la version 2005.

Le type de données Integer offre des performances optimales sur un processeur de 32 bits. Les autres types intégraux sont plus lents à charger et à stocker à partir de et dans la mémoire.

Difficile de savoir si cela est toujours d'actualité.
Si les "Integer" sont plus performant sur les système 32 bits, on pourrait présumer que les "Long" sont plus performant sur les système 64 bits.
Question d'adressage en fait.
Mais cela reste à vérifier.

A+, Hervé.

[toubib]

Après de multiples essais:

Effectivement si la boucle fait 30 à 40 millisecondes les résultats sont aberrants, si j'augmente la première boucle d'un facteur 100, les temps atteignent 3000 à 4000 ms et là les résultats deviennent plus cohérents:
La différence entre 2 routines identiques est très minime (quoique jamais égale c'est normal car Stopwath a un certains degré d’incertitude).

J'ai testé les additions (ordinateur 64bits) en jouant sur le facteur:
Unité centrale cible (propriété du projet, onglet Compiler)

Pour les Integer et les Long
AnyCPU préférer 32 bis coché : 3870 et 4040ms
AnyCPU, préférer 32 bits non coché: 6967 et 6940 ms
x86 :3870 et 4040ms
x64 :6967 et 6940 ms
Donc en 32bits les Integers sont très légèrement plus rapides.
en 64 bits les longs sont très légèrement plus rapides que les integers mais curieusement les routines sont plus longues globalement.

Pour les virgules flottantes:
x86 : Single 52030, Double 5208ms
x64 : Single 6500, Double 6400ms

Bien sur les Decimals sont dix fois plus long que les Integers.

Je remet le code:

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
24
25
26
27
28
29
 Dim b As Integer
        Dim c As Integer
        Dim i As Integer
        Dim s As Long
        Dim sw As New Stopwatch
        Label1.Text = ""
        Label2.Text = ""
        sw.Start()
        ' Ici  routine 1
        For c = 1 To 3000000
            i = 1
            For b = 0 To 250
                i = i + 1
            Next
        Next
        sw.Stop()
        Label1.Text = sw.ElapsedMilliseconds.ToString()
        Dim sw1 = New Stopwatch
 
        sw1.Start()
        ' Ici  routine 2
        For c = 1 To 3000000
            s = 1
            For b = 0 To 250
                s = s + 1
            Next
        Next
        sw1.Stop()
        Label2.Text = sw1.ElapsedMilliseconds.ToString()

Bien sur les différences sont minimes. Mais les calculs en 64 bits semblent plus lents.
Commentaires ?

[Pol63]

en 64 bits les longs sont très légèrement plus rapides que les integers mais curieusement les routines sont plus longues globalement.

microsoft confirme, je crois que c'était concernant vs2012 "nous n'avons pas fait de version x64 car c'est plus lent"