1. Lecture 21 Last lecture Today’s lecture Cache Memory Virtual memory
Direct mapping
Fully associative
Set associative
Today’s lecture
Virtual memory
Why virtual memory?
Virtual address and physical address
Page table: virtual address to physical address translation
Paging
Segmentation
Translation look-aside buffer

2. Exercise
Suppose we have a computer that uses a memory address word size of 8 bits. This computer has a 16-byte cache with 4 bytes per block. The computer accesses a number of memory locations throughout the course of running a program.
Suppose this computer uses direct-mapped cache. The format of a memory address as seen by the cache is shown below:
The system accesses memory addresses in this exact order: 0x6E, 0xB9, 0x17, 0xE0, 0x4E, 0x4F, 0x50, 0x91, 0xA8, 0xA9, 0xAB, 0xAD, 0x93, and 0x94.
What is the hit ratio for the entire memory reference sequence given above, assuming we count the first four accesses as misses?
What memory blocks will be in the cache after the last address has been accessed?

3. Exercise

4. Why Virtual Memory?
Today computers run multiple processes, each with its own address space
Too expensive to dedicate a full-address-space worth of memory for each process
Principle of Locality
allows caches to offer speed of cache memory with size of DRAM memory
DRAM can act as a “cache” for secondary storage (disk)  Virtual Memory
Virtual memory – divides physical memory into blocks and allocate them to different processes

5. Virtual Memory Cache memory Virtual memory
Providing faster memory access speed.
Virtual memory
Providing greater memory capacity, without the expense of adding main memory.
Extending main memory with a portion of a disk drive.

6. Virtual Memory Terminology
Virtual addresses: the logical or program address that the process uses. CPU generates an address in terms of virtual address space.
Physical address – the real address in physical memory.
Mapping: the mechanism by which virtual addresses are translated into physical ones.
Page frames: the equal-size chunks or blocks into which main memory (physical memory) is divided.
Pages: the chunks or blocks into which virtual memory (the logical address space) is divided, each equal in size to a page frame. Virtual pages are stored on disk until needed.
Paging: the process of copying a virtual page from disk to a page frame in main memory.
Fragmentation: memory that becomes unusable.
Page fault: an event that occurs when a requested page is not in main memory and must be copied into memory from disk.

7. Page Table
Maintaining the Information concerning the location of each page, whether on disk or in memory.
There is one page table for each active process.

8. Virtual Address & Physical Address
Two fields: A page field, and an offset field.
Page field: determines the page location of the virtual address
Offset field: indicates the location of the address within the page.
Physical address
Two fields: a page frame field, and an offset field.
Page frame field: determines the page frame location in main memory
The logical page number is translated into a physical page frame through a lookup in the page table.

9. Virtual Address Translation - 1
Extract the page number from the virtual address.
Extract the offset from the virtual address
Translate the page number into a physical page frame number using the page table.
Look up the page number in the page table (using the virtual page number as an index)

10. Virtual Address Translation - 2
Check the valid bit for that page
Valid bit is 1
Virtual page number is replaced by physical frame number.
Access the data at offset in the physical page frame.
Valid bit is 0:
Page fault: meaning that the page is not in memory and must be fetched from disk.
Locate the desired the page on disk.
If necessary, a page is evicted from memory and is replaced by the page retrieved from disk, and the valid bit is set to 1.
Update the page table and resume execution.

11. Exercise
As an example, suppose a system has a virtual address space of 8KB and a physical address space of 4KB, and the system uses byte addressing. The page size is 1KB.
A virtual address has 13 bits (8K = 213)
213/210 = 23 virtual pages
3 bits for the page field and 10 for the offset.
A physical memory address requires 12 bits, the first two bits for the page frame and the trailing 10 bits the offset.

12. Exercise Suppose we have the page table shown below.
What happens when CPU generates address = = 0x1553?

13. Exercise
The address is converted to physical address = 0x1363 because the page field 101 is replaced by frame number 01 through a lookup in the page table.
The high-order 3 bits of the virtual address, 101 (510), provide the page number in the page table.

14. Exercise
What happens when the CPU generates address ?

15. Effective Access Time
Effective access time (EAT) takes all levels of memory into consideration.
Thus, virtual memory is also a factor in the calculation, and we also have to consider page table access time.
EAT = (1 – page fault rate) x 2 x main memory access time + page fault rate x page fault penalty
Suppose a main memory access takes 200ns, the page fault rate is 1%, and it takes 10ms to load a page from disk. We have:
EAT = 0.99(200ns + 200ns) (10ms) = 100, 396 ns.
Even if we had no page faults, the EAT would be 400ns because memory is always read twice: First to access the page table, and second to access the page from memory.

16. Translation Look-aside Buffer (TLB)
Because page tables are read constantly, it makes sense to keep them in a special cache called a translation look-aside buffer (TLB).
TLBs are a special associative cache that stores the mapping of virtual pages to physical pages.

17. TLB lookup process 1. Extract the page number from
the virtual address.
2. Extract the offset from the virtual address.
3. Search for the virtual page number in the TLB.
4. If the (virtual page #, page frame #) pair is found in the TLB, add the offset to the physical frame number and access the memory location.
5. If there is a TLB miss, go to the page table to get the necessary frame number.
If the page is in memory, use the corresponding frame number and add the offset to yield the physical address.
6. If the page is not in main memory, generate a page fault and restart the access when the page fault is complete.

18. Putting it all together: The TLB, Page Table, and Main Memory

19. Segmentation Paging: dividing memory into equal-sized pages,
Segmentation: virtual address space is divided into variable-length segments.
A segment is located through its entry in a segment table, which contains the segment’s memory location and a bounds limit that indicates its size.
After a page fault, the operating system searches for a location in memory large enough to hold the segment that is retrieved from disk.

20. Fragmentation Both paging and segmentation can cause fragmentation.
Paging is subject to internal fragmentation because a process may not need the entire range of addresses contained within the page. Thus, there may be many pages containing unused fragments of memory.
Segmentation is subject to external fragmentation, which occurs when contiguous chunks of memory become broken up as segments are allocated and deallocated over time.
The next slides illustrate internal and external fragmentation.

21. Paging: Internal Fragmentation
Consider a small computer having 32K of memory.
32K memory is divided into 8 page frames of 4K each.
A schematic of this configuration is shown at the right.
The numbers at the right are memory frame addresses.
Suppose there are four processes waiting to be loaded into the system with memory requirements as shown in the table.
These processes require 31K of memory.

22. Paging: Internal Fragmentation
When the first three processes are loaded, memory looks like this:
All of the frames are occupied by three of the processes.
Despite the fact that there are enough free bytes in memory to load the fourth process, P4 has to wait for one of the other three to terminate, because there are no unallocated frames.
This is an example of internal fragmentation.

23. Segmentation: External Fragmentation
Suppose that instead of frames, our 32K system uses segmentation.
The memory segments of two processes is shown in the table at the right.
The segments can be allocated anywhere in memory.

24. Segmentation: External Fragmentation
All of the segments of P1 and one of the segments of P2 are loaded as shown at the right.
Segment S2 of process P2 requires 11K of memory, and there is only 1K free, so it waits.

25. Segmentation: External Fragmentation
Eventually, Segment 2 of Process 1 is no longer needed, so it is unloaded giving 11K of free memory.
But Segment 2 of Process 2 cannot be loaded because the free memory is not contiguous.

26. Segmentation: External Fragmentation
Over time, the problem gets worse, resulting in small unusable blocks scattered throughout physical memory.
This is an example of external fragmentation.
Eventually, this memory is recovered through compaction, and the process starts over.