1. Part IV: Memory Management
Operating Systems
Part IV: Memory Management

2. Main Memory Large array of words or bytes each having its own address
Several processes must be kept in main memory to improve utilization and system response: memory sharing
Memory management algorithms vary from simple approach to paging and segmentation strategies

3. Memory Basics Types of memory addresses
Symbolic (e.g. program variables)
Relocatable (e.g. offset + 100)
Absolute (e.g. 255)
Address binding: Which data goes where. May be determined in any of the following phases
Compile time: compiler generates absolute code for execution in a fixed address
Load time: compiler generates relocatable code, link- loader computes relocation addresses during link time
Execution time: allows executing processes to move, by simply changing values of segment registers.

4. Logical & Physical Addresses
Logical or virtual address – address generated by the CPU.
Physical address – address loaded into the memory-address register of RAM
Compile-time and load-time binding generate identical logical and physical addresses
Execution-time binding generate differing logical and physical addresses
Memory management unit – maps virtual to physical addresses during runtime.

5. Improving Memory Utilization
Dynamic loading
Subroutines are stored on disk in relocatable format, and are not loaded until called
Dynamic linking
Linking to subroutine libraries postponed until run-time; stub used as pointer to routine in a shared DLL.
Conserves disk space – a single copy of library is shared by all executing processes. Versioning issue.
Overlays
Keeps only needed instructions in memory
Other instructions overwrite previously occupied address when needed. May be implemented by programmer.

6. Swapping Used if memory is no longer sufficient
The roll out (swap out to disk) and roll in (swap to MM) drastically increases time for context switch

7. Swapping
Needs a fast backing store (secondary memory) for efficient implementation
Waiting processes are good candidates to be swapped out to disk
Processes waiting on I/O should not be swapped out, since the I/O could be into their address space, or I/O should be done into OS buffers only.

8. Swapping
Modified version of swapping used in Unix. Swapping normally disabled. Enabled when memory runs out due to many running processes.In Linux, only R/W data segment needs to be swapped out, R/O code segment are just overwritten, since it can be reread from disk.
Microsoft Windows provides partial swapping - if not enough memory for a new program, current program is swapped out to disk. User determines swap rather than scheduler

9. Memory Protection
OS must protect itself from user processes, and must protect user processes from each other.
Each process is assigned a relocation register and a limit register.
Relocation register contains the value of the smallest physical address.
Logical address must be less than the limit register

10. How memory protection works

11. Contiguous Allocation
Type of allocation where each process occupies only a single continuous block in main memory
Simple two-partition scheme
Low memory: usually contains resident O/S since interrupt vectors are here
Rest of memory: for user processes

12. Contiguous Allocation
Multiple-Partition Algorithm
Simplest is multiple fixed partition
Each partition is allocated to a process
Multiprogramming limited to number of partitions
Dynamic partitioning
Starts with one large memory block called a “hole”
Processes arrive and are allocated a block
Holes become available as processes terminate

13. Contiguous Allocation
Multiple-Partition Algorithm
Dynamic Partitioning (cont’d) OS OS OS OS
process 5
process 5
process 5
process 5
process 9
process 9
process 8
process 10
process 2
process 2
process 2
process 2

14. Contiguous Allocation
Dynamic storage allocation problem
looking for freed memory for waiting processes
set of holes searched to see w/c one to allocate
first-fit - allocate first hole big enough for process (search may start from beginning or end)
best-fit - allocate smallest hole that is big enough
worst-fit - allocate largest hole -> produces largest leftover (sometimes useful than smaller ones)
first/best better in time/storage utilization, respectively
first-fit is generally faster

15. Contiguous Allocation
Fragmentation
External
Enough memory exists but not contiguous
50% rule - given N allocated blocks, the next 0.5N blocks will be lost due to fragmentation (1/3 is unusable) when first-fit is used.
Internal
Allocate memory in fixed-sized units, say 4k blocks. Memory actually allocated to a process may be slightly larger than requested memory. The difference is internal fragmentation.

16. Contiguous Allocation
Compaction
A solution to external fragmentation – shuffle memory contents to place all free memory together in one large block.
Not always possible if relocatable addressing at execution time is not supported
Algorithm 1: move processes to one end (expensive if many processes are moved)
Algorithm 2: create big hole in the middle
Swapping may be combined w/ compaction
processes rolled out to backing store then back in
compaction not possible w/ disk due to slow access

17. Paging
Allows non-contiguous allocation -> solves external fragmentation
Logical memory
Fixed sized blocks called pages
Physical memory
Fixed-sized blocks called frames
Page table converts pages to frames, using address translation hardware
page# + offset -> frame# + offset, using page table
Backing store (swap partition in Linux)
same structure as logical memory

18. Paging Examples

19. Internal Fragmentation in Paging
External fragmentation is eliminated but internal fragmentation is not since processes rarely take up all the memory space allocated to them
Worst case:
Process needs (n pages + 1 byte)
Wasted space of (page size bytes – 1 byte)

20. Page Table Structure
Each O/S has own method for storing page tables -> most allocate a page table per process
Context-switch time increases with paging due to need to store page tables in PCB of each process
Each page table entry might include access type as r/o (constant data), r/w (variable data), or x/o (code), to implement a further level of memory protection
Page table structure: linear, multilevel hierarchical, hashed, inverted.

21. Shared Pages Shared read-only/execute-only code
When several instances of a single program are running, only one copy of the program code is stored in memory, but each instance has its own program data. Code must be reentrant.
Possibility of sharing common code is another advantage of paging
Similar to sharing of address space of a task by threads.

22. Shared Pages: An Example

23. Segmentation Scheme divides logical memory into segments
More intuitive view of memory from user’s point of view (e.g. program divided into segments -- subroutines, procedures, data -- that have different length)

24. Logical View of Segmentation1 4 2 3 1 2 3 4
user space
physical memory space

25. Segmentation Hardware
Logical (2-dimensional) vs. physical (1- dimensional) -> mapping effected through a segment table
Entry consists of segment base (=starting address in physical memory) and limit (= length of segment)
Similar to concept of pages except segments do not have fixed length
Intel 80x86 is based on segmentation

26. Mapping Segments to Physical Memory

27. Segments and Fragmentation
Segmentation may cause external fragmentation
Happens when all free blocks are too small to accommodate a segment
Compaction may be used to solve the problem
Process may wait if segment cannot be found

28. Segmentation with Paging
Solves the external fragmentation problem of pure segmentation
Each segment is composed of several equal-sized pages