Chapter 3 · RAM and Memory Internals

Knowledge Check

8 min read

Try to answer before you open the answers. Guessing is fine; checking your guess is how you learn.

Quick Review (5 minutes)

  1. Why is RAM volatile, and why does that matter?
  2. What is the difference between DRAM and SRAM, and where is each used?
  3. What is virtual memory, and what problem does it solve?
  4. What is the role of the MMU?
  5. What is a TLB, and why does it matter for speed?
  6. What is a page fault? Is it always a bad thing?
  7. What is the difference between the stack and the heap?
  8. What is heap fragmentation?
  9. What is Copy-on-Write, and why is it efficient?
  10. What is a memory-mapped file?

ANSWER KEY — DO NOT READ UNTIL YOU'VE ANSWERED

Click to reveal answers

1. Why RAM is volatile

DRAM holds data as a tiny electric charge that needs continuous power. Once the power is cut, nothing keeps the data. So RAM can never be trusted for permanent storage. Anything that must survive a shutdown has to be written to non-volatile storage.

2. DRAM vs. SRAM

DRAM: One capacitor + one transistor per bit, needs constant refreshing, cheap and dense. Used for main system RAM.
SRAM: A six-transistor loop per bit, no refreshing, much faster but far more expensive per byte. Used for CPU caches (L1/L2/L3).

3. Virtual memory

Virtual memory gives every process its own private, large-looking address space, separate from the real layout and size of RAM. It gives isolation (processes cannot see each other's memory) and abstraction (programs do not need to know the physical RAM layout). Together with paging, it also lets the total memory demand go above the installed RAM.

4. The MMU's role

The Memory Management Unit is CPU hardware. On every single memory access it turns the program's virtual address into the real physical address in RAM, and at the same time it checks the per-page permissions (read/write/execute/privilege level).

5. The TLB

The Translation Lookaside Buffer is a small, fast cache of recent virtual-to-physical translations. Without it, every memory access would need a full multi-level page table walk. A TLB hit skips the walk completely. A TLB miss needs the slower walk.

6. Page faults

A page fault is a hardware exception that happens when a program touches a virtual page that is not currently mapped to physical RAM. It is not always bad. Minor/soft faults (fixing a mapping to data already in memory) are normal and fast. Major/hard faults (a read from storage/pagefile is needed) are the slow kind that matters for performance.

7. Stack vs. heap

Stack: Automatic, LIFO memory for function calls and local variables. Fast, freed automatically when a function returns, one per thread.
Heap: Memory requested on purpose, with flexible size and lifetime. Slower to allocate. Must be freed by hand (or by a garbage collector), because it is not tied to a single function call.

8. Heap fragmentation

The total free heap memory is big enough, but it is scattered in small separate pieces. So a request for one big continuous block can fail even though enough free space exists in total.

9. Copy-on-Write

Two mappings share the same physical page (marked read-only) until one side tries to write. Only then does the OS make a private copy for the writer. It is efficient because the costly copy happens only for pages that really change, not for every shared page up front.

10. Memory-mapped files

A file's contents are mapped straight into a process's virtual address space, so the file can be read and written with ordinary memory access instead of explicit read/write calls. Pages are brought in from storage on demand through the normal page fault mechanism.

UNDERSTANDING QUESTIONS

These need longer answers. Write a few sentences for each.

1. Explain why virtual memory is necessary even on a PC with "plenty" of RAM

If a PC has more than enough RAM for everything that is open, why does the operating system still use virtual memory and address translation, instead of letting programs use physical addresses directly?

2. Explain the full journey of a memory access, from a CPU instruction to physical RAM

Follow a MOV EAX, [0x00401000] instruction from the CPU through the TLB, the page table (if needed), and finally to physical RAM. What is different on a TLB hit, a TLB miss and a full page fault?

3. Explain why a buggy program normally cannot crash the whole operating system, but a buggy driver can

Link this to Chapter 2's privilege levels and to this chapter's memory protection ideas.

4. Explain why Copy-on-Write makes starting many copies of the same program cheaper than you would expect

What exactly is shared, and what finally forces a real copy?

5. Explain why a PC can feel "frozen" even though Task Manager shows low CPU usage

Which memory idea from this chapter explains it best, and why does it look like the PC is unresponsive rather than crashed?

SCENARIO QUESTIONS (Troubleshooting)

Scenario 1: "My computer has 16 GB of RAM but feels sluggish, and the disk light is always on"

What is probably happening at the memory level? What would you check first?

Scenario 2: "A long-running background service's memory use keeps climbing, day after day, and never goes down"

What is the likely problem? How would you tell it apart from normal caching?

Scenario 3: "My program crashes immediately with an access violation the moment it uses a pointer that was never set up"

What is really happening at the hardware and OS level when this crash occurs? Why does it crash straight away instead of quietly corrupting something?

Scenario 4: "A recursive function crashes with a stack overflow after working fine on smaller inputs"

What exactly is being used up, and why does Windows catch it reliably instead of letting it damage nearby memory?

Scenario 5: "Opening the same large application a second time feels almost instant, but the first launch was slow"

Which memory ideas from this chapter could explain the difference?

INTERVIEW QUESTIONS

These are questions a technical interviewer might ask:

1. Explain the difference between a process's virtual address space and physical RAM, and why that difference matters for security.

2. What is a TLB miss, and why does it cost more than it first seems?

3. Explain Copy-on-Write and give a real example of where an operating system uses it.

4. Why does a 32-bit process have a hard 4 GB memory limit, and how does 64-bit computing remove it?

5. Explain the difference between a memory leak and heap fragmentation. They can look alike but are different problems.

PRACTICAL TASK

Task: Diagnose a Simulated Memory Pressure Scenario

Using Task Manager and Resource Monitor (from the Practical Lab), write a short report that covers:

  1. Baseline state: Total RAM, plus the "In use," "Available," and "Committed" figures when the PC is idle
  2. Under load: Open enough apps or browser tabs to push memory use up noticeably, and record the same figures again
  3. Hard fault behaviour: Did you see a spike in Hard Faults/sec while opening something new? What was it?
  4. Verdict: From the numbers, is this PC close to needing more RAM, or does it have comfortable room? Explain your answer using the "Committed" vs. physical RAM relationship from Section 5.6.

Why This Matters

  • You can now read Task Manager's memory numbers and understand what "Committed," "Cached," and "Compressed" mean inside the machine
  • You can tell a PC that is really short of memory from one that is just using Windows' normal caching. Most users (and even many IT professionals) get this wrong

CHAPTER SUMMARY

What you learned:

  • RAM is volatile, fast, temporary memory. It exists to bridge the huge speed gap between the CPU and storage
  • DRAM (main RAM) and SRAM (CPU cache) trade speed, cost and density differently, and DDR standards define how fast DRAM talks to the rest of the system
  • Virtual memory gives every process a private, isolated address space. The CPU's MMU translates it to real physical RAM using page tables, sped up by the TLB
  • Paging lets total memory demand go above physical RAM by moving idle pages to the pagefile, at a steep speed cost if it happens too much
  • A process's address space has predictable regions: stack, heap, data segment and code segment
  • Static, stack and heap allocation trade speed, flexibility and lifetime differently. Heap allocation brings fragmentation and leak risks that the other two do not have
  • Memory protection (per-page permissions, process isolation, guard pages) is why one process's bug cannot corrupt another process or the kernel
  • Copy-on-Write and shared memory let many processes share identical or cooperating memory without needless copying
  • Modern refinements — memory compression, NUMA-awareness, persistent memory — keep improving how well the RAM layer is used

Key diagram:

Process's virtual address
        │
        ▼
   MMU + TLB + page tables   →   Physical RAM address
        │                              │
        ▼                              ▼
  (protection checked:            (if not resident:
   read/write/execute/             page fault →
   privilege level)                 load from storage,
                                     or from pagefile)
  • Extends: Chapter 1 (Complete Computer Architecture), Chapter 2 (CPU Internals — cache hierarchy, privilege levels, interrupts)
  • Required for: Chapter 9 (Processes — process address space and creation build directly on this chapter), Chapter 10 (Threads — per-thread stacks), Chapter 27 (Application Memory, later in the course)
  • Related concepts: Chapter 4 (Motherboard and Hardware Communication), Chapter 8 (Windows Architecture — the Memory Manager component in detail)