what is branch prediction
Branch prediction is a processor technique that guesses which way a program's conditional branch will go before that branch is actually evaluated, letting the processor keep executing ahead speculatively instead of stalling and waiting to find out for certain.
```flowchart
{
"rows": [
{ "type": "nodes", "items": [
{ "title": "Program reaches a conditional branch", "sub": "outcome not yet known until the condition is evaluated", "tone": "neutral" }
]},
{ "type": "arrow" },
{ "type": "group", "title": "Branch predictor guesses the likely outcome", "items": [
{ "title": "Processor speculatively executes down that path", "sub": "based on patterns from past branch behavior", "tone": "orange" }
]},
{ "type": "arrow" },
{ "type": "nodes", "items": [
{ "title": "Correct guess: work is kept, no time lost", "sub": "wrong guess: speculative work discarded, correct path resumes", "tone": "blue" }
]}
]
}
```
**Branch prediction exists because waiting for a conditional branch's outcome before continuing execution would waste a significant amount of processor time on every single branch in a program.** Modern processors execute instructions through several sequential internal stages, and a conditional branch's true outcome often isn't known until relatively late in that process; rather than stalling completely until the outcome is confirmed, branch prediction guesses the likely outcome based on patterns from past branch behavior and lets the processor speculatively continue executing down that predicted path immediately.
```svg
```
```svg
```
| Aspect | No branch prediction | With branch prediction |
|---|---|---|
| Behavior at a branch | Stall until outcome is known | Speculatively continue on predicted path |
| Correct guess outcome | N/A | No time lost, work is kept |
| Wrong guess outcome | N/A | Speculative work discarded, restart |
| Common use | Not viable for modern performance | Standard in virtually all modern processors |
**Modern branch predictors achieve high accuracy by tracking detailed patterns of past branch outcomes, often for many branches simultaneously, rather than making simple, isolated guesses.** Rather than treating each branch as an independent coin flip, sophisticated branch predictors maintain historical pattern information across many branches and their past outcomes, using that accumulated pattern history to make significantly more accurate predictions than a naive always-guess-the-same-way approach could achieve.
**A mispredicted branch carries a real performance cost, since all speculatively executed work down the wrong path has to be discarded and execution has to restart from the correct path.** When a branch prediction turns out to be wrong, the processor must discard any speculative results it computed along the incorrect path and restart execution from the actual correct path, a penalty whose size depends on how many pipeline stages of speculative work had already been completed — this misprediction penalty is why branch prediction accuracy matters so much for overall processor performance.
**Branch prediction accuracy varies significantly depending on how predictable a program's actual branching behavior is, meaning its real-world benefit differs considerably across different types of software.** Highly predictable, repetitive branch patterns, common in many loops, are generally easy for a branch predictor to learn and predict accurately, while more irregular or genuinely data-dependent branching behavior is inherently harder to predict well — this variability is why branch prediction's practical performance benefit differs meaningfully from one workload to another.
Read branch prediction through an educated-guess lens: rather than pausing at every fork in the road until the map confirms which way to go, the processor makes an informed guess based on which way it usually goes, and only backtracks on the rare occasions that guess turns out to be wrong.