Geekly articles weekly

Alat untuk menganalisis dan men-debug aplikasi .NET

Anda dapat melihat di bawah kap kode atau melihat perangkat CLR internal menggunakan banyak alat. Posting ini lahir dari tweet , dan saya harus berterima kasih kepada semua orang yang membantu membuat daftar alat yang sesuai. Jika saya melewatkan salah satu dari mereka, tulis di komentar.


Pertama, saya harus menyebutkan bahwa debugger yang baik sudah ada di Visual Studio dan VSCode . Ada juga banyak profiler (komersial) .NET dan alat pemantauan aplikasi yang bagus. Sebagai contoh, saya baru-baru ini mencoba untuk bekerja dengan Codetrack dan terkesan dengan kemampuannya.


Namun, pos yang tersisa dikhususkan untuk alat untuk melakukan tugas individu , yang akan membantu untuk lebih memahami apa yang terjadi. Semua alat adalah sumber terbuka .



PerfView oleh Vance Morrison


PerfView adalah alat hebat yang telah saya gunakan selama beberapa tahun. Ini bekerja atas dasar Windows Event Tracing (ETW) dan memungkinkan Anda untuk lebih memahami apa yang terjadi di dalam CLR, dan juga memberikan kesempatan untuk mendapatkan profil penggunaan memori dan CPU. Untuk menguasai alat ini, Anda harus menyerap banyak informasi, misalnya dengan bantuan video pelatihan , tetapi sepadan dengan waktu dan upaya.


Alat ini sangat berguna sehingga insinyur Microsoft sendiri menggunakannya, dan banyak peningkatan kinerja baru-baru ini di MSBuild muncul setelah menganalisis kemacetan menggunakan PerfView.
Alat ini didasarkan pada perpustakaan Microsoft.Diagnostics.Tracing.TraceEvent , yang dapat Anda gunakan untuk membuat alat Anda sendiri. Selain itu, karena kode sumber perpustakaan terbuka, terima kasih kepada komunitas, banyak fungsi berguna telah muncul di dalamnya, misalnya, grafik nyala :



SharpLab oleh Andrey Shcheokin


SharpLab muncul sebagai alat untuk memeriksa kode IL yang dihasilkan oleh kompiler Roslyn, dan seiring waktu berkembang menjadi sesuatu yang lebih :


SharpLab adalah lingkungan interaktif untuk menjalankan kode .NET, yang menampilkan langkah-langkah menengah dan hasil kompilasi kode. Beberapa fungsi bahasa hanyalah pembungkus untuk yang lain, misalnya menggunakan () menjadi try / catch. Dengan SharpLab, Anda akan melihat kode ketika kompilator melihatnya dan lebih memahami esensi bahasa .NET.

Alat ini mendukung C #, Visual Basic dan F #, tetapi fungsi yang paling menarik di dalamnya adalah Dekompilasi / Pembongkaran:
Fungsi dekompilasi / pembongkaran dapat digunakan untuk:


  1. C #
  2. Visual basic
  3. IL
  4. JIT Asm (Kode Asm asli)

Anda mengerti dengan benar: alat mengeluarkan kode assembler yang dihasilkan oleh .NET JIT dari kode C # Anda:



Object Layout Inspector oleh Sergey Teplyakov


Dengan alat ini, Anda dapat menganalisis struktur objek .NET di memori, mis. bagaimana JITter mengatur bidang yang termasuk dalam kelas atau struktur Anda. Ini berguna saat menulis kode kinerja tinggi. Sangat menyenangkan memiliki alat yang bekerja keras untuk kita.


Tidak ada dokumentasi resmi yang menggambarkan struktur lapangan, karena penulis CLR berhak untuk mengubahnya di masa mendatang. Tetapi pengetahuan tentang struktur dapat berguna jika Anda bekerja pada aplikasi berkecepatan tinggi.
Bagaimana Anda bisa mempelajari strukturnya? Anda dapat melihat memori mentah di Visual Studio atau menggunakan perintah !dumpobj di SOS Debugging Extension . Kedua pendekatan ini membutuhkan banyak upaya, jadi kami akan membuat alat yang akan menampilkan struktur objek saat runtime.


Menurut contoh di repositori GitHub, jika Anda menggunakan TypeLayout.Print<NotAlignedStruct>() dengan kode yang serupa:


 public struct NotAlignedStruct { public byte m_byte1; public int m_int; public byte m_byte2; public short m_short; }

Output berikut akan muncul, yang secara akurat akan menunjukkan bagaimana CLR akan mengatur struct dalam memori berdasarkan aturan optimasi dan padding.


 Size: 12. Paddings: 4 (%33 of empty space) |================================| | 0: Byte m_byte1 (1 byte) | |--------------------------------| | 1-3: padding (3 bytes) | |--------------------------------| | 4-7: Int32 m_int (4 bytes) | |--------------------------------| | 8: Byte m_byte2 (1 byte) | |--------------------------------| | 9: padding (1 byte) | |--------------------------------| | 10-11: Int16 m_short (2 bytes) | |================================|

The Ultimate .NET Experiment (TUNE) oleh Conrad Coconuts


Sebagaimana dinyatakan pada halaman GitHub , TUNE adalah alat yang menjanjikan. Ini akan membantu Anda belajar tentang .NET internal dan cara meningkatkan kinerja dengan bereksperimen dengan kode C #.


Informasi terperinci tentang dia dapat ditemukan di pos ini , tetapi pada tingkat tinggi, fungsinya sebagai berikut :


  • tulis contoh kode C # yang berfungsi yang mengandung setidaknya satu kelas dengan metode publik yang mengambil satu parameter string. Kode diluncurkan menggunakan tombol Run. Anda dapat memasukkan sejumlah metode dan kelas. Tetapi ingat bahwa metode publik pertama dari kelas publik pertama akan dieksekusi menggunakan parameter pertama dari jendela input di bawah kode;
  • klik tombol Jalankan untuk mengkompilasi dan menjalankan kode. Selain itu, itu akan dikompilasi menjadi kode IL-dan kode assembler di tab yang sesuai;
  • saat Tune sedang berjalan (termasuk saat runtime), alat ini membuat grafik yang menampilkan data pengumpul sampah. Ini berisi informasi tentang ukuran timbulan dan sesi pengumpulan sampah (direpresentasikan sebagai garis vertikal dengan angka di bawah ini, yang menunjukkan di mana pengumpulan sampah generasi dilakukan).

Ini terlihat seperti ini:



Alat CLR Memory Diagnostics (ClrMD)


Akhirnya, mari kita lihat pada kategori alat tertentu. Sejak rilis .NET, pengembang selalu dapat menggunakan WinDBG dan SOS Debugging Extension untuk melihat apa yang terjadi di runtime .NET. Namun, ini bukan alat yang paling mudah untuk seorang kenalan pertama dan, sebagaimana dinyatakan dalam tweet berikutnya, tidak selalu yang paling produktif:



Untungnya, Microsoft menyediakan pustaka ClrMD (juga dikenal sebagai Microsoft.Diagnostics.Runtime ), dan sekarang siapa pun dapat membuat alat untuk menganalisis dump memori untuk program .NET. Informasi terperinci dapat ditemukan di blog resmi . Saya juga merekomendasikan untuk melihat ClrMD.Extensions , yang "... menyediakan integrasi dengan LINPad dan membuatnya lebih mudah menggunakan ClrMD . "


Saya ingin mengumpulkan daftar semua alat yang ada dan meminta bantuan Twitter . Mengingatkan diri sendiri: berhati-hatilah dengan tweet. Manajer yang bertanggung jawab untuk WinDBG dapat membacanya dan menjadi marah!



Sebagian besar alat ini bekerja berdasarkan ClrMD, karena ini paling mudah. Tetapi jika Anda mau, Anda dapat menggunakan antarmuka COM secara langsung . Perlu juga dicatat bahwa alat berbasis ClrMD apa pun bukan lintas-platform , karena ClrMD sendiri dirancang hanya untuk Windows. Opsi lintas-platform dijelaskan dalam Menganalisis .NET Core Core Dump di Linux .


Akhirnya, untuk menjaga keseimbangan, versi WinDBG yang ditingkatkan baru- baru ini muncul, yang segera mereka coba tambahkan fungsionalitas:



Setelah semua kata-kata ini, buka daftar:


  • SuperDump ( GitHub )
    • Alat untuk analisis otomatis dari crash dump ( presentasi )
  • msos ( github )
    • Lingkungan dengan antarmuka baris perintah seperti WinDbg untuk mengeksekusi perintah SOS tanpa adanya SOS.
  • MemoScope.Net ( GitHub )
    • Alat untuk menganalisis memori proses dalam .NET. Anda dapat membuang memori aplikasi ke file dan membacanya nanti.
    • File ini berisi semua data (objek) dan informasi tentang utas (status, susunan, susunan panggilan). MemoScope.Net akan menganalisis data dan membantu Anda menemukan kebocoran memori dan kebuntuan.
  • dnSpy ( github )
    • Debugger dan editor perakitan NET
    • Itu dapat digunakan untuk mengedit dan men-debug majelis, bahkan jika Anda tidak memiliki kode sumber.
  • MemAnalyzer ( GitHub )
    • Alat analisis memori untuk kode terkelola. Ada antarmuka baris perintah.
    • Seperti !DumpHeap di !DumpHeap dapat menentukan objek mana yang paling banyak menggunakan heap tanpa harus menginstal debugger.
  • DumpMiner ( GitHub )
  • Lacak CLI ( GitHub )
    • Alat untuk debugging dan pelacakan selama operasi
  • Gudang ( GitHub )
    • Shed adalah aplikasi yang menganalisis pelaksanaan suatu program di .NET. Ini dapat digunakan untuk menganalisis malware untuk mendapatkan data tentang informasi apa yang disimpan ketika perangkat lunak tersebut diluncurkan. Gudang dapat:
    • Ambil semua objek yang disimpan di tumpukan yang dikelola
    • garis tampilan yang disimpan dalam memori;
    • membuat snapshot tumpukan dalam format JSON untuk diproses lebih lanjut;
    • buang semua modul yang dimuat ke dalam memori.

Anda dapat menemukan banyak alat lain yang menggunakan ClrMD . Mempersiapkannya adalah ide bagus dari Microsoft.


Alat lainnya


Alat lain yang layak disebut:


  • Debugdiag
    • Alat DebugDiag dirancang untuk memperbaiki masalah seperti membeku, kinerja buruk, kebocoran memori atau fragmentasi, serta kegagalan dalam proses mode pengguna (sekarang dengan integrasi CLRMD).
  • SOSEX (mungkin tidak lagi dikembangkan)
    • ... ekstensi untuk debug kode terkelola yang mengurangi ketidakpuasan saya dengan SOS.
  • VMMap dari Sysinternals
    • VMMap adalah alat untuk menganalisis memori proses virtual dan fisik.
    • Saya menggunakannya untuk menganalisis penggunaan memori di CLR

Source: https://habr.com/ru/post/id463305/

More articles:


All Articles