Skip to topic
    ← Back to course topics

    Structure and function of the processor — OCR A-Level Computer Science

    Structure and function of the processor explained

    Structure and function of the processor covers 5 specification points, including Data, address and control: how this relates to… and (b) The Fetch-Decode-Execute Cycle; including….

    Read the full explanation

    Open a point below for its explanation and revision guidance.

    (a) The Arithmetic and Logic Unit; ALU, Control Unit and Registers (Program Counter; PC, Accumulator; ACC, Memory Address Register; MAR, Memory Data Register; MDR, Current Instruction Register; CIR). Buses: data, address and control: how this relates to assembly language programs.

    Covers the ALU, Control Unit and registers, and how buses link them to assembly language. The ALU performs arithmetic and logic operations; the Control Unit coordinates other parts through control signals. Registers hold key values: the PC stores the next instruction's address, the ACC stores results, the MAR holds the address being accessed, the MDR holds data read from or written to memory, and the CIR holds the current instruction. Buses carry data (two-way), addresses (from the processor to memory) and control signals such as read and write. Assembly instructions such as ADD map to machine code that uses these registers and buses; tracing one shows how the parts interact.

    (b) The Fetch-Decode-Execute Cycle; including its effects on registers.

    The fetch-decode-execute cycle is the repeated process the CPU uses to run each instruction, and this statement asks how it changes registers. In fetch, the PC's address is copied to the MAR, the PC is incremented, and the instruction is read into the MDR and then copied to the CIR. In decode, the Control Unit interprets the opcode in the CIR. In execute, the ALU carries out the operation; results may go to the ACC, and a branch may load a new address into the PC. Tracing PC, MAR, MDR, CIR and ACC values through one instruction shows how each stage changes registers.

    (c) The factors affecting the performance of the CPU: clock speed, number of cores, cache.

    This statement asks you to explain how three features change CPU performance: clock speed, number of cores and cache. Clock speed is the number of cycles completed each second, measured in hertz. A 3.5 GHz processor completes 3.5 × 10⁹ cycles per second, so one cycle lasts about 0.29 ns. More cores run more instruction streams at once, but only parallel software gains the full benefit. Cache is small, fast memory between the cores and main memory, holding recently used data and instructions, so a larger or closer cache reduces waiting for main memory. For each factor, give the mechanism, a concrete example and a limitation.

    (d) The use of pipelining in a processor to improve efficiency.

    This statement asks you to explain how pipelining improves processor efficiency. Pipelining splits instruction execution into stages, such as fetch, decode, execute and write-back, so different instructions occupy different stages at once. Without pipelining, four instructions in a five-stage processor take 4 × 5 = 20 cycles. With pipelining they take 5 + (4 − 1) = 8 cycles, so the speedup is 20 ÷ 8 = 2.5. Efficiency rises because each functional unit is busy more of the time. Hazards limit this: a branch can flush instructions already in the pipeline, and a data dependency can force a stall. Use a worked cycle count and name one hazard.

    (e) Von Neumann, Harvard and contemporary processor architecture.

    This statement asks you to compare three architectures by how they organise memory and buses. In a Von Neumann architecture, instructions and data share one memory and one set of buses, so fetching an instruction and transferring data happen in sequence, which creates the von Neumann bottleneck. A Harvard architecture stores instructions and data in separate memories with separate buses, so an instruction fetch and a data access can occur at the same time. Contemporary designs mix these ideas: modern processors often use split instruction and data caches over a shared main memory, and they add multiple cores and pipelining. For each architecture, state the feature, explain its effect on performance, and give an example.

    Your focus

    1. Identify the ALU, Control Unit and five named registers by their function.
    2. Describe the roles of the data, address and control buses.
    3. Explain how an assembly instruction relates to registers and buses.
    Show all 15 objectives
    1. Sequence the fetch, decode and execute stages with their register transfers.
    2. Describe how the PC, MAR, MDR and CIR change during fetch.
    3. Explain how the Control Unit and ALU act during decode and execute.
    4. Explain how clock speed, number of cores and cache affect CPU performance.
    5. Calculate the cycle time in seconds for a given clock speed in hertz.
    6. Evaluate the limitations that stop each performance factor from giving a proportional gain.
    7. Describe how pipelining overlaps the stages of several instructions.
    8. Calculate the number of cycles needed to execute a sequence of instructions in a pipeline.
    9. Explain how a branch or a data dependency reduces pipeline efficiency.
    10. Draw and label Von Neumann and Harvard architectures showing memory, buses and processor.
    11. Explain how shared versus separate buses affect the speed of instruction and data access.
    12. Describe at least one contemporary processor feature and its effect on performance.

    Structure and function of the processor exam tips

    Marking Points
    • Identifies the ALU as the component that performs arithmetic and logic operations on data.
    • Explains that the Control Unit directs the other components by sending control signals.
    • Distinguishes the PC, ACC, MAR, MDR and CIR by what each stores, such as an address, a result, data or an instruction.
    • Describes the data bus as carrying data in both directions and the address bus as carrying memory addresses from the processor.
    • Links the control bus to signals such as read and write rather than to data or addresses.
    • Relates buses and registers to assembly instructions that refer to registers and memory addresses.
    • States that the contents of the PC are copied to the MAR at the start of fetch.
    • Explains that the PC is incremented during fetch so that it holds the address of the next instruction.
    • Describes the instruction being read into the MDR and then copied into the CIR.
    • Explains that the Control Unit decodes the opcode held in the CIR during the decode stage.
    • Identifies that the ALU performs the operation during execute, with results possibly stored in the ACC.
    • Identifies that a branch instruction may load a new address into the PC during execute.
    • Defines clock speed as cycles per second measured in hertz and converts 3.5 GHz to 3.5 × 10⁹ Hz correctly.
    • Explains that a higher clock speed completes more instructions per second only if the design and cooling sustain it.
    • Explains that additional cores allow parallel execution, so multi-threaded software benefits most.
    • Explains that cache holds frequently used data and instructions close to the core, which reduces memory access time.
    • Identifies a limitation for each factor, such as heat restricting clock speed or serial code restricting the gain from extra cores.
    • Explains that pipelining overlaps the stages of several instructions so that each stage is busy at the same time.
    • Calculates the non-pipelined time as 4 × 5 = 20 cycles and the pipelined time as 5 + (4 − 1) = 8 cycles.
    • Links the throughput gain to more instructions completed per unit of time, so the processor is used more efficiently.
    • Identifies at least one hazard, such as a branch flushing instructions or a data dependency causing a stall.
    • Identifies that a Von Neumann architecture uses one memory store and one set of buses for both instructions and data.
    • Explains that shared buses force instruction fetches and data transfers to take place in sequence, creating the von Neumann bottleneck.
    • Explains that a Harvard architecture uses separate instruction and data memories with separate buses, allowing simultaneous access.
    • Describes a contemporary feature such as split instruction and data caches, multiple cores or pipelining, and states its effect on performance.
    • Gives a suitable application for each architecture, such as a microcontroller for Harvard-style memory.
    Examiner Tips
    • 💡Learn each register through one purpose statement, such as what kind of value it stores, and check each MCQ option against it.
    • 💡When an option names a bus, ask whether the item is data, an address or a control signal before accepting it.
    • 💡Trace a short assembly instruction through the registers and buses to test options that link hardware to assembly language.
    • 💡Write the register transfers in order (PC to MAR, memory to MDR, MDR to CIR) and check each MCQ option against that sequence.
    • 💡Remember that a branch instruction changes the PC, while a normal instruction only increments it.
    • 💡For each option, check which register changes at each stage before accepting it.
    • 💡Give each of the three factors its own paragraph containing a mechanism, an example and a limitation.
    • 💡Convert units before calculating: 3.5 GHz means 3.5 × 10⁹ cycles per second, so the cycle time is 1 ÷ (3.5 × 10⁹) s.
    • 💡Link each factor to its effect on instruction execution or memory access rather than only naming it.
    • 💡Draw a small timing table with one column per cycle to check your cycle count before writing the answer.
    • 💡Show the formula for pipelined cycles as stages plus (instructions − 1) before substituting the numbers.
    • 💡Name one specific hazard and describe its effect on the pipeline, not just its name.
    • 💡Draw a labelled diagram of each architecture showing memory, buses and processor to check you can distinguish them.
    • 💡Structure each comparison as feature, then effect, then example, so that all three architectures receive full coverage.
    • 💡For Von Neumann, name which transfers compete for the shared bus when explaining the bottleneck.
    Common Mistakes
    • Confuses the MAR with the MDR; the MAR holds the address being accessed, while the MDR holds the data being transferred.
    • Describes the ACC as holding the next instruction's address; the PC holds that address and the ACC holds results.
    • Treats the control bus as carrying data; the data bus carries data, while the control bus carries signals such as read and write.
    • Places the instruction in the CIR before it has been fetched from memory; the instruction passes through the MDR first, then reaches the CIR.
    • Describes the PC as being incremented after execution; the PC is incremented during fetch.
    • Treats decode as carrying out the instruction; decode only interprets the opcode, and the ALU performs the operation in execute.
    • Treats clock speed as the only factor that determines performance; state that the number of cores and the cache also affect it.
    • Assumes four cores make a program four times faster; state that only tasks that can run in parallel gain close to that speedup.
    • Describes cache as main memory or secondary storage; correct this to small, fast memory placed between the core and RAM.
    • Treats pipelining as making each individual instruction finish faster; correct this by stating that the latency of one instruction does not fall while throughput rises.
    • Calculates the pipelined time for four instructions as 4 × 5 = 20 cycles; use 5 + (4 − 1) = 8 cycles for four instructions in five stages.
    • Ignores hazards and claims pipelining always gives the full speedup; state that branches and data dependencies cause flushes or stalls.
    • Treats Harvard architecture as always faster than Von Neumann; correct this by stating that separate access helps only when simultaneous instruction and data access is useful.
    • Describes Von Neumann as having separate buses; correct this by stating that it shares one memory and one set of buses for instructions and data.
    • Presents contemporary architecture as a separate third model; correct this by showing it combines split caches with shared main memory and multi-core features.
    • Lists features without linking them to their effect on performance; correct this by stating the consequence of each feature in one sentence.