1

Virtual Memory

Chapter 8

2

Virtual memory concept Simple paging segmentation

pages or segments are loaded into frames that may not necessarily be contiguous

address references in the loaded pages or segments is dynamically calculated

Virtual memory Similar to the above two things except that we do not need

to load the whole program into memory Only a small portion of the whole program is first loaded

into memory (the resident portion) The rest loaded when needed Swapped out to disk when space is needed for other

processes

3

Hardware and Control Structures Memory references are dynamically translated into

physical addresses at run time A process may be swapped in and out of main memory

such that it occupies different regions A process may be broken up into pieces that do not

need to located contiguously in main memory All pieces of a process do not need to be loaded in

main memory during execution

4

Execution of a Program Operating system brings into main memory a few pieces of the

program Resident set - portion of process that is in main memory An interrupt is generated when an address is needed that is not in

main memory Operating system places the process in a blocking state Piece of process that contains the logical address is brought into

main memory Operating system issues a disk IO Read request Another process is dispatched to run while the disk IO takes place An interrupt is issued when disk IO complete which causes the

operating system to place the affected process in the Ready state

5

Advantages of breaking up a Process More processes may be maintained in main

memory Only load in some of the pieces of each process With so many processes in main memory it is

very likely a process will be in the Ready state at any particular time

A process may be larger than all of main memory

6

Types of Memory

Real memory Main memory where programs are actually

loaded Virtual memory

Memory view that is unlimited - that includes the space on disk

A programmerrsquos view of memory - Allows for effective multiprogramming and relieves the user of tight constraints of main memory

7

Concept of Thrashing Sometimes when portion of a program is loaded

into memory to run and the loaded portion immediately need another module which is not in memory So it have to be loaded from disk

Sometimes a piece of a process is swapped out just before that piece is needed So it have to be reloaded from disk

There will be a time when there are many processes loaded in memory that needs to do the swap in and the processor spends more time swapping in and out as compared to doing real processing This is called thrashing

8

To avoid Thrashing - Principle of Locality To avoid thrashing OS will guess which part

of a process is not needed in the near future and swap it out for new process to be loaded in

Only process that will be used in a short time will remain in memory The selection is based on principle of locality (POL)

9

Principle of Locality Principle of locality states that program and

data references within a process tend to cluster Only a few pieces of a process will be needed

over a short period of time ie within a short period of time the same set of instructions and data will be repeatedly used

Possible to make intelligent guesses about which pieces will be needed in the future

This suggests that virtual memory may work efficiently

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

2

Virtual memory concept Simple paging segmentation

pages or segments are loaded into frames that may not necessarily be contiguous

address references in the loaded pages or segments is dynamically calculated

Virtual memory Similar to the above two things except that we do not need

to load the whole program into memory Only a small portion of the whole program is first loaded

into memory (the resident portion) The rest loaded when needed Swapped out to disk when space is needed for other

processes

3

Hardware and Control Structures Memory references are dynamically translated into

physical addresses at run time A process may be swapped in and out of main memory

such that it occupies different regions A process may be broken up into pieces that do not

need to located contiguously in main memory All pieces of a process do not need to be loaded in

main memory during execution

4

Execution of a Program Operating system brings into main memory a few pieces of the

program Resident set - portion of process that is in main memory An interrupt is generated when an address is needed that is not in

main memory Operating system places the process in a blocking state Piece of process that contains the logical address is brought into

main memory Operating system issues a disk IO Read request Another process is dispatched to run while the disk IO takes place An interrupt is issued when disk IO complete which causes the

operating system to place the affected process in the Ready state

5

Advantages of breaking up a Process More processes may be maintained in main

memory Only load in some of the pieces of each process With so many processes in main memory it is

very likely a process will be in the Ready state at any particular time

A process may be larger than all of main memory

6

Types of Memory

Real memory Main memory where programs are actually

loaded Virtual memory

Memory view that is unlimited - that includes the space on disk

A programmerrsquos view of memory - Allows for effective multiprogramming and relieves the user of tight constraints of main memory

7

Concept of Thrashing Sometimes when portion of a program is loaded

into memory to run and the loaded portion immediately need another module which is not in memory So it have to be loaded from disk

Sometimes a piece of a process is swapped out just before that piece is needed So it have to be reloaded from disk

There will be a time when there are many processes loaded in memory that needs to do the swap in and the processor spends more time swapping in and out as compared to doing real processing This is called thrashing

8

To avoid Thrashing - Principle of Locality To avoid thrashing OS will guess which part

of a process is not needed in the near future and swap it out for new process to be loaded in

Only process that will be used in a short time will remain in memory The selection is based on principle of locality (POL)

9

Principle of Locality Principle of locality states that program and

data references within a process tend to cluster Only a few pieces of a process will be needed

over a short period of time ie within a short period of time the same set of instructions and data will be repeatedly used

Possible to make intelligent guesses about which pieces will be needed in the future

This suggests that virtual memory may work efficiently

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

3

Hardware and Control Structures Memory references are dynamically translated into

physical addresses at run time A process may be swapped in and out of main memory

such that it occupies different regions A process may be broken up into pieces that do not

need to located contiguously in main memory All pieces of a process do not need to be loaded in

main memory during execution

4

Execution of a Program Operating system brings into main memory a few pieces of the

program Resident set - portion of process that is in main memory An interrupt is generated when an address is needed that is not in

main memory Operating system places the process in a blocking state Piece of process that contains the logical address is brought into

main memory Operating system issues a disk IO Read request Another process is dispatched to run while the disk IO takes place An interrupt is issued when disk IO complete which causes the

operating system to place the affected process in the Ready state

5

Advantages of breaking up a Process More processes may be maintained in main

memory Only load in some of the pieces of each process With so many processes in main memory it is

very likely a process will be in the Ready state at any particular time

A process may be larger than all of main memory

6

Types of Memory

Real memory Main memory where programs are actually

loaded Virtual memory

Memory view that is unlimited - that includes the space on disk

A programmerrsquos view of memory - Allows for effective multiprogramming and relieves the user of tight constraints of main memory

7

Concept of Thrashing Sometimes when portion of a program is loaded

into memory to run and the loaded portion immediately need another module which is not in memory So it have to be loaded from disk

Sometimes a piece of a process is swapped out just before that piece is needed So it have to be reloaded from disk

There will be a time when there are many processes loaded in memory that needs to do the swap in and the processor spends more time swapping in and out as compared to doing real processing This is called thrashing

8

To avoid Thrashing - Principle of Locality To avoid thrashing OS will guess which part

of a process is not needed in the near future and swap it out for new process to be loaded in

Only process that will be used in a short time will remain in memory The selection is based on principle of locality (POL)

9

Principle of Locality Principle of locality states that program and

data references within a process tend to cluster Only a few pieces of a process will be needed

over a short period of time ie within a short period of time the same set of instructions and data will be repeatedly used

Possible to make intelligent guesses about which pieces will be needed in the future

This suggests that virtual memory may work efficiently

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

4

Execution of a Program Operating system brings into main memory a few pieces of the

program Resident set - portion of process that is in main memory An interrupt is generated when an address is needed that is not in

main memory Operating system places the process in a blocking state Piece of process that contains the logical address is brought into

main memory Operating system issues a disk IO Read request Another process is dispatched to run while the disk IO takes place An interrupt is issued when disk IO complete which causes the

operating system to place the affected process in the Ready state

5

Advantages of breaking up a Process More processes may be maintained in main

memory Only load in some of the pieces of each process With so many processes in main memory it is

very likely a process will be in the Ready state at any particular time

A process may be larger than all of main memory

6

Types of Memory

Real memory Main memory where programs are actually

loaded Virtual memory

Memory view that is unlimited - that includes the space on disk

A programmerrsquos view of memory - Allows for effective multiprogramming and relieves the user of tight constraints of main memory

7

Concept of Thrashing Sometimes when portion of a program is loaded

into memory to run and the loaded portion immediately need another module which is not in memory So it have to be loaded from disk

Sometimes a piece of a process is swapped out just before that piece is needed So it have to be reloaded from disk

There will be a time when there are many processes loaded in memory that needs to do the swap in and the processor spends more time swapping in and out as compared to doing real processing This is called thrashing

8

To avoid Thrashing - Principle of Locality To avoid thrashing OS will guess which part

of a process is not needed in the near future and swap it out for new process to be loaded in

Only process that will be used in a short time will remain in memory The selection is based on principle of locality (POL)

9

Principle of Locality Principle of locality states that program and

data references within a process tend to cluster Only a few pieces of a process will be needed

over a short period of time ie within a short period of time the same set of instructions and data will be repeatedly used

Possible to make intelligent guesses about which pieces will be needed in the future

This suggests that virtual memory may work efficiently

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

5

Advantages of breaking up a Process More processes may be maintained in main

memory Only load in some of the pieces of each process With so many processes in main memory it is

very likely a process will be in the Ready state at any particular time

A process may be larger than all of main memory

6

Types of Memory

Real memory Main memory where programs are actually

loaded Virtual memory

Memory view that is unlimited - that includes the space on disk

A programmerrsquos view of memory - Allows for effective multiprogramming and relieves the user of tight constraints of main memory

7

Concept of Thrashing Sometimes when portion of a program is loaded

into memory to run and the loaded portion immediately need another module which is not in memory So it have to be loaded from disk

Sometimes a piece of a process is swapped out just before that piece is needed So it have to be reloaded from disk

There will be a time when there are many processes loaded in memory that needs to do the swap in and the processor spends more time swapping in and out as compared to doing real processing This is called thrashing

8

To avoid Thrashing - Principle of Locality To avoid thrashing OS will guess which part

of a process is not needed in the near future and swap it out for new process to be loaded in

Only process that will be used in a short time will remain in memory The selection is based on principle of locality (POL)

9

Principle of Locality Principle of locality states that program and

data references within a process tend to cluster Only a few pieces of a process will be needed

over a short period of time ie within a short period of time the same set of instructions and data will be repeatedly used

Possible to make intelligent guesses about which pieces will be needed in the future

This suggests that virtual memory may work efficiently

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

6

Types of Memory

Real memory Main memory where programs are actually

loaded Virtual memory

Memory view that is unlimited - that includes the space on disk

A programmerrsquos view of memory - Allows for effective multiprogramming and relieves the user of tight constraints of main memory

7

Concept of Thrashing Sometimes when portion of a program is loaded

into memory to run and the loaded portion immediately need another module which is not in memory So it have to be loaded from disk

Sometimes a piece of a process is swapped out just before that piece is needed So it have to be reloaded from disk

There will be a time when there are many processes loaded in memory that needs to do the swap in and the processor spends more time swapping in and out as compared to doing real processing This is called thrashing

8

To avoid Thrashing - Principle of Locality To avoid thrashing OS will guess which part

of a process is not needed in the near future and swap it out for new process to be loaded in

Only process that will be used in a short time will remain in memory The selection is based on principle of locality (POL)

9

Principle of Locality Principle of locality states that program and

data references within a process tend to cluster Only a few pieces of a process will be needed

over a short period of time ie within a short period of time the same set of instructions and data will be repeatedly used

Possible to make intelligent guesses about which pieces will be needed in the future

This suggests that virtual memory may work efficiently

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

7

Concept of Thrashing Sometimes when portion of a program is loaded

into memory to run and the loaded portion immediately need another module which is not in memory So it have to be loaded from disk

Sometimes a piece of a process is swapped out just before that piece is needed So it have to be reloaded from disk

There will be a time when there are many processes loaded in memory that needs to do the swap in and the processor spends more time swapping in and out as compared to doing real processing This is called thrashing

8

To avoid Thrashing - Principle of Locality To avoid thrashing OS will guess which part

of a process is not needed in the near future and swap it out for new process to be loaded in

Only process that will be used in a short time will remain in memory The selection is based on principle of locality (POL)

9

Principle of Locality Principle of locality states that program and

data references within a process tend to cluster Only a few pieces of a process will be needed

over a short period of time ie within a short period of time the same set of instructions and data will be repeatedly used

Possible to make intelligent guesses about which pieces will be needed in the future

This suggests that virtual memory may work efficiently

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

8

To avoid Thrashing - Principle of Locality To avoid thrashing OS will guess which part

of a process is not needed in the near future and swap it out for new process to be loaded in

Only process that will be used in a short time will remain in memory The selection is based on principle of locality (POL)

9

Principle of Locality Principle of locality states that program and

data references within a process tend to cluster Only a few pieces of a process will be needed

over a short period of time ie within a short period of time the same set of instructions and data will be repeatedly used

Possible to make intelligent guesses about which pieces will be needed in the future

This suggests that virtual memory may work efficiently

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

9

Principle of Locality Principle of locality states that program and

data references within a process tend to cluster Only a few pieces of a process will be needed

over a short period of time ie within a short period of time the same set of instructions and data will be repeatedly used

Possible to make intelligent guesses about which pieces will be needed in the future

This suggests that virtual memory may work efficiently

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

10

Support Needed for Virtual Memory Hardware support for paging and

segmentation Operating system must be able to

management the movement of pages andor segments between secondary memory (disk) and main memory

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

11

Implementation of Virtual memory Virtual memory can be implemented for

system using paging segmentation combination of paging and segmentation

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

12

Virtual memory using Paging Each process has its own page table Each page table entry contains

the frame number of the corresponding page in main memory

Present bit - to indicate whether the page is in main memory or not

Modify bit - to indicate if the page has been altered since it was last loaded into main memory If no change has been made the page does not have to be written to the disk when it needs to be swapped out

Address refered in the program (the logical address) will have two parts 1048713 Page number 1048713 Offset

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

13

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

14

Two-Level Scheme for 32-bit Address

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

15

2-level Page Table

The entire page table may take up too much main memory

Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running

In a two level page table scheme ndash at first level a logical address points to a page table directory of page table From page table directory there will be another pointer to the actual page table

When a process is running part of its page table is in main memory

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

16

2-level Page Table scheme

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

17

Inverted Page Table Page number portion of a virtual address is mapped into

a hash value Hash value points to inverted page table Fixed proportion of real memory is required for the tables

regardless of the number of processes Contents of page table

Page number Process identifier Control bits Chain pointer

Used on PowerPC UltraSPARC and IA-64 architecture

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

18

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

19

Translation Lookaside Buffer

Each virtual memory reference can cause two physical memory accesses One to fetch the page table One to fetch the data

This will increase memory access time To overcome this we can cache (store

temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB)

TLB normally resides in main memory

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

20

Translation Lookaside Buffer

Given a virtual address processor examines the TLB

If page table entry is present (TLB hit) the frame number is retrieved and the real address is formed

If page table entry is not found in the TLB (TLB miss) the page number is used to index the process page table

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

21

Translation Lookaside Buffer

First checks if page is already in main memory If not in main memory a page fault is issued

The TLB is updated to include the new page entry

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

22

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

23

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

24

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

25

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

26

Issue in Paging - Page Size Smaller page size means

less amount of internal fragmentation But more pages required per process

More pages per process means larger page tables this means large portion of page tables in virtual memory

Secondary memory is designed to efficiently transfer large blocks of data so a large page size is better

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

27

Page Size

Small page size large number of pages will be found in main memory

As time goes on during execution the pages in memory will all contain portions of the process near recent references Page faults low

Increased page size causes pages to contain locations further from any recent reference Page faults rise

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

28

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

29

Example Page Sizes

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

30

Segmentation

May be unequal dynamic size Simplifies handling of growing data structures Allows programs to be altered and

recompiled independently Lends itself to sharing data among processes Lends itself to protection

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

31

Segment Tables

Corresponding segment in main memory Each entry contains the length of the

segment A bit is needed to determine if segment is

already in main memory Another bit is needed to determine if the

segment has been modified since it was loaded in main memory

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

32

Segment Table Entries

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

33

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

34

Combined Paging and Segmentation Paging is transparent to the programmer Segmentation is visible to the programmer Each segment is broken into fixed-size pages

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

35

Combined Segmentation and Paging

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

36

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

37

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

38

OS Support for Virtual Memory Virtual memory using Paging and

segmentation require hardware support OS software support the various algorithm

involved in managing the policies for page fetching page placement page replacement after swap out Management of resident set of pages Cleaning of pages Load control

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

39

All the above policies rely on Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program

The nature of the application The programming language it is written in The compiler used The style of the programmerwho wrote it The behaviour of the user (in the case of interactive program)

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

40

The OS designer must therefore choose a set of policies depending on the target users of the OS based on the current knowledge Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

41

Fetch Policy

Fetch Policy Determines when a page should be brought into

memory Demand paging only brings pages into main

memory when a reference is made to a location on the page Many page faults when process first started

Prepaging brings in more pages than needed More efficient to bring in pages that reside contiguously

on the disk

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

42

Placement Policy

Determines where in real memory a process piece is to reside

Important in a segmentation system Paging or combined paging with

segmentation hardware performs address translation

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

43

Replacement Policy

Replacement Policy Which page is replaced Page removed should be the page least likely to

be referenced in the near future Most policies predict the future behavior on the

basis of past behavior

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

44

Replacement Policy

Frame Locking If frame is locked it may not be replaced Kernel of the operating system Control structures IO buffers Associate a lock bit with each frame

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

45

Basic Replacement Algorithms Optimal policy Least Recently Used (LRU) First-in first-out (FIFO) Clock Policy

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

46

Basic Replacement Algorithms Optimal policy

Selects for replacement that page for which the time to the next reference is the longest

Impossible to have perfect knowledge of future events

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

47

Basic Replacement Algorithms Least Recently Used (LRU)

Replaces the page that has not been referenced for the longest time

By the principle of locality this should be the page least likely to be referenced in the near future

Each page could be tagged with the time of last reference This would require a great deal of overhead

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

48

Basic Replacement Algorithms First-in first-out (FIFO)

Treats page frames allocated to a process as a circular buffer

Pages are removed in round-robin style Simplest replacement policy to implement Page that has been in memory the longest is

replaced These pages may be needed again very soon

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

49

Basic Replacement Algorithms Clock Policy

Additional bit called a use bit When a page is first loaded in memory the use bit is set to

1 When the page is referenced the use bit is set to 1 When it is time to replace a page the first frame

encountered with the use bit set to 0 is replaced During the search for replacement each use bit set to 1 is

changed to 0

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

50

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

51

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

52

Comparison of Replacement Algorithms

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

53

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

54

To improve paging performance A strategy that can improve paging

performance is by using a simple replacement policy but on top of that employ page buffering

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

55

Page Buffering

In page buffering a replaced page is put into either one of the two lists Free page list - page that have not been modified Modified page list - page that have been modified This page

have to be written back to hard disk When a page is to be read in

the page frame ahead in the free page list is overwritten If the page is to be replaced is an unmodified page the page

frame is moved to the tail of the free page list If the page is to be replaced is a modified page the page frame

is moved to the tail of the modified page list The important fact here is that the replaced pages still remains in

memory The modified pages can later be written back to disk

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

56

Resident set management

Resident set management deals with the followings issues How many page frames are to be allocated to

each active process Whether to limit the pages to replace to just the

pages that cause the page fault or the whole pages that belong to the process

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

57

Factors in Resident set management The following factors comes into play

Less amount of memory allocated to process means more process can be loaded thus more ready process available

Rate of page fault is high if less memory frames allocated to process

Beyond certain size even though more memory is allocated to process the will be no noticable impact

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

58

Policies and Scope in Resident set management Two different policies can be employed in resident

set management Fixed-allocation - fixing number of pages to allocate for a

process at load time Variable-allocation - let the number of pages allocated to

be varied over the lifetime of the process OS will have to assess the behaviour of each process This require software overhead

The scope of replacement strategy can be Global - choose pages to replace among all unlocked

pages in main memory from any processes at all Local - choose pages to replace only among the resident

pages of the process that generate page fault

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

59

Relationship between policies and scope The relationship between resident set size

allocation and the scope can be one of the followings 1048713 Fixed allocation local scope 1048713 Variable allocation local scope 1048713 Variable allocation global scope

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

60

Fixed Allocation Local Scope

Decide ahead of time the amount of allocation to give a process

If allocation is too small there will be a high page fault rate

If allocation is too large there will be too few programs in main memory

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

61

Variable Allocation Global Scope Easiest to implement Adopted by many operating systems Operating system keeps list of free frames Free frame is added to resident set of

process when a page fault occurs If no free frame replaces one from another

process

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

62

Variable Allocation Local Scope When new process added allocate number

of page frames based on application type program request or other criteria

When page fault occurs select page from among the resident set of the process that suffers the fault

Reevaluate allocation from time to time

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

63

Relationship between policies and scope

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

64

Cleaning Policy

Cleaning policy determines when a modified page should be written to disk 2 main alternatives are Demand cleaning

A page is written out only when it has been selected for replacement

Precleaning Pages are written out in batches

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

65

Cleaning Policy

Best approach uses page buffering Replaced pages are placed in two lists

Modified and unmodified Pages in the modified list are periodically written

out in batches Pages in the unmodified list are either reclaimed if

referenced again or lost when its frame is assigned to another page

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

66

Load Control

Load control is concerned with determining the number of processes that will be resident in main memory

Too few processes many occasions when all processes will be blocked and much time will be spent in swapping

Too many processes will lead to thrashing

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

67

Multiprogramming Load control is Also refered to as

multiprogramming level The objective is to avoid thrashing

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

68

Process Suspension

If multiprogramming level is to be reduced one or more of the currently resident process needs to be suspended (swapped out) There are 6 possibilities Lowest priority process Faulting process

This process does not have its working set in main memory so it will be blocked anyway

Last process activated This process is least likely to have its working set resident

Process with smallest resident set This process requires the least future effort to reload

Largest process Obtains the most free frames

Process with the largest remaining execution window

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

69

UNIX and Solaris Memory Management Paging System

Page table Disk block descriptor Page frame data table Swap-use table

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

70

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

71

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

72

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

73

UNIX and Solaris Memory Management Page Replacement

Refinement of the clock policy

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

74

Kernel Memory Allocator

Lazy buddy system

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

75

Linux Memory Management

Page directory Page middle directory Page table

76

77

78

Windows Memory Management Paging

Available Reserved Committed

76

77

78

Windows Memory Management Paging

Available Reserved Committed

77

78

Windows Memory Management Paging

Available Reserved Committed

78

Windows Memory Management Paging

Available Reserved Committed