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

The Linking Function

0 Module A
CALL B

Object Modules
Length L

L-1
L

0 Module B

M-1

Length M

Return
Module B
JSR L+M

Load Module
L+M-1

Return

Module A
JSR L

L-1 Return

CALL C

L+M

Return
Module C

0 Module C
Length N
L+M+N-1
N-1

Return

Return
9

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
0

int I;
goto p1;
p1

250

Symbolic Address

Re-locatable Address

10

2250

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

1424

LOAD j

LOAD 2224

Compile

DATA
j

2224

Source Code

Absolute Load Module

12
The
TheCPU
CPUgenerates
generatesthe
theabsolute
absoluteaddresses
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

JUMP i

JUMP 400

400

LOAD j

LOAD 1200

Compile

Link

DATA
j

1200

Source Code

Relative Load Module

15

Binding at Loader Time (Cont.)

Absolute Addresses
(Physical Memory Addresses)
1024
JUMP 1424
1424

Load

LOAD 2224

2224

Process Image (Part)

16
The
TheCPU
CPUgenerates
generatesthe
theabsolute
absoluteaddresses
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
Generated
By CPU

Seen By
Memory Unit

0 to MAX

Binding
Bindingat
atexecution
execution
time
time(when
(whenreference
reference
isismade)
made)

Map LA
to PA

18

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 compile-time 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

Static Linking and Loading

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
Pass11
Pass
Pass22
Sym.
Sym.Table
Table
Common
CommonRou.
Rou.

70K
70K
80K
80K
20K
20K
30K
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
IBMs 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
fixed-size 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