Main Memory

Chapter 8: Memory Management

 Background
 Swapping
 Contiguous Memory Allocation
 Segmentation
 Paging
 Structure of the Page Table
 Base and Limit Registers
 A pair of base and limit registers define the logical address space
 CPU must check every memory access generated in user mode to
be sure it is between base and limit for that user
 Swapping

 A process can be swapped temporarily out of memory to a backing store,

and then brought back into memory for continued execution

 Backing store – fast disk large enough to accommodate copies of all

memory images for all users;

 Roll out, roll in – swapping variant used for priority-based scheduling

algorithms;
Schematic View of Swapping
 Contiguous Allocation

 Main memory must support both OS and user processes

 Contiguous allocation is one early method

 Main memory usually into two partitions:

 Resident operating system, usually held in low memory with

interrupt vector

 User processes then held in high memory

 Each process contained in single contiguous section of

memory
 Dynamic Storage-Allocation Problem
How to satisfy a request of size n from a list of free holes?

 First-fit: Allocate the first hole that is big enough

 Best-fit: Allocate the smallest hole that is big enough; must

search entire list, unless ordered by size
 Produces the smallest leftover hole

 Worst-fit: Allocate the largest hole; must also search entire list
 Produces the largest leftover hole

First-fit and best-fit better than worst-fit in terms of speed and storage
utilization
 Fragmentation
 External Fragmentation – total memory space exists to
satisfy a request, but it is not contiguous

 Internal Fragmentation – allocated memory may be slightly

larger than requested memory; this size difference is memory
internal to a partition, but not being used
 Paging
 Physical address space of a process can be noncontiguous;
process is allocated physical memory whenever the latter is
available
 Avoids external fragmentation

 Divide physical memory into fixed-sized blocks called frames

 Size is power of 2, between 512 bytes and 16 Mbytes

 Divide logical memory into blocks of same size called pages

 To run a program of size N pages, need to find N free frames and

load program

 Set up a page table to translate logical to physical addresses

 Address Translation Scheme
 Address generated by CPU is divided into:
 Page number (p) – used as an index into a page table which
contains base address of each page in physical memory
 Page offset (d) – combined with base address to define the
physical memory address that is sent to the memory unit

page number page offset

p d
m -n n

 For given logical address space 2m and page size 2n

Paging Model of Logical and Physical Memory
Paging Example
 Free Frames

Before allocation After allocation

Paging Hardware
 Structure of the Page Table
Hierarchical Page Tables
 Break up the logical address space into multiple page
tables
 A simple technique is a two-level page table
 We then page the page table
Two-Level Page-Table Scheme
 Two-Level Paging Example
 A logical address (on 32-bit machine with 1K page size) is divided into:
 a page number consisting of 22 bits
 a page offset consisting of 10 bits

 Since the page table is paged, the page number is further divided into:
 a 12-bit page number
 a 10-bit page offset
 Thus, a logical address is as follows:

 where p1 is an index into the outer page table, and p2 is the

displacement within the page of the inner page table
Address-Translation Scheme
 Segmentation
 Memory-management scheme that supports user view of memory
 A program is a collection of segments
 A segment is a logical unit such as:
main program
procedure
function
method
object
local variables, global variables
common block
stack
symbol table
arrays
User’s View of a Program
Logical View of Segmentation

4
1

3 2
4

user space physical memory space

 Segmentation Architecture
 Logical address consists of a two tuple:
<segment-number, offset>,

 Segment table – maps two-dimensional physical addresses; each

table entry has:
 base – contains the starting physical address where the
segments reside in memory
 limit – specifies the length of the segment

 Segment-table base register (STBR) points to the segment table

’s location in memory

 Segment-table length register (STLR) indicates number of

segments used by a program;
segment number s is legal if s < STLR
Segmentation Hardware
 Chapter 10: Virtual Memory
 Background
 Demand Paging
 Page Replacement
 Allocation of Frames
 Thrashing
 Operating System Examples
 Background
 Virtual memory – separation of user logical memory from
physical memory.

 Only part of the program needs to be in memory for execution.

 Logical address space can therefore be much larger than

physical address space.

 Allows address spaces to be shared by several processes.

.
Virtual Memory That is Larger Than Physical Memory
 Demand Paging
 A demand-paging system is similar to a paging system with
swapping

 A lazy swapper is used. It never swaps a page into memory

unless that page will be needed.

 A swapper manipulate entire processes, whereas a pager is

concerned with the individual pages of process.

 Page is needed  reference to it

 invalid reference  abort
 not-in-memory  bring to memory
Transfer of a Paged Memory to Contiguous Disk Space
Page Table When Some Pages Are Not in Main Memory
 Page Fault

 If there is ever a reference to a page that is not in the memory,

first reference will trap to OS  page fault
 OS looks at another table to decide:
 Invalid reference  abort.
 Just not in memory.
 Get empty frame.
 Swap page into frame.
 Reset tables, validation bit = 1.
 Restart instruction: Least Recently Used
 block move

 auto increment/decrement location

Steps in Handling a Page Fault
 What happens if there is no free frame?

 Page replacement – find some page in memory, but not really in use, swap
it out.
 algorithm
 performance – want an algorithm which will result in minimum number of
page faults.

 Same page may be brought into memory several times.

Need For Page Replacement
 Basic Page Replacement
1. Find the location of the desired page on disk.

2. Find a free frame:

- If there is a free frame, use it.
- If there is no free frame, use a page replacement
algorithm to select a victim frame.

3. Read the desired page into the (newly) free frame. Update the
page and frame tables.

4. Restart the process.

Page Replacement
 Page Replacement Algorithms
 We must solve two major problems in demand paging: We must
develop:
 A frame-allocation algorithm – How many frames are
allocated to each process.
 A page-replacement algorithm – Which frames are
selected to be replaced.
 Which algorithm? We want lowest page-fault rate.
 Evaluate algorithm by running it on a particular string of memory
references (reference string) and computing the number of
page faults on that string.
 They can be generated by a random generator or from the
system memory reference record.
 In all our examples, the reference string is
1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5.
 First-In-First-Out (FIFO) Algorithm
 Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
 3 frames (3 pages can be in memory at a time per process)

1 1 4 5
2 2 1 3 9 page faults
3 3 2 4
 4 frames
1 1 5 4
2 2 1 5 10 page faults
3 3 2

4 4 3
FIFO Page Replacement
 Optimal Algorithm
 Replace page that will not be used for longest period of time.
 4 frames example
1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

1 4
2 6 page faults
3

4 5
 How do you know this?
 Used for measuring how well your algorithm performs.
Optimal Page Replacement
Least Recently Used (LRU) Algorithm
 Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

1 5
2

3 5 4
4 3
 Counter implementation
 Every page entry has a counter; every time page is referenced through
this entry, copy the clock into the counter.
 When a page needs to be changed, look at the counters to determine
which are to change.
LRU Page Replacement
 Allocation of Frames
 Each process needs minimum number of pages.

 Two major allocation schemes.

 fixed allocation
 proportional allocation
 Allocation of Frames
 Equal allocation – e.g., if 100 frames and 5 processes, give
each 20 pages.
 Proportional allocation – Allocate according to the size of
process.
si size of process pi
S   si
m total number of frames
si
ai allocation for pi  m
S
m 64
si 10
s2 127
10
a1  64 5
137
127
a2  64 59
137
 Global vs. Local Allocation

 Global replacement – process selects a replacement frame from the set of

all frames; one process can take a frame from another.

 Local replacement – each process selects from only its own set of allocated

frames.
 Thrashing
 If a process does not have “enough” pages, the page-fault rate is very high.
This leads to:
 low CPU utilization.
 operating system thinks that it needs to increase the degree of
multiprogramming.
 another process added to the system.

 Thrashing  a process is busy swapping pages in and out.

 Allocating Kernel Memory

 When a process is executing in user mode and it requests the additional

memory, then the kernel maintains the allocation of pages from the list of
free page frames.

 The process by which the kernel of the operating system allocates memory
for its internal operations and data structures is called kernel memory
allocation.“

 allocating kernel memory is a critical task, therefore, it must be performed

correctly and efficiently.
Buddy Memory Allocation System
 the available memory space is divided into blocks of a fixed and equal size

 In buddy system, whenever a request is made for memory allocation, the

memory allocator finds a bock of appropriate memory size.

 If it found a block of a larger size than required, it is repetitively divided

into smaller blocks until a block of the desired size is obtained.

 Once the block of the desired size is found, the allocator marks it as allocated

and sends a pointer to the requesting process.