Apakah DateTime. Sekarang cara terbaik untuk mengukur kinerja suatu fungsi?

Saya perlu menemukan hambatan dan perlu seakurat mungkin mengukur waktu.

Apakah potongan kode berikut ini cara terbaik untuk mengukur kinerja?

DateTime startTime = DateTime.Now;

// Some execution process

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

Tidak, tidak. Gunakan Stopwatch (dalam System.Diagnostics)

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

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

Stopwatch secara otomatis memeriksa keberadaan timer presisi tinggi.

Perlu disebutkan bahwa DateTime.Nowseringkali sedikit lebih lambat daripada DateTime.UtcNowkarena pekerjaan yang harus dilakukan dengan zona waktu, DST dan semacamnya.

DateTime.UtcNow biasanya memiliki resolusi 15 ms. Lihat posting blog John Chapman tentang DateTime.Nowpresisi untuk ringkasan yang bagus.

Hal-hal sepele yang menarik: Stopwatch kembali hidup DateTime.UtcNowjika perangkat keras Anda tidak mendukung penghitung frekuensi tinggi. Anda dapat memeriksa untuk melihat apakah Stopwatch menggunakan perangkat keras untuk mencapai presisi tinggi dengan melihat Stopwatch bidang statis .

Jika Anda menginginkan sesuatu yang cepat dan kotor saya sarankan menggunakan Stopwatch sebagai gantinya untuk tingkat presisi yang lebih tinggi.

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

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

Atau, jika Anda membutuhkan sesuatu yang sedikit lebih canggih Anda mungkin harus mempertimbangkan untuk menggunakan profiler pihak ke-3 seperti SEMUT .

Artikel ini mengatakan bahwa pertama-tama Anda perlu membandingkan tiga alternatif Stopwatch,, DateTime.NowDAN DateTime.UtcNow.

Ini juga menunjukkan bahwa dalam beberapa kasus (ketika penghitung kinerja tidak ada) Stopwatch menggunakan DateTime.UtcNow + beberapa pemrosesan tambahan. Karena itu jelas bahwa dalam hal ini DateTime.UtcNow adalah pilihan terbaik (karena yang lain menggunakannya + beberapa pemrosesan)

Namun, ternyata, penghitung hampir selalu ada - lihat Penjelasan tentang penghitung kinerja resolusi tinggi dan keberadaannya terkait dengan .NET Stopwatch? .

Ini adalah grafik kinerja. Perhatikan bagaimana UtcNow berbiaya rendah dibandingkan dengan alternatif:

Sumbu X adalah ukuran data sampel, dan sumbu Y adalah waktu relatif dari contoh.

Satu hal Stopwatchyang lebih baik adalah memberikan pengukuran waktu resolusi yang lebih tinggi. Lain adalah sifatnya yang lebih OO. Namun, membuat pembungkus OO UtcNowtidak sulit.

Sangat berguna untuk mendorong kode pembandingan Anda ke kelas / metode utilitas. The StopWatchkelas tidak perlu Disposedatau Stoppedpada kesalahan. Jadi, kode paling sederhana untuk menentukan waktu beberapa tindakan adalah

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

Contoh kode panggilan

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

Ini adalah versi metode ekstensi

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

Dan contoh kode panggilan

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

The stopwatch fungsi akan lebih baik (presisi tinggi). Saya juga merekomendasikan hanya mengunduh salah satu profiler populer, ( DotTrace dan ANTS adalah yang paling sering saya gunakan ... percobaan gratis untuk DotTrace berfungsi penuh dan tidak mengomel seperti yang lain).

Gunakan kelas 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, ini jauh lebih baik.

Mengenai pengukuran kinerja, Anda juga harus memeriksa apakah "// Beberapa Proses Eksekusi" Anda adalah proses yang sangat singkat.

Ingat juga bahwa proses pertama "// Some Execution Process" Anda mungkin lebih lambat daripada proses selanjutnya.

Saya biasanya menguji metode dengan menjalankannya 1000 kali atau 1000000 kali dalam satu lingkaran dan saya mendapatkan data yang jauh lebih akurat daripada menjalankannya sekali.

Ini semua adalah cara yang bagus untuk mengukur waktu, tetapi itu hanya cara yang sangat tidak langsung untuk menemukan hambatan.

Cara paling langsung untuk menemukan bottneck di utas adalah menjalankannya, dan saat melakukan apa pun yang membuat Anda menunggu, hentikan dengan jeda atau kunci istirahat. Lakukan ini beberapa kali. Jika kemacetan Anda memakan waktu X%, X% adalah probabilitas bahwa Anda akan menangkapnya dalam aksi di setiap snapshot.

Berikut adalah penjelasan yang lebih lengkap tentang bagaimana dan mengapa itu bekerja

@ Sean Chambers

FYI, kelas .NET Timer bukan untuk diagnostik, ini menghasilkan peristiwa pada interval yang telah ditentukan, seperti ini (dari 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);
}

Jadi ini benar-benar tidak membantu Anda tahu berapa lama sesuatu, hanya saja sejumlah waktu telah berlalu.

Timer juga ditampilkan sebagai kontrol di System.Windows.Forms ... Anda dapat menemukannya di kotak alat desainer Anda di VS05 / VS08

Ini cara yang benar:

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);
    }
}

Untuk informasi lebih lanjut, gunakan Use Stopwatch alih-alih DataTime untuk mendapatkan penghitung kinerja yang akurat .

Sistem Tim Visual Studio memiliki beberapa fitur yang dapat membantu mengatasi masalah ini. Pada dasarnya Anda dapat menulis unit test dan mencampurnya dalam skenario yang berbeda untuk dijalankan terhadap perangkat lunak Anda sebagai bagian dari stress atau load test. Ini dapat membantu mengidentifikasi area kode yang paling memengaruhi kinerja aplikasi Anda.

Grup Pola dan Praktik Microsoft memiliki beberapa panduan dalam Pedoman Pengujian Kinerja Sistem Tim Visual Studio .

Saya baru saja menemukan posting di blog Vance Morrison tentang kelas CodeTimer yang ditulisnya yang membuat penggunaan StopWatchlebih mudah dan melakukan beberapa hal yang rapi di samping.

Ini tidak cukup profesional:

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

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

Versi yang lebih andal adalah:

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);

Dalam kode saya yang sebenarnya, saya akan menambahkan panggilan GC.Collect untuk mengubah tumpukan terkelola ke status yang diketahui, dan menambahkan panggilan Tidur sehingga interval kode yang berbeda dapat dengan mudah dipisahkan dalam profil ETW.

Saya telah melakukan sangat sedikit pemeriksaan kinerja semacam ini (saya cenderung hanya berpikir "ini lambat, buatlah lebih cepat") jadi saya sudah hampir selalu melakukannya.

Google tidak mengungkapkan banyak sumber daya / artikel untuk memeriksa kinerja.

Banyak yang menyebutkan menggunakan pinvoke untuk mendapatkan informasi kinerja. Banyak materi yang saya pelajari hanya benar-benar menyebutkan menggunakan perfmon ..

Edit:

Terlihat pembicaraan StopWatch .. Bagus! Saya telah belajar sesuatu :)

Ini terlihat seperti artikel yang bagus

Cara saya menggunakan dalam program saya menggunakan kelas StopWatch seperti yang ditunjukkan di sini.

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


// Critical lines of code

long elapsedMs = sw.Elapsed.TotalMilliseconds;