Trova il tempo di esecuzione di un metodo

Question

Sto realizzando un progetto di Steganography di immagini per il mio college. Ho terminato il progetto e ho mantenuto diversi algoritmi per nascondere i dati nelle immagini.

Quello che voglio chiedere è che c'è un modo in C# attraverso il quale posso trovare l'esecuzione/tempo di esecuzione tra due punti in un programma. Per esempio

//Some Code 
//Code to start recording the time. 
hideDataUsingAlgorithm(); 
//Code to stop recording and get the time of execution of the above function. 

che voglio fare questo per mostrare la differenza tra semplice (meno tempo) e gli algoritmi più efficienti, ma in termini di tempo (utilizzando medesimi dati e della stessa immagine). Ho circa 10 algoritmi diversi per le immagini a colori e in scala di grigi.

Non c'è il multithreading, quindi non sarà un problema. C'è semplicemente una discussione principale.

Answer 1

System.Environment.TickCount e la classe System.Diagnostics.Stopwatch sono due che funzionano bene per una risoluzione migliore e un utilizzo semplice.

Vedere anche:

1. Is DateTime.Now the best way to measure a function’s performance?
2. High resolution timer in .NET
3. Environment.TickCount vs DateTime.Now
4. What’s the best way to benchmark programs in Windows?

Answer 2

È possibile utilizzare StopWatch classe:

var timer = System.Diagnostics.StopWatch.StartNew(); 
hideDataUsingAlgorithm(); 
timer.Stop(); 
var elapsed = timer.ElapsedMilliseconds; 

Answer 3

Si tratta di un metodo di estensione utile per Cronometro:

public static class StopwatchExt 
{ 
    public static string GetTimeString(this Stopwatch stopwatch, int numberofDigits = 1) 
    { 
     double time = stopwatch.ElapsedTicks/(double)Stopwatch.Frequency; 
     if (time > 1) 
      return Math.Round(time, numberofDigits) + " s"; 
     if (time > 1e-3) 
      return Math.Round(1e3 * time, numberofDigits) + " ms"; 
     if (time > 1e-6) 
      return Math.Round(1e6 * time, numberofDigits) + " µs"; 
     if (time > 1e-9) 
      return Math.Round(1e9 * time, numberofDigits) + " ns"; 
     return stopwatch.ElapsedTicks + " ticks"; 
    } 
} 

usare in questo modo:

Stopwatch stopwatch = Stopwatch.StartNew(); 
//Call your method here 
stopwatch.Stop(); 
Console.WriteLine(stopwatch.GetTimeString()); 

Answer 4

È possibile dichiarare al vostro metodo di prova un delegato e utilizzare uno dei seguenti metodi di estensione a eseguilo N volte. In base alla stringa di formato passata si ottiene stampato per console:

• Prima volta chiamata
• tempo trascorso
• frequenza delle chiamate

quali sono tutti i valori utili. I metodi di estensione utilizzano Cronometro per ottenere la massima precisione.

Action acc = hideDataUsingAlgorithm; 
acc.Profile(100*1000, "Method did run {runs} times in {time}s, Frequency: {frequency}"); 

di controllare anche gli effetti di avvio è possibile utilizzare

acc.ProfileFirst(100*1000, "First call {0}s", "Method did run {runs} times in {time}s, Frequency: {frequency}"); 

questo modo si può facilmente controllare i metodi se il metodo in questione non è un metodo vuoto tali da falsare tempi perché l'invocazione delegato avrebbe essere paragonabile alla tua chiamata al metodo. L'idea originale è bloggata here.

Per un'analisi approfondita del tempo di chiamata, anche un profiler è molto utile. Dovresti provare a usare anche questi per essere in grado di diagnosticare problemi più difficili.

using System; 
using System.Globalization; 
using System.Diagnostics; 

namespace PerformanceTester 
{ 
    /// <summary> 
    /// Helper class to print out performance related data like number of runs, elapsed time and frequency 
    /// </summary> 
    public static class Extension 
    { 
     static NumberFormatInfo myNumberFormat; 

     static NumberFormatInfo NumberFormat 
     { 
      get 
      { 
       if (myNumberFormat == null) 
       { 
        var local = new CultureInfo("en-us", false).NumberFormat; 
        local.NumberGroupSeparator = " "; // set space as thousand separator 
        myNumberFormat = local; // make a thread safe assignment with a fully initialized variable 
       } 
       return myNumberFormat; 
      } 
     } 

     /// <summary> 
     /// Execute the given function and print the elapsed time to the console. 
     /// </summary> 
     /// <param name="func">Function that returns the number of iterations.</param> 
     /// <param name="format">Format string which can contain {runs} or {0},{time} or {1} and {frequency} or {2}.</param> 
     public static void Profile(this Func<int> func, string format) 
     { 

      Stopwatch watch = Stopwatch.StartNew(); 
      int runs = func(); // Execute function and get number of iterations back 
      watch.Stop(); 

      string replacedFormat = format.Replace("{runs}", "{3}") 
             .Replace("{time}", "{4}") 
             .Replace("{frequency}", "{5}"); 

      // get elapsed time back 
      float sec = watch.ElapsedMilliseconds/1000.0f; 
      float frequency = runs/sec; // calculate frequency of the operation in question 

      try 
      { 
       Console.WriteLine(replacedFormat, 
            runs, // {0} is the number of runs 
            sec, // {1} is the elapsed time as float 
            frequency, // {2} is the call frequency as float 
            runs.ToString("N0", NumberFormat), // Expanded token {runs} is formatted with thousand separators 
            sec.ToString("F2", NumberFormat), // expanded token {time} is formatted as float in seconds with two digits precision 
            frequency.ToString("N0", NumberFormat)); // expanded token {frequency} is formatted as float with thousands separators 
      } 
      catch (FormatException ex) 
      { 
       throw new FormatException(
        String.Format("The input string format string did contain not an expected token like "+ 
           "{{runs}}/{{0}}, {{time}}/{{1}} or {{frequency}}/{{2}} or the format string " + 
           "itself was invalid: \"{0}\"", format), ex); 
      } 
     } 

     /// <summary> 
     /// Execute the given function n-times and print the timing values (number of runs, elapsed time, call frequency) 
     /// to the console window. 
     /// </summary> 
     /// <param name="func">Function to call in a for loop.</param> 
     /// <param name="runs">Number of iterations.</param> 
     /// <param name="format">Format string which can contain {runs} or {0},{time} or {1} and {frequency} or {2}.</param> 
     public static void Profile(this Action func, int runs, string format) 
     { 
      Func<int> f =() => 
      { 
       for (int i = 0; i < runs; i++) 
       { 
        func(); 
       } 
       return runs; 
      }; 
      f.Profile(format); 
     } 

     /// <summary> 
     /// Call a function in a for loop n-times. The first function call will be measured independently to measure 
     /// first call effects. 
     /// </summary> 
     /// <param name="func">Function to call in a loop.</param> 
     /// <param name="runs">Number of iterations.</param> 
     /// <param name="formatFirst">Format string for first function call performance.</param> 
     /// <param name="formatOther">Format string for subsequent function call performance.</param> 
     /// <remarks> 
     /// The format string can contain {runs} or {0},{time} or {1} and {frequency} or {2}. 
     /// </remarks> 
     public static void ProfileWithFirst(this Action func, int runs, string formatFirst, string formatOther) 
     { 
      func.Profile(1, formatFirst); 
      func.Profile(runs - 1, formatOther); 
     } 
    } 
} 

Answer 5

È inoltre possibile utilizzare BenchmarkDotNet

Poi si fa:

1) Creare un progetto di console con un riferimento al codice che si desidera testare.

using BenchmarkDotNet.Running; 
using BenchmarkDotNet.Attributes; 
class Program 
{ 
    static void Main() 
    { 
     var summary = BenchmarkRunner.Run<YourBenchmarks>(); 
    } 
} 

public class YourBenchmarks 
{ 
    [Benchmark] 
    public object HideDataUsingAlgorithm() 
    { 
     return Namespace.hideDataUsingAlgorithm(); // call the code you want to benchmark here 
    } 
} 

2) Creare in versione ed eseguire senza debugger.

3) Aprire il report che si trova nella bin/release/YourBenchmarks-report-stackoverflow.md

Il rapporto contiene mediana e StdDev per impostazione predefinita. BenchmarkDotNet si occupa di warmup e avvia il processo un numero di volte per fornire statistiche accurate.

Esempio di rapporto:

    Method |  Median | StdDev | 
----------------------- |------------ |---------- | 
HideDataUsingAlgorithm | 252.4869 ns | 8.0261 ns | 

Per la configurazione leggere il docs.