Quelle est la meilleure façon de mesurer combien de temps le code nécessaire à l'exécution?

Je suis en train de déterminer l'approche à la suppression d'une chaîne est le plus rapide.

J'ai simplement obtenir le commencer et fin temps et de montrer la différence.

Mais les résultats sont si varié, par exemple, comme illustré ci-dessous la même méthode peut prendre à partir de 60 ms 231 ms.

Quelle est la meilleure méthode pour obtenir des résultats plus précis?

le texte d'alt http://www.deviantsart.com/upload/1q4t3rl.png

using System;
using System.Collections;
using System.Collections.Generic;

namespace TestRemoveFast
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int j = 0; j < 10; j++)
            {
                string newone = "";
                List<string> tests = new List<string>();
                for (int i = 0; i < 100000; i++)
                {
                    tests.Add("{http://company.com/Services/Types}ModifiedAt");
                }

                DateTime start = DateTime.Now;
                foreach (var test in tests)
                {
                    //newone = ((System.Xml.Linq.XName)"{http://company.com/Services/Types}ModifiedAt").LocalName;
                    newone = Clean(test);
                }

                Console.WriteLine(newone);
                DateTime end = DateTime.Now;
                TimeSpan duration = end - start;
                Console.WriteLine(duration.ToString());
            }

            Console.ReadLine();
        }

        static string Clean(string line)
        {
            int pos = line.LastIndexOf('}');
            if (pos > 0)
                return line.Substring(pos + 1, line.Length - pos - 1);
                //return line.Substring(pos + 1);
            else
                return line;
        }
    }
}
  • Je ne pense pas qu'il n'y a rien d'intrinsèquement imprécis sur la meassurements eux-mêmes. Tu veux sans doute dire que ne m'attendais pas à grande dispersion. Je suppose que vous avez à faire assurez-vous qu'aucun autre programme sur votre ordinateur, utilisez tout votre temps cpu ou de la mémoire.
  • Notez que le "mur de l'horloge", mesurée par le DateTime est que la précision de quelque chose comme 30 mme. DateTime est de représenter les choses comme une horloge sur le mur, ou le temps que vous dernière modification d'un fichier; il se complique pas avoir l'ordre de la nanoseconde précision, et donc il n'a pas.
InformationsquelleAutor Edward Tanguay | 2010-01-15
  1. 46

    Vous devez utiliser Système.Diagnostics.Chronomètre, et vous pourriez envisager un échantillon de grande taille. Par exemple, répéter le test à quelque chose comme 10 000 fois et la moyenne des résultats. Si vous pensez à ce sujet scientifiquement, c'est logique. La plus grande de l'échantillon, le mieux. Vous pouvez éliminer beaucoup de cas de bord de cette façon, et de vraiment voir ce que le rendement de base est comme.

    Une autre chose à considérer est que la compilation JIT et la création d'un objet peut certainement fausser vos résultats, alors assurez-vous de démarrer et arrêter le Chronomètre au moment approprié, et d'appeler les méthodes que vous souhaitez tester au moins une fois avant de commencer vos tests. Essayez de séparer simplement les pièces que vous souhaitez tester le reste de votre code autant que possible.

    • Aussi, j'ai l'habitude assurez-vous d'avoir invoqué les méthodes de test pour éviter d'avoir compilation JIT fois inclus dans la mesure.
    • Ouais, bon point, Fredrik. Vous souhaitez assurez-vous de briser votre test en seulement les bits que vous souhaitez surveiller. Un grand nombre de fois des gens ne pensent pas comment créer de nouveaux objets et JIT peut fausser les résultats.
    • Certainement ajouter de répéter. À des morceaux de <10s système de remise de temps PROCESSEUR pour d'autres tâches peuvent affecter les performances du test au sérieux. Un test de ~10 minutes, c'est plus fiable. Aussi, de tuer tous les autres gourmands en ressources PROCESSEUR et le disque-les processus les plus gourmands.
    • Sont de bonnes techniques de randomisation? Tout simplement de l'exécution de chaque méthode de 10 000 fois et la comparaison est susceptible d'être fortement biaisée par la corrélation sérielle. Besoin d'alterner ou aléatoire entre chaque exécution.
    InformationsquelleAutor Scott Anderson
  2. 36

    Trois remarques simples:

    1. Utilisation Système.Diagnostics.Chronomètre.

    2. N'avez pas le profil de votre code sur la même entrée d'un million de fois. Essayez de trouver votre distribution d'intrants et de profil de sur celui. C'est le profil sur le monde réel d'entrée, pas de données de laboratoire.

    3. Exécuter le Clean méthode une fois avant d'entrer dans le profilage de la boucle pour éliminer JITting temps. Parfois, c'est important.

    De ces, note 1. et 2. sont de loin le plus important.

    Votre profilage résultats sont inutiles, si vous n'êtes pas à l'aide d'un timer haute résolution. Notez que nous n'avons pas le temps Usain Bolt à l'aide d'un horloge à eau.

    Votre profilage résultats sont inutiles, si vous n'êtes pas d'essais sur le monde réel de l'entrée. Notez que les tests de collision accident de voitures sur la tête dans les autres voitures, à 35 km /H, pas dans les murs de marshmellows à 5 MPH.

    Ainsi:

    //expectedInput is string[1000000]
//populate expectedInput with real-world input
Clean(expectedInput[0]);
Stopwatch sw = new Stopwatch();
sw.Restart();          //So you dont have to call sw.Reset()
for (int i = 0; i < 1000000; i++) {
    string t = Clean(expectedInput[i]);
}
sw.Stop();
Console.WriteLine(sw.Elapsed);

    Un complexe remarque:

    Si vous avez vraiment besoin de faire de profilage, d'obtenir un profiler comme Les FOURMIS.

    • Je ne trouve pas le Propre de la méthode de n'importe où, aussi ne pouvait pas le trouver sur MSDN?
    • se trouve être le nom de la méthode que l'OP est le benchmarking; c'est pourquoi nous nous référons à Clean ici.
    InformationsquelleAutor jason
  3. 6

    Vous pouvez utiliser le Chronomètre classe.

    Le Chronomètre mesure le temps écoulé par
    le comptage du minuteur de tiques dans le sous-jacent
    minuterie mécanisme. Si l'installé
    matériel et système d'exploitation soutien
    une haute résolution de compteur de performance,
    alors que le Chronomètre de la classe qui utilise
    compteur pour mesurer le temps écoulé.

    var sw = new Stopwatch();

sw.Start();
//...
sw.Stop();
    InformationsquelleAutor João Angelo
  4. 3

    Si vous êtes inquiet au sujet de la tester dans votre propre code...utiliser un System.Diagnostics.Stopwatch

    D'habitude, je préfère casser ce genre de chose dans mon code et à l'aide d'un vrai Profiler comme RedGate de la Performance Profiler

    InformationsquelleAutor Justin Niessner
  5. 2

    Il y a beaucoup d'activité sous le capot de l'OS, qui est très susceptible de gâcher votre temps de mesure. Afin d'améliorer la précision de la mesure de temps vous devez exécuter les tests plusieurs fois et supprimer les plus faibles et les plus grands moments de la finale des résultats. Cette approche permettra d'exclure la plupart des facteurs externes qui peuvent influencer votre code de temps d'exécution et vous sera très utile dans la plupart des cas. Le Chronomètre classe est utilisée pour mesurer le temps, car il est beaucoup plus précise que l'utilisation DateTime.

    Vous pouvez facilement créer une classe de test pour automatiser cela. J'ai publié une telle classe dans mon blog. On peut comparer la performance des deux C# fragments de code/algorithmes. Tout ce que vous avez à faire est de remplacer le Method1 et Method2 méthodes en y mettant les fragments de code que vous souhaitez tester et d'utiliser la classe de test comme ceci:

    Test test = new CustomTest();
Console.WriteLine("\n==============================");
Console.WriteLine(test.Execute());
Console.WriteLine("==============================\n");
    InformationsquelleAutor Pavel Vladov
  6. 0

    Vous pouvez avoir à appliquer quelques techniques statistiques, ici, de fer hors de la variance. Essayez d'exécuter le même morceau de code 1000 fois, puis prendre la moyenne des temps, et de les comparer. Les Simulations utilisent généralement une sorte de méthodes pour "nettoyer" les chiffres, et c'est l'un de ceux-ci.

    InformationsquelleAutor Extrakun
  7. 0

    En général: Ne pas regarder les wallclock temps, mais le temps CPU consommé par le processus afin de déterminer combien de temps il a couru. Surtout pour les choses qui sont juste calcul de ce qui est beaucoup plus fiable parce qu'il ne sera pas affectée par d'autres processus en cours d'exécution en même temps.

    • Cela peut être problématique, cependant, parce que le temps de calcul sera également compte pas les choses comme l'attente d'e/S, ou pour un défaut de page (?). Ces répercussions sur les performances du système réel et doivent être prises en compte.
    • C'est pourquoi j'ai noté que c'est principalement pour le calcul uniquement des tâches.
    InformationsquelleAutor Joey
  8. 0

    Le problème avec toutes les de l'horloge d'approches, c'est que vous n'êtes jamais tout à fait certain de ce que vous êtes timing. Vous pouvez, si vous en soyez conscients ou non, de les inclure dans votre calendrier:

    • retards alors que l'o/s préempte votre processeur;
    • de commutation de contexte
    • stands, tandis que le programme attend les données;
    • et beaucoup beaucoup plus.

    Je ne dis pas que tous ceux-ci s'appliquent à ce calendrier, mais pour les timings en général. Donc, vous devez compléter n'importe quel timing, vous ne avec une certaine prise en compte de la façon dont de nombreuses opérations de base de votre alternative codes exécuter -- quelques considérations de complexité ne pas l'ignorer (comme nous avons l'habitude de le faire) les termes constants.

    Dans votre cas particulier, vous devez vous efforcer de temps beaucoup plus longue exécutions; lorsque votre fois sont des sous-deuxième l'o/s, il est extrêmement probable que désordre autour de vous. Alors courez 10^6 itérations et l'utilisation de la moyenne de plus de suffisamment de pistes pour vous donner un véritable calcul de la moyenne et de la variance. Et assurez-vous que, si vous prenez cette approche, que vous n'avez pas par inadvertance, d'accélérer le deuxième procès en ayant des données déjà chargées après la fin du premier procès. Vous devez vous assurer que chacun des 10^6 essais fait exactement ce que le 1er essai n'.

    Avoir du plaisir

    Marque

    InformationsquelleAutor High Performance Mark
  9. 0

    Je vais recommander le très profiler inclus dans Visual Studio Team Suite ou le Développement de l'Édition (ou de la prochaine Visual Studio 2010 Premium ou Ultimate est encore mieux) comme le meilleur moyen. Il est hautement configurable, extrêmement puissant, simple à utiliser, très rapide, et fonctionne à la fois en maternelle et en code managé. Je ne suis pas familier avec le flux de travail de Les FOURMIS, mais qui semble être une autre option. Sans doute à l'aide d'un profileur de l' seulement option pour un développeur qui est concerné par leur performance applicative. Il n'y a pas de substitut, et vous ne peut pas vraiment prendre tout développeur de travail sur la performance qui permettrait de passer d'un profiler au sérieux.

    Toutefois, si vous êtes intéressé dans les mesures pour l'un des suivants, vous ne pouvez pas avoir accès à un tel profiler, dans lequel cas, le Chronomètre de la classe peuvent constituer une base pour votre technique de mesure:

    • Un étudiant ou amateur intéressé par la performance de leurs projets (un commercial profiler peut-être hors de portée pour des raisons financières)
    • Dans une société libérée de l'application, vous pouvez de temps les sections de code qui s'exécute sur le thread de l'INTERFACE utilisateur et les statistiques du rapport de peut assurer les opérations de jamais cause des délais d'attente pour l'un de vos utilisateurs. Le Bureau de l'équipe a utilisé une méthode comme ceci, avec un énorme succès (Outlook 2007 SP2 n'importe qui?), et je sais que l'équipe Visual Studio a ce code dans au moins la version 2010.
    • Très profiler?
    InformationsquelleAutor Sam Harwell
  10. -1

    Vous pouvez également utiliser log4net, il suffit d'ajouter log.Info("Test") où vous voulez suivre des trucs et vous trouverez toutes les infos et le temps que la ligne a été exécuté dans un fichier txt, par exemple: 2018-12-13 10:02:16,704 [9] INFO Hms.Domain.Concrete.RoomsRepository [(null)] - Test Lire plus à ce sujet ici: https://www.infoworld.com/article/3120909/application-development/how-to-work-with-log4net-in-c.html

    InformationsquelleAutor Krisi Suci