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

• 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

System
Library
• The linker combines object modules into a single executable binary file (load module) static linking
• 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

0
Module A
CALL B
L-1
Return
0
Module B
CALL C
M-1
Return
0 Module C
Length L
Length M
Object Modules
Load Module
0
Module A
JSR “L”
L-1
L
Return
Module B
JSR “L+M”
L+M-1
L+M
Return
Module C
Length N
L+M+N-1 Return
N-1
Return
9

• 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
2250
Symbolic Address
250
Re-locatable Address Absolute Address
(Physical Memory)
10

• 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

j i
Symbolic
Addresses
PROGRAM
JUMP i
LOAD j
DATA
Compile
1024
Absolute Addresses
(Physical Memory Addresses)
1424
JUMP 1424
LOAD 2224
2224
Source Code Absolute Load Module
12
The CPU generates the absolute addresses
Link

Load
Absolute Addresses
(Physical Memory Addresses)
1024
1424
JUMP 1424
LOAD 2224
2224
Process Image (Part)
13

• 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

j i
Symbolic
Addresses
PROGRAM
JUMP i
LOAD j
DATA
Source Code
Relative (Relocatable)
Addresses
0
Compile
400
JUMP 400
LOAD 1200
1200
15
Relative Load Module
Link

Load
Absolute Addresses
(Physical Memory Addresses)
1024
1424
JUMP 1424
LOAD 2224
2224
Process Image (Part)
16
The CPU generates the absolute addresses

– 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
17
Relative (Relocatable)
Addresses
0
400
JUMP 400
LOAD 1200
1200
MAX =2000

14000 to
14000+MAX
0 to MAX
Generated
By CPU
Seen By
Memory Unit
Binding at execution time (when reference is made)
18
Map LA to PA

• 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

• 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
gcc
Printf.o
ar
Static
Library
HelloWorld.c
gcc
Linker a.out
(or name of your command)
Loader
Memory
HelloWorld.o

• 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

• 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

Pass 1 70K
Pass 2 80K
Sym. Table 20K
Common Rou. 30K
Assembler
Total Memory
Available = 150K
Overlay (Cont.)
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 2 U
• If a request of size s such that 2 U-1 < s <=
2 U , 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

• Base register
• Bounds register
These values are set when the process is loaded or when the process is swapped in
Relocation

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: 2 32 bytes of physical memory; page size of 2 10 bytes; 2 16 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

• 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