Chapter07

Report
Operating Systems:
Internals and Design Principles, 6/E
William Stallings
Chapter 7
Memory Management
Patricia Roy
Manatee Community College, Venice, FL
©2008, Prentice Hall
Given Credit Where It is Due
• Some of the lecture notes are borrowed
from Dr. 柯皓仁 at National Chiao Tung
University, Taiwan
• One slide is borrowed from Dr. Hugh C.
Lauer at Worcester Polytechnic Institute
• I have modified them and added new
slides
Memory Management
• Subdividing memory to accommodate
multiple processes
• Memory needs to be allocated to ensure a
reasonable supply of ready processes to
consume available processor time
Memory Management
Requirements
•
•
•
•
•
Relocation
Protection
Sharing
Logical organization
Physical organization
Memory Management
Requirements
• Relocation
– Programmer does not know where the
program will be placed in memory when it is
executed
– While the program is executing, it may be
swapped to disk and returned to main
memory at a different location (relocated)
– Memory references must be translated in the
code to actual physical memory address
Addressing Requirement
Background
• Program must be brought into memory and placed within a
process for it to be executed
• Input (job) queue – collection of processes on the disk that
are waiting to be brought into memory for execution
• User programs go through several steps before being
executed
7
Steps for Loading a Process
in Memory
System
Library
static linking
• The linker combines object modules into
a single executable binary file (load module)
• The loader places the load module in physical memory
Linking: combine all the object
modules of a program into a
binary program image
8
dynamic linking
System
Library
The Linking Function
0
0 Module A
CALL B
Object Modules
JSR “L”
Length L
L-1 Return
L-1
L
0 Module B
CALL C
Length M
Return
Return
Module B
JSR “L+M”
Load Module
L+M-1
M-1
Module A
L+M
Return
Module C
0 Module C
Length N
L+M+N-1
N-1
Return
9
Return
Address Binding – Mapping from
one address space to another
• Address representation
– Source program: symbolic (such as count)
– After compiling: re-locatable address
• 14 bytes from the beginning of this module
– After linkage editor, loader or run-time referring: absolute address
• Physical memory address 2014
2000
int I;
goto p1;
0
p1
2250
250
Symbolic Address
Re-locatable Address
10
Absolute Address
(Physical Memory)
Address Binding (Cont.)
• Address binding of instructions and data to physical memory
addresses can happen at three different stages
– Compile time: If memory location known a priori, absolute code can
be generated
• Must recompile code if starting location changes
• MS-DOS .COM-format program
11
Binding at Compile Time
Symbolic
Addresses
Absolute Addresses
(Physical Memory Addresses)
PROGRAM
1024
JUMP i
JUMP 1424
i
1424
LOAD j
LOAD 2224
Compile
DATA
j
2224
Source Code
Absolute Load Module
12
The CPU generates the absolute addresses
Link
Binding at Compile Time
(Cont.)
Absolute Addresses
(Physical Memory Addresses)
1024
JUMP 1424
1424
Load
LOAD 2224
2224
Process Image (Part)
13
Address Binding (Cont.)
• Address binding of instructions and data to physical memory
addresses can happen at three different stages
– Load time: Must generate re-locatable code if memory location is
not known at compile time
• Physical memory address is fixed at load time
• Must reload if starting location changes
14
Binding at Loader Time
Symbolic
Addresses
Relative (Relocatable)
Addresses
PROGRAM
0
JUMP i
JUMP 400
i
400
LOAD j
LOAD 1200
Compile
DATA
j
1200
Source Code
Relative Load Module
15
Link
Binding at Loader Time
(Cont.)
Absolute Addresses
(Physical Memory Addresses)
1024
JUMP 1424
1424
Load
LOAD 2224
2224
Process Image (Part)
16
The CPU generates the absolute addresses
Address Binding (Cont.)
– Execution time: Binding
delayed until run time
• The process can be moved
during its execution from
one memory segment to
another
• The CPU generates the
relative (virtual) addresses
• Need hardware support for
address maps (e.g., base
and limit registers)
• Most general-purpose OS
use this method
– Swapping, Paging,
Segmentation
Relative (Relocatable)
Addresses
0
JUMP 400
400
LOAD 1200
1200
MAX =2000
17
Dynamic Relocation Using a
Relocation Register
14000 to
14000+MAX
Seen By
Memory Unit
Generated
By CPU
0 to MAX
Binding at execution
time (when reference
is made)
18
Map LA
to PA
Logical vs. Physical Address
Space
• The concept of binding a logical address space to a physical
address space is central to proper memory management
– Logical address – generated by the CPU; also referred to as virtual
address
– Physical address – address seen by the memory unit
• Logical and physical addresses are the same in compiletime and load-time address-binding schemes
• Logical and physical addresses differ in execution-time
address-binding scheme
19
Memory-Management Unit
(MMU)
• Hardware device that maps virtual to physical address
• In MMU scheme, the value in the relocation register is
added to every address generated by a user process (CPU)
at the time it is sent to memory
• The user program deals with logical addresses; it never
sees the real physical addresses
20
Printf.c
HelloWorld.c
Static
Library
gcc
Printf.o
gcc
ar
HelloWorld.o
Linker
a.out
(or name of
your command)
Loader
Memory
Dynamic Linking
• The linking of some external modules is done after the
creation of the load module (executable file)
– Windows: external modules are .DLL files
– Unix: external modules are .SO files (shared library)
• The load module contains references to external modules
which are resolved either at:
– Loading time (load-time dynamic linking)
– Run time: when a call is made to a procedure defined in the external
module (run-time dynamic linking)
• OS finds the external module and links it to the load module
– Check to see if the external module has been loaded into memory
22
Advantages of Dynamic
Linking
• The external module is often an OS utility. Executable files
can use another version of the external module without the
need of being modified
• Code sharing: the same external module needs to be
loaded in main memory only once. Each process is linked to
the same external module
– Saves memory and disk space
23
Memory Management
Techniques
•
•
•
•
•
•
•
No OS Support: User-Managed Overlays
Fixed Partitioning
Dynamic Partitioning
Simple Paging
Simple Segmentation
Virtual Memory Paging
Virtual Memory Segmentation
Overlays
• Keep in memory only those instructions
and data that are needed at any given
time
• Needed when process is larger than
amount of memory allocated to it
• Implemented by user, no special support
needed from operating system,
programming design of overlay structure is
complex
25
Overlay (Cont.)
Pass 1
70K
Pass 2
80K
Sym. Table
20K
Common Rou. 30K
Assembler
Total Memory
Available = 150K
26
Fixed Partitioning
• Equal-size partitions
– Any process whose size is less than or equal
to the partition size can be loaded into an
available partition
– If all partitions are full, the operating system
can swap a process out of a partition
– Equal-size partitions was used in early IBM’s
OS/MFT (Multiprogramming with a Fixed
number of Tasks)
Fixed Partitioning
• Equal-size partitions
– A program may not fit in a partition. The
programmer must design the program with
overlays
– Main memory use is inefficient. Any program,
no matter how small, occupies an entire
partition
• This is called internal fragmentation
Fixed Partitioning
Placement Algorithm
• Equal-size
– Placement it trivial
• Unequal-size
– Can assign each process to the smallest
partition within which it will fit
– Queue for each partition
– Processes are assigned in such a way as to
minimize wasted memory within a partition
Fixed Partitioning
Fixed Partitioning
Fixed Partitioning
• Like equal-size partitions, unequal-size
partitions still suffer the following problems:
– A program may not fit in a partition. The
programmer must design the program with
overlays
– Main memory use is inefficient. Any program, no
matter how small, occupies an entire partition
• This is called internal fragmentation
Dynamic Partitioning
• Partitions are of variable length and
number
• Process is allocated exactly as much
memory as required
Dynamic Partitioning
Dynamic Partitioning
Dynamic Partitioning
• Partitions are of variable length and
number
• Process is allocated exactly as much
memory as required
• Eventually get holes in the memory. This is
called external fragmentation
Dynamic Partitioning
Must use compaction to shift processes so they are contiguous
and all free memory is in one block
Dynamic Partitioning
• Operating system must decide which free
block to allocate to a process
• Best-fit algorithm
– Chooses the block that is closest in size to the
request
– Worst performer overall
– Since the smallest block is found for process,
the fragmentation of the smallest size is left
– Memory compaction must be done more often
Dynamic Partitioning
• First-fit algorithm
– Scans memory form the beginning and
chooses the first available block that is large
enough
– Fastest
– May have many processes loaded in the front
end of memory that must be searched over
when trying to find a free block
Dynamic Partitioning
• Next-fit
– Scans memory from the location of the last
placement
– More often allocate a block of memory at the
end of memory where the largest block is
found
– The largest block of memory is broken up into
smaller blocks
– Compaction is required to obtain a large block
at the end of memory
Allocation
Buddy System
• Entire space available is treated as a
single block of 2U
• If a request of size s such that 2U-1 < s <=
2U, entire block is allocated
– Otherwise block is split into two equal buddies
– Process continues until the smallest block
greater than or equal to s is generated
Example of Buddy System
Relocation
• When program loaded into memory the
actual (absolute) memory locations are
determined
• A process may occupy different partitions
which means different absolute memory
locations during execution (from
swapping)
Relocation
• Compaction will also cause a program to
occupy a different partition which means
different absolute memory locations
Relocation
• Base register
• Bounds register
These values are set
when the process is
loaded or when the
process is swapped
in
Paging
• Partition memory into small equal fixedsize chunks and divide each process into
the same size chunks
• The chunks of a process are called pages
and chunks of memory are called frames
Paging
• Operating system maintains a page table
for each process
– Contains the frame location for each page in
the process
– Memory address consists of a page number
and offset within the page
Process and Frames
Process and Frames
Page Table
Logical Addresses
Paging
Comparison
• What are the advantages of paging
mechanism vs. fixed partitioning and
dynamic partitioning mechanisms?
Segmentation
• All segments of all programs do not have
to be of the same length
• There is a maximum segment length
• Addressing consist of two parts - a
segment number and an offset
• Since segments are not equal,
segmentation is similar to dynamic
partitioning
Logical Addresses
Segmentation
Comparison
• What are the advantages of the
segmentation mechanism vs. the dynamic
partitioning mechanism?
In-Class Exercise
• Prob. 7.12 Consider a simple paging system
with the following parameters: 232 bytes of
physical memory; page size of 210 bytes; 216
pages of logical address space.
– A. how many bits are in a logical address?
– B. how many bytes in a frame?
– C. how many bits in the physical address specify the
frame?
– D. how many entries in the page table?
– E. how many bits in each page table entry? Assume
each page table entry contains a valid/invalid bit.
Appendix
Memory Management
Requirements
• Protection
– Processes should not be able to reference
memory locations in another process without
permission
– Impossible to check absolute addresses at
compile time, must be checked at run time
Memory Management
Requirements
• Sharing
– Allow several processes to access the same
portion of memory
– For instance, if a number of processes are
executing the same program, it is better to
allow each process access to the same copy
of the program rather than have their own
separate copy
Memory Management
Requirements
• Logical Organization
– Programs are written in modules
– Modules can be written and compiled
independently
– Different degrees of protection given to
modules (read-only, execute-only)
– Share modules among processes
Memory Management
Requirements
• Physical Organization
– Memory available for a program plus its data
may be insufficient
– System responsibility: control the information
move between main and secondary memory
Dynamic Loading
• Routine is not loaded until it is called
• Better memory-space utilization
– Unused routine is never loaded.
• Useful when large amounts of code are needed to handle
infrequently occurring cases
– Like error routines
• No special support from the operating system is required
implemented through program design
– Responsibility of users to design dynamic-loading programs
– OS may help the programmer by providing library routines
66

similar documents