Tetap teratur dengan koleksi
Simpan dan kategorikan konten berdasarkan preferensi Anda.
Grafik flame
Cloud Profiler menampilkan data pembuatan profil menggunakan
Flame Graph. Tidak seperti hierarki dan grafik,
grafik api menggunakan ruang layar secara efisien dengan merepresentasikan informasi
dalam jumlah besar dalam format yang ringkas dan mudah dibaca.
Untuk memperkenalkan flame graph, halaman ini mengilustrasikan cara mengonversi hierarki
menjadi flame graph dan meringkas fitur utama flame graph.
Membuat grafik api
Untuk membuat grafik api dari hierarki, selesaikan langkah-langkah yang diilustrasikan dalam diagram berikut:
Hapus panah yang menunjukkan panggilan fungsi dari hierarki.
Ganti setiap node hierarki dengan frame.
Bingkai berbentuk persegi panjang dan semua bingkai memiliki tinggi yang sama.
Untuk contoh di halaman ini, total waktu CPU yang digunakan oleh fungsi yang bernama
dalam frame menentukan lebar frame.
Kode pseudo untuk setiap fungsi dijelaskan dalam tabel
berikut. Pekerjaan intensif CPU yang dilakukan selama eksekusi fungsi menentukan waktu CPU mandiri:
Kode pseudo fungsi
waktu CPU mandiri (detik)
total waktu CPU (detik)
func main():
foo1()
foo2()
// CPU intensive work
// for 2 seconds
2
4 + 3 + 2 = 9
func foo1():
bar()
// CPU intensive work
// for 1.5 seconds
1,5
2,5 + 1,5 = 4
func foo2():
bar()
// CPU intensive work
// for 0.5 seconds
0,5
2,5 + 0,5 = 3
func bar():
// CPU intensive work
// for 2.5 seconds
2,5
2,5
Langkah berikutnya adalah menghapus spasi vertikal di antara frame
dan frame rata kiri sambil mempertahankan urutan panggilan.
Secara opsional, Anda dapat menentukan skema warna dan mewarnai frame sesuai
dengan definisi. Misalnya, Anda dapat mewarnai frame berdasarkan paketnya,
berdasarkan total waktu CPU, berdasarkan waktu CPU mandiri, atau berdasarkan ukuran yang berbeda.
Setelah menghapus spasi kosong yang berlebihan dan mewarnai frame menurut waktu
CPU mandiri, grafik api kini muncul sebagai berikut:
Perhatikan bahwa stack panggilan untuk foo1 dan foo2
telah dipertahankan, meskipun stack panggilan yang dimulai dengan foo2
sekarang berada di samping frame untuk foo1.
Ringkasan
Contoh sederhana ini mengilustrasikan hal berikut:
Diagram api adalah representasi ringkas dari hierarki dan Anda dapat membuat ulang
stack panggilan dengan melacak frame dari atas ke bawah.
Frame memberi nama fungsi dan lebar frame adalah pengukuran relatif
dari total waktu CPU fungsi tersebut.
Dalam contoh ini, karena total waktu CPU foo2 adalah sepertiga dari
total waktu CPU main, frame untuk foo2 adalah sepertiga lebar
frame untuk main.
Lebar ruang kosong di bawah frame adalah pengukuran relatif
waktu CPU mandiri untuk fungsi yang dinamai dalam frame.
Misalnya, di bawah frame foo1, 1,5 unit kosong dan 2,5 unit
diisi oleh bar. Oleh karena itu, waktu CPU mandiri foo1 adalah
37,5% dari total waktu CPU-nya, atau 1,5 s.
Saat Anda mengikuti stack panggilan, lebar frame akan berkurang karena
total waktu CPU pemanggil tidak boleh lebih dari total waktu CPU
pemanggil. Perilaku ini yang menyebabkan bentuk api.
Dalam contoh, foo1 memanggil bar dan total waktu CPU foo1
ditentukan sebagai total waktu CPU barditambah waktu CPU mandiri
foo1. Oleh karena itu, total waktu CPU bar tidak boleh lebih dari
total waktu CPU foo1.
[[["Mudah dipahami","easyToUnderstand","thumb-up"],["Memecahkan masalah saya","solvedMyProblem","thumb-up"],["Lainnya","otherUp","thumb-up"]],[["Sulit dipahami","hardToUnderstand","thumb-down"],["Informasi atau kode contoh salah","incorrectInformationOrSampleCode","thumb-down"],["Informasi/contoh yang saya butuhkan tidak ada","missingTheInformationSamplesINeed","thumb-down"],["Masalah terjemahan","translationIssue","thumb-down"],["Lainnya","otherDown","thumb-down"]],["Terakhir diperbarui pada 2025-09-04 UTC."],[],[],null,["# Flame graphs\n============\n\nCloud Profiler displays profiling data by using\n[Flame Graphs](http://www.brendangregg.com/flamegraphs.html). Unlike trees and graphs,\nflame graphs make efficient use of screen space by representing a large amount\nof information in a compact and readable format.\n\nTo introduce flame graphs, this page illustrates how to convert a tree\ninto a flame graph and summarizes key features of flame graphs.\n\nCreating a flame graph\n----------------------\n\nTo create a flame graph from a tree, complete the steps illustrated in the\nfollowing diagram:\n\n1. Remove from the tree the arrows that indicate function calls.\n\n2. Replace each tree node with a *frame*.\n\n Frames are rectangular in shape and all frames have the same height.\n For the example on this page, the total CPU time used by the function named\n in the frame determines the frame width.\n | **Key Point:** In profiling, a functions' *total CPU time* is the CPU time used by the function including the CPU time used by all functions it calls. A function's *self CPU time* is the CPU time used by a function excluding the CPU time used by the functions it calls.\n\n The pseudo code for each of the functions is described in the following\n table. The CPU intensive work performed during a function's execution\n defines the self CPU time:\n\n \u003cbr /\u003e\n\n3. The next step is to remove the *vertical* space between the frames\n and left align frames while preserving call sequences.\n Optionally, you can define a color scheme and color the frames according\n to the definition. For example, you can color frames by their package,\n by total CPU time, by self CPU time, or by a different measure.\n\n After removing excess whitespace and coloring frames by the self\n CPU time, the flame graph now appears as follows:\n\n Notice that the call stacks for `foo1` and `foo2`\n have been preserved, even though the call stack starting with `foo2` is\n now next to the frame for `foo1`.\n\nSummary\n-------\n\nThis simple example illustrates the following:\n\n- Flame graphs are a compact representation of a tree and you can recreate a call stack by tracing frames from the top downwards.\n- Frames name a function and the frame width is the relative measure of that function's total CPU time. In this example, because the total CPU time of `foo2` is one third of the total CPU time of `main`, the frame for `foo2` is one third the width of the frame for `main`.\n- The width of the empty space below a frame is the relative measure of the self CPU time for the function named in the frame. For example, below the frame `foo1`, 1.5 units are empty and 2.5 units are occupied by `bar`. Therefore the self CPU time of `foo1` is 37.5% of its total CPU time, or 1.5 s.\n- As you follow a call stack, the widths of the frames decrease because the\n total CPU time of a callee can never be more than the total CPU time\n of the caller. This behavior is what causes the flame shape.\n\n In the example, `foo1` calls `bar` and the total CPU time of `foo1`\n is defined to be the total CPU time of `bar` *plus* the self CPU time of\n `foo1`. Therefore, the total CPU time of `bar` cannot be more than the\n total CPU time of `foo1`.\n\nWhat's next\n-----------\n\n- [Select the profiles to analyze](/profiler/docs/selecting-profiles)\n- [Interact with the flame graph](/profiler/docs/interacting-flame-graph)\n- [Filter the flame graph](/profiler/docs/filtering-profiles)\n- [Focus the flame graph](/profiler/docs/focusing-profiles)\n- [Compare profiles](/profiler/docs/comparing-profiles)"]]