1. Chapter 8 Main Memory

2. Announcement Reading assignment:
Finish reading Chapter by next Monday

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

4. Process Execution
Where is a process located when it is executed on a CPU?
In a multiprogramming environment, there are often more than one user processes in the main memory

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

6. Memory Management Requirements
Protection
Processes should not be able to reference memory locations in another process without permission
Sharing
Allow several processes to access the same portion of memory
E.g., if several processes are executing the same program, better to allow each process access to the same copy of the program rather than have their own separate copy

7. Memory Management Requirements
Relocation
Programmer often 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 in the code must be translated to actual physical memory address

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

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

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

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

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

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

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

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

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

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

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

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

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

21. 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
In compile-time and load-time address-binding schemes, logical and physical addresses are the same
In execution-time address-binding scheme, logical and physical addresses differ

22. Memory-Management Unit (MMU)
Hardware device that maps virtual to physical address
In the simple 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

23. Memory Management Techniques
Fixed Partitioning
Dynamic Partitioning
Simple Paging
Simple Segmentation
Virtual Memory Paging
Virtual Memory Segmentation

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

25. Fixed Partitioning Equal-size partitions
A program may not fit in a partition.
Main memory use is inefficient. Any program, no matter how small, occupies an entire partition
This is called internal fragmentation

26. Dynamic Partitioning Partitions are of variable length and number
Process is allocated exactly as much memory as required, no internal fragmentation

27. Dynamic Partitioning

28. Dynamic Partitioning
Eventually get holes in the memory. This is called external fragmentation

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

30. 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
Since the smallest block is found for process, the fragmentation of the smallest size is left
Memory compaction must be done more often
Algorithm speed? Fast or Slow?

31. Dynamic Partitioning Worst-fit algorithm First-fit algorithm
Chooses the block that is largest in size
First-fit algorithm
Scans memory form the beginning and chooses the first available block that is large enough
Fast
Next-fit algorithm
Scans memory from the location of the last placement and chooses the first available block that is large enough

32. Contiguous vs. Non-contiguous Memory Allocation
The memory management techniques discussed so far all require the physical address space of a process to be contiguous
Paging and Segmentation permit the physical address space of a process to be non-contiguous

33. 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
The chunks of memory are called frames

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

35. Process and Frames

36. Process and Frames

37. Page Table

38. Logical Addresses

39. Paging

40. Comparison
What is the advantage of the paging mechanism vs. the fixed partitioning mechanism?
Paging leads to smaller internal fragmentations
Paging permits the physical address space of a process to be non-contiguous
What is the advantage of the paging mechanism vs. the dynamic partitioning mechanisms?
Paging has no external fragmentation

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

42. In-Class Exercise
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? (26)
B. how many bytes in a frame? (210)
C. how many bits in the physical address specify the frame? (22)
D. how many entries in the page table? (216)
E. how many bits in each page table entry? Assume each page table entry contains a valid/invalid bit. (23)

43. Memory Management Techniques
Fixed Partitioning
Dynamic Partitioning
Simple Paging
Simple Segmentation
Virtual Memory Paging
Virtual Memory Segmentation

44. Segmentation
All segments of all programs do not have to be of the same length
There is a maximum segment length
Addressing consists of two parts - a segment number and an offset
Since segments are not equal, segmentation is similar to dynamic partitioning

45. Logical Addresses

46. Segmentation

47. Comparison
What is the advantage of the segmentation mechanism vs. the dynamic partitioning mechanism?
Segmentation permits the physical address space of a process to be non-contiguous

48. Appedix

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

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

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

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

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

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