Generate Flamegraph Using perf record and Flamegraph.pl

Topic Overview

Stack Samples as a Heat Map

Flame graphs turn thousands of perf record stack samples into one SVG where width equals sample count. Brendan Gregg invented them to answer which functions dominate CPU time across whole call chains, not just flat self time. Kernel developers, database teams, and game studios use the same workflow when a service is hot but the culprit function is buried five frames deep.

From Samples to SVG

Record at high frequency, collapse stacks, feed them to flamegraph.pl. The y-axis is stack depth; the x-axis is proportion of samples. Wide plateaus are where you optimize first.

bashCopy
Loading…

• Use -g so call chains appear, not just leaf symbols
• Disable ASLR only when you need stable addresses for diffing two runs
• Compare two flame graphs side by side after a change to confirm the hotspot moved
• Idle time does not appear; profile under realistic load

Working Through the Exercise

Keep the relevant documentation open while you implement. When your output disagrees with the reference, trace one failing case by hand before changing random lines.

• Trace first: walk one failing input step by step
• Read the manual: skim the official doc for the mechanism named in this task
• Compare baselines: save measurements from the prior step so speedups are honest

Why for this exercise

You will write a program with deliberate hotspots and generate a flame graph from perf record output. This exercise requires you to identify the widest frame and tie it back to a specific loop in your source.

Your Task

A flame graph is built from "folded" stack samples, the format that stackcollapse-perf.pl produces from perf record -g. Each line is a call stack from the root to the leaf, plus the number of samples in which that exact stack was on-CPU. Merge the stacks into a tree, draw it (a text "icicle" version of the flame graph), rank functions by self time (samples where the function was the leaf), and zoom into one function with focus.

Input

cCopy
Loading…

Stack lines may appear anywhere, and commands see all the stacks read so far.

Rules

• Tree. Stacks with a common prefix share nodes. A node's count is the sum of the samples passing through it. Children are ordered by name (flamegraph.pl sorts alphabetically, so the x-axis is not time).
• graph prints every node depth-first, indented two spaces per level: [BAR] NAME COUNT PCT. BAR has WIDTH characters, with round(count * WIDTH / base) of them # (half up) and the rest spaces. The base is the total sample count.
• top: self = samples where the function is the leaf. Total = samples of stacks in which the function appears, counted once per stack even if it recurses. Sort by self (descending), then name, and print the first N.
• focus FUNC: take each stack from the first frame named FUNC, merge the parts below it into a new tree, and draw it with width 20, using the focused samples as the base.
• Percentages are rounded half up to 1 decimal. Errors: bad line: TEXT, focus FUNC: not found, and graph: width 1..80.

Output

cCopy
Loading…

Top lines use " %-12s self ...".

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Build the tree by walking each stack from the root and creating or reusing a child per frame. A flame graph is nothing more than this prefix tree.
2. Count a recursive function's total once per stack, otherwise its total could exceed 100%.

Hidden tests cover deep recursion (a function appearing several times in one stack), several roots (stacks that do not all start at main), a narrow bar width, top with ties, a focus function that appears under several parents, and malformed lines.