Straight-line sequencing

Straight-line sequencing is the default mode of instruction execution: fetch the instruction at PC, execute it, increment PC to point to the next instruction, repeat. Every instruction executes in the order it appears in memory until a branch or jump changes PC explicitly.

For a 32-bit ISA, straight-line means PC increments by 4 per cycle:

PC = i      → fetch instruction at i,    PC ← i + 4
PC = i + 4  → fetch instruction at i+4,  PC ← i + 8
PC = i + 8  → fetch instruction at i+8,  PC ← i + 12
...

Each instruction lives at the next word address; instructions are 4 bytes; PC steps in 4-byte chunks.

In the diagram: a 4-instruction program sits at consecutive addresses $i,i+4,i+8,i+12$. Data lives elsewhere (at addresses $A$, $B$, $C$). The processor fetches and executes the four instructions in order.

What breaks straight-line

Three things alter the normal sequence:

1. Branch instructions — beq, bne, bgt, etc. If the branch condition is true, PC ← branch target; otherwise PC continues to PC + 4.
2. Unconditional jumps — br LABEL, jmp R5. Always set PC to a new value.
3. Subroutine calls and returns — call LABEL saves the return address and jumps; ret jumps to the saved return address.

Each of these is a deviation from straight-line execution. Without them, programs would just run from start to end with no loops, conditionals, or function calls — useful only for the simplest sequences.

Why we care about it

Straight-line is the predictable case. The processor predicts it implicitly — it can pre-fetch the next instruction at PC + 4 in parallel with executing the current one, because the next address is known immediately.

Branches break this prediction. The branch target may be far from the current PC, and may not even be known until the branch instruction is partly executed. That’s where pipelined processors face the branch hazard — they have to stall, predict, or speculatively execute to avoid wasting cycles. None of that complexity exists for straight-line code.

For programs that are mostly straight-line with occasional well-predicted branches, modern wide superscalar processors achieve 3–4+ instructions per cycle of sustained throughput, not just 1. The “1 IPC” figure is the ideal of a simple 5-stage in-order RISC pipeline; real desktop and server CPUs are 4–8-wide superscalar with deep out-of-order windows, so they retire several straight-line instructions per cycle when the dependency graph allows. Programs with frequent unpredictable branches (e.g., interpreters with switch tables) lose much of that throughput because branch mispredictions flush the in-flight pipeline.