Discussion :

[Archimède]

Voilà, en lisant quelques posts aujourd'hui, je vois que certains s'acharnent à utiliser des variables en word, double etc....
un collègue m'avait confié une fois que delphi en fait tournait plus vite sur des variables de type extended pour les réels et integer pour les entiers.
les autres types seraient donc descendants de ceux-ci... et ralentiraient plutôt les opérations.
Est-ce vrai ou pas ?

[ShaiLeTroll]

Pour avoir fait des tests sur les floattants, plus, ils sont volumineux en octet plus ils sont lents, voir ICI
pour les entiers, je n'ai pas fait le test, mais le processeur étant un 32bit, cela semble a priori optimisé sur l'integer/cardinal

[sjrd]

Pour les flottants, c'est faux. Tout dépend de comment le co-processeur est configuré. Il peut être configuré pour travailler avec des Single, des Double ou des Extended. Un programme Delphi configure normalement le co-processeur pour Extended. Si tu le configures en-dessous, les Extended auront même précision que les Double (dans leur calcul).
Mais question performances, c'est en effet essentiellement la taille qui est déterminante.

Pour les entiers, avoir un processeur 32 bits signifie (plus ou moins) que faire quelque chose sur 4 octets prend autant de temps que sur 1 octet. Cependant, 1 octet reste plus petit en taille que 4, forcément. Donc en général on utilise les Byte/Word pour la taille, ou alors pour l'étendue.
Mais faire des opérations sur des Word n'est pas plus lent que les faire sur des Integer.

[droggo]

Keo,

Pour les entiers, avoir un processeur 32 bits signifie (plus ou moins) que faire quelque chose sur 4 octets prend autant de temps que sur 1 octet. Cependant, 1 octet reste plus petit en taille que 4, forcément. Donc en général on utilise les Byte/Word pour la taille, ou alors pour l'étendue.
Mais faire des opérations sur des Word n'est pas plus lent que les faire sur des Integer.

Sauf que les processeurs sont sensibles au mélange d'accès 8/16/32 bits, et on aura généralement dégradation si on utilise le tout sans faire attention.

[ShaiLeTroll]

Pour les flottants, c'est faux

Euh qu'est ce qui est faux ? ceci

un collègue m'avait confié une fois que delphi en fait tournait plus vite sur des variables de type extended

ou cela

plus, ils sont volumineux en octet plus ils sont lents

car les deux sont fausses et vraies, en fait cela dépend totalement du processeur, entre le P3 et le P4, il y a un véritable fossé de performance, ... j'ai retrouvé le sujet sur Phidels, sur l'optimisation des flottants

en fait, cela semble varié selon la valeur elle-même ... personnellement, j'ai raconté ce que j'ai pu constaté ..., et j'ai eu des résultats improbables ...

testez vous même

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
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
procedure TFrmTestMemory.BtnTempsFlottantClick(Sender: TObject);
var
   StartTick, EndTick, TickPerSec, TimeIteration: Int64;
   i, k: integer;
 
   S, S2, SR: Single;
   D, D2, DR: Double;
   E, E2, ER: Extended;
   ED: Extended;
begin
   S := 0.001;
   S2 := 111.0001;
   for k := 1 to 10 do
   begin
      QueryPerformanceCounter(StartTick);
      try
         for i := 1 to 10000000 do
         begin
            SR := S + S2;
         end;
      finally
         QueryPerformanceCounter(EndTick);
         QueryPerformanceFrequency(TickPerSec);
         TimeIteration := Round((EndTick - StartTick) / TickPerSec * 1000);
         MemoTimes.Lines.Add('Single N°' + IntToStr(k) + ' : ' + IntToStr(TimeIteration) + ' ms = ' + FloatToStr(SR));
      end;
   end;
 
   D := 0.001;
   D2 := 111.0001;
   for k := 1 to 10 do
   begin
      QueryPerformanceCounter(StartTick);
      try
         for i := 1 to 10000000 do
         begin
            DR := D + D2;
         end;
      finally
         QueryPerformanceCounter(EndTick);
         QueryPerformanceFrequency(TickPerSec);
         TimeIteration := Round((EndTick - StartTick) / TickPerSec * 1000);
         MemoTimes.Lines.Add('Double N°' + IntToStr(k) + ' : ' + IntToStr(TimeIteration) + ' ms = ' + FloatToStr(DR));
      end;
   end;
 
   E := 0.001;
   E2 := 111.0001;
   for k := 1 to 10 do
   begin
      QueryPerformanceCounter(StartTick);
      try
         for i := 1 to 10000000 do
         begin
            ER := E + E2;
         end;
      finally
         QueryPerformanceCounter(EndTick);
         QueryPerformanceFrequency(TickPerSec);
         TimeIteration := Round((EndTick - StartTick) / TickPerSec * 1000);
         MemoTimes.Lines.Add('Extended N°' + IntToStr(k) + ' : ' + IntToStr(TimeIteration) + ' ms = ' + FloatToStr(ER));
      end;
   end;
end;

j'ai obtenu sur un P4 3Ghz 512Mo WinXP

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
30
Single N°1 : 17 ms = 111,001098632813
Single N°2 : 17 ms = 111,001098632813
Single N°3 : 20 ms = 111,001098632813
Single N°4 : 18 ms = 111,001098632813
Single N°5 : 21 ms = 111,001098632813
Single N°6 : 18 ms = 111,001098632813
Single N°7 : 18 ms = 111,001098632813
Single N°8 : 18 ms = 111,001098632813
Single N°9 : 18 ms = 111,001098632813
Single N°10 : 18 ms = 111,001098632813
Double N°1 : 340 ms = 111,0011
Double N°2 : 340 ms = 111,0011
Double N°3 : 339 ms = 111,0011
Double N°4 : 338 ms = 111,0011
Double N°5 : 334 ms = 111,0011
Double N°6 : 337 ms = 111,0011
Double N°7 : 338 ms = 111,0011
Double N°8 : 335 ms = 111,0011
Double N°9 : 337 ms = 111,0011
Double N°10 : 338 ms = 111,0011
Extended N°1 : 94 ms = 111,0011
Extended N°2 : 96 ms = 111,0011
Extended N°3 : 94 ms = 111,0011
Extended N°4 : 97 ms = 111,0011
Extended N°5 : 94 ms = 111,0011
Extended N°6 : 96 ms = 111,0011
Extended N°7 : 94 ms = 111,0011
Extended N°8 : 94 ms = 111,0011
Extended N°9 : 98 ms = 111,0011
Extended N°10 : 95 ms = 111,0011

[sjrd]

Euh qu'est ce qui est faux ?

Je parlais de "les Extended vont plus vite".

Ceci dit, à la lumière de ce que tu me montres, va falloir que je me remette en question J'aurais quand même pas imaginé que les Double aillent si lentement.

[ShaiLeTroll]

C'est tellement complexe tout ça, avec toutes les options de compilation (que je ne connais pas pour le co-proc), les modèles de processeur, et est-il pensable que la valeur flottante elle-même influence la complexité du calcul ? et de l'humeur de la machine, j'ai des temps qui change, parfois le double est aussi rapide que le single, parfois c'est le temps d'un extended... testez donc sur vos machines, pour comparer, parce que, c'est la première fois que j'ai des temps comme ceci ! ça doit être un mauvais jour ... ou alors j'ai changé un truc qu'il ne fallait pas un jour ...

[Archimède]

merci pour vos réponses tout à fait pertinentes...
je teste...
et je revoie mon jugement...
ce n'est pas une question inintéressante...
a+