Foundations — Performance profiling — CPU, memory, I - O profiling

Before you can read the parent note, you need to genuinely understand a small pile of words and squiggles it throws at you: fractions like $p$, a speedup $S$, the difference between a stopwatch on the wall and a stopwatch on the brain, a square root that measures uncertainty, and pictures called flame graphs. We build each one from nothing.

0. The most basic picture: a program is a timeline

Everything starts here. Imagine time flowing left to right. A program runs along this line. At each instant it is doing one of: computing, or waiting for something.

1. Time itself — two different clocks

The parent note's "most important distinction" is between two ways of measuring time. You must feel the difference before any formula.

The picture: look back at figure s01. The full width is $T_{\text{wall}}$. Add up only the black chunks and you get $T_{\text{CPU}}$. The red waiting chunk is $T_{\text{wait}}$ — exactly the gap between the two.

2. Fractions and percentages — the language of "how much"

Profiling constantly says things like "this function is 75% of the time". A fraction is just a part-of-a-whole written as a number between $0$ and $1$.

The picture: cut the timeline bar into slices. $p$ is the width of one slice as a fraction of the full bar.

3. Speedup $S$ and factor $s$ — measuring "how much faster"

Two closely-named symbols. Keep them straight:

The picture: if the old bar was 100 ms wide and the new bar is 50 ms wide, the new bar is half as long, so $S=100/50=2$.

4. The $\Sigma$-free sum you already know: decomposing the whole

Amdahl's derivation writes $T=(1-p)+p$. This is not scary — it is just "the whole = the part you touch + the part you don't."

The bracket-with-word-underneath notation $\underset{\text{label}}{\underbrace{}}$ is just an arrow saying "this chunk means this." Nothing more.

5. The hat $\hat{p}$ and the square root — measuring uncertainty

Sampling profilers do not know the true $p$; they estimate it by taking random snapshots. Statisticians put a hat on a symbol to mean "our estimate of, not the true value".

Now — why the square root? Because a guess from random samples has wobble, and the amount of wobble is what the square-root formula measures.

6. Self time vs cumulative time — the tree of calls

A program's functions call other functions, forming a tree. Two ways to add up a function's cost:

The picture: a boss (parent function) who delegates. Cumulative = the whole department's hours. Self = only the boss's own hours. A boss who only forwards emails has huge cumulative time but tiny self time.

7. The flame graph — a picture where width = time

Once self/cumulative time and the call tree click, a flame graph is obvious: stack the call tree as boxes, and make each box's width proportional to time. Wide box = hotspot.

This is the parent note's main visual. Everything you need to read it, you now have: a call tree (§6), and time-as-width (which is just fraction $p$ turned into pixels, §2). Deep dive lives in Flame Graphs.

The three resources, named once

The topic splits "slow" into three buckets. You met all three in figure s01 conceptually; here are their names.

How the foundations feed the topic

This map is a preview of the parent topic. If any box confuses you, re-read its section above.

Equipment checklist

Say the answer out loud before revealing. If you miss one, revisit its section.