CPU Architecture

Why This Matters

Every line of code you write — every variable assignment, every function call, every loop iteration — gets turned into CPU instructions. The processor does not understand JavaScript or Python. It understands a tiny set of primitive operations: load this value, add these numbers, store the result, jump to that address.

Understanding the fetch-decode-execute cycle explains why some operations are fast and others slow. It explains why accessing a register is instant but reading from disk takes millions of times longer. It explains why your code runs at all. This is the engine under the hood.

Define Terms

Visual Model

Code Example

// How a = b + c maps to CPU instructions
// High-level code:
let b = 10;
let c = 25;
let a = b + c;
console.log(a);  // 35

// What the CPU actually does (pseudocode):
// LOAD R1, [address_of_b]    -- copy b into register R1
// LOAD R2, [address_of_c]    -- copy c into register R2
// ADD  R3, R1, R2            -- R3 = R1 + R2
// STORE [address_of_a], R3   -- write R3 to memory location of a

// Each line above is one fetch-decode-execute cycle
// On a 3 GHz CPU, each cycle takes about 0.33 nanoseconds

// You can see how many operations matter:
function sumArray(arr) {
  let total = 0;             // LOAD R1, 0
  for (let i = 0; i < arr.length; i++) {
    total = total + arr[i];  // LOAD, ADD, STORE per iteration
  }
  return total;
}

const numbers = [1, 2, 3, 4, 5];
console.log(sumArray(numbers));  // 15
// For 5 elements: roughly 5 x 3 = 15 CPU instructions in the loop

Interactive Experiment

Try these exercises:

• In Python, use dis.dis() to inspect the bytecode of a simple function. Count how many operations a single return a + b produces.
• Write a loop that sums numbers 1 to 1,000,000. Time it with console.time() (JS) or time.time() (Python). Then try 10,000,000. Does it take 10x longer? Why or why not?
• Think about why arr[0] is fast but reading from a file is slow. How many layers of the memory hierarchy does each operation cross?
• Try accessing an array element versus computing a math expression. Which feels instant? Both are, but one involves more CPU cycles than the other.

Quick Quiz

Coding Challenge

Real-World Usage

CPU architecture directly shapes the technology landscape:

• Intel vs ARM: Intel and AMD use the x86 instruction set (CISC — complex instructions). ARM uses a simpler instruction set (RISC — reduced instructions). Simpler instructions mean less power consumption, which is why your phone uses ARM but data centers traditionally used x86.
• Apple M-series: Apple designed custom ARM-based CPUs (M1, M2, M3, M4) that combine the CPU, GPU, and memory onto a single chip. This "unified memory architecture" reduces the distance data has to travel, making it faster and more power efficient.
• Pipelining: Modern CPUs do not wait for one instruction to finish before starting the next. They overlap fetch, decode, and execute stages like an assembly line. A 5-stage pipeline can have 5 instructions in progress simultaneously.
• Multi-core processors: Instead of one fast core, modern CPUs have multiple cores (4, 8, 16, or more) that execute instructions in parallel. Your operating system distributes work across cores. This is why "multi-threaded" software can be dramatically faster.
• Clock speed vs real performance: A 3 GHz CPU is not automatically faster than a 2 GHz one. Architecture improvements (wider pipelines, better branch prediction, larger caches) can matter more than raw clock speed.
• Speculative execution: CPUs guess which branch of an if-statement will be taken and start executing it before the condition is evaluated. If the guess is wrong, the work is discarded. This speeds up programs significantly but has led to famous security vulnerabilities like Spectre and Meltdown.

Connections