Halo dan selamat datang.
Dalam kuliah ini, saya ingin membahas sedikit tentang call stack, apa sebenarnya call stack itu dan bagaimana
Anda dapat membacanya untuk membantu debug program Anda.
Jejak stack, yang pada dasarnya adalah call stack, dihasilkan setiap kali aplikasi Anda mengalami crash
karena kesalahan fatal.
Alasan penggunaan istilah stack adalah karena istilah ini mengacu pada struktur data yang umum digunakan dalam pemrograman.
Tumpukan adalah struktur data yang dikenal sebagai LIFO, masuk terakhir, keluar pertama, dan begitulah cara data
disimpan.
Elemen data terakhir yang ditambahkan adalah elemen data pertama yang Anda ambil kembali.
Anda bisa membayangkannya seperti makan setumpuk pancake, pancake pertama ada di bagian bawah yang
Anda tambahkan.
Pancake terakhir ada di bagian atas.
Saat Anda akan memakannya, Anda akan memakan yang terakhir ditambahkan.
Jadi, stack trace sangat berguna ketika program Anda mengalami kerusakan karena berisi informasi yang membantu Anda
melakukan debug.
Jadi, stack trace menunjukkan daftar pemanggilan fungsi yang menyebabkan kesalahan.
Dan apa yang akan terjadi adalah dalam sebuah program ketika Anda memanggil fungsi utama Anda, itulah titik masuknya.
Fungsi utama akan memanggil fungsi-fungsi lainnya.
Fungsi-fungsi tersebut akan memanggil fungsi-fungsi lain dan semua fungsi yang diimplementasikan atau dipanggil
akan diletakkan di atas stack.
Jadi yang dapat Anda lakukan adalah ketika sebuah program mengalami crash, call stack akan memberi tahu Anda fungsi terakhir
yang dipanggil dan baris kode tertentu yang menyebabkan kesalahan.
Jadi, Callstack berisi banyak informasi yang bagus.
Ini akan menyertakan nama file dan nomor baris kode yang menyebabkan pengecualian atau kesalahan
fatal terjadi.
Bagian atas tumpukan berisi panggilan terakhir yang menyebabkan kesalahan dan mungkin ada panggilan bersarang.
Bagian bawah tumpukan berisi panggilan pertama yang memulai rantai panggilan untuk memanggil kesalahan.
Jadi, jika biasanya di C Anda akan berada di rutin utama, Anda memanggil main, main memanggil fungsi lain, yang memanggil
fungsi lain dan seterusnya dan seterusnya.
Dan kemudian baris terakhir itu dirinci.
Ini sangat, sangat membantu ketika aplikasi untuk aplikasi macet.
Jadi, ketika program C macet, program tersebut mungkin menghasilkan kesalahan segmentasi dan tidak memberi tahu Anda banyak
informasi.
Itu berarti sesuatu yang buruk telah terjadi.
Itu juga akan menghasilkan file inti.
Anda bisa menganalisis file inti yang berisi call stack, yang akan memberi tahu Anda baris kode yang
tepat yang menyebabkan masalah pada crash Anda.
Jadi, Anda perlu menemukan panggilan dalam aplikasi Anda yang menyebabkan kerusakan.
Dan call stack mungkin merupakan cara terbaik untuk melakukan ini.
Dan Anda tidak perlu selalu melihat file inti itu.
Anda juga dapat menganalisis tumpukan panggilan dalam menggunakan GDB dengan debugger.
Dan saya ingin menunjukkan kepada Anda, seperti apa bentuknya.
Seorang programmer juga dapat membuang jejak stack kapan saja.
Jadi, jika Anda menangkap kesalahan atau Anda menyadari bahwa kesalahan fatal mungkin terjadi, Anda dapat membuang tumpukan
panggilan untuk melihat apa yang terjadi.
Jika Anda tidak benar-benar tahu kapan kesalahan akan terjadi, Anda masih dapat membuang
tumpukan panggilan untuk melihat jejak saat ini yang mengarah ke panggilan tertentu.
Ketika menggunakan GDB, tumpukan panggilan akan terlihat seperti ini.
Anda dapat mengakses call stack melalui menu ketika Anda menjalankan debugger di GDB dan saya akan menunjukkan
kepada Anda bagaimana cara melakukannya, tetapi seperti inilah tampilannya dan apa yang akan Anda lihat di sini
adalah ada nomor, alamat, dan fungsi.
Tumpukan panggilan khusus di sini memiliki banyak panggilan yang berbeda, jadi pasti telah melakukan banyak penumpukan yang berbeda
dan banyak panggilan fungsi yang berbeda.
Tetapi di bagian paling bawah tumpukan pada baris 22, tertulis GTK main.
Itu artinya.
Itu berarti, kemungkinan besar ia menjalankan fungsi utama.
Dan kemudian pada baris 21, sepertinya ini dieksekusi.
Mungkin ada pernyataan yang mengatakan main loop run.
Dan kemudian terlihat seperti memanggil fungsi yang disebut G main context iterate.
Dan di dalam fungsi itu, ada beberapa setiap kali ada panggilan lain ke fungsi pengiriman
konteks utama IAG.
Jadi ada fungsi iterate, kemudian fungsi dispatch, dan kemudian tanda tanya di baris 18 berarti
tidak ada informasi debugging.
Tidak tahu apa yang terjadi di sana.
Dan itulah mengapa ketika Anda membuat program, Anda bisa membuatnya untuk dirilis atau Anda membuatnya
dengan informasi debugging.
Ketika Anda membuatnya dengan informasi debugging, informasi ini berisi informasi tambahan ketika Anda mengkompilasi sehingga ketika
Anda menjalankannya, Anda dapat melihat tumpukan panggilan.
Ketika Anda merilisnya, buatlah sesuatu untuk dirilis.
File yang dapat dieksekusi jauh lebih kecil dan mungkin tidak berisi informasi ini.
Ini mungkin mengandung lebih banyak tanda tanya.
Tetapi ini juga akan memberi tahu Anda jika Anda memanggil pustaka apa pun, program tambahan apa pun, ia akan memanggilnya dan akan memberi
tahu Anda tumpukan panggilan dari sana.
Namun, sekali lagi, apa yang ditunjukkan oleh hal ini adalah kejadian bersarang yang berbeda untuk panggilan di bagian paling atas adalah
hal yang penting, karena hal itu akan menandakan apa yang menyebabkan kecelakaan.
Jadi, sepertinya dalam call stack khusus ini, penyegaran bagian dalam menyebabkan masalah.
Dan Anda dapat melihat bahwa dari baris 22 hingga baris nol, ada banyak pemanggilan kode yang berbeda.
Tetapi program akhirnya crash di baris nol tumpukan panggilan.
Anda juga dapat melihat tumpukan panggilan saat program berjalan untuk melihat informasi sehingga Anda dapat melacaknya
kembali.
Jadi, jika Anda meletakkan breakpoint di dalam sebuah fungsi, Anda melakukan debug, Anda menjalankan debugger pada fungsi tersebut.
Debugger akan berhenti pada breakpoint tersebut.
Anda kemudian dapat membuka call stack dan akan memberi tahu Anda bagaimana Anda sampai pada baris kode tersebut.
Fungsi ini dipanggil sebelum fungsi ini.
Dan sekali lagi, biasanya akan dimulai dengan fungsi utama.
Anda juga dapat beralih ke frame yang berbeda jika Anda terbiasa dengan stack dan konsepnya serta bagaimana
ia berada di memori, Anda dapat melihat frame yang berbeda, tetapi ini adalah alat yang sangat berguna untuk menemukan
crash terutama di C, dan sangat mudah dibaca.
Jika Anda hanya melihat bagian atas dan Anda tidak memahami banyak hal tentang call stack,
Anda dapat melihat bagian atas dan berkata, Oh, itu adalah sumber, itu adalah baris kode yang menyebabkan crash.
Berikut ini contoh bagus yang saya temukan di web.
Excma.
Edu.
Hal tersebut mengilustrasikan contoh-contoh pemanggilan fungsi stack.
Jadi jika kita melihat contoh dalam kode seperti yang akan kita lihat, kita hanya memiliki beberapa kode sederhana.
Perhitungannya tidak terlalu penting.
Pada dasarnya kita hanya memanggil beberapa fungsi.
Jadi kita memiliki fungsi mogrify dan fungsi truly half ini dan main akan memanggil fungsi mogrify dan kemudian
akan memanggil truly half dan kemudian akan mogrify sehingga kita dapat mengilustrasikan
call stack dan seperti apa tampilannya pada panggilan ini dengan pada dasarnya hanya mengatur breakpoint sederhana
di main dan kemudian melihat call stack saat kita maju dan melakukan panggilan.
Jadi sekali lagi, kita akan lebih mengenal breakpoint dan informasi seperti itu.
Tetapi saya hanya ingin mendemonstrasikan call stack dengan cepat dan kami akan memberikan contoh yang lebih rinci
tentang call stack nanti.
Jadi di sini saya menetapkan breakpoint.
Saya dapat melanjutkan dan membangun serta mengkompilasinya dan saya dapat memulai debugger dan kita akan mencapai breakpoint.
Dan apa yang akan Anda perhatikan sekarang, Anda dapat melihat semua menu debugger di sini, di sisi kanan bawah,
dan Anda akan melihat call stack.
Mari kita buat ini sedikit lebih besar.
Namun ketika berhenti di baris 14, di sini hanya ada beberapa pernyataan penugasan dan Anda akan melihat bahwa
call stack menunjukkan main.
Jika kita melangkahi itu dan pergi ke baris berikutnya, kita bisa melihat bahwa itu hanya sampai ke baris 15
sebelum memanggil Mogrify, bukan?
Dan Anda akan melihat bahwa tumpukan panggilan tetap berada di Main.
Jika kita masuk ke dalam, Anda sekarang akan melihat bahwa call stack menunjukkan Mogrify.
Jadi, kita sebenarnya berada di dalam fungsi ini.
Kita bisa melangkah lebih dari itu.
Jadi, ia mengeksekusi baris pertama dan kemudian akan mengembalikan temp.
Ia masih tetap berada dalam fungsi tersebut dan kemudian kembali ke tempat ia mencetak F pada baris 16, Anda dapat melihat bagaimana
call stack berubah.
Kita kemudian pergi ke baris 18, panggil stack stills di main dan kita melangkah ke fungsi yang sesungguhnya.
Dan sekarang Anda melihat perubahan call stack di mana ia menunjukkan bahwa separuh fungsi di bagian atas selalu merupakan
fungsi yang terakhir kali dipanggil.
Sekali lagi, kami melangkah dan Anda melihat bahwa kami masih berada di setengah bagian.
Kita kembali ke Main, kita mencetak sesuatu pada baris 19, kita pergi ke baris 21.
Kita kembali melompat ke fungsi modify, yang sekali lagi Anda lihat di call stack, kita lompati, kita lompati dan akhirnya
kita mencetak hasil akhir di baris 23 dan dikembalikan dari program.
Namun, call stack kembali menunjukkan urutan fungsi yang dipanggil dari satu fungsi ke fungsi berikutnya.
Jadi, jika Anda memiliki fungsi bersarang, ini bisa semakin rumit.
Keuntungan dari call stack adalah jika Anda memiliki baris kode yang mengalami crash, katakanlah pada baris keempat, Anda akan memiliki
call stack yang berisi di bagian paling atas di mana baris tersebut mengalami crash.
Jadi, Anda sebenarnya dapat melihat dengan menelusuri call stack, baris kode apa yang terakhir kali dipanggil
dan itu akan memberi tahu Anda baris kode apa yang mengalami crash.
Tetapi Anda akan ingin menggunakan alat ini ketika program Anda mengalami kerusakan.
Terima kasih.