Computer architecture Revision Notes

The Central Processing Unit (CPU) is often described as the 'brain' of the computer because it is responsible for executing instructions and processing data. Every task a computer performs, from running applications to managing hardware, depends on the CPU interpreting and carrying out program instructions stored in memory.

The CPU fetches instructions from the computer's memory, decodes what actions are required, and then executes those instructions. This cycle repeats continuously while the computer is powered on and running programs.

Without the CPU, a computer cannot function because there would be no component to process data or control other parts of the system.

• Executes instructions from programs.
• Processes data and controls hardware components.
• Coordinates the operation of the entire computer system.

The CPU consists of several key parts that work together to perform its functions:

The Arithmetic Logic Unit (ALU) performs all arithmetic calculations (such as addition and subtraction) and logical operations (such as comparisons).

The Control Unit (CU) manages the flow of data within the CPU and between the CPU and other components. It directs the fetching, decoding, and execution of instructions by sending control signals to other parts of the computer system.

• Arithmetic Logic Unit (ALU) for calculations and logic.
• Control Unit (CU) for managing instruction execution.
• Registers for temporarily holding data and instructions.

Registers are small, fast storage locations within the CPU that temporarily hold data, instructions, or addresses during processing. They enable quick access to data that the CPU needs immediately, improving processing speed.

For example, when adding two numbers, the CPU might load the numbers into registers, perform the addition in the ALU, and then store the result back in a register before writing it to memory.

Registers are essential for efficient instruction execution and data manipulation within the CPU.

• Hold data and instructions temporarily.
• Enable fast access during processing.
• Support the fetch-decode-execute cycle.

A microprocessor is a single integrated circuit (chip) that contains the entire CPU. It combines the ALU, control unit, and registers on one small piece of silicon.

Microprocessors are the foundation of modern computers and many electronic devices because they provide the processing power in a compact, efficient form.

For example, the microprocessor inside a smartphone controls all the operations, from running apps to managing sensors and communication modules.

• An integrated circuit containing the CPU components.
• Enables compact and efficient processing units.
• Used in computers, smartphones, embedded systems, and more.

The CPU performs the essential task of executing instructions, while the microprocessor is the physical hardware that implements the CPU's functions.

In early computers, the CPU was made from multiple separate components, but modern CPUs are microprocessors, making devices smaller, faster, and more reliable.

Understanding that the microprocessor is the CPU in chip form helps clarify how computing power is embedded in various devices beyond traditional computers.

• CPU is the functional unit; microprocessor is the physical chip.
• Microprocessors integrate CPU functions into a single chip.
• This integration allows for compact and powerful computing devices.

The Von Neumann architecture is a foundational model for most modern computers. It features a single memory space that stores both instructions (program code) and data. The central processing unit (CPU) is the core component responsible for executing instructions stored in memory.

Within the CPU, three main components work together: the Arithmetic Logic Unit (ALU), the Control Unit (CU), and registers. These components collaborate to process instructions and manipulate data efficiently.

• Single memory stores both data and instructions.
• CPU contains ALU, CU, and registers.
• CPU fetches and executes instructions sequentially.

Each CPU component has a specific role: the ALU performs all arithmetic (such as addition and subtraction) and logical operations (such as comparisons). The Control Unit orchestrates the entire process by directing data flow and managing the execution of instructions. Registers are small, fast storage locations inside the CPU that temporarily hold data, instructions, or addresses during processing.

Key registers include the Program Counter (PC), which holds the address of the next instruction to fetch, and the Memory Address Register (MAR), which holds the address of the memory location currently being accessed. The Memory Data Register (MDR) temporarily stores data read from or written to memory.

• ALU executes arithmetic and logic operations.
• CU controls instruction execution and data flow.
• Registers temporarily hold data and addresses.
• PC tracks the next instruction address.
• MAR holds the memory address to access.
• MDR holds data being transferred to/from memory.

The fetch-decode-execute (FDE) cycle is the continuous process by which the CPU runs instructions. It consists of three main stages:

1. Fetch: The CPU uses the Program Counter (PC) to find the address of the next instruction. This address is copied to the Memory Address Register (MAR). The instruction stored at that memory address is then read into the Memory Data Register (MDR). Finally, the instruction is transferred to the Current Instruction Register (CIR) for decoding. The PC is incremented to point to the next instruction.

2. Decode: The Control Unit interprets the instruction in the CIR, determining what operation is required and which operands are involved. It prepares the necessary components for execution, such as selecting registers or setting control signals for the ALU or memory access operations. 3. Execute: The ALU or other CPU components carry out the instruction. This might involve performing calculations, moving data between registers, or reading/writing memory. The result may be stored back in a register or memory. After execution, the cycle repeats for the next instruction.

• Fetch: Retrieve instruction from memory using PC and MAR.
• Decode: CU interprets instruction and prepares execution.
• Execute: ALU or CPU components perform the operation.
• PC increments to next instruction address.
• Cycle repeats continuously during program run.

Consider a simple instruction: ADD R1, R2, R3 — which means add the contents of registers R2 and R3, then store the result in R1.

Fetch: The CPU fetches this instruction from memory at the address in the PC.

Decode: The CU decodes the instruction and recognises it as an addition operation involving registers R2 and R3, with the result to be stored in R1. Execute: The ALU adds the values in R2 and R3. The sum is then stored in R1. The PC increments to the next instruction address, ready to fetch the next instruction.

• Instruction: ADD R1, R2, R3.
• Fetch instruction from memory.
• Decode operation and operands.
• Execute addition in ALU.
• Store result in R1.
• Increment PC for next instruction.

Understanding the FDE cycle and CPU components is essential because it reveals how a computer processes instructions at the hardware level. The cycle ensures instructions are handled one at a time in a controlled sequence, allowing complex programs to run correctly.

Each CPU component plays a vital role: the ALU performs the actual data manipulation, the CU manages the process flow, and registers provide quick access to data and addresses. This organisation allows the CPU to operate efficiently and reliably.

• FDE cycle controls instruction processing.
• ALU performs calculations and logic.
• CU manages control signals and timing.
• Registers provide fast temporary storage.
• Together, they enable sequential program execution.

A core is an individual processing unit within a CPU capable of executing instructions independently. Modern CPUs often contain multiple cores, such as dual-core, quad-core, or even octa-core processors.

Having multiple cores allows a CPU to perform several tasks simultaneously, known as parallel processing. For example, a quad-core CPU can handle four separate instruction streams at once, improving multitasking and speeding up programs designed to use multiple cores.

However, not all software benefits equally from multiple cores; some applications are single-threaded and mainly use one core. Therefore, more cores improve performance primarily when running multiple programs or software optimized for parallelism.

• Single core executes one instruction stream at a time.
• Multiple cores enable parallel processing and multitasking.
• Software must be designed to use multiple cores effectively.

Cache is a small amount of very fast memory located inside the CPU. It stores frequently used data and instructions to reduce the time needed to access this information compared to fetching it from the slower main memory (RAM).

There are typically multiple levels of cache (L1, L2, L3), with L1 being the smallest and fastest, closest to the cores, and L3 being larger but slower. The CPU checks the cache first when it needs data; if the data is found (a cache hit), it can proceed quickly.

For example, if a program repeatedly accesses the same variables or instructions, storing these in cache avoids delays caused by accessing RAM, thus improving overall CPU speed.

• Cache stores frequently accessed data and instructions.
• Multiple cache levels balance speed and size (L1 fastest, smallest; L3 slower, larger).
• Cache hits reduce data access time, improving CPU efficiency.

Clock speed, measured in gigahertz (GHz), indicates how many cycles the CPU can perform per second. Each cycle allows the CPU to execute parts of instructions or complete simple instructions.

For instance, a CPU with a clock speed of 3 GHz can perform 3 billion cycles per second. Generally, a higher clock speed means the CPU can process instructions faster, but this is not the only factor affecting performance.

Clock speed alone does not guarantee better performance if the CPU has fewer cores or smaller cache. Also, increasing clock speed raises power consumption and heat output, which can limit practical maximum speeds.

• Clock speed is measured in GHz (cycles per second).
• Higher clock speeds usually mean faster instruction execution.
• Performance depends on clock speed combined with cores and cache.

CPU performance depends on the balance between cores, cache, and clock speed. For example, a CPU with many cores but low clock speed may excel at multitasking but perform slower on single-threaded tasks.

Similarly, a CPU with a high clock speed but small cache might process instructions quickly but suffer delays when accessing data from RAM.

An ideal CPU for a given use case balances these factors. For gaming, high clock speed and sufficient cache are important, while for video editing or running multiple applications, more cores improve performance.

• Multiple cores improve multitasking and parallel processing.
• Cache reduces delays caused by accessing main memory.
• Clock speed determines how fast each core executes instructions.
• Balanced CPU design depends on intended use and software optimization.

An instruction set is a predefined list of all the commands that a CPU can understand and execute directly in machine code. Machine code consists of binary patterns that represent specific operations. Each instruction tells the CPU to perform a particular task, such as arithmetic calculations, data transfer, or controlling program flow.

For example, an instruction might tell the CPU to add two numbers stored in registers or to move data from memory to a register. The instruction set acts as the CPU’s vocabulary, defining what it can do at the most fundamental level.

• Contains all machine code commands executable by the CPU.
• Defines the CPU’s operational capabilities.
• Is specific to each CPU architecture.

Instruction sets typically include several categories of commands: arithmetic operations (like addition and subtraction), logic operations (such as AND, OR, NOT), data transfer instructions (moving data between registers and memory), and control instructions (like jumps and branches that alter the sequence of execution).

For example, a CPU might have an instruction to increment a register value by one or to compare two values and branch if one is greater. These instructions are encoded in binary and decoded by the CPU during execution.

• Arithmetic and logic operations.
• Data movement commands.
• Control flow instructions (jumps, branches).

The instruction set determines what tasks a CPU can perform and how efficiently it can do them. A richer instruction set can allow more complex operations to be done with fewer instructions, potentially improving performance.

However, more complex instruction sets can also increase the CPU design complexity and execution time per instruction. Conversely, simpler instruction sets may require more instructions to perform a task but can be executed faster or with simpler hardware.

For example, Reduced Instruction Set Computing (RISC) CPUs use a smaller, simpler instruction set to achieve high performance through faster instruction execution.

• Defines CPU capabilities and limitations.
• Impacts CPU design complexity and speed.
• Influences software compatibility and performance.

Machine code is the binary representation of instructions from the instruction set. Each instruction has a unique binary code that the CPU fetches and executes during the fetch-decode-execute cycle.

For example, an instruction to add two registers might be represented as a specific 8-bit or 16-bit binary pattern. The CPU’s control unit decodes this pattern to activate the appropriate circuits to perform the operation.

Understanding machine code is essential for low-level programming and for understanding how software interacts directly with hardware.

• Machine code encodes instructions in binary.
• Each instruction corresponds to a unique binary pattern.
• CPU decodes and executes machine code instructions.

Consider a simple CPU with the following instructions:

LOAD: Move data from memory to a register (e.g., LOAD R1, 1000).

ADD: Add values in two registers and store the result (e.g., ADD R1, R2). STORE: Move data from a register back to memory (e.g., STORE R1, 1000). JUMP: Change the program counter to a specified address (e.g., JUMP 200). Each of these instructions is represented in machine code and executed by the CPU to perform the intended operation.

• LOAD, ADD, STORE, JUMP as typical instructions.
• Each instruction has a binary machine code equivalent.
• Instructions control data movement and processing.

An embedded system is a specialised computer designed to perform a dedicated function or set of functions within a larger mechanical or electrical system. Unlike general-purpose computers, which can run a wide range of software applications, embedded systems are built to carry out specific control, monitoring, or processing tasks. They are integrated into the device they control and are not usually visible as separate units to the user.

For example, the microcontroller inside a digital thermostat is an embedded system that regulates temperature by reading sensors and controlling heating or cooling devices. It does not perform unrelated tasks like running a web browser or word processor.

• Embedded systems are specialised computers within larger devices.
• They perform dedicated, narrowly defined tasks.
• They are integrated and often invisible to the end user.

The main purpose of an embedded system is to control, monitor, or assist the operation of the device it is embedded in. This can include managing inputs from sensors, processing data, and controlling outputs such as motors, displays, or alarms.

Embedded systems enable automation and precise control, improving the functionality and efficiency of devices. For instance, in a washing machine, the embedded system controls the wash cycle timing, water temperature, and spin speed based on user settings and sensor feedback.

Because they focus on specific tasks, embedded systems can be optimised for performance and reliability in their particular application.

• Control and monitor device functions.
• Process sensor inputs and manage outputs.
• Enable automation and improve device efficiency.
• Optimised for specific tasks rather than general computing.

Embedded systems have several defining characteristics that distinguish them from general-purpose computers:

Real-time operation: Many embedded systems must respond to inputs and events within strict time constraints to function correctly. For example, an airbag control system in a car must deploy airbags within milliseconds of detecting a collision.

Reliability: Since embedded systems often operate critical functions, they must be highly reliable and robust against failures or errors over long periods without maintenance or rebooting, such as in medical devices or automotive controls. Efficiency: Embedded systems are designed to use minimal resources, including processing power, memory, and energy, to reduce cost and power consumption. This is important in battery-powered devices like wearable fitness trackers. Dedicated hardware and software: The hardware and software are tailored specifically for the task, often using microcontrollers with limited instruction sets and memory. Low power consumption: Many embedded systems operate on limited power sources and must conserve energy to extend battery life or reduce heat generation.

• Real-time operation with strict timing requirements.
• High reliability and fault tolerance.
• Resource efficiency in processing, memory, and power.
• Dedicated hardware and software optimised for specific tasks.
• Low power consumption for battery-operated devices.

Embedded systems are ubiquitous in modern technology and can be found in a wide range of everyday devices. Some common examples include:

Household appliances such as washing machines, microwave ovens, and dishwashers, where embedded systems control cycles, timing, and user interfaces.

Automotive systems including engine control units (ECUs), anti-lock braking systems (ABS), and airbag controllers, which manage safety and performance functions in real time. Consumer electronics like digital cameras, smart TVs, and fitness trackers, where embedded systems handle user inputs, display control, and sensor data processing. Industrial machines and robotics, where embedded systems automate manufacturing processes and monitor equipment status. Medical devices such as pacemakers and infusion pumps, which require reliable and precise control to ensure patient safety.

• Household appliances (washing machines, microwaves).
• Automotive control systems (engine management, ABS).
• Consumer electronics (digital cameras, smart devices).
• Industrial automation and robotics.
• Medical devices requiring precise control.