Performances de débogage et de publication

J’ai rencontré le paragraphe suivant:

«Le paramètre Déboguer / Libérer dans l’EDI lorsque vous comstackz votre code dans Visual Studio ne fait pratiquement aucune différence en termes de performances… le code généré est presque identique. Le compilateur C # ne fait pas vraiment d’optimisation. Le compilateur C # ne fait que cracher IL… et à l’exécution, c’est JITer qui fait toute l’optimisation. Le JITer a un mode Debug / Release et cela fait une énorme différence en termes de performances. Mais cela ne détermine pas si vous exécutez la configuration Debug ou Release de votre projet, qui détermine si un débogueur est connecté ou non.

La source est ici et le podcast est ici .

Quelqu’un peut-il me diriger vers un article Microsoft qui peut réellement le prouver?

Googler ” C # debug vs release performance ” renvoie principalement des résultats en disant ” Debug a beaucoup de performances touchées “, ” release est optimisée ” et ” ne pas déployer le débogage en production “.

Partiellement vrai En mode débogage, le compilateur émet des symboles de débogage pour toutes les variables et comstack 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 retirées de la boucle par le compilateur si elles se révèlent être des invariants
  • le code écrit sous la directive #debug n’est pas inclus, etc.

Le rest est à l’ordre du JIT.

Edit: Liste complète des optimisations ici grâce à Eric Lippert

Il n’y a aucun article qui “prouve” quelque chose sur une question de performance. La manière de prouver une affirmation concernant l’impact d’un changement sur les performances consiste à l’essayer dans les deux sens et à la tester dans des conditions réalistes mais contrôlées.

Vous posez une question sur la performance, donc vous vous souciez clairement de la performance. Si vous vous souciez de la performance, la bonne chose à faire est de définir des objectives de performance, puis d’écrire vous-même une suite de tests pour suivre vos progrès par rapport à ces objectives. Une fois que vous avez une telle suite de tests, vous pouvez facilement l’utiliser pour tester 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% moins rapide dans des conditions réalistes” est plus significatif.

Passez le temps que vous auriez passé à rechercher cette question en ligne sur la création d’un appareil répondant à la question. Vous obtiendrez des résultats beaucoup plus précis de cette façon. Tout ce que vous lisez en ligne n’est qu’une idée de ce qui pourrait arriver. Raison des faits que vous avez vous-même recueillis, et non 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 pas déployer le débogage en production» tient toujours parce que le code de débogage fait généralement pas mal de choses différentes dans les gros produits. D’une part, vous pouvez avoir des commutateurs de débogage actifs et, pour un autre, il y aura probablement des vérifications de sécurité redondantes et des sorties de débogage supplémentaires 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.DebuggableAtsortingbute. Dans la version de débogage, la propriété IsJitOptimizerEnabled est définie sur True, dans la version finale, sur False. Vous pouvez voir cet atsortingbut dans le manifeste d’assembly avec ildasm.exe

Le compilateur JIT utilise cet atsortingbut pour désactiver les optimisations qui rendent le débogage difficile. Ceux qui déplacent le code comme le levage en boucle invariant. Dans certains cas, cela peut faire une grande différence dans les performances. Pas habituellement

Le mappage des points d’arrêt aux adresses d’exécution est le travail du débogueur. Il utilise le fichier .pdb et les informations générées par le compilateur JIT qui fournit l’instruction IL pour coder l’adresse. Si vous écriviez votre propre débogueur, vous utiliseriez ICorDebugCode :: GetILToNativeMapping ().

Fondamentalement, le déploiement du débogage sera plus lent car les optimisations du compilateur JIT sont désactivées.

Ce que vous lisez est tout à fait valide. La libération est généralement plus maigre en raison de l’optimisation JIT, n’incluant pas le code de débogage (#IF DEBUG ou [Conditional (“DEBUG”)]). Les performances différentes sont plus évidentes lorsque vous exécutez le code dans VS à cause du nombre plus important de PDB et de symboles chargés, mais si vous l’exécutez indépendamment, les différences de performances peuvent être moins apparentes. Certains codes s’optimiseront mieux que d’autres et utilisent les mêmes heuristiques d’optimisation que dans les 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 parameters de débogage et de publication.

Une chose que vous devez noter, en ce qui concerne les performances et si le débogueur est connecté ou non, quelque chose qui nous a pris par surprise.

Nous avions un morceau de code, impliquant de nombreuses boucles serrées, qui semblait prendre une éternité à déboguer, mais fonctionnait assez bien seul. En d’autres termes, aucun client ou client ne rencontrait de problème, 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 crachait des milliers de messages de journal, restés depuis une session de débogage il ya quelque temps. Il semble que lorsque le débogueur est connecté et qu’il écoute de telles sorties, il y a un surcoût qui ralentit le programme. Pour ce code particulier, il était de l’ordre de 0,2 à 0,3 seconde d’exécution, et de 30 secondes et plus lorsque le débogueur était connecté.

Solution simple, supprimez simplement les messages de débogage devenus inutiles.

Dans le site msdn …

Libérer les configurations de débogage

Pendant que vous travaillez encore sur votre projet, vous allez généralement créer 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 la version afin de vous assurer que vous n’avez pas introduit de bogues qui ne se manifestent que sur un type de génération ou l’autre. Dans la programmation de .NET Framework, de tels bogues sont très rares, mais ils peuvent se produire.

Lorsque vous êtes prêt à dissortingbuer votre application aux utilisateurs finaux, créez une version finale, 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 la construction dans le volet Générer du Concepteur de projets ou dans la barre d’outils Générer. Pour plus d’informations, voir Configurations de construction.

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 firebase database, 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. Puis j’ai réalisé que le projet était en mode Debug et que le projet de test était en mode Release. J’ai basculé le projet principal en mode Release et la liste complète des produits n’a pris que 4 secondes pour afficher tous les résultats.

Résumé: Le mode débogage est beaucoup plus lent que le mode 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. Vous pouvez ainsi enregistrer les erreurs avec des numéros de ligne, par exemple.

Dans une large mesure, cela dépend si votre application est liée au calcul, et ce n’est pas toujours facile à dire, comme dans l’exemple de Lasse. Si j’ai la moindre question à propos de ce que je fais, je l’arrête quelques fois et examine la stack. S’il y a quelque chose en plus que je n’ai pas vraiment besoin, ça le repère immédiatement.

Les modes Debug et Release ont des différences. Il existe un outil Fuzzlyn : c’est un fuzzer qui utilise Roslyn pour générer des programmes C # aléatoires. Il exécute ces programmes sur le kernel .NET et s’assure qu’ils donnent les mêmes résultats lorsqu’ils sont compilés en mode débogage et en version.

Avec cet outil, il a été trouvé et a signalé beaucoup de bugs.