================ Start Lecture #14 ================
Moving the entire processes between disk and memory is called
Multiprogramming with Variable Partitions
Both the number and size of the partitions change with time.
IBM OS/MVT (multiprogramming with a varying number of tasks).
Also early PDP-10 OS.
Job still has only one segment (as with MFT). That is, the
virtual address is contiguous.
The physical address is also contiguous, that is, the process is
stored as one piece in memory.
The job can be of any
size up to the size of the machine and the job size can change
A single ready list.
A job can move (might be swapped back in a different place).
This is dynamic address translation (during run time).
Must perform an addition on every memory reference (i.e. on every
address translation) to add the start address of the partition.
Called a DAT (dynamic address translation) box by IBM.
Eliminates internal fragmentation.
Find a region the exact right size (leave a hole for the
Not quite true, can't get a piece with 10A755 bytes. Would
get say 10A760. But internal fragmentation is much
reduced compared to MFT. Indeed, we say that internal
fragmentation has been eliminated.
Introduces external fragmentation, i.e., holes
outside any region.
What do you do if no hole is big enough for the request?
- Can compactify
Transition from bar 3 to bar 4 in diagram below.
This is expensive.
Not suitable for real time (MIT ping pong).
- Can swap out one process to bring in another, e.g., bars 5-6
and 6-7 in the diagram.
- There are more processes than holes. Why?
Because next to a process there might be a process or a hole
but next to a hole there must be a process
So can have “runs” of processes but not of holes
If after a process one is equally likely to have a process or
a hole, you get about twice as many processes as holes.
- Base and limit registers are used.
Storage keys not good since compactifying or moving would require
changing many keys.
Storage keys might need a fine granularity to permit the
boundaries to move by small amounts (to reduce internal
fragmentation). Hence many keys would need to be changed.
MVT Introduces the “Placement Question”
That is, which hole (partition) should one choose?
- Best fit, worst fit, first fit, circular first fit, quick fit, Buddy
Best fit doesn't waste big holes, but does leave slivers and
is expensive to run.
Worst fit avoids slivers, but eliminates all big holes so a
big job will require compaction. Even more expensive than best
fit (best fit stops if it finds a perfect fit).
Quick fit keeps lists of some common sizes (but has other
problems, see Tanenbaum).
Round request to next highest power of two (causes
Look in list of blocks this size (as with quick fit).
If list empty, go higher and split into buddies.
When returning coalesce with buddy.
Do splitting and coalescing recursively, i.e. keep
coalescing until can't and keep splitting until successful.
See Tanenbaum for more details (or an algorithms book).
- A current favorite is circular first fit, also known as next fit.
Use the first hole that is big enough (first fit) but start
looking where you left off last time.
Doesn't waste time constantly trying to use small holes that
have failed before, but does tend to use many of the big holes,
which can be a problem.
- Buddy comes with its own implementation. How about the others?
4.2.1: Memory Management with Bitmaps
Divide memory into blocks and associate a bit with each block, used
to indicate if the corresponding block is free or allocated. To find
a chunk of size N blocks need to find N consecutive bits
indicating a free block.
The only design question is how much memory does one bit represent.
- Big: Serious internal fragmentation.
- Small: Many bits to store and process.