Apakah blok coba / tangkap melukai kinerja ketika pengecualian tidak dilakukan?

Selama tinjauan kode dengan karyawan Microsoft, kami menemukan sebagian besar kode di dalam try{}blok. Dia dan perwakilan TI menyarankan ini dapat memiliki efek pada kinerja kode. Bahkan, mereka menyarankan sebagian besar kode harus di luar blok coba / tangkap, dan hanya bagian-bagian penting yang harus diperiksa. Karyawan Microsoft menambahkan dan mengatakan bahwa buku putih yang akan datang memperingatkan terhadap blok try / catch yang salah.

Saya telah melihat sekeliling dan menemukan itu dapat mempengaruhi pengoptimalan , tetapi tampaknya hanya berlaku ketika variabel dibagi di antara cakupan.

Saya tidak bertanya tentang kelestarian kode, atau bahkan menangani pengecualian yang benar (kode yang dipermasalahkan perlu dipertimbangkan ulang, tidak diragukan lagi). Saya juga tidak merujuk menggunakan pengecualian untuk kontrol aliran, ini jelas salah dalam kebanyakan kasus. Itu adalah masalah penting (beberapa lebih penting), tetapi bukan fokus di sini.

Bagaimana pengaruh coba / tangkap blok mempengaruhi kinerja ketika pengecualian tidak dilemparkan?

Periksa.

static public void Main(string[] args)
{
    Stopwatch w = new Stopwatch();
    double d = 0;

    w.Start();

    for (int i = 0; i < 10000000; i++)
    {
        try
        {
            d = Math.Sin(1);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }

    w.Stop();
    Console.WriteLine(w.Elapsed);
    w.Reset();
    w.Start();

    for (int i = 0; i < 10000000; i++)
    {
        d = Math.Sin(1);
    }

    w.Stop();
    Console.WriteLine(w.Elapsed);
}

Keluaran:

00:00:00.4269033  // with try/catch
00:00:00.4260383  // without.

Dalam milidetik:

449
416

Kode baru:

for (int j = 0; j < 10; j++)
{
    Stopwatch w = new Stopwatch();
    double d = 0;
    w.Start();

    for (int i = 0; i < 10000000; i++)
    {
        try
        {
            d = Math.Sin(d);
        }

        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }

        finally
        {
            d = Math.Sin(d);
        }
    }

    w.Stop();
    Console.Write("   try/catch/finally: ");
    Console.WriteLine(w.ElapsedMilliseconds);
    w.Reset();
    d = 0;
    w.Start();

    for (int i = 0; i < 10000000; i++)
    {
        d = Math.Sin(d);
        d = Math.Sin(d);
    }

    w.Stop();
    Console.Write("No try/catch/finally: ");
    Console.WriteLine(w.ElapsedMilliseconds);
    Console.WriteLine();
}

Hasil baru:

   try/catch/finally: 382
No try/catch/finally: 332

   try/catch/finally: 375
No try/catch/finally: 332

   try/catch/finally: 376
No try/catch/finally: 333

   try/catch/finally: 375
No try/catch/finally: 330

   try/catch/finally: 373
No try/catch/finally: 329

   try/catch/finally: 373
No try/catch/finally: 330

   try/catch/finally: 373
No try/catch/finally: 352

   try/catch/finally: 374
No try/catch/finally: 331

   try/catch/finally: 380
No try/catch/finally: 329

   try/catch/finally: 374
No try/catch/finally: 334

Setelah melihat semua statistik dengan coba / tangkap dan tanpa coba / tangkap, rasa ingin tahu memaksa saya untuk melihat ke belakang untuk melihat apa yang dihasilkan untuk kedua kasus. Ini kodenya:

C #:

private static void TestWithoutTryCatch(){
    Console.WriteLine("SIN(1) = {0} - No Try/Catch", Math.Sin(1)); 
}

MSIL:

.method private hidebysig static void  TestWithoutTryCatch() cil managed
{
  // Code size       32 (0x20)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldstr      "SIN(1) = {0} - No Try/Catch"
  IL_0006:  ldc.r8     1.
  IL_000f:  call       float64 [mscorlib]System.Math::Sin(float64)
  IL_0014:  box        [mscorlib]System.Double
  IL_0019:  call       void [mscorlib]System.Console::WriteLine(string,
                                                                object)
  IL_001e:  nop
  IL_001f:  ret
} // end of method Program::TestWithoutTryCatch

C #:

private static void TestWithTryCatch(){
    try{
        Console.WriteLine("SIN(1) = {0}", Math.Sin(1)); 
    }
    catch (Exception ex){
        Console.WriteLine(ex);
    }
}

MSIL:

.method private hidebysig static void  TestWithTryCatch() cil managed
{
  // Code size       49 (0x31)
  .maxstack  2
  .locals init ([0] class [mscorlib]System.Exception ex)
  IL_0000:  nop
  .try
  {
    IL_0001:  nop
    IL_0002:  ldstr      "SIN(1) = {0}"
    IL_0007:  ldc.r8     1.
    IL_0010:  call       float64 [mscorlib]System.Math::Sin(float64)
    IL_0015:  box        [mscorlib]System.Double
    IL_001a:  call       void [mscorlib]System.Console::WriteLine(string,
                                                                  object)
    IL_001f:  nop
    IL_0020:  nop
    IL_0021:  leave.s    IL_002f //JUMP IF NO EXCEPTION
  }  // end .try
  catch [mscorlib]System.Exception 
  {
    IL_0023:  stloc.0
    IL_0024:  nop
    IL_0025:  ldloc.0
    IL_0026:  call       void [mscorlib]System.Console::WriteLine(object)
    IL_002b:  nop
    IL_002c:  nop
    IL_002d:  leave.s    IL_002f
  }  // end handler
  IL_002f:  nop
  IL_0030:  ret
} // end of method Program::TestWithTryCatch

Saya bukan ahli dalam IL tetapi kita dapat melihat bahwa objek pengecualian lokal dibuat pada baris keempat .locals init ([0] class [mscorlib]System.Exception ex)setelah itu semuanya sama seperti untuk metode tanpa mencoba / menangkap sampai baris tujuh belas IL_0021: leave.s IL_002f. Jika pengecualian terjadi, kontrol akan melompat ke baris, IL_0025: ldloc.0jika tidak, kita akan beralih ke label IL_002d: leave.s IL_002fdan fungsi kembali.

Saya dapat dengan aman berasumsi bahwa jika tidak ada pengecualian terjadi maka itu adalah overhead untuk membuat variabel lokal untuk menyimpan objek pengecualian saja dan instruksi lompat.

Tidak. Jika optimasi sepele blok percobaan / akhirnya menghalangi sebenarnya memiliki dampak yang terukur pada program Anda, Anda mungkin tidak boleh menggunakan .NET di tempat pertama.

Penjelasan yang cukup komprehensif tentang model pengecualian .NET.

Tidbits Performa Rico Mariani: Biaya Pengecualian: Kapan melempar dan kapan tidak

Jenis biaya pertama adalah biaya statis untuk memiliki penanganan perkecualian dalam kode Anda sama sekali. Pengecualian terkelola sebenarnya cukup baik di sini, yang saya maksudkan biaya statis bisa jauh lebih rendah daripada katakan dalam C ++. Kenapa ini? Nah, biaya statis benar-benar dikeluarkan di dua jenis tempat: Pertama, situs yang sebenarnya dari coba / akhirnya / tangkap / lempar di mana ada kode untuk konstruksi tersebut. Kedua, dalam kode tidak berubah, ada biaya siluman yang terkait dengan melacak semua objek yang harus dihancurkan jika ada pengecualian. Ada sejumlah besar logika pembersihan yang harus ada dan bagian liciknya adalah bahkan kode yang tidak

Dmitriy Zaslavskiy:

Sesuai catatan Chris Brumme: Ada juga biaya yang terkait dengan fakta bahwa beberapa optimasi tidak dilakukan oleh JIT di hadapan tangkapan

Struktur ini berbeda dalam contoh dari Ben M . Ini akan diperpanjang overhead di dalam forloop batin yang akan menyebabkannya menjadi perbandingan yang tidak baik antara dua kasus.

Berikut ini lebih akurat untuk perbandingan tempat seluruh kode untuk diperiksa (termasuk deklarasi variabel) di dalam blok Coba / Tangkap:

        for (int j = 0; j < 10; j++)
        {
            Stopwatch w = new Stopwatch();
            w.Start();
            try { 
                double d1 = 0; 
                for (int i = 0; i < 10000000; i++) { 
                    d1 = Math.Sin(d1);
                    d1 = Math.Sin(d1); 
                } 
            }
            catch (Exception ex) {
                Console.WriteLine(ex.ToString()); 
            }
            finally { 
                //d1 = Math.Sin(d1); 
            }
            w.Stop(); 
            Console.Write("   try/catch/finally: "); 
            Console.WriteLine(w.ElapsedMilliseconds); 
            w.Reset(); 
            w.Start(); 
            double d2 = 0; 
            for (int i = 0; i < 10000000; i++) { 
                d2 = Math.Sin(d2);
                d2 = Math.Sin(d2); 
            } 
            w.Stop(); 
            Console.Write("No try/catch/finally: "); 
            Console.WriteLine(w.ElapsedMilliseconds); 
            Console.WriteLine();
        }

Ketika saya menjalankan kode tes asli dari Ben M , saya melihat perbedaan dalam konfigurasi Debug dan Releas.

Versi ini, saya perhatikan ada perbedaan dalam versi debug (sebenarnya lebih dari versi lain), tetapi tidak ada perbedaan dalam versi Rilis.

Kesimpulan :
Berdasarkan tes ini, saya pikir kita dapat mengatakan bahwa Try / Catch memang memiliki dampak kecil pada kinerja.

EDIT:
Saya mencoba untuk meningkatkan nilai loop dari 10.000000 ke 1000000000, dan berlari lagi di Rilis untuk mendapatkan beberapa perbedaan dalam rilis, dan hasilnya adalah ini:

   try/catch/finally: 509
No try/catch/finally: 486

   try/catch/finally: 479
No try/catch/finally: 511

   try/catch/finally: 475
No try/catch/finally: 477

   try/catch/finally: 477
No try/catch/finally: 475

   try/catch/finally: 475
No try/catch/finally: 476

   try/catch/finally: 477
No try/catch/finally: 474

   try/catch/finally: 475
No try/catch/finally: 475

   try/catch/finally: 476
No try/catch/finally: 476

   try/catch/finally: 475
No try/catch/finally: 476

   try/catch/finally: 475
No try/catch/finally: 474

Anda melihat bahwa hasilnya tidak sesuai. Dalam beberapa kasus, versi yang menggunakan Try / Catch sebenarnya lebih cepat!

Saya menguji dampak sebenarnya dari try..catchlingkaran ketat, dan terlalu kecil untuk menjadi perhatian kinerja dalam situasi normal apa pun.

Jika loop tidak banyak bekerja (dalam pengujian saya melakukan x++), Anda dapat mengukur dampak penanganan pengecualian. Pengulangan dengan penanganan pengecualian membutuhkan waktu sekitar sepuluh kali lebih lama untuk dijalankan.

Jika loop melakukan beberapa pekerjaan yang sebenarnya (dalam pengujian saya, saya disebut metode Int32.Parse), penanganan pengecualian memiliki dampak terlalu kecil untuk dapat diukur. Saya mendapat perbedaan yang jauh lebih besar dengan menukar urutan loop ...

coba tangkap blok memiliki dampak yang dapat diabaikan pada kinerja tetapi pengecualian Melempar bisa sangat besar, ini mungkin di mana rekan kerja Anda bingung.

Coba / tangkap HAS berdampak pada kinerja.

Tapi itu bukan dampak yang besar. coba / tangkap kompleksitas umumnya O (1), sama seperti tugas sederhana, kecuali ketika mereka ditempatkan dalam satu lingkaran. Jadi, Anda harus menggunakannya dengan bijak.

Berikut ini adalah referensi tentang kinerja try / catch (tidak menjelaskan kompleksitasnya, tetapi tersirat). Lihatlah Throw sedikit Pengecualian bagian

Secara teori, blok coba / tangkap tidak akan berpengaruh pada perilaku kode kecuali jika benar-benar terjadi pengecualian. Namun, ada beberapa keadaan yang jarang, di mana keberadaan blok coba / tangkap mungkin memiliki efek besar, dan beberapa yang tidak umum tetapi hampir tidak jelas di mana efeknya dapat terlihat. Alasannya adalah karena kode yang diberikan seperti:

Action q;
double thing1()
  { double total; for (int i=0; i<1000000; i++) total+=1.0/i; return total;}
double thing2()
  { q=null; return 1.0;}
...
x=thing1();     // statement1
x=thing2(x);    // statement2
doSomething(x); // statement3

kompiler mungkin dapat mengoptimalkan statement1 berdasarkan pada fakta bahwa statement2 dijamin untuk dieksekusi sebelum statement3. Jika kompilator dapat mengenali bahwa thing1 tidak memiliki efek samping dan thing2 tidak benar-benar menggunakan x, ia dapat dengan aman menghilangkan thing1 sama sekali. Jika [seperti dalam kasus ini] hal1 mahal, itu bisa menjadi optimasi besar, meskipun kasus di mana hal1 mahal juga mereka yang paling tidak mungkin dikompilasi oleh kompiler. Misalkan kode diubah:

x=thing1();      // statement1
try
{ x=thing2(x); } // statement2
catch { q(); }
doSomething(x);  // statement3

Sekarang ada urutan peristiwa di mana statement3 bisa dieksekusi tanpa statement2 dieksekusi. Bahkan jika tidak ada dalam kode untuk thing2bisa melempar pengecualian, akan ada kemungkinan bahwa utas lain dapat menggunakan Interlocked.CompareExchangeuntuk melihat yang qtelah dihapus dan mengaturnya Thread.ResetAbort, dan kemudian melakukan Thread.Abort()sebelum statement2 menulis nilainya x. Maka catchakan mengeksekusi Thread.ResetAbort()[via delegateq ], yang memungkinkan eksekusi untuk melanjutkan dengan statement3. Urutan peristiwa seperti itu tentu saja sangat tidak mungkin, tetapi kompiler diperlukan untuk menghasilkan kode yang bekerja sesuai dengan spesifikasi bahkan ketika peristiwa yang mustahil terjadi.

Secara umum, kompiler jauh lebih mungkin untuk melihat peluang untuk meninggalkan bit kode sederhana daripada yang kompleks, dan dengan demikian akan jarang untuk mencoba / menangkap dapat mempengaruhi kinerja banyak jika pengecualian tidak pernah dibuang. Namun, ada beberapa situasi di mana keberadaan blok coba / tangkap dapat mencegah optimasi yang - tetapi untuk coba / tangkap - akan memungkinkan kode untuk berjalan lebih cepat.

Meskipun " Pencegahan lebih baik daripada penanganan ", dalam perspektif kinerja dan efisiensi kita bisa memilih try-catch daripada pre-varication. Pertimbangkan kode di bawah ini:

Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 1; i < int.MaxValue; i++)
{
    if (i != 0)
    {
        int k = 10 / i;
    }
}
stopwatch.Stop();
Console.WriteLine($"With Checking: {stopwatch.ElapsedMilliseconds}");
stopwatch.Reset();
stopwatch.Start();
for (int i = 1; i < int.MaxValue; i++)
{
    try
    {
        int k = 10 / i;
    }
    catch (Exception)
    {

    }
}
stopwatch.Stop();
Console.WriteLine($"With Exception: {stopwatch.ElapsedMilliseconds}");

Inilah hasilnya:

With Checking: 20367
With Exception: 13998

Lihat diskusi tentang implementasi try / catch untuk diskusi tentang cara kerja try / catch blocks, dan bagaimana beberapa implementasi memiliki overhead yang tinggi, dan beberapa memiliki overhead nol, ketika tidak ada pengecualian. Secara khusus, saya pikir implementasi Windows 32 bit memiliki overhead yang tinggi, dan implementasi 64 bit tidak.