fetch execute cycle

The Fetch-Execute Cycle (also called the Fetch-Decode-Execute Cycle) is the fundamental process by which a CPU processes instructions stored in memory. It operates continuously while the computer is running, executing billions of cycles per second.

Key Components:

Program Counter (PC): A special register holding the memory address of the next instruction to be executed. It increments automatically after each fetch unless a jump/branch instruction alters it.

Memory Address Register (MAR): Holds the address of the memory location to be read from or written to during the current cycle.

Memory Data Register (MDR) or Memory Buffer Register (MBR): Temporarily stores data being transferred between the CPU and main memory.

Current Instruction Register (CIR): Stores the instruction currently being decoded and executed.

Accumulator (ACC): A general-purpose register used for arithmetic and logical operations, storing intermediate results.

The Four-Stage Cycle:

1. FETCH: Copy address from PC to MAR → Increment PC → Copy instruction from memory location (addressed by MAR) into MDR → Transfer instruction from MDR to CIR

2. DECODE: The Control Unit interprets the instruction in CIR, identifying the opcode (operation) and operand (data/address)

3. EXECUTE: The identified operation is performed (e.g., ADD, LOAD, STORE, JUMP)

4. RESET: Results are stored appropriately, and the cycle repeats

Cambridge Note: Exam questions frequently ask for step-by-step descriptions with register names. Always reference specific registers (PC, MAR, MDR, CIR) for full marks.

Analogy: The Library Book Retrieval System

Imagine the Fetch-Execute Cycle as a librarian retrieving and processing book requests:

• Program Counter: A numbered list of book requests; the librarian notes which request is next
• MAR: The specific shelf location written on a note
• MDR: The trolley carrying the book between shelf and desk
• CIR: The request form being read at the desk
• Execute: Actually fulfilling the request (stamping, filing, etc.)

The librarian checks their list (PC), writes down the shelf number (MAR), walks to that shelf, places the book on the trolley (MDR), brings it to the desk, reads the request form (CIR), then processes it (EXECUTE). They then move to the next request number.

Real-World Application: Smartphone Gaming

When playing a mobile game, every frame rendered involves millions of fetch-execute cycles:

• FETCH: The CPU retrieves game instructions ("check if screen was touched")
• DECODE: Interprets this as a conditional branch instruction
• EXECUTE: Compares touch sensor data; if touched, jumps to "fire weapon" code

Modern processors execute 3-5+ billion cycles per second (GHz). A 3GHz processor completes 3,000,000,000 fetch-execute cycles every second, enabling smooth 60fps gameplay.

Pipelining Enhancement: Advanced CPUs don't wait for one cycle to complete. While one instruction executes, the next fetches simultaneously—like multiple librarians working on different stages of different requests. This dramatically improves throughput.