English:Computer Architecture
Computer Architecture
Introduction
Computer architecture is the plan that explains how the main parts of a computer are organized, how they communicate, and how they work together to execute instructions. It connects hardware with software: programs give instructions, while processors, memory, storage, buses, and input/output devices make those instructions happen.
In this course, you will study a simplified model of a modern computer. You will learn how a CPU processes instructions, how RAM provides working memory, how data moves along buses, how storage keeps information when power is off, and why features such as cache, clock speed, and multiple cores affect performance. You will also compare the von Neumann model with the Harvard model.
By the end of the course, you should be able to trace the path of an instruction through a computer, explain the role of major hardware components, compare memory and storage technologies, interpret basic architecture diagrams, and make evidence-based judgments about computer performance.
What Computer Architecture Describes
Computer architecture can be described at several levels. At a high level, it tells you what major components exist and how they connect. At the instruction set architecture level, it describes the instructions, registers, data types, and addressing rules that software can use. At the microarchitecture level, it describes how a particular processor design actually carries out those instructions.
For Grades 9–10, the most useful starting point is the system view: input → processing → memory/storage → output. A keyboard can provide input, the CPU can process it, RAM can hold active data, storage can save it, and a screen can display the result. Real computers are more complex, but this model helps you reason about the flow of information.
Hardware, Software, and Instructions
A computer is useful because its hardware can follow instructions supplied by software. Each instruction is represented in machine code using binary patterns. A processor does not understand a sentence such as “add these two numbers.” Instead, it receives a coded operation together with information about where the data comes from and where a result should go.
The exact binary instruction format depends on the processor's instruction set. This is why software compiled directly for one processor family may not run natively on another processor family without translation or emulation.
The Main Components of a Computer
A typical computer system includes a CPU, main memory, storage, input devices, output devices, and communication pathways. These parts are connected through a motherboard or another system board.
The motherboard provides physical connections, electrical pathways, power delivery, sockets, slots, and controllers. Modern designs vary widely: a desktop computer may use separate replaceable components, while a phone or embedded device may combine many functions into a single system on a chip.
Central Processing Unit
The CPU is the component that executes program instructions. A simplified CPU contains a control unit, an arithmetic logic unit, and registers. Modern CPUs also contain cache memory and many other units.
The control unit coordinates instruction execution. It interprets the current instruction and sends control signals that cause other parts of the processor to perform the required actions.
The arithmetic logic unit, or ALU, performs arithmetic operations such as addition and subtraction and logical operations such as comparisons and Boolean operations.
Registers are very small, very fast storage locations inside the processor. They hold values that the CPU needs immediately, such as operands, addresses, instructions, and intermediate results.
From Transistors to Logic Gates
At a lower level, processors are built from enormous numbers of transistors. Transistors can be combined into logic gates, and logic gates can be combined into larger circuits such as adders, registers, and control circuits.
An AND gate, OR gate, and NOT gate follow simple Boolean rules, but large networks of these gates can perform complex operations. Computer architecture usually works at a higher level than individual transistors, yet understanding this connection shows how binary logic becomes real hardware.
The processor die image above shows the physical complexity hidden behind a simple CPU symbol in a block diagram. The visible regions contain many functional structures, but the exact layout depends on the processor design.
The Fetch–Decode–Execute Cycle
A processor repeatedly performs an instruction cycle. In a simplified model, the cycle has three main stages: fetch, decode, and execute.
During fetch, the CPU obtains the next instruction from memory. A program counter keeps track of the address of the next instruction. Teaching models may also use a memory address register, a memory data register, and an instruction register to show how addresses and values move.
During decode, the control unit interprets the instruction. It determines which operation is required and which data or registers are involved.
During execute, the processor performs the operation. This may involve the ALU, a register transfer, a memory access, or communication with another part of the system. The result may be kept in a register or written to memory.
The cycle then continues with the next instruction. Modern processors can overlap stages through techniques such as pipelining, so several instructions may be at different stages at the same time.
A Simple Instruction Trace
Imagine an instruction that means “add the value in register A to the value in register B and place the result in register C.” The CPU fetches the encoded instruction from memory, decodes the operation and register names, sends the two values to an execution unit such as the ALU, performs the addition, and stores the result in the chosen register.
This trace is simplified, but it reveals an important idea: a program becomes a sequence of controlled data movements and operations inside hardware.
The Von Neumann Model
In the traditional von Neumann model, program instructions and ordinary data share the same main memory and are transferred through shared pathways. The CPU fetches both instructions and data from memory.
This stored-program idea is extremely important because a computer can treat a program as information held in memory. Programs can therefore be loaded, copied, changed, and executed without rewiring the machine.
A limitation of a simple von Neumann design is that instructions and data compete for access to the pathway between processor and memory. This is often called the von Neumann bottleneck. Modern computers reduce the effect with cache memories, wider and faster memory systems, pipelining, prefetching, and other techniques.
Harvard and Modified Harvard Designs
A traditional Harvard architecture uses separate storage and pathways for program instructions and data. This can allow instruction and data access at the same time. Some microcontrollers and digital signal processors use Harvard-style designs.
Many modern processors use a modified Harvard approach internally: main memory may appear unified to software, while separate instruction and data caches give the processor parallel access close to the CPU. The boundary between architecture types can therefore be less simple in real machines than in school diagrams.
Buses and Data Movement
A bus is a communication pathway that carries information between components. A simplified system often distinguishes three types: the data bus, address bus, and control bus.
The data bus carries actual data values and instruction bits. The address bus identifies the memory location or device involved in a transfer. The control bus carries signals that coordinate actions such as reading, writing, timing, and interrupts.
The number of wires, signal standards, and directions differ among real systems. Modern computers also use high-speed point-to-point links, so the classic three-bus picture is a teaching model rather than a complete diagram of every modern machine.
Memory and Storage
A computer needs different kinds of memory because no single technology is simultaneously the fastest, largest, cheapest, and lowest-power option.
Registers and Cache
Registers are the smallest and fastest storage locations directly used by CPU instructions. Cache memory is also very fast and keeps copies of data and instructions that the processor is likely to use soon.
Modern processors commonly use several cache levels, often called L1, L2, and L3. Lower-numbered caches are usually smaller and closer to the execution units. Cache works because programs often reuse recently accessed data and nearby memory locations.
Random-Access Memory
RAM is the computer's main working memory. It holds active programs and data while the system is running. Ordinary system RAM is volatile, which means its contents are lost when power is removed.
When you open a program, its instructions and required data are typically copied from storage into RAM so that the CPU can access them much more quickly.
Memory Hierarchy
Computer memory is organized as a hierarchy. In a simplified view, the levels nearest the CPU are smaller and faster, while levels farther away are larger and slower.
A useful order to remember is registers → cache → RAM → secondary storage. This is a general performance pattern, not a fixed timing rule for every device. Designers balance speed, capacity, cost, power use, and physical size.
Secondary Storage
Secondary storage keeps programs and files even when the computer is powered off. Common technologies include solid-state drives and hard disk drives.
An SSD stores data electronically in flash memory and has no moving read/write head. A hard disk drive stores data magnetically on rotating platters. SSDs usually provide much lower access latency, while hard drives can still be useful where large capacity at lower cost is important.
An M.2 device is a physical card format and connector family, not a guarantee of one particular speed. Many high-performance M.2 SSDs use NVMe over PCI Express, but other combinations also exist.
Input, Output, and Peripherals
Input devices send information into a computer system. Examples include keyboards, microphones, cameras, sensors, and touchscreens. Output devices present or transmit results. Examples include displays, speakers, printers, and actuators.
Peripherals usually communicate through controllers and interfaces rather than directly with the ALU. USB, PCI Express, display interfaces, network interfaces, and storage controllers are examples of technologies that help move data between the processor, memory, and devices.
An interrupt is a signal that asks the processor to respond to an event. For example, a device may use an interrupt to report that data has arrived. This lets the CPU perform other work instead of constantly checking every device.
Performance: Why One Number Is Not Enough
Computer performance depends on several interacting factors. Clock rate tells you how many clock cycles occur per second, but it does not tell you how much useful work is completed in each cycle. Two processors with different designs can perform very differently even at the same clock rate.
Core count matters when software can divide work into tasks that run in parallel. A program that uses only one thread may not gain much from many unused cores.
Cache size and design can reduce delays caused by waiting for main memory. Memory bandwidth affects how quickly large amounts of data can move. Storage speed affects booting, loading, and file operations. Power and temperature limits can also change sustained speed because a processor may reduce its frequency when it becomes too hot or exceeds a power target.
For this reason, reliable performance comparisons use tests that match the real task. A gaming benchmark, a video-encoding test, and a battery-life test measure different goals.
Architecture Trade-Offs
Engineers rarely maximize every feature at once. A faster design may use more power. A larger cache uses more chip area. More cores can increase performance for parallel tasks but also increase complexity and energy use. A device designed for a small sensor may value low power and low cost more than maximum speed.
Computer architecture is therefore a study of trade-offs: speed, energy, cost, reliability, size, compatibility, and programmability must be balanced for the intended use.
Interactive Tasks
Quiz: Test Your Knowledge
What does computer architecture mainly describe? (How computer components are organized and work together) (!Only the visual design of a computer case) (!Only the software installed on a computer) (!Only the amount of storage in a computer)
Which CPU component performs arithmetic and logical operations? (ALU) (!Control unit) (!Power supply) (!Keyboard)
What is a main role of the control unit? (Coordinate and direct instruction execution) (!Store files permanently) (!Display images on a monitor) (!Provide electrical power to the computer)
Which type of storage is located inside the processor and holds values needed immediately? (Register) (!Hard drive) (!Optical disc) (!Printer buffer)
What is a key feature of the traditional von Neumann model? (Instructions and data share main memory) (!Instructions can never be stored) (!Every program needs separate physical wiring) (!The CPU has no registers)
Which stage comes first in the simplified instruction cycle? (Fetch) (!Decode) (!Execute) (!Output)
What does an address bus identify? (A memory location or device involved in a transfer) (!The color of a data value) (!The physical size of a processor) (!The name of a software license)
Why is ordinary system RAM described as volatile? (It loses its contents when power is removed) (!It is always slower than a hard drive) (!It can store only program instructions) (!It can never be rewritten)
Why does a CPU use cache memory? (To keep likely needed data close to the processor) (!To replace all permanent storage) (!To provide power to the motherboard) (!To connect a monitor to the computer)
Why is clock rate alone not enough to compare processor performance? (Different processors can do different amounts of work per cycle) (!Clock rate measures only storage capacity) (!Every processor has exactly the same design) (!Higher clock rate always means lower performance)
Memory Game
| CPU | Executes program instructions |
| ALU | Performs arithmetic and logical operations |
| Register | Holds a very small amount of immediately needed data |
| RAM | Stores active programs and working data while power is on |
| Cache | Keeps likely needed information close to the processor |
| Bus | Carries data addresses or control signals between components |
Drag and Drop
| Match the correct terms. | Topic |
|---|---|
| Fetch | Obtain the next instruction from memory |
| Decode | Interpret what the instruction requires |
| Execute | Carry out the required operation |
| Writeback | Place a result in its destination |
| Repeat | Continue with the next instruction |
...
Crossword Puzzle
| Processor | What component executes program instructions? |
| Register | What very fast storage location exists inside a CPU? |
| Control | What unit coordinates instruction execution? |
| Address | What kind of bus identifies a memory location? |
| Cache | What fast memory keeps likely needed data near the CPU? |
| Motherboard | What main circuit board connects major computer components? |
LearningApps
Cloze Text
Open-Ended Tasks
Easy
- Computer hardware diagram: Draw and label a simple computer architecture diagram with CPU, RAM, storage, input, output, and buses. Use arrows to show the likely direction of information flow.
- Instruction cycle comic: Create a four-panel comic that shows fetch, decode, execute, and writeback using a simple instruction such as adding two values.
- Memory hierarchy poster: Make a poster that compares registers, cache, RAM, and secondary storage using the ideas of speed, capacity, and persistence.
- Motherboard observation: Study a safe photograph or disconnected classroom motherboard and identify at least five visible components or connectors. Explain what each one is used for.
Standard
- Computer technician interview: Interview a computer technician, IT support worker, or knowledgeable teacher about common hardware bottlenecks. Summarize which architecture features matter in real troubleshooting.
- Unplugged CPU simulation: Work in a group to act out a CPU, memory, and buses. Pass written instruction and data cards through a fetch–decode–execute cycle and record where delays occur.
- Processor comparison: Compare two current or classroom-available processors using clock rate, core count, cache, power use, and benchmark evidence. Explain why no single specification decides the winner.
- Memory hierarchy animation: Produce a short animation that follows one piece of data from storage to RAM to cache to a register and then back toward storage.
Advanced
- Architecture design challenge: Design a computer for a specific purpose such as a school laptop, game console, environmental sensor, or robot. Justify your choices for processor, memory, storage, and input/output.
- Benchmark investigation: Plan and carry out a fair performance test on two computers or devices. Control at least three variables, collect results, and explain which architecture differences may have affected the outcome.
- Microcontroller case study: Research one microcontroller used in a real product. Identify its processor core, memory types, input/output features, and whether its design shows Harvard or modified Harvard characteristics.
- Computer architecture video: Create a three-to-five-minute explainer video that teaches younger learners how an instruction moves through a computer. Include a diagram, an analogy, and one limitation of the analogy.
Learning Assessment
- System reasoning: Given a diagram of a computer with one missing connection, explain what communication would fail and justify which bus or pathway should be restored.
- Instruction transfer: Trace a simple load-add-store sequence through CPU registers, memory, and buses, and explain what information moves at each stage.
- Performance evaluation: Compare two hypothetical computers with different clock rates, core counts, cache sizes, and memory bandwidth, then choose the better one for two different workloads and defend both choices.
- Architecture comparison: Explain one advantage and one limitation of a traditional von Neumann design and compare them with a Harvard-style design for an embedded system.
- Memory decision: Recommend whether a task should depend mainly on registers, cache, RAM, or secondary storage, and justify the choice using speed, capacity, and persistence.
- Design trade-off: Propose one change that could improve the performance of a small computer and explain at least one cost or disadvantage that the change could introduce.
Evidence of Learning
- Knowledge: You can accurately explain CPU, ALU, control unit, registers, cache, RAM, storage, buses, and the fetch–decode–execute cycle.
- Systems thinking: You can trace how instructions, addresses, data, and control signals move between components.
- Comparison skill: You can compare von Neumann, Harvard, and modified Harvard ideas without treating simplified diagrams as exact models of every modern processor.
- Performance reasoning: You can explain why clock rate, cores, cache, memory, storage, software, power, and temperature can all affect observed performance.
- Products: Your diagrams, posters, animations, test reports, interviews, or videos communicate architecture concepts clearly and accurately.
- Transfer: You can apply architecture ideas to unfamiliar devices such as phones, game consoles, microcontrollers, robots, and laptops.
- Evaluation: You can justify a hardware choice for a purpose and identify the trade-offs behind that choice.
OERs on the Topic
Linked Learning Areas
.jpg){kind=link}
