Discussion :

[Zarr.be]

Suite à différents tests, j'ai remarqué une énorme dégradation des performances en mode Relase 32bit par rapport au mode Debug 32 bit sous VS 2010, Windows 7 64

Voici le bout de code que j'ai utilisé

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
namespace TestNullBool
{
    class Program
    {
        static Stopwatch sw = new Stopwatch();
        static void Main(string[] args)
        {
            Console.ReadKey();
            sw.Start();
            TestNull();
            sw.Stop();
            Console.WriteLine(sw.Elapsed);
 
            sw.Reset();
            sw.Start();
         TestBool();
            sw.Stop();
            Console.WriteLine(sw.Elapsed);
            Console.ReadKey();
        }
 
        static void TestBool()
        {
            bool b = false;
 
            for(int i = 0 ; i < 2000000000 ; i++)
            {
                if(b==true)
                {
                    b = false; 
                }
                else
                {
                    b = true;
                }
            }
        }
        static void TestNull ()
        {
            int[] eb = new int[3] ;
            int[] e = eb;
 
            for(int i = 0 ; i < 2000000000 ; i++)
            {
                if(e==null)
                {
                    e= eb; 
                }
                else
                {
                    e= null;
                }
            }
        }
    }
}

Faites le test avec différentes options de compilation pour voir si vous aussi vous avez la même dégradation de performance en mode Relase 32bit

[Zarr.be]

Pour être plus clair voici un tableau des performances que j'obtiens

Mode, temps d'exécution
debug 32 10sec
relase 32 18sec <------------ Ici il y a comme un problème ;-)
debug 64 10sec
relase 64 8sec

MS Aurait-il un intérêt a brider les performances du .net en 32 bit ?

[DonQuiche]

Bonjour.

Pour ma part je parviens pas à reproduire ces résultats, j'obtiens 10s en debug-32 et 8s en release-32, ce qui est cohérent en soi mais contraire aux chiffres que tu rapportes. Les chiffres en x64 sont similaires.

[Zarr.be]

Les résultats varient suivant le Framework que l'on utilise
Avec le 4.0 client J'ai ce résultats

Il faudrait qu'il y ait d'autres personnes qui testent pour voir

[moldavi]

Bonjour.

Avec 4.0 Client, j'ai 8/9 secondes en debug et 4/5 secondes en release (sur un OS 32 bits). Je testerai plus tard sur du 64.

[_PascalC_]

Essaie d’exécuter ton programme sans passer par Visual Studio. La différence peut être assez importante...

[tomlev]

Debug (compilé avec csc /o- /d:DEBUG /debug+ /platform:x86 test_perf.cs) :
00:00:05.1850707
00:00:05.0050579

Release (compilé avec csc /o+ /debug- /platform:x86 test_perf.cs) :
00:00:01.5669078
00:00:01.3946975

(.NET 4.5 sous Windows 8 ; tout est exécuté à partir de la console, donc pas d'interférences dues au debugger)

Donc pas de surprise de mon côté... Tu as fait le test plusieurs fois pour voir si ce n'était pas une anomalie statistique ?

EDIT: en x64 la différence est encore plus impressionnante :

Debug (compilé avec csc /o- /d:DEBUG /debug+ /platform:x64 test_perf.cs) :
00:00:05.2561199
00:00:05.3038858

Release (compilé avec csc /o+ /debug- /platform:x64 test_perf.cs) :
00:00:00.1957871
00:00:00.1389896

(le JIT x64 optimise de façon assez agressive, donc je ne serais pas étonné qu'il détecte que la variable modifiée dans la boucle n'est pas utilisée après et qu'il dégage donc les affectations, et peut-être même la boucle puisqu'elle ne sert plus à rien...)

[_PascalC_]

J'avais obtenus les mêmes résultats que toi Tomlev (mais framework 4 + win 7).
Par contre si j’exécutais le projet depuis VS2012, la version Release X64 passait de 0.1s à 3s environ.

[moldavi]

Bonjour.

Ce programme ne faisant rien, peut-être qu'il met en déroute l'optimisateur de VS. Il faudrait aussi comparer avec un programme qui calcule et stocke réellement des valeurs.

Si l'optimisation était puissante, on devrait avoir 0 millisecondes pour le programme ci-dessus...

[sisqo60]

Bonjour,

J'ai fait moi-même le test et j'obtiens les mêmes résultats que vous. 10 en debug x86 et 5 en Release x86. Mon pc ne prend pas en charge le x64.
En modifiant le paramètre "Optimiser le code", j'obtiens le même temps en Debug qu'en Release...

Je te conseille de bien vérifier tes options de projet. Néanmoins le test que Tomlev a fait reste impressionnant en plateforme x64 (il optimise bien ). Il serait intéressant que tu fasses le test croisé en debug/release + Optimisé/nonOptimisé + x86/x64.

Bon dév.

[tomlev]

Il serait intéressant que tu fasses le test croisé en debug/release + Optimisé/nonOptimisé + x86/x64

Debug/release et optimisé/non optimisé, c'est un peu redondant, vu que la principale différence entre relase et debug est le fait d'activer ou non les optimisations
(et le fait qu'en debug on génère les infos de debug (fichiers PDB), mais ça n'influe pas sur les performances tant qu'il n'y a pas d'exceptions)

[sisqo60]

Question idiote...

Merci pour ta réponse...