Single ou Double ?

Bonjour,

Je suis en train de finaliser la dernière version de CiDess, un logiciel de dessin de circuits imprimés codé en VB5. Je l'avais commencé en... 1997, bien que je m'en soit servit avant la première version "public" a du sortir en 2003 ou 2004, bref le prog a 20 ans...

L'appli est assez grosse et est toujours utilisée par un certain nombre d'utilisateurs. La petite mise à jour réalisée, la taille de l'appli et le temps que j'ai de disponible ne justifient encore pas la création d'une version .NET :aie:

Alors j'ai pas mal optimisé la vitesse du code :D

Mais il me reste une question : en VB5 les calculs sont-ils plus rapides avec des flottants de type Single ou Double ?

A priori oui. De plus les singles occupent 32 bits contre 64 pour les doubles. VB5 c'est du 32 bits. Et CiDess se destine aussi à des ordinateurs anciens que l'on trouve dans des ateliers.

MAIS pas mal de fonctions mathématiques et autres du langage VB5 ne renvoient ou ne demandent des résultats en Double ; donc lors de l'appel de ces fonctions avec des Single il y a donc une conversion de type ce qui est lent...

Pire, lors d'un calcul avec des opérateurs (+ - * / ...) et des constantes, comment être sûr que tout soit en single ?

Faut-il impérativement faire suivre toutes les constants du symbole "!" pour garantir qu'elles soient en single ?

Merci

A bientôt

Bon alors j'ai fait un test (code en bas, il faut une form avec une zone texte de nom "TxtRes")

L'utilisation de type "single" génère un code, en .EXE (tests faits sous Seven 32 bits), environ 2 à 7% plus rapide qu'avec des "doubles" :?

Chose intéressante : l'usage de constantes déclarées explicitement en single (avec "!") ou en double (avec "#") ou non déclarée (sans caractère de type) ne change rien à la performance :weird:

Je pensais qu'en faisant des calculs "tout single" (donc avec que des types single et que des opérations + - * / et que des constantes déclarées avec "!") l'augmentation de la vitesse serait sensible mais non...

Les processeurs actuels ne font-ils tous les calculs en double, le gain ne s'expliquant alors que parcequ'un type single fait 32 bit contre 64 pour le double et donc que les accès mémoire sont moins nombreux ?

Ou alors c'est le compilateur VB5 qui fait tous les calculs en flottant en double ?

Il serait intéressant que je refasse ce test de performance sous mon vieux PC pour voir ce qu'il se passe :mrgreen: (Cyrix 166+ sous Windows 95 OSR2 - c'était mon premier PC, acheté en 1997, il marche encore, le disque dur avait lâché il y a quelques semaines mais j'en ai retrouvé un autre et un petit coup de Norton Ghost plus tard il est revenu à la vie :mouarf:)

Le fait que certaines fonctions maths ne prennent et ne renvoient que des résultats de type double ne change rien non plus.

Donc pour résumer avec le type single par rapport au double on a :
- un code 2 à 6% plus rapide
- une occupation mémoire deux fois moindre

Si votre critère c'est l’occupation mémoire le type single est intéressant
Mais si c'est la rapidité le gain est modique

Il faut aussi comprendre qu'avec des singles la précision est moindre et que des nombres très grands ou très proches de zéro ne peuvent êtres représentés

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
Option Explicit
 
 
Enum CommandeSouris
    Cmd1
    Cmd2
    Cmd3
    Cmd4
    Cmd5
End Enum
 
Private Sub Form_Load()
    Dim Debut As Single
    Dim Fin As Single
 
    TxtRes.Text = "IMPORTANT : Faire ces tests depuis le EXE et non depuis le compilateur" + vbCrLf
 
    DoEvents
    Debut = Timer
    Call Test2
    Fin = Timer
    TxtRes.Text = TxtRes.Text + "Chaine : " + Format(Fin - Debut, "0.000") + vbCrLf
 
    DoEvents
    Debut = Timer
    Call Test3
    Fin = Timer
    TxtRes.Text = TxtRes.Text + "Integer : " + Format(Fin - Debut, "0.000") + vbCrLf
 
    DoEvents
    Debut = Timer
    Call Test4
    Fin = Timer
    TxtRes.Text = TxtRes.Text + "Enum : " + Format(Fin - Debut, "0.000") + vbCrLf
 
    DoEvents
    Debut = Timer
    Call Test5
    Fin = Timer
    TxtRes.Text = TxtRes.Text + "single : " + Format(Fin - Debut, "0.000") + vbCrLf
 
    DoEvents
    Debut = Timer
    Call Test6
    Fin = Timer
    TxtRes.Text = TxtRes.Text + "double : " + Format(Fin - Debut, "0.000") + vbCrLf
 
End Sub
 
Private Sub Test5()
    Dim X1 As Single, Y1 As Single
    Dim X2 As Single, Y2 As Single
    Dim X3 As Single, Y3 As Single
    Dim X4 As Single, Y4 As Single
    Dim i As Long
    For i = 1 To 1000000
        X1 = Rnd
        Y1 = Rnd
        X2 = Rnd
        Y2 = Rnd
 
        X3 = X2 + X1 + 0.3429532509245
        Y3 = Y2 + Y1 + 0.342918745
        X4 = X2 * X1 * 0.3429186665
        Y4 = Y2 * Y1 * 0.342762595325092
        X3 = Cos(X4)
        Y3 = Sin(Y4)
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
        X3 = X2 + X1 + 0.3422432509245
        Y3 = Y2 + Y1 + 0.122918745
        X4 = X2 * X1 * 1.3429186665
        Y4 = Y2 * Y1 * 3.34276259532509
        X3 = Cos(X4)
        Y3 = Sin(Y4)
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
        X3 = X2 + X1 + 4.3329532509245
        Y3 = Y2 + Y1 + 1.342918745
        X4 = X2 * X1 * 4.3429186665
        Y4 = Y2 * Y1 * 2.34276259532509
        X3 = Sqr(Abs(X4))
        Y3 = Sqr(Abs(Y4))
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
    Next i
 
End Sub
 
Private Sub Test6()
    Dim X1 As Double, Y1 As Double
    Dim X2 As Double, Y2 As Double
    Dim X3 As Double, Y3 As Double
    Dim X4 As Double, Y4 As Double
    Dim i As Long
    For i = 1 To 1000000
        X1 = Rnd
        Y1 = Rnd
        X2 = Rnd
        Y2 = Rnd
 
        X3 = X2 + X1 + 0.3429532509245
        Y3 = Y2 + Y1 + 0.342918745
        X4 = X2 * X1 * 0.3429186665
        Y4 = Y2 * Y1 * 0.342762595325092
        X3 = Cos(X4)
        Y3 = Sin(Y4)
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
        X3 = X2 + X1 + 0.3422432509245
        Y3 = Y2 + Y1 + 0.122918745
        X4 = X2 * X1 * 1.3429186665
        Y4 = Y2 * Y1 * 3.34276259532509
        X3 = Cos(X4)
        Y3 = Sin(Y4)
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
        X3 = X2 + X1 + 4.3329532509245
        Y3 = Y2 + Y1 + 1.342918745
        X4 = X2 * X1 * 4.3429186665
        Y4 = Y2 * Y1 * 2.34276259532509
        X3 = Sqr(Abs(X4))
        Y3 = Sqr(Abs(Y4))
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
    Next i
 
End Sub
 
 
Private Sub Test2()
    Dim Commande As String
    Dim i As Long
    Dim j As Integer
    j = 0
    For i = 1 To 1000000
        j = j + 1
        If j = 0 Then
        Commande = "Cmd1"
        ElseIf j = 1 Then
        Commande = "Cmd2"
        ElseIf j = 2 Then
        Commande = "Cmd3"
        ElseIf j = 3 Then
        Commande = "Cmd4"
        ElseIf j = 4 Then
        Commande = "Cmd5"
        End If
        If Commande = "Cmd5" Then j = 0
    Next i
End Sub
 
Private Sub Test3()
    Dim Commande As Integer
    Dim i As Long
    Dim j As Integer
    j = 0
    For i = 1 To 1000000
        j = j + 1
        If j = 0 Then
        Commande = 1
        ElseIf j = 1 Then
        Commande = 2
        ElseIf j = 2 Then
        Commande = 3
        ElseIf j = 3 Then
        Commande = 4
        ElseIf j = 4 Then
        Commande = 5
        End If
        If Commande = 5 Then j = 0
    Next i
End Sub
 
Private Sub Test4()
    Dim Commande As CommandeSouris
    Dim i As Long
    Dim j As Integer
    j = 0
    For i = 1 To 1000000
        j = j + 1
        If j = 0 Then
        Commande = Cmd1
        ElseIf j = 1 Then
        Commande = Cmd2
        ElseIf j = 2 Then
        Commande = Cmd3
        ElseIf j = 3 Then
        Commande = Cmd4
        ElseIf j = 4 Then
        Commande = Cmd5
        End If
        If Commande = Cmd5 Then j = 0
    Next i
End Sub
 
Private Sub Test1()
 
'    Dim X1 As Integer
'    Dim X2 As Integer
'    Dim Y1 As Integer
'    Dim Y2 As Integer
    Dim X1 As Long
    Dim X2 As Long
    Dim Y1 As Long
    Dim Y2 As Long
    Dim R As Integer
    Dim RS As Single
    Dim CX1X2 As Double
    Dim CY1Y2 As Double
    Dim i As Long
    Randomize
    For i = 1 To 1000000
        X1 = Int(2000 * Rnd)
        X2 = Int(2000 * Rnd)
        Y1 = Int(2000 * Rnd)
        Y2 = Int(2000 * Rnd)
        X1 = X2 - Y1
        X2 = X1 - Y2
        'Plus lent : 0.508s
        'R = Sqr((X1 - X2) ^ 2 + (Y1 - Y2) ^ 2)
        'Plus rapide : 0.254s
        'R = CInt(Sqr(CDbl(X1 - X2) * CDbl(X1 - X2) + CDbl(Y1 - Y2) * CDbl(Y1 - Y2)))
        'Plus rapide : 0.254s
        'RS = Sqr(CDbl(X1 - X2) * CDbl(X1 - X2) + CDbl(Y1 - Y2) * CDbl(Y1 - Y2))
        'Plus lent : 0.289s
        'CX1X2 = CDbl(X1 - X2)
        'CY1Y2 = CDbl(Y1 - Y2)
        'R = CInt(Sqr(CX1X2 * CX1X2 + CY1Y2 * CY1Y2))
        'Plus rapide : 0.234s
        RS = CSng(X1 - X2) * CSng(X1 - X2) + CSng(Y1 - Y2) * CSng(Y1 - Y2)
    Next i
 
End Sub

J'ai refait des tests sous Windows 95 :

single : 31,309 sec
single strict (constantes avec "!") : 28,121 sec
double : 28,398 sec

Bref aucun gain de vitesse avec les singles, il y a même une petite dégradation de performance quand on utilise des fonctions mathématiques

Voici le calcul testé un million de fois (la seule chose qui change c'est que les variables X1...Y4 sont de type single ou double) :

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
        X1 = Rnd
        Y1 = Rnd
        X2 = Rnd
        Y2 = Rnd
 
        X3 = X2 + X1 + 0.3429532509245
        Y3 = Y2 + Y1 + 0.342918745
        X4 = X2 * X1 * 0.3429186665
        Y4 = Y2 * Y1 * 0.342762595325092
        X3 = Cos(X4)
        Y3 = Sin(Y4)
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
        X3 = X2 + X1 + 0.3422432509245
        Y3 = Y2 + Y1 + 0.122918745
        X4 = X2 * X1 * 1.3429186665
        Y4 = Y2 * Y1 * 3.34276259532509
        X3 = Cos(X4)
        Y3 = Sin(Y4)
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
        X3 = X2 + X1 + 4.3329532509245
        Y3 = Y2 + Y1 + 1.342918745
        X4 = X2 * X1 * 4.3429186665
        Y4 = Y2 * Y1 * 2.34276259532509
        X3 = Sqr(Abs(X4))
        Y3 = Sqr(Abs(Y4))
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
        X3 = X2 + X1 + 0.3429532509245
        Y3 = Y2 + Y1 + 0.342918745
        X4 = X2 * X1 * 0.3429186665
        Y4 = Y2 * Y1 * 0.342762595325092
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
        X3 = X2 + X1 + 0.3429532509245
        Y3 = Y2 + Y1 + 0.342918745
        X4 = X2 / X1 * 0.3429186665
        Y4 = Y2 / Y1 * 0.342762595325092
        X1 = X3 + X4 + 1
        Y1 = Y3 + Y4 - 2
        X2 = X3 * X4 + 4
        Y2 = Y3 * Y4 - 5
        X3 = X2 + X1 + 0.3429532509245
        Y3 = Y2 + Y1 + 0.342918745
        X4 = X2 / X1 * 0.3429186665
        Y4 = Y2 / Y1 * 0.342762595325092