Intro to Paging

Objectives

1. Introduce the basic concepts of paging.

Notes

• In the last notes, we discussed contiguous memory.
  • All memory associated with a program is in one block
  • Fragmentation can occur
  • And eliminating that is problematic.
• Paging is a memory use policy that is better
• Memory divided into blocks
  • These blocks are called frames in physical memory
  • And pages in virtual memory.
  • Pages and blocks are the same size.
• When a process starts is is allocated the number of pages it needs to function.
  • These pages are mapped to frames of memory.
• If I have
  • 2^m bytes of memory, ie m bit addresses
  • the block size will be 2ⁿ , for n < m,
  • There will be k = m-n bits left over.
    • These will number the 2^k frames
  • Consider a 9 (m) bit address with 5 bit block size.
    • So 2⁹ = 512 bytes of memory.
    • The size of each block is 2⁵ = 32 bites.
    • 512/32 = 16 or 16 blocks total.
    • But that is not a surprise because 9-5 =4 , 2⁴ = 16

  • Frame: 0 (0000) Real Address 0 - 31 Low Binary: 0000 00000 High Binary: 0000 11111

    Frame: 1 (0001) Real Address 32 - 63 Low Binary: 0001 00000 High Binary: 0001 11111

    Frame: 2 (0010) Real Address 64 - 95 Low Binary: 0010 00000 High Binary: 0010 11111

    Frame: 3 (0011) Real Address 96 - 127 Low Binary: 0011 00000 High Binary: 0011 11111

    ...

    Frame: 14 (1110) Real Address 448 - 479 Low Binary: 1110 00000 High Binary: 1110 11111

    Frame: 15 (1111) Real Address 479 - 512 Low Binary: 1111 00000 High Binary: 1111 11111

• Pages are mapped to frames via a page table.
  • if we have f = 2^k frames
  • We can build a table with f entries.
  • The index into the table is a process' page number
  • Each entry is a corresponding frame number.
• For an n bit address
  • The top f bits form the address into the page table.
    • These get replaced with the f bits stored in the table.
  • The bottom n bits form the address in the frame.
• The page table is per process.
• Example:
  • 9 bit address.
  • 32 byte block size (5 bits)
  • 4 bit page/frame size

    Address
    Page Number	Frame Offset
    4 bits	5 bits

  • The page table would have 16 entries.
  • Assume the process has 4 pages. (valid addresses 0000 00000 through 0011 11111)
  • The page table contains

    index	Frame No
    0 (0000)	0101 (5)
    1 (0001)	1101 (13)
    2 (0010)	0001 (1)
    3 (0011)	1001 (9)
    > 3	XXXX (don't care)

    • In this case, page 0 is mapped to frame 5
    • So the address 0000 xxxxx becomes 0101 xxxxx
    • In this case, page 1 is mapped to frame 13
    • So the address 0001 xxxxx becomes 1101 xxxxx
    • See the picture on page 361
• The os maintains a list of free frames.
  • In our example, frames 0, 2-4, 6-8, 10-12, 14-15 are possibly free.
  • Or they could be filled with pages from other processes.
  • Assume process 2 has 3 pages, and the following page table:

    index	Frame No
    0 (0010)	0001 (0)
    1 (0010)	0011 (3)
    2 (0011)	1011 (11)
    > 2	XXXX (don't care)

  • Is this consistent?
  • Draw memory and label with Process:page
  • What is the free frame list
  • Translate the following logical addresses to physical addresses
    • P1 0010 11010
    • P1 0011 00011
    • P2 0001 00111
    • P2 0000 00000
• Note there is no external fragmentation (all frames "fit" tight)
• But there could be (most likely is) internal fragmentation.
  • For n processes, the expected value is 1/n * frame size.
  • So we should have small pages to reduce waste.
• But storage overhead for the page table (per process) would be a problem.
  • Consider a 32 bit address space.
  • Each entry in the page table is 32 - m bits.
  • And there are 32-m of them.
    • A 4K frame, m = 12, f = 20
    • Original linux limited the page table to 1024 entries.
    • So 12 + 10 = 22, or 2²² = 4MB physical memory.
    • Because a page table of 2²⁰ is ridiculously large.
    • 2²⁰ = 1,048,476 or 1 million or 1mb table size.
  • And most of these entries would be empty.
  • So page tables are not the maximum size.