Embed Size (px)
Citation preview
Memory Management
Chapter 5
Memory Management - Early Systems Single-User Contiguous Scheme
• Each program is loaded in its entirety into memory and is allocated as much contiguous memory space as needed.
• If program was too large - it couldn’t be executed.
• Minimal amount of work done by Memory Manager.
• Hardware needed : • 1) register to store base address; • 2) accumulator to track size of program as it is
loaded into memory.
Memory
OS
Job1
Job2
Job3
Job4
0
256
300
420
880
1024
300
120
Base register
Limit register
Fixed (Static) Partitions
• Allows multiprogramming by using fixed partitions - one partition for each job
• The size of each partition remains static once the system is in operation. Each partition can only be reconfigured when the computer system is shut down, reconfigured and restarted.
• The partition sizes are critical. If the partition sizes are too small, larger jobs will be rejected. If partition sizes are too big, memory can be wasted if a job does not occupy the entire partition.
• Entire program is stored contiguously in memory during entire execution.
• Internal fragmentation is a problem. Internal fragmentation occurs when there are unused memory spaces within the partition itself.
Memory
300k
300k
300k
300k
300k
Job1 = 250kJob1(250k)
Job 2 = 30k
Job 2 (30k)
50k
270k
Internal fragmentation
Job 3 = 200kJob 3 (200k)
100k
Memory
300k
300k
300k
300k
300k
User Program = 720k
180k
Internal fragmentation
UserProgram
(720k)
Simplified Fixed Partition Memory Table (Table 2.1)
Partition size
Memory address
Access Partition status
100K 200K Job 1 Busy 25K 300K Job 4 Busy 25K 325K Free 50K 350K Job 2 Busy
• As each job terminates, the status of its memory partition is changed from busy to free so that an incoming job can be assigned to that partition.
• The fixed partition scheme works well if all of the jobs run on the same system are of the same size of if the sizes are known ahead of time and don’t vary between reconfigurations.
• Job 3 must wait even though 70K of free space is available in Partition 1 where Job 1 only occupies 30K of the 100K available. The jobs are allocated space on the basis of “ first available partition of required size.”
Memory
100k
25k
25k
50k
J1 = 30k
J1 (30k)
J2 = 50k70k
J3 = 30k
J4 = 25k
J2 (50k)
J4 (25k)
J3 (30k)
Dynamic Partitions
• Available memory are kept in contiguous blocks and jobs are given only as much memory as they request when loaded.
• Improves memory use over fixed partitions.
• Performance deteriorates as new jobs enter the system
• Fragments of free memory are created between blocks of allocated memory (external fragmentation).
J1 = 10kJ2 = 15k
20k J3 = 20kJ4 = 50k
OS10k
55k
35k
105k
J1 (10k)
J2 (15k)
J3 (20k)
J4 (50k)
10k
50k
J5 = 5k
J5 (5k)
5k
J6 = 30k
J6 (30k)
20k
15k
85k
J7 = 10k20k
J7 (10k)
10k45k J8 = 30k
External fragmentation
• In this example eight jobs are submitted for processing and allocated space on the basis of “first-come-first-served.” Job 8 has to wait even though there’s enough free memory between partitions to accommodate it because the free memory space available is not contiguous. Since jobs are loaded in a contiguous manner, Job 8 needs to wait.
Dynamic Partition Allocation Schemes
• First-fit: Allocate the first partition that is big enough.– Keep free/busy lists organized by memory location
(low-order to high-order).– Faster in making the allocation.
• Best-fit: Allocate the smallest partition that is big enough– Keep free/busy lists ordered by size (smallest to
largest). – Produces the smallest leftover partition.– Makes best use of memory.
First-Fit Allocation Example (Table 2.2)
• Using a first-fit scheme, Job 1 claims the first available space. Job 2 then claims the first partition large enough to accommodate it, but by doing so it takes the last block large enough to accommodate Job 3.
• Therefore, Job 3 (indicated by the asterisk) must wait until a large block becomes available, even though there’s 75K of unused memory space (internal fragmentation).
• Notice that the memory list is ordered according to memory location.
Fixed Partition Memory
30k
50k
15k
20k
J1 = 10k
J1 (10k)
J2 = 20k20k
J3 = 30k
J4 = 15k
J2 (20k)
J4 (15k)
First-Fit Allocation
30k
5k
Is waiting
Dynamic Partition Memory
30k
50k
15k
20k
J1 = 10k
J1 (10k)
J2 = 20k20k
J3 = 30k
J4 = 15k
J2 (20k)
J4 (15k)
First-Fit Allocation
20k
J3 (30k)
• Note:• A request for a block of 200 spaces has just been given to
the Memory Manager. Using the first-fit algorithm and starting from the top of the list, the Memory manager locates the first block of memory large enough to accommodate the job, which is at location 6785.
• The job is then loaded, starting at location 6785 and occupying the next 200 spaces.
• The next step is to adjust the free list to indicate the block of free memory now starts at location 6985 (not 6785 as before) and that it contains only 400 spaces (not 600 as before)
105k
600k
5k
20k
J1 = 200k
First-Fit Allocation
205k
4050k
230k
1000k
J1 (200k)67856985
400k
Fixed Partition Memory
15k
30k
20k
50k
J1 = 10k
J1 (10k)
J2 = 20k5k
J3 = 30k
J4 = 10kJ2 (20k)
J4 (10k)
Best-Fit Allocation
J3 (30k)
40k
J5 = 5k (is waiting)
Internal fragmentation
15k
30k
20k
50k
J1 = 10k
J1 (10k)
J2 = 20k5k
J3 = 30k
J4 = 10kJ2 (20k)
J4 (10k)
Best-Fit Allocation
J3 (30k)
40k
Dynamic Partition Memory
J5 = 5k
J5 (5k)
• A request for a block of 200 spaces has just been given to the Memory Manager. Using the best-fit algorithm and starting from the top of the list, the Memory Manager searches the entire list and locates a block of memory starting at location 7600, which is the smallest block that’s large enough to accommodate the job. The choice of this block minimizes the wasted space (only 5 spaces are wasted, which is less than in the four alternative blocks).
• The job is then stored, starting at location 7600 and occupying the next 200 spaces.
• Now the free list must be adjusted to show that the block of free memory starts at location 7800 (not 7600 as before) and that it contains only 5 spaces (not 205 as before).
105k
600k
5k
20k
J1 = 200k
Best-Fit Allocation
205k
4050k
230k
1000k
J1 (200k)7600
7800 5k
• Best-Fit vs. First-Fit
First-Fit Best-Fit
Faster to implement but not may not be making efficient use of memory space.
Uses memory efficiently but slower to implement because the entire free list table needs to be searched before allocation can be made.
Algorithm is less complex. Algorithm is more complex because it needs to find smallest block of memory into which the job can fit.
Memory list organized according to memory locations, low-order
Memory list organized according to memory size, smallest to largest.
• Release of Memory Space : Deallocation
• Deallocation for fixed partitions is simple– Memory Manager resets status of memory block to “free”.
• Deallocation for dynamic partitions will be more complex because it tries to combine free areas of memory whenever possible.
• Example :• If the block to be deallocated is adjacent to another free block• Then • The deallocated block is combined together with the free block • The memory list is changed to reflect the starting address of the
new free block(if starting address of new free block has changed) • The free memory block size is changed to show its new size
• Relocatable Dynamic Partitions• The Memory Manager relocates programs to gather together all
of the empty blocks and compact them to make one block of memory large enough to accommodate some or all of the jobs waiting to get in.
• Compaction• Used to consolidate all external fragments (free areas in memory)
into one contiguous block. In some cases, compaction enhances throughput by allowing more programs to be active at the same time.
• Compaction Steps• Relocate every program in memory so they’re contiguous.• Adjust every address, and every reference to an address, within
each program to account for program’s new location in memory. • Must leave alone all other values within the program (e.g., data
values).
• Relocation• The process by which programs are repositioned in main memory to allow
compaction of free memory areas. When relocation takes place, the addresses specified by a program for either branching or data reference are modified, during execution, to allow the program to execute correctly.
• Memory Manager relocates programs to gather all empty blocks and compact them to make 1 memory block.
• Memory compaction (garbage collection, defragmentation) performed by OS to reclaim fragmented sections of memory space.
• Memory Manager optimizes use of memory & improves throughput by compacting & relocating.
• Relocation can be time-consuming and should be done sparingly. The options on the frequency of doing relocation and compaction include:-– When a certain percentage of main memory is used up (e.g. 75% used
up)– When the number of programs waiting for execution reaches a prescribed
upper limit.– When a prescribed amount of time has elapsed. – Combinations of all the above options.
Example
30k
OS10k
92k
62k
210k
J1 (8k)
J4 (32k)
12k
J5 (48k)
54k
18k
156k
30kJ6 = 84k
J2 (16k)108k
30k
OS10k
92k
62k
J1 (8k)
J4 (32k)
12k
J5 (48k)
54k
18k
156k
30k
J2 (16k)108k
50k
OS10k
114k
66k
J1 (8k)
J4 (32k)
J5 (48k)
96k
18k
156k
J2 (16k)Compaction
50k
OS10k
114k
66k
J1 (8k)
J4 (32k)
J5 (48k)
12k
18k
198k
J2 (16k)J6 = 84k
J6 (84k)
210k
Memory Management – Recent Systems
• Early schemes were limited to storing entire program in memory.
– Fragmentation.– Overhead due to relocation.– More sophisticated memory schemes now that:– Eliminate need to store programs contiguously.– Eliminate need for entire program to reside in memory during
execution.
• More Recent Memory Management Schemes include:• Paged Memory Allocation• Demand Paging Memory Allocation• Segmented Memory Allocation
Paged Memory Allocation
• Divides each incoming job into pages of equal size.• Works well if page size = size of memory block size
(page frames) = size of disk section (sector, block).• Before executing a program, the Memory Manager:
• 1. Determines number of pages in program.• 2. Locates enough empty page frames in
main memory• 3. Loads all of the program’s pages into them.
• At compilation time every job is divided into pages:– Page 0 contains the first hundred lines.– Page 1 contains the second hundred
lines.– Page 2 contains the third hundred lines.– Page 3 contains the last fifty lines.
• Program has 350 lines.• Referred to by system as line 0 through line
349.
Job11st 100 lines
2nd 100 lines
3rd 100 lines
50 lines
Job 1 (350 lines)0
349
OSOS
100k
100k
100k
100k
100k
100k
100k
100k
100k
100k
Page frame
012
3456
91011
100k
100k
100k
78
12
Page 0
Page 1
Page 2
Page 3
Page 0
Page 1
Page 2
Page 3
123
99100
..
101102
199200
.
.
201202
.
.
299300301302
.
.
• Paging Requires 3 Tables to Track a Job’s Pages
• 1. Job Table (JT) - 2 entries for each active job.– Size of job & memory location of its page map table.– Dynamic – grows/shrinks as jobs loaded/completed.
• 2. Page Map Table (PMT) - 1 entry per page.– Page number & corresponding page frame memory
address.– Page numbers are sequential (Page 0, Page 1 …)
• 3. Memory Map Table (MMT) - 1 entry for each page frame.– Location & free/busy status.
Job Table (JT) Page Map Table (PMT)
Memory Map Table (MMT)
Job Size
0Job 1(360k)
360
Memory Address
Job 2(200k)
Page No Frame No
Page 0 Frame 8Page 1 Frame 10Page 2 Frame 5Page 3 Frame 11
Frame 8Frame 9Frame 10Frame 11Frame 12
Frame No Status
busyfreebusybusy
free
• Displacement (Figure 3.2)
• Displacement (offset) of a line -- how far away a line is from the beginning of its page.– Used to locate that line within its page
frame.– Relative factor.
• For example, lines 0, 100, 200, and 300 are first lines for pages 0, 1, 2, and 3 respectively so each has displacement of zero.
• Example:• If we use 100 lines as the page size, the page
number and the displacement (the location within that page) of Line 214 can be calculated:-
• 2• 100 214• 200• 14• Quotient 2 Page Number • Remainder 2 Displacement• Line 214 is located on Page 2, 15 lines (Line 14)
from the top of the page
Page size Page No
Displacement
Line no to be located
1st 100 lines
2nd 100 lines
Page 0
Page 1
Page 2
0Job is 215 lines
12...
99100101102.
.
.
199200201202
.
.
.
.214
0
99
.
.
.
99
.
.
0
0...
14
Remaining15 lines
Demand Paging
• Bring a page into memory only when it is needed, so less I/O and memory is needed.– Faster response.
• Takes advantage of the fact that programs are written sequentially, so not all pages are needed at once. For example:– User-written error handling modules.– Mutually exclusive modules.– Certain program options are either mutually exclusive
or not always accessible.– Many tables assigned fixed amount of address space
even though only a fraction of table is actually used. • Demand paging has made virtual memory widely
available.
Demand paging
Program A
Program B
1 4
2 3
Swap out
Swap in
1
4
9
7
5
7
8
2
3
Demand paging
Program A
Program B
1 4
7 3Swap in
1
4
2
3
7
• Requires use of a high-speed direct access storage device that can work directly with CPU.
• How and when the pages are passed (or “swapped”) depends on predefined policies that determine when to make room for needed pages and how to do so.
• Thrashing Is a Problem With Demand Paging• Thrashing – an excessive amount of page swapping back and
forth between main memory and secondary storage.– Operation becomes inefficient.– Caused when a page is removed from memory but is called
back shortly thereafter. – Can occur across jobs, when a large number of jobs are vying
for a relatively few number of free pages.– Can happen within a job (e.g., in loops that cross page
boundaries). • Page fault – a failure to find a page in memory.
Tables in Demand Paging
• Job Table.• Page Map Table (with 3 new fields).
– Determines if requested page is already in memory.– Determines if page contents have been modified.– Determines if the page has been referenced recently.
• Used to determine which pages should remain in main memory and which should be swapped out.
• Memory Map Table.
Page Fault
A B
C D E F
M
C
A
FM
Physical Memory
DiskO/S
C
A
Load M
F
A 0
i
C 2
F 5
Page Map Table
Logical Processes
Load X
A 0
M 1
C 2
F 5
Page Fault
A B
C D E F
M
C
A
FM
Physical Memory
DiskO/S
C
A
Load M
F
A 0
M i
C 2
F 5
Page Map Table
Logical Processes
C
A
F
X
r
Z
Physical Memory
C
A
N
F
X
NXN
Page Replacement Policies
• Policy that selects page to be removed is crucial to system efficiency. Policies used include:– First-in first-out (FIFO) policy – best page to
remove is the one that has been in memory the longest.
– Least-recently-used (LRU) policy – chooses pages least recently accessed to be swapped out.
A B A C A B D B A C D
a) First-In-First-Out (FIFO)
ABA
9 page faults
BC
AB A
CA
CD
AB
DC
D
A B A C A B D B A C D
a) Least Recently Used (LRU)
ABA
8 page faults
A ACA
CD
BB
A
C B
D
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
a) First-In-First-Out (FIFO)
707
1
32
Example: 3 frames (3 pages can be in memory for the process)
07
1
02
1 0
32 4
0
3
1
4
0
2
4
2
3
2
3
0
3
0
1
0
12
12
7
2
7
0
15 page faults
7
0
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1Example: 3 frames
b) Least Recently Used (LRU)Replace the page that has been used for the longest period of time
707
1
02
07
1
02
3 7
12 page faults
0
3
4
0
4
2
4
2
3
2
3
0
2
3
1
2
1
0
1
0
• LRU• The efficiency of LRU is only slightly better
than with FIFO. • LRU is a stack algorithm removal policy –
increasing main memory causes either a decrease in or same number of page interrupts.– LRU doesn’t have same anomaly that FIFO
does.
Belady’s anomaly problem (in FIFO)
2
4
6
8
10
12
14
16
18
1 2 3 4 5 6 7
No of Page faults
No of Frames
• Pros and Cons of Demand Paging
• A job is no longer constrained by the size of physical memory (virtual memory). (Pro)
• Uses memory more efficiently than previous schemes because sections of a job used seldom or not at all aren’t loaded into memory unless specifically requested. (Pro)
• Increased overhead caused by tables and page interrupts. (Con)
• Segmented Memory Allocation
• Programmers commonly structure their programs in modules (logical groupings of code).– A segment is a logical unit such as: main program,
subroutine, procedure, function, local variables, global variables, common block, stack, symbol table, or array.
– Main memory is not divided into page frames because the size of each segment is different.
• In a segmented memory allocation scheme, jobs are divided into a number of distinct logical units called segments, one for each module that contains pieces that performs related functions.
• Memory is allocated dynamically.
• Segment Map Table (SMT)
• When a program is compiled, segments are set up according to program’s structural modules.
• Each segment is numbered and a Segment Map Table (SMT) is generated for each job.– Contains segment numbers, their lengths,
access rights, status, and (when each is loaded into memory) its location in memory.
• Tables Used in Segmentation
• Memory Manager needs to track segments in memory:
• Job Table (JT) lists every job in process (one for whole system).
• Segment Map Table lists details about each segment (one for each job).
• Memory Map Table monitors allocation of main memory (one for whole system).
Seg 0
Seg 1
Subroutine
A
Main Program
Seg 0
4000
7000
Subroutine B
Seg 1
Seg 2
Segment Map Table (SMT)
Seg No Size Status Access Memory Address
0 200 busy E 40001 400 busy E 70002 240 free E 6700
Memory
• Pros and Cons of Segmentation• Compaction.• External fragmentation.• Secondary storage handling.• Memory is allocated dynamically.
P1
P3
P0
P2Memory
Seg 0
Seg 2
Seg 1
Seg 3
Program B (340k)
200k
100k
80k
40k
No segment can fit the program B, so External fragmentation
P1
P3
P0
P2
Memory
Frame 0
Frame 2
Frame 1
Frame 3
Frame 4
Frame 5
Frame 6
Frame 7
100k
100k
100k
100k
100k
100k
100k
100k
Program B (340k)
100k
100k
100k
40k
Page 0
Page 1
Page 2
Page 3
Page 0
Page 1
Page 2
Page 3
How paging overcome the segmentation
Internal fragmentation
• Virtual Memory (VM)
• Even though only a portion of each program is stored in memory, virtual memory gives the appearance that programs are being completely loaded in main memory during their entire processing time.
• Shared programs and subroutines are loaded “on demand,” reducing storage requirements of main memory.
• • VM is implemented through demand paging and
segmentation schemes.
Comparison of VM with Paging and with Segmentation
Paging Segmentation
Allows internal fragmentation within page frames
Doesn’t allow internal fragmentation
Doesn’t allow external fragmentation Allows external fragmentation
Programs are divided into equal-sized pages
Programs are divided into unequal-sized segments
Absolute address calculated using page number and displacement
Absolute address calculated using segment number and displacement
Requires PMT Requires SMT
Advantages of VM
1. Works well in a multiprogramming environment because most programs spend a lot of time waiting.
2. Job’s size is no longer restricted to the size of main memory (or the free space within main memory).
3. Memory is used more efficiently.
4. Allows an unlimited amount of multiprogramming.
5. Eliminates external fragmentation when used with paging and eliminates internal fragmentation when used with segmentation.
6. Allows a program to be loaded multiple times occupying a different memory location each time.
7. Allows the sharing of code and data.
8. Facilitates dynamic linking of program segments.
• Disadvantages of VM
• Increased processor hardware costs.
• Increased overhead for handling paging interrupts.
• Increased software complexity to prevent thrashing.
