Czy DateTime.Now jest najlepszym sposobem pomiaru wydajności funkcji?

Muszę znaleźć wąskie gardło i precyzyjnie zmierzyć czas.

Czy poniższy fragment kodu jest najlepszym sposobem pomiaru wydajności?

DateTime startTime = DateTime.Now;

// Some execution process

DateTime endTime = DateTime.Now;
TimeSpan totalTimeTaken = endTime.Subtract(startTime);

Nie, nie jest. Użyj stopera (w System.Diagnostics)

Stopwatch sw = Stopwatch.StartNew();
PerformWork();
sw.Stop();

Console.WriteLine("Time taken: {0}ms", sw.Elapsed.TotalMilliseconds);

Stoper automatycznie sprawdza istnienie precyzyjnych timerów.

Warto wspomnieć, że DateTime.Nowczęsto jest to nieco wolniejsze niż DateTime.UtcNowze względu na pracę, którą należy wykonać w strefach czasowych, DST i tym podobnych.

DateTime.UtcNow zazwyczaj ma rozdzielczość 15 ms. Zobacz Johna Chapmana blogu o DateTime.Nowdokładności do wielkiego podsumowania.

Ciekawe ciekawostki: Stoper wraca, DateTime.UtcNowjeśli twój sprzęt nie obsługuje licznika wysokich częstotliwości. Możesz sprawdzić, czy stoper używa sprzętu do osiągnięcia wysokiej precyzji, patrząc na pole statyczne Stopwatch.IsHighResolution .

Jeśli chcesz czegoś szybkiego i brudnego, sugeruję użycie stopera zamiast tego dla większej precyzji.

Stopwatch sw = new Stopwatch();
sw.Start();
// Do Work
sw.Stop();

Console.WriteLine("Elapsed time: {0}", sw.Elapsed.TotalMilliseconds);

Alternatywnie, jeśli potrzebujesz czegoś bardziej wyrafinowanego, prawdopodobnie powinieneś rozważyć użycie zewnętrznego profilera, takiego jak ANTS .

Ten artykuł mówi, że przede wszystkim musisz porównać trzy alternatywy Stopwatch, DateTime.NowAND DateTime.UtcNow.

Pokazuje także, że w niektórych przypadkach (gdy licznik wydajności nie istnieje) Stoper używa DateTime.UtcNow + dodatkowe przetwarzanie. Z tego powodu jest oczywiste, że w takim przypadku najlepsza jest opcja DateTime.UtcNow (ponieważ inni używają jej + trochę przetwarzania)

Jak się jednak okazuje, licznik prawie zawsze istnieje - patrz Objaśnienie dotyczące licznika wydajności wysokiej rozdzielczości i jego istnienia związanego z .NET Stopwatch? .

Oto wykres wydajności. Zauważ, jak niski koszt wydajności UtcNow w porównaniu z alternatywami:

Oś X to przykładowy rozmiar danych, a oś Y to czas względny z przykładu.

Jedna rzecz Stopwatchjest lepsza w tym, że zapewnia pomiary czasu w wyższej rozdzielczości. Innym jest jego bardziej charakter OO. Jednak utworzenie opakowania OO UtcNownie może być trudne.

Przydatne jest umieszczenie kodu testu porównawczego w klasie / metodzie użyteczności. StopWatchKlasa nie musi być Disposedalbo Stoppedw przypadku błędu. Tak, to najprostszy kod do czasu niektóre działania jest

public partial class With
{
    public static long Benchmark(Action action)
    {
        var stopwatch = Stopwatch.StartNew();
        action();
        stopwatch.Stop();
        return stopwatch.ElapsedMilliseconds;
    }
}

Przykładowy kod wywołujący

public void Execute(Action action)
{
    var time = With.Benchmark(action);
    log.DebugFormat(“Did action in {0} ms.”, time);
}

Oto wersja metody rozszerzenia

public static class Extensions
{
    public static long Benchmark(this Action action)
    {
        return With.Benchmark(action);
    }
}

I przykładowy kod wywołujący

public void Execute(Action action)
{
    var time = action.Benchmark()
    log.DebugFormat(“Did action in {0} ms.”, time);
}

Funkcjonalność stopera byłaby lepsza (większa precyzja). Polecam również pobranie jednego z popularnych profilerów (jednak najczęściej korzystałem z DotTrace i ANTS ... bezpłatna wersja próbna DotTrace jest w pełni funkcjonalna i nie ma w tym nic dziwnego).

Użyj klasy System.Diagnostics.Stopwatch.

Stopwatch sw = new Stopwatch();
sw.Start();

// Do some code.

sw.Stop();

// sw.ElapsedMilliseconds = the time your "do some code" took.

Ditto Stopwatch, jest o wiele lepszy.

Jeśli chodzi o pomiar wydajności, powinieneś również sprawdzić, czy Twój proces // // Some Execution Process jest bardzo krótki.

Należy również pamiętać, że pierwsze uruchomienie „// Some Execution Process” może być znacznie wolniejsze niż kolejne.

Zazwyczaj testuję metodę, uruchamiając ją 1000 razy lub 1000000 razy w pętli i uzyskuję znacznie dokładniejsze dane niż raz.

Są to świetne sposoby mierzenia czasu, ale jest to tylko bardzo pośredni sposób na znalezienie wąskiego gardła (wąskich gardeł).

Najbardziej bezpośrednim sposobem na znalezienie wąskiego gardła w wątku jest uruchomienie go, a gdy robi to, co sprawia, że ​​czekasz, zatrzymaj go za pomocą klawisza pauzy lub złamania. Zrób to kilka razy. Jeśli twoje wąskie gardło zajmuje X% czasu, X% to prawdopodobieństwo, że złapiesz go na akcie na każdej migawce.

Oto pełniejsze wyjaśnienie, w jaki sposób i dlaczego to działa

@ Sean Chambers

Do Twojej wiadomości, klasa .NET Timer nie jest przeznaczona do diagnostyki, generuje zdarzenia w ustalonych odstępach czasu, takich jak ten (z MSDN ):

System.Timers.Timer aTimer;
public static void Main()
{
    // Create a timer with a ten second interval.
    aTimer = new System.Timers.Timer(10000);

    // Hook up the Elapsed event for the timer.
    aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);

    // Set the Interval to 2 seconds (2000 milliseconds).
    aTimer.Interval = 2000;
    aTimer.Enabled = true;

    Console.WriteLine("Press the Enter key to exit the program.");
    Console.ReadLine();
}

// Specify what you want to happen when the Elapsed event is 
// raised.
private static void OnTimedEvent(object source, ElapsedEventArgs e)
{
    Console.WriteLine("The Elapsed event was raised at {0}", e.SignalTime);
}

To naprawdę nie pomaga wiedzieć, ile czasu zajęło, tylko że minęła pewna ilość czasu.

Timer jest również widoczny jako element sterujący w System.Windows.Forms ... można go znaleźć w skrzynce narzędzi projektanta w VS05 / VS08

To jest właściwy sposób:

using System;
using System.Diagnostics;

class Program
{
    public static void Main()
    {
        Stopwatch stopWatch = Stopwatch.StartNew();

            // some other code

        stopWatch.Stop();

        // this not correct to get full timer resolution
        Console.WriteLine("{0} ms", stopWatch.ElapsedMilliseconds);

        // Correct way to get accurate high precision timing
        Console.WriteLine("{0} ms", stopWatch.Elapsed.TotalMilliseconds);
    }
}

Aby uzyskać więcej informacji, przejdź do Użyj stopera zamiast DataTime w celu uzyskania dokładnego licznika wydajności .

Visual Studio Team System ma pewne funkcje, które mogą pomóc w rozwiązaniu tego problemu. Zasadniczo możesz pisać testy jednostkowe i mieszać je w różnych scenariuszach, aby uruchomić je z oprogramowaniem w ramach testu obciążenia lub obciążenia. Pomoże to zidentyfikować obszary kodu, które mają największy wpływ na wydajność aplikacji.

Grupa Microsoft ds. Wzorców i praktyk zawiera wskazówki w Visual Studio Team System Performance Testing Guidance .

Właśnie znalazłem post na blogu Vance'a Morrisona na temat napisanej przez niego klasy CodeTimer , która ułatwia korzystanie z niej StopWatchi robi porządne rzeczy z boku.

To nie jest wystarczająco profesjonalne:

Stopwatch sw = Stopwatch.StartNew();
PerformWork();
sw.Stop();

Console.WriteLine("Time taken: {0}ms", sw.Elapsed.TotalMilliseconds);

Bardziej niezawodna wersja to:

PerformWork();

int repeat = 1000;

Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < repeat; i++)
{
   PerformWork();
}

sw.Stop();

Console.WriteLine("Time taken: {0}ms", sw.Elapsed.TotalMilliseconds / repeat);

W moim prawdziwym kodzie dodam wywołanie GC.Collect, aby zmienić sterowaną stertę na znany stan, i dodam wywołanie uśpienia, aby różne przedziały kodu można było łatwo rozdzielić w profilu ETW.

Zrobiłem bardzo niewiele z tego rodzaju sprawdzania wydajności (zwykle myślę, że „to jest powolne, przyspieszam”), więc prawie zawsze to robiłem.

Google ujawnia wiele zasobów / artykułów do sprawdzania wydajności.

Wielu wspomina o użyciu pinvoke w celu uzyskania informacji o wydajności. Wiele materiałów, które badam, wspomina tylko o użyciu perfmon.

Edytować:

Widziałem rozmowy StopWatch .. Fajnie! Nauczyłem się czegoś :)

To wygląda na dobry artykuł

Sposób, w jaki korzystam z moich programów, to użycie klasy StopWatch, jak pokazano tutaj.

Stopwatch sw = new Stopwatch();
sw.Start();


// Critical lines of code

long elapsedMs = sw.Elapsed.TotalMilliseconds;