13.2.1. Motivation

Page tables are usually kept in main memory; therefore, for each data reference, we will typically require two memory accesses if we do not take any measure. One access will be to access the page table entry itself, and then the second memory reference will access the actual data we require from main memory.

This chunk discusses how page tables are stored and accessed. When we need to access data in memory, the first step is to look up the corresponding entry in the page table, which tells us where the data resides. If we have a process that doesn't optimize this lookup, we end up accessing memory twice: once for the page table entry and once for the actual data. This leads to a delay, as accessing main memory is slower than accessing data in cache.

Think of a library where you need to find a book. First, you check the catalog (the page table in this analogy) to find the exact shelf location of the book. This step takes time. Then you go to that shelf to pick up the book. If you have to look up the catalog every time you want to read a page, it slows down your reading process just like multiple memory accesses slow down computer processing.

Main memory references are typically very costly. Main memory accesses take about 50 to 70 nanoseconds compared to cache accesses, which can be around 5 to 10 nanoseconds.

This chunk highlights how accessing main memory is much slower than accessing cache. Cache stores frequently used data, allowing for quicker access. The significant difference in time (50-70 nanoseconds for main memory versus 5-10 nanoseconds for cache) underscores the importance of reducing main memory accesses as much as possible.

Imagine if every time you wanted to grab a snack from the pantry (main memory), it took you 50 seconds, but if you had a small bowl of snacks (cache) right next to you, it only took 5 seconds. You'd want to minimize how often you went to the pantry to save time!

There are two typical strategies employed to reduce page table access time: implementing the page table in hardware and using a translation lookaside buffer (TLB).

To speed up the access of page tables, computer systems can either use dedicated hardware to store and access the page table directly or implement a Translation Lookaside Buffer (TLB). The TLB acts as a small cache for the most commonly accessed page table entries, significantly speeding up memory access when a match is found.

Consider a restaurant. If the chef has a list of the most popular dishes at hand (TLB), he can whip them up quickly rather than searching through the entire cookbook (the full page table). This speeds up service for the patrons.

When the page table is implemented in hardware, it is done through dedicated registers. This method works best for systems with smaller page table sizes, like embedded systems. During a context switch, all page table registers are reloaded to restore the previous state of the process.

In systems with smaller address spaces, hardware page tables can be effective since all information can fit into dedicated registers. A context switch is when the CPU switches from running one process to another. Reloading registers to restore the process state helps maintain efficiency. However, this method becomes impractical for larger systems due to the overwhelming number of entries in the page table.

Picture a small team where each member (register) has a specific set of tasks they can handle. When the team changes roles (context switch), you can quickly reassign tasks because the team is small. But in a larger organization, it would take much longer to reassign tasks due to the sheer number of team members involved.

For computers with large address spaces (e.g., 32-bit systems), storing the entire page table in hardware is impractical due to the massive number of entries. Therefore, page tables are typically stored in memory for such systems.

This part explains the limitations faced by larger systems. For example, a 32-bit system that uses 4 KB pages ends up needing millions of entries in its page table. Given that this size cannot fit into hardware registers, such tables are stored in main memory instead. The challenge is to efficiently manage and access these tables even when they grow large.

Think of organizing a large library where every book title is on a separate card (the page table). In a small library, you could keep all the cards on one small shelf (hardware). However, as the library grows, you might need to store all the cards in a filing cabinet (main memory), making them slower to access.

--