Types of processor — OCR A-Level Computer Science Revision

    This topic explores the architectural differences between CISC and RISC processors, highlighting their distinct design philosophies and typical use cases.

    Topic Synopsis

    This topic explores the architectural differences between CISC and RISC processors, highlighting their distinct design philosophies and typical use cases. It also covers the role of GPUs beyond graphics processing and the principles of multicore and parallel processing systems.

    Key Concepts & Core Principles

    Exam Tips & Revision Strategies

    Common Misconceptions & Mistakes to Avoid

    Examiner Marking Points

    Types of processor

    OCR
    A-Level

    This topic explores the architectural differences between CISC and RISC processors, highlighting their distinct design philosophies and typical use cases. It also covers the role of GPUs beyond graphics processing and the principles of multicore and parallel processing systems.

    0
    Objectives
    3
    Exam Tips
    3
    Pitfalls
    0
    Key Terms
    4
    Mark Points

    Topic Overview

    The 'Types of processor' topic in OCR A-Level Computer Science explores the different architectures and designs of central processing units (CPUs). This includes the classic Von Neumann architecture, where data and instructions share a single memory bus, and the Harvard architecture, which uses separate memory and buses for data and instructions. Understanding these distinctions is crucial for grasping how computers execute programs, manage memory, and achieve performance gains through parallelism.

    This topic also covers modern processor designs such as RISC (Reduced Instruction Set Computer) and CISC (Complex Instruction Set Computer), which represent different philosophies in instruction set design. RISC processors use simple, fixed-length instructions that can be executed in one clock cycle, while CISC processors have complex, variable-length instructions that can perform multiple operations. Additionally, you'll learn about pipelining, which allows multiple instructions to be processed simultaneously by overlapping their fetch-decode-execute cycles, and the challenges it introduces like hazards.

    Mastering this topic is essential for understanding how processors work at a hardware level, which underpins performance analysis, system design, and optimisation. It connects to other areas such as assembly language programming, memory management, and parallel processing. By the end, you should be able to compare architectures, explain the trade-offs between RISC and CISC, and describe how pipelining improves throughput.

    Key Concepts

    Core ideas you must understand for this topic

    • →Von Neumann vs Harvard architecture: Von Neumann uses a single shared memory for data and instructions, leading to the 'Von Neumann bottleneck'; Harvard uses separate memories, allowing simultaneous access and faster execution.
    • →RISC vs CISC: RISC (Reduced Instruction Set Computer) has a small, simple instruction set with fixed-length instructions, emphasising software efficiency; CISC (Complex Instruction Set Computer) has a large, complex instruction set with variable-length instructions, aiming to reduce the number of instructions per program.
    • →Pipelining: A technique where the fetch-decode-execute cycle is split into stages, and multiple instructions are processed concurrently at different stages. This increases throughput but can cause hazards (data, control, structural) that reduce efficiency.
    • →Parallel processing: Using multiple processors or cores to execute instructions simultaneously, improving performance. This includes concepts like SIMD (Single Instruction, Multiple Data) and MIMD (Multiple Instruction, Multiple Data).
    • →FDE cycle: The fundamental process by which a CPU executes instructions: Fetch (get instruction from memory), Decode (interpret instruction), Execute (perform operation). Different architectures affect how this cycle is implemented.

    What You Need to Demonstrate

    Key skills and knowledge for this topic

    • Differences between CISC and RISC architectures
    • Uses of CISC and RISC processors
    • Role and applications of GPUs
    • Concepts of multicore and parallel systems

    Marking Points

    Key points examiners look for in your answers

    • Differences between CISC and RISC architectures
    • Uses of CISC and RISC processors
    • Role and applications of GPUs
    • Concepts of multicore and parallel systems

    Examiner Tips

    Expert advice for maximising your marks

    • 💡Be prepared to compare CISC and RISC in terms of instruction sets and clock cycles
    • 💡Focus on the 'why' behind using a GPU for non-graphical tasks, such as parallel data processing
    • 💡Ensure you can explain the performance benefits of parallel systems
    • 💡When comparing architectures, always mention specific advantages and disadvantages. For example, Von Neumann is simpler and cheaper but suffers from the bottleneck; Harvard is faster but more complex and expensive. Use real-world examples like Intel x86 (CISC) vs ARM (RISC).
    • 💡For pipelining questions, draw a diagram showing the stages and how instructions overlap. Explain hazards clearly: data hazards (read-after-write), control hazards (branches), and structural hazards (resource conflicts). Mention solutions like forwarding, branch prediction, and stalling.
    • 💡In exam answers, define key terms precisely. For instance, 'throughput' is the number of instructions completed per unit time, not the same as 'latency'. Show understanding of trade-offs: RISC's simplicity allows easier pipelining but may require more instructions; CISC's complexity can reduce code size but makes pipelining harder.

    Common Mistakes

    Pitfalls to avoid in your exam answers

    • Confusing the specific architectural advantages of RISC over CISC
    • Assuming GPUs are only used for rendering graphics
    • Failing to distinguish between multicore and parallel processing
    • Misconception: RISC processors are always faster than CISC. Correction: RISC processors can execute simple instructions quickly, but CISC processors may complete complex tasks in fewer instructions. Performance depends on the application and how well the instruction set matches the task.
    • Misconception: Pipelining always speeds up execution. Correction: Pipelining increases throughput, but hazards (e.g., data dependencies, branch predictions) can cause stalls or flushes, reducing the speedup. The ideal speedup is equal to the number of pipeline stages, but this is rarely achieved.
    • Misconception: Harvard architecture is only used in microcontrollers. Correction: While common in microcontrollers (e.g., PIC, AVR), Harvard architecture is also used in DSPs (Digital Signal Processors) and some modern CPUs (e.g., ARM Cortex-M series) to improve performance by allowing simultaneous instruction and data access.

    Frequently Asked Questions

    Common questions students ask about this topic

    Before You Start

    Prior knowledge that will help with this topic

    • •Basic understanding of the fetch-decode-execute cycle and CPU components (ALU, control unit, registers).
    • •Knowledge of binary representation and memory addressing.
    • •Familiarity with assembly language instructions (e.g., LDR, ADD) is helpful but not essential.

    Likely Command Words

    How questions on this topic are typically asked

    Compare
    Describe
    Explain
    Identify

    Ready to test yourself?

    Practice questions tailored to this topic

    Related Topics in OCR A-Level Computer Science

    Algorithms

    View Topic

    Analysis of the problem

    View Topic

    Applications Generation

    View Topic

    Boolean Algebra

    View Topic