Unit 5

UNIT V

MEMORY MANAGEMENT

� Basics of memory management,

� Swapping, Virtual memory,

� Page replacement algorithm,

� FIFO,second chance PR, clock PR, Least recently used, working set PR,

WS clock PR,

� Design issues for Paging systems,� Design issues for Paging systems,

� OS involvement with paging,

� page fault handling,

� Segmentation

MEMORY MANAGEMENT

� Objective of Chapter

� What is Memory.

� Students are able to understand Concept of Swapping .

� Concept of Paging ,Segmentation.� Concept of Paging ,Segmentation.

� Different type of Page replacement algorithms

BASICS OF MEMORY MANAGEMENT

� Memory management is the function of a computer

operating system responsible for managing the computer's

primary memory.

� The memory management function keeps track of the status

of each memory location, either allocated or free.of each memory location, either allocated or free.

� Something is needed to manage the movement of programs

between O.S. and memory. The part of the operating system

that does this is known as the memory manager.

MEMORY MANAGEMENT REQUIREMENTS

� Relocation

� Protection

� Sharing

� Logical Organization

� Physical Organization

BASIC MEMORY MANAGEMENT

� Without swaping

� Monoprogramming

� Multiprogramming with fixed partitions

� With swaping and paging

MONOPROGRAMMING

� Simplest scheme possible

� Only one program will be executed at a time

� The OS copies the program from disk to memory and

executes it. Once finished, the OS is ready to accept a new executes it. Once finished, the OS is ready to accept a new

command from the user

� New commands overwrite the old program in memory with

the new

MONOPROGRAMMING

Three configurations

a) is rarely used anymore

b) is in use by MP3 players, Palm devices

c) was the model of early PCs, eg: DOS

MULTIPROGRAMMING WITH FIXED PARTITIONS

� It support multiprogramming

� This scheme based on contiguous

allocation.

� memory is divided in to fixed

number of partitions

Operating

system

p1

number of partitions

� Each partition is of fixed size.

� each partition can accommodate

one program for execution.

p2

p3

p4

Fixed-size partitioning

PLACEMENT ALGORITHM

� The most common strategies to allocate free partition to

program

� First-fit.

� Best-fit.

� Worst-fit.� Worst-fit.

� First-fit:- allocates the first free partition large enough to

accommodate the process.

� Best-fit:- allocates the smallest free partition free partition

� Worst-fit:-allocates the largest free partition free partition .

MULTIPROGRAMMING WITH DYNAMIC PARTITION

� In dynamic partition, neither the size nor the number of

dynamically allocated partitions can be fixed.

� The memory manager continues creating partitions until

all physical memory exhausted.

� The main problem with fixed partition is wastage of � The main problem with fixed partition is wastage of

memory by programs are smaller than their partitions

,this is also known as internal fragmentation.

� With dynamic partitioning the number and size of

partition is vary. This improves utilization of memory

SWAPPING

� Swapping a process consists of bringing the process into memory,

from disk, in its entirety. The process is executed for some time

and then placed back on the disk

VIRTUAL MEMORY

� Techniques that automatically move program and data

blokes in to the physical main memory when they are

required for execution are called virtual memory

technique.technique.

WHAT IS PAGING

� Paging is a memory management technique which basically makes use of part of your hard drive as it itwere RAM, thus creating "virtual memory.“

� It is useful if your PC doesn't have enough RAM to store everything on, so it can temporarily transfer some of it to the hard drive and store it until you need it again.to the hard drive and store it until you need it again.

� . When paging is used, the processor divides the linear address space into fixed-size pages (of 4KBytes, 2 MBytes, or 4 MBytes in length) that can be mapped into physical memory and/or disk storage.

� A special hardware unit,called the memory management unit (MMU) translates virtual address into physical address.

ROLL OF MMU

PAGING� Address generated by CPU divided into:

� Page number (p) - index to page table

� page table contains base address of each page in physical memory

(frame)

� Page offset (d) - offset into page/frame

CPU p d

page table

f

f d

physical

memory

PAGING EXAMPLE

Page 0

� Page size 4 bytes

� Memory size 32 bytes (8 pages)

10

Page 0

Page 2

0

1

2

3

Page 1

Page 2

Page 3

4

3

7

1

2

3

Page TableLogical

Memory

Page 1

Page 3

Physical

Memory

4

5

6

7

PAGING EXAMPLE

Pa

ge

0P

ag

e 1

0100

000

001

010

011

000

001

010

011

0 0 1 0 1 1

Page

Offset

Frame

Pa

ge

2P

ag

e 3

11

00

10

01

10

11

Page Table

Logical

Memory

100

101

110

111

Physical

Memory

100

101

110

111

Physical Address

Offset

HOW TO IMPLEMENT PAGING?

� Page Table (One per process)

OffsetVirtualPage #Virtual Address:

Access

Error

>PageTableSize

PageTablePtr page #0

page #2

page #3

page #4

page #5

V,R

page #1 V,R

V,R,W

V,R,W

N

V,R,W

page #1 V,R

Check Perm

Access

Error

PhysicalPage #

� Page Table (One per process)� Resides in physical memory� Contains physical page and permission for each virtual page

� Permissions include: Valid bits, Read, Write, etc

� Virtual address mapping� Offset from Virtual address copied to Physical Address

� Example: 10 bit offset ⇒ 1024-byte pages

� Virtual page # is all remaining bits� Example for 32-bits: 32-10 = 22 bits, i.e. 4 million entries� Physical page # copied from table into physical address

� Check Page Table bounds and permissions

PAGING HARDWARE

� address space 2m

� page offset 2n

� page number 2m-n

phsical

memory

2m bytes

page number

p

page offset

d

m-n n

•note: not losing any bytes!

PAGING EXAMPLE

� Consider:

� Physical memory = 128 bytes

� Physical address space = 8 frames

� How many bits in an address?

� How many bits for page number?� How many bits for page number?

� How many bits for page offset?

� Can a logical address space have only 2 pages? How big would the page table be?

ANOTHER PAGING EXAMPLE

� Consider:

� 8 bits in an address

� 3 bits for the frame/page number

� How many bytes (words) of physical memory?

How many frames are there?� How many frames are there?

� How many bytes is a page?

� How many bits for page offset?

� If a process’ page table is 12 bits, how many logical pages does it have?

PAGE TABLE EXAMPLE

Page 0A

Page 0B

0

1

2

3

Page 0

Page 1

Process B

3

7

0

1

Page Table

page number page offset

b=7

1

4

0

1

Page Table

Page 0

Page 1

Process A

Page 1A

Page 1B

Physical

Memory

4

5

6

7

p

page offset

d

m-n=3 n=4

PAGING TRADEOFFS

� Advantages

� no external fragmentation (no compaction)

� relocation (now pages, before were processes)

� Disadvantages

� internal fragmentation

� consider: 2048 byte pages, 72,766 byte proc

� 35 pages + 1086 bytes = 962 bytes� 35 pages + 1086 bytes = 962 bytes

� avg: 1/2 page per process

� small pages!

� overhead

� page table / process (context switch + space)

� lookup (especially if page to disk)

IMPLEMENTATION OF PAGE TABLE

� Page table kept in main memory

� Page Table Base Register (PTBR)

Page 0

Page 1

1

4

0

1

Page 1

Page 0

0

1

2

1 4

PTBRPage 1 41

Page TableLogical

MemoryPhysical

Memory

Page 02

3

PTBR

• Page Table Length

• Two memory accesses per data/inst access.

– Solution? Associative Registers

ASSOCIATIVE REGISTERS

CPU

p d

f dpage

number

frame

numberhit

logical

address10-20% mem time

page table

f

physical

memory

associative

registers

miss

physical

address

(Intel P3 has 32 entries)

(Intel P4 has 128 entries)

PAGE REPLACEMENT ALGORITHM

� When the page fault occurs i.e. required page is not in

memory during execution , the o.s has to choose a page

to move from memory to make room for the incoming

page.

PROCEDURE OF PAGE REPLACEMENT

�1]Page to be removed is selected.

�2]If the page to be removed is modified it must �2]If the page to be removed is modified it must

be written to the disk to bring the disk copy up to

date

�3]If the page to be removed has not been

modified , it can be overwritten .

TYPES OF PAGE REPLACEMENT

ALGORITHM

1) FIFO( First in first out) page replacement algorithm.

2) Second chance page replacement.

3) Clock page replacement.

4) Least Recently Used page replacement

5) Working set page replacement

6) Working Set Clock page replacement.

� Suppose we have 3 page frames, 4 virtual pages, and following reference stream: � A B C A B D A D B C B

� Consider FIFO Page replacement:

EXAMPLE: FIFO

CDA

BCBDADBACBA

1

Ref:

Page:

� FIFO: 7 faults.

� When referencing D, replacing A is bad choice, since need A again right away

C

B

A

D

C

B

A

3

2

1

2.SECOND CHANCE PAGE REPLACEMENT

� 1] It is modified version of FIFO algo.

� 2] It avoids the problem of throwing out a heavily used page.

� 3] An additional bit R (read) is attached to each page in memory.memory.

� 4] Whenever a page is accessed R bit is set to 1.

� 5]If it is 0,page is old and unused and replaced immediately

� 6] If it is 1,it is cleared and inserted back in the FIFO queue.

SECOND CHANCE ILLUSTRATION

�Max page table size 4

� Page B arrives

� Page A arrives

� Access page A

� Page D arrives

� Page C arrives

B u:0

first loaded page

A u:1 D u:0 C u:0

last loaded page



� Page B arrives

� Page A arrives

� Access page A

� Page D arrives

� Page C arrives

� Page F arrives

B u:0

first loaded page

A u:1 D u:0 C u:0

last loaded page



� Page B arrives

� Page A arrives

� Access page A

� Page D arrives

� Page C arrives

� Page F arrives

A u:1

first loaded page

D u:0 C u:0 F u:0

last loaded page



� Page B arrives

� Page A arrives

� Access page A

� Page D arrives

� Page C arrives

� Page F arrives

� Access page D

� Page E arrives

A u:1

first loaded page

D u:1 C u:0 F u:0

last loaded page



� Page B arrives

� Page A arrives

� Access page A

� Page D arrives

� Page C arrives

� Page F arrives

� Access page D

� Page E arrives

D u:1

first loaded page

C u:0 F u:0 A u:0

last loaded page



� Page B arrives

� Page A arrives

� Access page A

� Page D arrives

� Page C arrives

� Page F arrives

� Access page D

� Page E arrives

C u:0

first loaded page

F u:0 A u:0 D u:0

last loaded page

E u:0

DISADVANTAGE OF SECOND CHANCE PAGE

REPLACEMENT ALGORITHM

� It is unnecessarily inefficient because it is

constantly moving pages around on its listconstantly moving pages around on its list

CLOCK REPLACEMENT ILLUSTRATION


� Invariant: point at oldest page

� Page B arrivesB u:0




� Page B arrives

� Page A arrives

� Access page A

B u:0

A u:0




� Page B arrives

� Page A arrives

� Access page A

� Page D arrives

B u:0

A u:1

D u:0




� Page B arrives

� Page A arrives

� Access page A

� Page D arrives

� Page C arrives

B u:0

A u:1

D u:0

C u:0




B u:0� Page B arrives

� Page A arrives

� Access page A

� Page D arrives

� Page C arrives

� Page F arrives

F u:0

A u:1

D u:0

C u:0



� Page B arrives

� Page A arrives


C u:0E u:0

� Page A arrives

� Access page A

� Page D arrives

� Page C arrives

� Page F arrives

� Access page D

� Page E arrives

A u:1A u:0

D u:1D u:0

F u:0

NTH CHANCE VERSION OF CLOCK ALGORITHM� Nth chance algorithm: Give page N chances

� OS keeps counter per page: # sweeps

� On page fault, OS checks use bit:� 1⇒clear use and also clear counter (used in last sweep)

� 0⇒increment counter; if count=N, replace page

� Means that clock hand has to sweep by N times without page being used before page is replaced

� How do we pick N?� Why pick large N? Better approx to LRU� Why pick large N? Better approx to LRU

� If N ~ 1K, really good approximation

� Why pick small N? More efficient� Otherwise might have to look a long way to find free page

� What about dirty pages?� Takes extra overhead to replace a dirty page, so give dirty pages an extra chance before replacing?

� Common approach:� Clean pages, use N=1

� Dirty pages, use N=2 (and write back to disk when N=1)

CLOCK ALGORITHMS: DETAILS

� Which bits of a PTE entry are useful to us?

� Use: Set when page is referenced; cleared by clock algorithm

� Modified: set when page is modified, cleared when page written to

disk

� Valid: ok for program to reference this page

� Read-only: ok for program to read page, but not modify

� For example for catching modifications to code pages!� For example for catching modifications to code pages!

� Do we really need hardware-supported “modified” bit?

� No. Can emulate it (BSD Unix) using read-only bit

� Initially, mark all pages as read-only, even data pages

� On write, trap to OS. OS sets software “modified” bit, and marks page as

read-write.

� Whenever page comes back in from disk, mark read-only

CLOCK ALGORITHMS DETAILS (CONTINUED)

� Do we really need a hardware-supported “use” bit?

� No. Can emulate it using “invalid” bit:� Mark all pages as invalid, even if in memory

On read to invalid page, trap to OS� On read to invalid page, trap to OS

� OS sets use bit, and marks page read-only

� When clock hand passes by, reset use bit and mark page as invalid again

LEAST RECENTLY USED PAGE REPLACEMENT ALGORITHM

� LRU replaces the page in memory that has not been used for the longest period of time.

� This algo. goes well with the principle of locality.

� A page that has not been used for a long time is least likely to be referenced in the near future.likely to be referenced in the near future.

� This algo. can be implemented by maintaining the backward distance of each page .

� When a page is referenced its backward distance is set to 0.

� Backward distance of other pages is incremented by 1.

� Consider the following: A B C D A B C D A B C D

� LRU Performs as follows (same as FIFO here):

D

WHEN WILL LRU PERFORM BADLY?

C

B

A

D

C

B

A

D

C

B

A

CBADCBADCBA D

3

2

1

Ref:

Page:

� Every reference is a page fault!

� MIN Does much better:

DABC3

B

C

DC

B

A

CBADCBADCBA D

3

2

1

Ref:

Page:

� For example

� Consider the reference string

2 3 2 1 5 2 4 5 3 2 5 2

No. of page frames =3

These are the page frame::

REFERENCE STRING

� Step 1:

2 3 2 1 5 2 4 5 3 2 5 22

� Step 2:It causes page faults and brought into empty

frames.

� At this point backward dist. of page 2=1

� Backward dist of 3=0� Backward dist of 3=0

2 3 2 1 5 2 4 5 3 2 5 22 2

3

step 3:

2 3 2 1 5 2 4 5 3 2 5 22 2

3

2

3

2

3

1

2

5

1

2

5

1

2

5

4

2

5

4

2

5

3

2

5

3

2

5

3

2

5

3

WORKING SET PAGE REPLACEMENT

ALGORITHM

� Working set: The set of process that a process is currently using.

� The working set algorithm is based on determining a working set and evicting any page that is not present in the working set.

� Locality of reference : A process reference only a small fraction of its pages during any particular page of its execution.

� Thrashing : Result when a program causes page fault every few instruction, causing the page to pulled up from the memory. No instruction, causing the page to pulled up from the memory. No “real” useful work is being accomplished.

� Prepaging: Working set loaded into the memory before it begins execution.

Information about one

page2084

2003

1

1Time of last use

Page table Reference bit

Page reference during

This tick

Page not reference during

This tick

2003

1980

1213

2014

2020

2032

1620

1

1

1

1

1

0

Time of last use

� Scan all pages examining R bit:

� if (R==1) set

time of last use to current virtual

time

If (R==0and age>stc)� If (R==0and age>stc)

remove this page

� If (R==0and age>stc)

remember the smallest time

WORKING SET CLOCK PAGE REPLACEMENT

ALGORITHM

� It is based on the clock algorithm but also uses the

working set information.

� Due to its simplicity of implementation and good

performance ,it is widely used.

1620

20322084

R=0

2204

20322084

R=1

New page

2020

2014

1213

1980

20032020

2014

1213

1980

2003

1620

20322084

1620

20322084

2020

2014

1213

1980

20032020

2014

1213

1980

2003

R=1

ALGORITHM COMMENT

FIFO Might throw out important

pages

Second chance Big improvement over FIFO

Clock RealisticClock Realistic

LRU Excellent but difficult to

implement exactly

Working set Somewhat expensive to

implement

WS clock Good efficient algorithm

DESIGN ISSUES FOR PAGING SYSTEMS

THE WORKING SET: � The reason that page faults decrease (and then stabilise) is

because processes normally exhibit a locality of reference

� At a particular execution phase of the process it only uses a

small fraction of the pages available to the entire processsmall fraction of the pages available to the entire process

� The set of pages that is currently being used is called its

working set

� If the entire working set is in memory then no page faults will

occur

� Only when the process moves onto its next phase will page

faults begin to occur again

oIf the memory of the computer is not large enough to hold the

entire working set, then pages will constantly be copied out to disc

and subsequently retrieved

oThis drastically slows a process down and the process is said to be

thrashing

oThe paging system has to keep track of a processes’ working set sooThe paging system has to keep track of a processes’ working set sothat it can be loaded into memory before it is restarted.

oThe approach is called the working set model (or prepaging). Its aim,as we have stated, is to avoid page faults being raised.

oInformation about working set can be used by the operating systemto reduce page fault rate.

LOCAL VERSUS GLOBAL ALLOCATION POLICIES

�A local alloction assigns a fixed number of frames to every running process.

�A global allocation dynamically allocates page frame among runnable processes.frame among runnable processes.

�Global policies tend to work better.�

� If you use a local policy and the working set grows, you can get thrashing

� Similarly, if the working set shrinks, you waste

memory.memory.

� With a global policy, though, you need to decide

how much memory to allocate to each process.

PAGE SIZE

� With large pages, we waste memory: on average, half of the last page isn’t used

� With small pages, we use a lot of memory for page tables� Call the average process size s and the page size p.� Assume that each page table entry (and associated data � Assume that each page table entry (and associated data

structures) takes e bytes� The overhead o is o = (s/p)e + p/2� To optimize for memory use, differentiate and set to 0:� do/dp = −se/p2 + 1/2 = 0� Best size: p = √2se

OPERATING SYSTEM INVOLVEMENT WITH PAGING

Four times when OS involved with paging1. Process creation

− determine program size− create page table

2. Process execution2. Process execution− MMU reset for new process

3. Page fault time− determine virtual address causing fault− swap target page out, needed page in

4. Process termination time− release page table, pages

PAGE FAULT HANDLING

1. Hardware traps to kernel

2. General registers saved

3. OS determines which virtual page needed

4. OS checks validity of address, seeks page frame

5. If selected frame is modified, write it to disk5. If selected frame is modified, write it to disk

6. OS schedules disk operation to bring new page in from disk

7. Page tables updated

8. Faulting process re scheduled for execution

9. Registers restored

10. Program continues

SEGMENTATION

WHY USE SEGMENTS?

�Segmentation allows the programmer to view memory consisting of multiple address spaces or segments.or segments.

�A program can be divided into code segment,stack segment and data segment.

�As segments are logically independent, a program segment can be changed or recomplied at any time without affecting other segments.

oSegmentation can be used to protect a

program from unauthorized access.program from unauthorized access.

It is easy to share segments by different

programs.

Each process has its own segment table.

SEGMENTATION ALLOWS EACH TABLE TO

GROW OR SHRINK INDEPENDENTLY

PROBLEMS WITH SEGMENTS?

�Maximum contiguous address space is limited by segment size.

�For example, on the Intel 286, segments were limited to 64K; that meant that no array could limited to 64K; that meant that no array could be larger than 64K bytes.

COMPARISON OF PAGING AND SEGMENTATION

Unit 5

Education

Transcript of Unit 5