The Memory Hierarchy: Why Computers Use Several Kinds of Memory

No single memory technology is simultaneously fast, large, and cheap. This article introduces the concept of a memory hierarchy that combines several different memory technologies to approximate the speed of the fastest one at the cost of the cheapest, then walks through the core technologies that make up each level.

Memory HierarchySRAM and DRAMMemory Technologies

~3 min read · Updated Sep 6, 2026

Why One Memory Type Is Never Enough

An ideal memory would be extremely fast, hold an enormous amount of data, and cost very little. In practice, no single technology achieves all three at once: faster memory is always more expensive per byte and typically smaller, while cheaper, larger memory is always slower. This tradeoff is the central problem that the Memory Hierarchy is designed to solve.

The Core Idea: Combine Several Levels

Rather than choosing one memory technology, a computer combines several different levels of memory, each with a different balance of speed, size, and cost. Data that is frequently used is kept in the smallest, fastest, most expensive level, while data used less often resides in progressively larger, slower, and cheaper levels further away from the processor.

Fastest, smallest, most expensive:
Registers → Cache → Main Memory → Disk/SSD
Slowest, largest, cheapest

SRAM: The Foundation for Fast, Small Memory

SRAM (Static Random Access Memory) stores each bit using a small circuit of transistors that holds its value continuously as long as power is supplied, without needing to be refreshed periodically. This makes SRAM very fast to access, but each storage cell requires several transistors, making it physically larger and more expensive per bit than the alternative used for main memory.

DRAM: The Foundation for Large, Cheap Memory

DRAM (Dynamic Random Access Memory) stores each bit using a single transistor and a capacitor, which is far more compact and cheaper to manufacture per bit than SRAM. The tradeoff is that the capacitor's charge leaks over time, so DRAM must be periodically Refreshed — its stored values re-written at regular intervals — to avoid losing data, and reading from it takes noticeably longer than reading from SRAM.

Why These Two Technologies Are Used Differently

Because of these tradeoffs, SRAM is used almost exclusively for small, extremely fast Cache memory built directly into or very close to the processor, while DRAM is used for larger Main Memory that holds far more data at a fraction of the per-bit cost, at the price of slower access time.

Beyond SRAM and DRAM: Persistent Storage

Below main memory in the hierarchy sits persistent storage, such as Solid-State Drives (SSDs) or traditional magnetic Hard Disk Drives (HDDs), which retain data even when power is removed, hold vastly more data than DRAM, but are significantly slower to access, particularly hard disk drives, which involve mechanical movement to physically locate data.

Why Understanding This Foundation Matters

Every technique discussed in the remainder of this chapter — caching strategies, virtual memory, and performance optimization — exists specifically because of the fundamental tradeoffs described here between speed, size, and cost. Without appreciating why no single memory technology can satisfy every requirement, the design decisions behind cache hierarchies would appear arbitrary rather than necessary.

Written & researched by Dr. Shahin Siami

Related Articles

Cache Fundamentals: How Small, Fast Memory Predicts What You Need Next

A cache works because programs tend to access the same or nearby data repeatedly rather than randomly. This article explains the principle of locality that makes caching effective, how a direct-mapped cache locates data using an address, and what happens on a cache hit versus a cache miss.

Continue

Common Misconceptions About Processor Design and Chapter Four's Big Picture

After covering datapaths, pipelining, hazards, and real-world processor comparisons, it is time to correct a handful of persistent misconceptions about how processors actually behave. This article addresses common fallacies about pipelining and performance, then ties together the full journey from simple datapaths to superscalar execution covered throughout this chapter.

Continue

Real-World Pipelines: Comparing ARM and Intel, and Speeding Up Matrix Multiply

Theoretical pipeline concepts take concrete shape in real commercial processors, which vary widely in pipeline depth and issue width depending on their design goals. This article compares how the ARM Cortex-A53 and Intel Core i7 implement pipelining differently for power efficiency versus raw performance, then shows how instruction-level parallelism accelerates matrix multiplication in practice.

Continue

Instruction-Level Parallelism: Executing More Than One Instruction at Once

A single pipeline can only advance one instruction into each stage per cycle, which caps its performance at roughly one instruction per clock. This article explains how processors go beyond that limit by issuing multiple instructions simultaneously, the hardware duplication this requires, and the fundamental limits imposed by dependencies between instructions.

Continue

How a Pipelined Processor Handles Exceptions

Not every instruction executes as expected — some trigger error conditions like an undefined opcode or an arithmetic overflow that the processor must respond to safely. This article explains what exceptions are, how a pipelined processor detects and handles them without corrupting program state, and why exceptions are treated similarly to control hazards.

Continue

Control Hazards: Handling Branches in a Pipelined Processor

Branches create a unique problem for pipelining: the processor must fetch the next instruction before it even knows whether a branch will be taken. This article explains what control hazards are, how branch prediction and delayed resolution attempt to minimize their cost, and what happens when a prediction turns out to be wrong.

Continue