Before you can compare ILP and TLP, you need to know what every word and symbol on that page means — starting from nothing. This page builds each brick in order. Read top to bottom; nothing appears before it is explained.
Picture a to-do list where every line is a single, absolutely simple action — nothing bigger.
Figure 1: A program drawn as a numbered stack of blue instruction boxes. Each box is one indivisible order (load a, add a+b -> s, ...). The yellow arrow points out that a single box = a single tiny order — this stack is the "list" that ILP overlaps.
Why the topic needs it: ILP is about overlapping these individual orders. If you don't picture the program as a list of separate instructions, "instruction-level" has nothing to hang on.
Figure 2: On the left, a single blue thread (one column of instruction boxes) — this is the arena where ILP operates. On the right, three separate coloured threads (blue, green, red) running side by side — this is the arena where TLP operates. Notice a thread is built out of instructions.
Why the topic needs it: running many threads at once is the whole second half of the parent note. We give the number of them a symbol (N) and its own hardware ("cores") in Section 6 — for now, just hold the picture of several independent to-do lists.
Picture a metronome. On each tick, work advances one small notch.
Figure 3: Dashed white lines mark clock ticks. The top blue row finishes exactly one instruction per tick (n=1). The bottom green row finishes three per tick (n=3). The yellow caption says it all: bigger n = more instructions overlapped per tick = more ILP.
Why the topic needs it: n is the "how much ILP" knob. Bigger n = more instructions overlapping = more ILP. It plugs directly into the speedup formula below.
Figure 4: Left (red) — a dependency chain: four boxes joined top-to-bottom by arrows, each step forced to wait for the one above, so they line up serially. Right (green) — four independent boxes sitting side by side with no arrows between them, free to run together. Chains block ILP; independent boxes enable it.
Why the topic needs it: dependencies are why ILP is limited. The fraction that has no dependencies is exactly the number f below.
Now every symbol is defined, so the parent's headline formula reads cleanly.
Applying it to ILP (using f and n) and to TLP (using p and N):
Read the denominator as "serial part left alone, plus parallel part shrunk by the speedup": (1−f) stays full size, while f/n is the parallel part divided among n (or p/N among N). This whole shape is Amdahls-Law — a prerequisite worth its own page.
Recall Why does the denominator have two terms?
Because total time = serial time + parallel time, and only the parallel term gets divided by how much parallelism you have. ::: The serial term (1−f) can never be sped up — that is the ceiling on any speedup.
This diagram shows how each foundation feeds the next and finally into the topic. In words: Instruction is the root — it feeds Thread, Clock cycle, and Dependency. Clock cycle gives us IPC n; Dependency gives us the fraction f; Thread gives us both the core count N and the fraction p. The pair (n, f) drives ILP speedup; the pair (N, p) drives TLP speedup; and SIMD enters as a separate third strand. All three arrive at the ILP vs TLP topic.
