From Monoprogramming to multiprogramming with swapping Memory Management From Monoprogramming to multiprogramming with swapping

Memory Hierarchy Small amount of expensive, fast, volatile cache Larger amount of still fast, but slower, volatile ram Vast amount of inexpensive, not volatile, but slow secondary storage

Memory Manager Keeps track of which parts of memory are in use Allocate memory to processes when needed Deallocate memory when processes complete

Monoprogramming Memory is divided between o/s, process, device drivers o/s signals user when process is finished. Waits for command to load another Two drawbacks: A single process can run. Time wasted waiting on i/o Processes (include o/s) are exposed to malicious or badly written code

monoprogramming a) Pre-1960 mainframes b) Embedded systems c) Early PCs

Multiprogramming Run process A when process B is waiting Degree of multiprogramming Processes spend up to 80% of time waiting for i/o Suppose process spends fraction, t, waiting for i/o If N processes, probability that all are waiting is tN Then CPU use is 1 - tN N is called degree of multiprogramming

Example Suppose we want 95% CPU use Suppose we want 90% CPU use ln 5 – ln 100 = n * (ln 8 – ln 10) N ~ 13.6

Multiprograming Requires that we rethink Memory 16 kb program runs alone. Finishes os loads new program. Finishes Now suppose os tries to multiprogram. Instead of evicting old program, adds new one above it. jmp 28 causes an error Problem: both programs reference static, physical addresses -

First Things First Multiprogramming requires solution to two problems protection: process 1 may not overwrite process 2 relocation: remap process memory to different parts of physical memory Address Space The set of addresses available to a process Each process has its own address space Key idea: address 28 in process 1 is not the same physical address as address 28 in process 2

Solution to Basic multiprogramming Problem Base and Limit Registers Simple solution to relocation problem. Base register holds the beginning address of the process Limit register holds length of the process jmp 28 jumps base register + 28

Problem Degree of multiprogramming limited by the amount of memory Windows/OS X/Linux 50 – 100 processes may be started up at boot time Two General Solutions Swapping Load each process Run it for a little while Save it to disk Virtual Memory Load only parts of processes

Swapping (Solution 1 to multiprogramming Problem) Memory allocation changes as processes come into memory and leave it. The shaded regions are unused memory

Swapping Issues Problem 1 Swapping creates holes in memory (external fragmentation) Can be relieved through (very expensive) memory compaction Problem 2 Have assumed that programs have a fixed size But many programming languages allow for dynamically allocated memory If free store is adjacent to a process, it can be claimed If not, the growing process will have to be moved to a hole large enough to accommodate it or swapped out and suspended.

Size Issue allocate extra space at load time Distinguish between dynamically allocated heap memory and local stack memory

Keeping Track of Growing/Shrinking Memory with bit maps and Linked Lists A part of memory with five processes and three holes. The tickmarks show the memory allocation units. The shaded regions (0 in the bitmap) are free. The corresponding bitmap Linked list memory management Problems with bit maps Large allocation unit results in holes in the last unit of the process Small allocation unit requires large bitmap Bitmap must be searched at each load to look for the right size space

Is X adjacent to another process? Process Terminates Is X adjacent to another process?

Finding a whole large enough for the process First fit Scan linked list looking for the first whole that is big enough Results in fragmentation Next fit Start search where last search ended to avoid small hole clustering Best fit Scan all of memory looking for the best fit Sounds good, but results in many tiny and useless holes Worst fit OK. Look for the largest available hole. Also produces fragmentation There are other possibilities, including a doubly linked list to make merging easier. Fragmentation is a problem with all possibilites