1. Chapter 7 Memory Management
Operating Systems: Internals and Design Principles, 6/E William Stallings
Chapter 7 Memory Management
Patricia Roy Manatee Community College, Venice, FL ©2008, Prentice Hall

2. 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

3. 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

4. Memory Management Requirements
Relocation
Protection
Sharing
Logical organization
Physical organization

5. 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

6. Addressing Requirement
The processor hardware and operating system software must be able to translate the memory references found in the code of the program into actual physical memory addresses, reflecting the current location of the program in the main memory.

7. 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

8. 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
System Library
dynamic linking

9. The Linking Function Object Modules Load Module L-1 L-1 Module A
L-1
L-1
Module A
CALL B
Return
Length L
Module B
CALL C
Length M
Module C
Length N
Module A
JSR “L”
Return
Module B
JSR “L+M”
Module C L
L+M-1
L+M
L+M+N-1
Object Modules
M-1
Load Module
JSR: Jump to SubRoutine
N-1

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

11. 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

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

13. Binding at Compile Time (Cont.)
Absolute Addresses (Physical Memory Addresses)
1024
JUMP 1424
LOAD 2224
1424
2224
Process Image (Part)
Load

14. 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

15. Binding at Loader Time Symbolic Addresses Source Code
PROGRAM
JUMP i
LOAD j
DATA i j
Source Code
Relative (Relocatable)
Addresses
JUMP 400
LOAD 1200
400
1200
Relative Load Module
Compile
Link

16. Binding at Loader Time (Cont.)
Absolute Addresses (Physical Memory Addresses)
1024
JUMP 1424
LOAD 2224
1424
2224
Process Image (Part)
Load
The CPU generates the absolute addresses

17. 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
JUMP 400
LOAD 1200
400
1200
MAX
=2000

18. Dynamic Relocation Using a Relocation Register
14000 to MAX
Seen By Memory Unit
Generated By CPU
0 to MAX
Binding at execution time (when reference is made)
Map LA to PA

19. 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

20. 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

21. Static Linking and Loading
Printf.c
Printf.o
Static
Library
gcc ar
Linker
Memory
HelloWorld.c
HelloWorld.o
Loader
a.out (or name of your command)
Unix: linker is inside gcc command
Loader is part of exec system call

22. 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
Unix: linker is inside gcc command
Loader is part of exec system call

23. 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

24. Memory Management Techniques
No OS Support: User-Managed Overlays
Fixed Partitioning
Dynamic Partitioning
Simple Paging
Simple Segmentation
Virtual Memory Paging
Virtual Memory Segmentation

25. 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

26. Overlay (Cont.) Pass 1 70K Pass 2 80K Sym. Table 20K Common Rou. 30K
Assembler
Total Memory Available = 150K

27. 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)

28. 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

29. Fixed Partitioning

30. Placement Algorithm Equal-size Unequal-size Placement it trivial
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

31. Fixed Partitioning

32. Fixed Partitioning

33. 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

34. Dynamic Partitioning Partitions are of variable length and number
Process is allocated exactly as much memory as required

35. Dynamic Partitioning

36. Dynamic Partitioning

37. 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

38. Dynamic Partitioning
Must use compaction to shift processes so they are contiguous and all free memory is in one block

39. 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

40. 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

41. 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

42. Allocation

43. 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

44. Example of Buddy System

45. 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)

46. Relocation
Compaction will also cause a program to occupy a different partition which means different absolute memory locations

47. Relocation Bounds register
Base register
Bounds register
These values are set when the process is loaded or when the process is swapped in
Base register
Starting address for the process
Bounds register
Ending location of the process
These values are set when the process is loaded or when the process is swapped in
The value of the base register is added to a relative address to produce an absolute address
The resulting address is compared with the value in the bounds register
If the address is not within bounds, an interrupt is generated to the operating system

48. 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

49. 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

50. Process and Frames

51. Process and Frames

52. Page Table

53. Logical Addresses

54. Paging

55. Comparison
What are the advantages of paging mechanism vs. fixed partitioning and dynamic partitioning mechanisms?

56. 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

57. Logical Addresses

58. Segmentation

59. Comparison
What are the advantages of the segmentation mechanism vs. the dynamic partitioning mechanism?

60. In-Class Exercise
Prob 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.

61. Appendix

62. 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

63. 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

64. 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

65. 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

66. 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