Performance de débogage contre libération
J'ai rencontré le paragraphe suivant:
“Le paramètre Debug vs. Release dans le IDE lorsque vous compilez votre code dans Visual Studio ne fait presque aucune différence en termes de performances… le code généré est presque identique. Le compilateur C # ne fait pas vraiment Le compilateur C # crache juste IL… et à l'exécution, c'est le JIT qui effectue toute l'optimisation.Le JIT dispose d'un mode Debug/Release et cela fait une énorme différence en termes de performances. exécutez la configuration Debug ou Release de votre projet, qui détermine si un débogueur est attaché. ”
La source est ici et le podcast est ici .
Est-ce que quelqu'un peut me diriger vers un article de Microsoft qui peut réellement le prouver?
Googler " C # debug vs performance de la version " renvoie principalement les résultats en indiquant " Le débogage a beaucoup de succès ", " la version est optimisée "et" ne déploie pas le débogage en production ".
Partiellement vrai. En mode débogage, le compilateur émet des symboles de débogage pour toutes les variables et compile le code tel quel. En mode release, certaines optimisations sont incluses:
- les variables non utilisées ne sont pas compilées du tout
- certaines variables de boucle sont extraites de la boucle par le compilateur s'il s'avère qu'elles sont invariantes
- le code écrit sous la directive #debug n'est pas inclus, etc.
Le reste appartient au JIT.
Edit: Liste complète des optimisations ici gracieuseté de Eric Lippert
Il n'y a pas d'article qui "prouve" quoi que ce soit à propos d'une question de performance. La meilleure façon de prouver une assertion sur l'impact d'un changement sur la performance est de l'essayer dans les deux sens et de le tester dans des conditions réalistes mais contrôlées.
Vous posez une question sur la performance, alors vous vous souciez clairement de la performance. Si vous vous souciez de la performance, la meilleure chose à faire est de définir des objectifs de performance, puis de vous rédiger une suite de tests qui permet de suivre vos progrès. Une fois que vous avez une telle suite de tests, vous pouvez facilement l'utiliser pour vérifier par vous-même la vérité ou la fausseté d'instructions telles que "la version de débogage est plus lente".
De plus, vous pourrez obtenir des résultats significatifs. "Plus lent" n'a pas de sens car il n'est pas clair si c'est une microseconde plus lente ou vingt minutes plus lente. "10% plus lent dans des conditions réalistes" est plus significatif.
Passez le temps que vous auriez consacré à la recherche de cette question en ligne sur la construction d'un appareil qui répond à la question. Vous obtiendrez ainsi des résultats beaucoup plus précis. Tout ce que vous lisez en ligne est juste un devinez à propos de ce que pourrait arriver. Raison des faits que vous avez recueillis vous-même, pas des suppositions des autres sur la façon dont votre programme pourrait se comporter.
Je ne peux pas commenter les performances, mais le conseil "ne déployez pas le débogage en production" est toujours valable, tout simplement parce que le code de débogage fait généralement plusieurs choses différemment dans les gros produits. D'une part, vous pouvez avoir des commutateurs de débogage actifs et, d'autre part, il y aura probablement des contrôles de cohérence redondants supplémentaires et des sorties de débogage qui n'appartiennent pas au code de production.
De msdn social
Ce n'est pas bien documenté, voici ce que je sais. Le compilateur émet une instance de System.Diagnostics.DebuggableAttribute. Dans la version de débogage, la propriété IsJitOptimizerEnabled est True, dans la version finale, elle est False. Vous pouvez voir cet attribut dans le manifeste d'assembly avec ildasm.exe.
Le compilateur JIT utilise cet attribut pour désactiver les optimisations rendant le débogage difficile. Celles qui déplacent le code comme un hissage invariant par les boucles. Dans certains cas, cela peut faire une grande différence en termes de performances. Pas généralement si.
La correspondance des points d'arrêt avec les adresses d'exécution est le travail du débogueur. Il utilise le fichier .pdb et les informations générés par le compilateur JIT qui fournit l'instruction IL pour coder le mappage des adresses. Si vous voulez écrire votre propre débogueur, vous utiliserez ICorDebugCode :: GetILToNativeMapping ().
En gros, le déploiement du débogage sera plus lent puisque les optimisations du compilateur JIT sont désactivées.
Ce que vous lisez est tout à fait valable. La libération est généralement plus légère en raison de l'optimisation JIT, sans inclure le code de débogage (#IF DEBUG ou [Conditionnel ("DEBUG")]), le chargement de symbole de débogage minimal et souvent n'étant pas pris en compte est un assemblage plus petit qui réduira le temps de chargement. Les performances différentes sont plus évidentes lors de l’exécution du code dans VS en raison de l’étendue de la PDB et des symboles chargés, mais si vous l’exécutez de manière indépendante, les différences de performances peuvent être moins évidentes. Certains codes seront optimisés mieux que d’autres et ils utilisent les mêmes méthodes heuristiques d’optimisation, comme dans d’autres langages.
Scott a une bonne explication sur l'optimisation de la méthode en ligne ici
Voir cet article qui explique brièvement pourquoi il est différent dans l'environnement ASP.NET pour les paramètres de débogage et de publication.
Une chose que vous devriez noter, en ce qui concerne les performances et si le débogueur est connecté ou non, est quelque chose qui nous a pris par surprise.
Nous avions un morceau de code, impliquant de nombreuses boucles serrées, qui semblait prendre un temps fou à déboguer, mais qui fonctionnait assez bien tout seul. En d'autres termes, aucun client ou client ne rencontrait de problèmes, mais lors du débogage, il semblait fonctionner comme de la mélasse.
Le coupable était un Debug.WriteLine dans l'une des boucles serrées, qui génèrent des milliers de messages de journal, laissés d'une session de débogage il y a quelque temps. Il semble que lorsque le débogueur est attaché et écoute une telle sortie, il en résulte une surcharge qui ralentit le programme. Pour ce code particulier, il était de l’ordre de 0,2 à 0,3 secondes d’exécution, et de 30 secondes ou plus lorsque le débogueur était attaché.
Solution simple cependant, supprimez simplement les messages de débogage devenus inutiles.
Dans msdn site ...
Configurations Release vs. Debug
Pendant que vous travaillez encore sur votre projet, vous construirez généralement votre application à l'aide de la configuration de débogage, car cette configuration vous permet d'afficher la valeur des variables et de contrôler l'exécution dans le débogueur. Vous pouvez également créer et tester des versions dans la configuration de l'édition afin de vous assurer que vous n'avez introduit aucun bogue ne se manifestant que sur un type de version ou l'autre. Dans la programmation .NET Framework, ces bogues sont très rares, mais ils peuvent se produire.
Lorsque vous êtes prêt à distribuer votre application aux utilisateurs finaux, créez une version validée, qui sera beaucoup plus petite et aura généralement de bien meilleures performances que la configuration de débogage correspondante. Vous pouvez définir la configuration de construction dans le volet de construction du concepteur de projet ou dans la barre d'outils de construction. Pour plus d'informations, voir Configurations de construction.
Les modes Debug et Release ont des différences. Il existe un outil Fuzzlyn : il s’agit d’un fuzzer qui utilise Roslyn pour générer des programmes C # aléatoires. Il exécute ces programmes sur le noyau .NET et s'assure qu'ils donnent les mêmes résultats lorsqu'ils sont compilés en mode débogage et libération.
Avec cet outil, il a été trouvé et a signalé beaucoup de bugs.
J'ai récemment rencontré un problème de performance. La liste complète des produits prenait trop de temps, environ 80 secondes. J'ai réglé la base de données, amélioré les requêtes et il n'y avait pas de différence. J'ai décidé de créer un TestProject et j'ai découvert que le même processus avait été exécuté en 4 secondes. Ensuite, j'ai réalisé que le projet était en mode débogage et le projet test en mode publication. J'ai basculé le projet principal en mode Publication et la liste complète des produits n'a pris que 4 secondes pour afficher tous les résultats.
Résumé: Le mode de débogage est beaucoup plus lent que le mode d’exécution, car il conserve les informations de débogage. Vous devez toujours déployer en mode Relase. Vous pouvez toujours avoir des informations de débogage si vous incluez des fichiers .PDB. De cette façon, vous pouvez enregistrer les erreurs avec les numéros de ligne, par exemple.
Cela dépend dans une large mesure du fait que votre application soit liée à l'informatique et il n'est pas toujours facile à dire, comme dans l'exemple de Lasse. Si j'ai la moindre question sur ce qu'il fait, je l'interromps quelques fois et examine la pile. S'il y a quelque chose de plus dont je n'avais pas vraiment besoin, cela le détecte immédiatement.