Basic Components of a Computer System

Approach: Work upward from the bottom of the stack, naming each layer, the responsibility it carries, and a representative example, then summarise the property that the layering buys.

Steps:

1. Hardware level:
   • Provides the basic physical devices
   • Performs the most elementary electronic operations
   • Examples: CPU, main memory, hard disk
2. Microprogram level:
   • Decomposes machine instructions into micro-operations
   • Coordinates the hardware components
   • Invisible to programmers
3. Operating system level:
   • Manages hardware resources
   • Provides a user interface
   • Examples: Windows, Linux
4. System software level:
   • Provides development tools
   • Manages databases
   • Examples: compilers, database systems
5. Application software level:
   • Serves the user directly
   • Implements a specific function
   • Examples: a browser, an office suite

Answer: The layered structure of a computer system consists, from bottom to top, of the hardware level, the microprogram level, the operating system level, the system software level, and the application software level. Its advantages are modularity, ease of maintenance, extensibility, and portability.

Approach: List the five components in the order in which the data flows through them and attach the one-line responsibility of each.

Steps:

1. Arithmetic logic unit (ALU):
   • Performs arithmetic operations (addition, subtraction, multiplication, division)
   • Performs logical operations (AND, OR, NOT)
   • Performs shift operations
2. Controller:
   • Fetches and decodes instructions
   • Issues control signals
   • Controls the order in which the program executes
3. Memory:
   • Stores programs and data
   • Includes main memory (RAM/ROM) and secondary storage (hard disk)
   • Provides the read and write operations
4. Input devices: convert external information into digital signals; examples: keyboard, mouse, scanner.
5. Output devices: convert the computed results into a form a human can understand; examples: monitor, printer, speakers.

Answer: The five components are the arithmetic logic unit, the controller, memory, input devices, and output devices. The core idea behind them is the stored program: instructions and data share one memory, and the controller fetches and executes them in order.

Approach: State the principle in one sentence, then list the four consequences that follow from it and the historical effect it had.

Steps:

1. Automatic execution: once a program is loaded it needs no human intervention, and the computer executes the instructions in order.
2. The program can be modified: because the program is stored in memory it can be patched, which even allows self-modifying programs.
3. Generality: the same machine can run different programs, and switching tasks only means loading a different program into memory.
4. Flexibility: programs and data are stored in the same way, so a program can be handled just like data.

Answer: The stored-program principle means that both program instructions and data are kept in the same memory and that the computer executes the instructions automatically in the order in which they are stored. It is historically decisive because it turned a special-purpose machine into a general-purpose one, and it remains the basis of every modern computer.

Approach: Compare the two kinds of storage on the same five axes (speed, capacity, price, volatility, and how the CPU reaches them), then explain why a machine needs both.

Steps:

1. Primary storage (main memory):
   • Fast
   • Smaller capacity
   • More expensive per byte
   • Volatile (lost when the power is cut)
   • Directly accessible by the CPU
   • Examples: RAM (DDR4 and DDR5 modules), ROM (the BIOS chip), and cache (the L1/L2/L3 levels)
2. Secondary storage (auxiliary storage):
   • Slower
   • Large capacity
   • Cheaper per byte
   • Non-volatile (retains data when the power is cut)
   • Not directly accessible by the CPU, so the data has to be loaded into main memory first
   • Examples: a mechanical hard disk (HDD), a solid state drive (SSD), and USB flash drives or optical discs
3. Why both are needed:
   • Primary memory is fast but expensive, so it holds the program and data currently in use
   • Secondary storage is large but slow, so it holds data over the long term
   • The two together balance speed against capacity

Answer: Primary storage is fast, small, expensive, volatile, and directly reachable by the CPU (RAM, ROM, cache), while secondary storage is slow, large, cheap, non-volatile, and reached only by loading into main memory (HDD, SSD, flash drives). A practical computer needs both, because neither the speed of primary memory nor the capacity of secondary storage is available anywhere else.

Approach: Define the ISA as an interface, enumerate what it fixes down, and then spell out the three consequences of having one.

Steps:

1. Definition: the interface between software and hardware; it fixes the instruction formats, their functions, and the way they are executed.
2. What it contains:
   • (a) Instruction format — how instructions are encoded
   • (b) Instruction function — what each instruction does
   • (c) Registers — how many, how wide, and what they are for
   • (d) Data types — which formats are supported
   • (e) Addressing modes — how an operand is located
3. Its role:
   • (a) As the software/hardware interface, software is written to the ISA and hardware executes to the ISA
   • (b) As a compatibility guarantee, different CPUs that implement the same ISA run the same programs — every x86 CPU can run Windows
   • (c) As a standard, it lets hardware and software evolve independently, so a hardware upgrade does not break the software

Answer: An ISA is the interface between software and hardware that defines a processor’s instruction formats, its registers, its data types, and its addressing modes. It exists so that software written to it stays portable across implementations and so that hardware can be replaced without rewriting the programs.

Approach: Justify the cache from three directions — the raw speed gap, the principle of locality that makes caching worthwhile, and the way the levels are tuned — then show the effect and give a concrete analogy.

Steps:

1. The speed gap: the CPU runs at 3-5 GHz, while a main memory access takes 10-100 ns; without a cache the processor would spend most of its time waiting.
2. The principle of locality: temporal locality means data that was just accessed is likely to be accessed again, and spatial locality means nearby data is likely to be accessed next.
3. The levels:
   • L1 is the fastest (1-2 clock cycles) and the smallest (32-64 KB), and is private to each core
   • L2 is faster (10-20 cycles) and larger (256 KB to 1 MB)
   • L3 is the slowest (30-50 cycles) and the largest (8-36 MB), and is shared by all cores
4. The effect: with a hit rate above 90%, the average access time is close to that of L1, which lifts overall CPU performance dramatically.
5. An analogy: your desk (L1), a bookshelf (L2), a library (L3), and an online bookstore (main memory) — the books you use often sit on the desk, the ones you use now and then sit on the shelf, the rare ones need a trip to the library, and only what is unavailable has to be bought.

Answer: Modern CPUs use a multi-level cache because processor speed has far outrun memory speed, because locality of reference makes caching effective, and because splitting the cache into levels lets each one trade capacity against latency optimally. The result is an average access time close to L1 while still backing a working set far larger than the cache itself.

Approach: Treat each architecture as a set of choices with a payoff and a cost, and finish with the state of the art.

Steps:

1. CISC (Complex Instruction Set Computer):
   • Many instructions (hundreds)
   • Powerful instructions that accomplish complex operations in one step
   • Variable instruction length
   • Many addressing modes
   • Advantages: short code, simpler compilers, good compatibility
   • Disadvantages: complex hardware, inconsistent instruction timing, low pipeline efficiency
   • Representatives: Intel x86, x86-64
2. RISC (Reduced Instruction Set Computer):
   • Few instructions (tens)
   • Simple instructions
   • Fixed instruction length
   • Simple addressing modes
   • Advantages: simple hardware, uniform instruction timing, high pipeline efficiency, low power consumption
   • Disadvantages: longer code, more complex compilers
   • Representatives: ARM, RISC-V, MIPS
3. The present state: modern processors are mostly hybrid — CISC on the outside for compatibility, translated internally into RISC-like micro-operations for performance.

Answer: CISC buys code density and compatibility with a large instruction repertoire at the cost of complex decoding and uneven timing, while RISC buys simple, uniform, pipeline-friendly execution at the cost of code length and compiler complexity. Modern designs claim both sides of the trade-off by exposing a CISC interface and executing a RISC core.

Approach: Define the bottleneck, show its two concrete symptoms, and then list the mitigations with the mechanism each one uses.

Steps:

1. Definition: because instructions and data share one memory and travel over one bus, the transfer of data between the CPU and memory becomes the performance bottleneck.
2. Symptom one, bus bandwidth: the CPU runs far faster than memory, so the bus saturates.
3. Symptom two, instruction and data conflict: fetching an instruction and fetching a data item compete for the bus and cannot proceed at the same time.
4. Mitigations:
   • (a) Cache technology, a fast cache between the CPU and memory that reduces the number of main memory accesses
   • (b) The Harvard architecture, separate stores and separate buses for instructions and data so both can be fetched at once
   • (c) Pipelining, which splits instruction execution into stages so several instructions are in flight
   • (d) A multi-level memory system of registers, L1/L2/L3 cache, main memory, and disk that balances speed against capacity
   • (e) Prefetching, which predicts the data that will be needed and loads it into the cache early
   • (f) More bus bandwidth, a wider data bus and a higher bus frequency, which is why DDR5 is faster than DDR4
5. The modern solution: a modern CPU combines all of the above and greatly reduces the bottleneck.

Answer: The von Neumann bottleneck is the contention that arises when instructions and data share a single memory and a single bus, so that the CPU-to-memory transfer, rather than the CPU itself, sets the pace. It is mitigated by caches, the Harvard separation of instruction and data paths, pipelining, multi-level memory, prefetching, and wider or faster buses — techniques a modern processor uses together.

Approach: Map every part of the specification onto one of the five components, then assess what the resulting machine is good at.

Steps:

1. ALU: the ALUs inside the Intel i7-12700K — 12 cores (8 performance cores plus 4 efficiency cores), each core with its own ALU, supporting the AVX-512 instruction set for advanced arithmetic.
2. Controller: the control units inside the same CPU — one controller per core, responsible for fetching, decoding, and issuing control signals, with hyper-threading giving 20 threads.
3. Memory:
   • Primary storage of 32 GB DDR5 at DDR5-4800 or better (volatile)
   • Cache built into the CPU at roughly 1 MB of L1, 12 MB of L2, and 25 MB of L3
   • Secondary storage of a 1 TB NVMe SSD reading and writing at 3000-7000 MB/s (non-volatile)
4. Input devices: not listed in the configuration; the usual ones are a keyboard, a mouse, a microphone, and a camera.
5. Output devices: not listed either; the usual ones are a monitor, speakers, and a printer.
6. Performance assessment: a high-end PC suited to gaming (with a discrete GPU added), video editing, 3D rendering, and software development.

Answer: The CPU package supplies both the arithmetic logic units and the controllers, the 32 GB DDR5 module and the on-chip cache supply the memory hierarchy together with the NVMe SSD, and the peripherals not listed would provide the input and output functions. Together they make a machine whose strength is general-purpose compute rather than any single workload.

Approach: Answer the “why” with the four shared properties, then show where the idea is exploited deliberately and where it turns into a security problem.

Steps:

1. Same storage form:
   • Programs and data are both stored in binary
   • Both live in the same memory
   • Both can be read and modified
   • The CPU cannot tell them apart by form alone
2. Mutual convertibility: a program can be read and patched as if it were data, and data can be executed as if it were a program.
3. Uniform handling: both can be loaded into memory, processed by the CPU, and written back to disk.
4. Deliberate applications:
   • Compilers read source code (data) and emit an executable (program)
   • JIT compilers turn code (data) into machine code (program) at run time
   • Dynamic loading turns a plugin (data) into a program
   • Self-modifying code rewrites its own instructions
5. Security consequences:
   • Viruses disguise themselves as data files and become malicious code once executed
   • Buffer overflows let data overwrite program code
   • Code injection writes malicious code into a data area and then runs it
6. Virtual machines: a virtual machine treats a program as data in order to emulate a program written for another platform.

Answer: Programs and data are essentially the same because both are bit patterns stored in the same memory and processed by the same unit, so the CPU itself cannot distinguish them. The concept is what makes compilers, JIT compilation, dynamic loading, and virtual machines possible — and it is exactly why modern operating systems must mark memory regions as executable or not.