Storage Allocation

Operating System
Hebrew University
Spring 2007

1
 Background
Program must be brought into memory and
placed within a process for it to be run.
Input queue collection of processes on the
disk that are waiting to be brought into
memory to run the program.
User programs go through several steps before
being run.

2
 Binding of Instructions and
Data to Memory
Address binding of instructions and data to
memory addresses can happen at three
different stages:

Compile time
Load time
Execution time

3
 Binding of Instructions and
Data to Memory
Compile time: If memory location known in advance,
absolute code can be generated;
Must recompile code if starting location changes.
Load time: Must generate relocatable code if memory
location is not known at compile time.
Execution time: Binding delayed until run time if the
process can be moved during its execution from one
memory segment to another. Need hardware support
for address maps (e.g., base and limit registers).

4
Multi-step Processing of a
User Program

5
 Division of Responsibility
Compiler: generates one object file for each source code
file containing information for that file. Information is
incomplete, since each source file generally uses some
things defined in other source files.
Linker/Loader: combines all of the object files for one
program into a single object file, which is complete and
self-sufficient.
Operating system: loads object files into memory,
allows several different processes to share memory at
once, provides facilities for processes to get more
memory after they have started running.
Run-time library: provides dynamic allocation routines,
such as malloc and free in C. 6
 Logical v. Physical Address Space
The concept of a logical address space that is
bound to a separate 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 and load time; logical (virtual) and
physical addresses differ in execution time.
7
 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 at the time it is sent to memory.
The user program deals with logical addresses;
it never sees the real physical addresses.

8
Dynamic Relocation using a
Relocation Register

9
 Contiguous Allocation
Single partition allocation (one process)
Relocation register scheme used to protect user
processes from each other, and from changing
operating system code and data.
Relocation register contains value of smallest
physical address;
Limit register contains range of logical
addresses each logical address must be less
than the limit register.
10
Hardware for Relocation
and Limit Registers

11
Hardware for Relocation
and Limit Registers

12
 Contiguous Allocation
Multiple partition allocation (multiple processes)
Hole block of available memory; holes of
various size are scattered throughout memory.
When a process arrives, it is allocated memory
from a hole large enough to accommodate it.
Operating system maintains information about:
a) allocated partitions
b) free partitions (hole)
13
Contiguous Allocation

14
 Dynamic Storage Allocation
Problem
Algorithms differ in how they manage the free holes:
Best fit: search the whole list on each allocation,
choose hole that comes closest to matching the needs
of the allocation, save the excess for later. During
release operations, merge adjacent free blocks.
First fit: scan for the first hole that is large enough.
Also merge on releases.
Worse fit: select the largest block, produces the
largest leftover hole.

15
 So Which One?
All could leave many small and useless holes.
Assuming 1K blocks:
Best-Fit sometimes performs better: Assume holes of
20K and 15K, requests for 12K followed by 16K can
be satisfied only by best-fit.
But First-Fit can also perform better: Assume holes of
20K and 15K, requests for 12K, followed by 14K,
and 7K, can be satisfied only by first-fit.
In practice (based on trace-driven simulation)
First-Fit is usually better than Best-Fit
First-Fit and Best-Fit are better than Worst Fit
16
 Fragmentation
External Fragmentation total memory space
exists to satisfy a request, but it is not
contiguous.

Internal Fragmentation allocated memory

may be slightly larger than requested memory;
this size difference is memory internal to a
partition, but not being used.

17
 Fragmentation
Reduce external fragmentation by compaction
Shuffle memory contents to place all free memory
together in one large block.
Compaction is possible only if relocation is
dynamic, and is done at execution time.

18
 Segmentation
Memory management scheme that supports user view
of memory.
A program is a collection of segments. A segment is a
logical unit such as:
main program
procedure,
function,
object,
local variables, global variables,
common block,
stack,
symbol table, arrays
19
User's View of a Program

20
Logical View of Segmentation

21
 Segmentation Architecture
Logical address consists of a two-tople:
<segment-number, offset>
Segment table maps two dimensional
physical addresses; each table entry has:
base contains the starting physical address where
the segments reside in memory.
limit specifies the length of the segment.

22
 Segmentation Architecture
Segment table base register (STBR) - points to
the segment tables location in memory.
Segment table length register (STLR) -
indicates number of segments used by a
program;
Segment number s is legal if s < STLR.

23
 Segmentation Architecture
Relocation.
dynamic
by segment table
Sharing
shared segments
same segment number
Allocation
first fit/best fit
external fragmentation
24
 Protection
Protection. With each entry in segment table
associate:
validation bit = 0 illegal segment
read/write/execute privileges
Protection bits associated with segments; code
sharing occurs at segment level.
Since segments vary in length, memory
allocation is a dynamic storage allocation
problem.
25
Segmentation Hardware

26
Segmentation Example

27
 The User Program
Information stored in memory is used in many
different ways. Some possible classifications are:
Role in Programming Language:
Instructions (operations and the operands in the operations).
Variables (change as the program runs: locals, globals,
parameters, dynamic storage).
Constants (used as operands, but that never changes: pi for
example).
Changeability:
Read-only: (code, constants).
Read & write: (variables).
28
 Variables and Locations
Can we allocate all the required memory to our
program in advanced (compilation time)?
It is in general impossible to know at compile time how
many variables are going to be created at run time
recursive procedures containing local variables
dynamic variables
We cannot solve all the allocations at compile time.
Do we want to allocate the required memory in
advanced?
We want to be efficient in the management of the memory:
We only want to allocate storage for a variable when
needed, and we want to de-allocate when possible. 29
 Variable Lifetime
lifetime of a variable - the period of time during
execution in which the variable has storage
allocated for it.
Global variables: Lifetime is entire runtime of
program.
Local variables (variables declared in a procedure):
Lifetime is during activation of procedure.
User-allocated variables (aka dynamic variables -
variables created with new/malloc and destroyed
with delete/free): Lifetime is from user allocation to
user de-allocation
30
 Storage Allocation Policies
We have the following storage allocation
policies:
Static Allocation
Dynamic Allocation of local variables
Dynamic Allocation of user-allocated variables

31
 Static Allocation (for globals only)
Done at compile time
Lifetime = entire runtime of program

Advantage: efficient execution time

32
 Dynamic Allocation of local
variables
Done at run time
Lifetimes = duration of procedure activation

Advantage: efficient storage use

Two Methods:
Stack Allocation (all variables allocated within the
procedure scope)
Heap Allocation (unless declared 'static')

33
Dynamic Allocation of user-allocated
variables
Done at run time
Lifetimes = until the user deletes it (or until it
is garbage-collected)

Advantage: permits creation of dynamic

structures, like lists, trees, etc.

Heap Allocation
34
 Memory Management
The memory of the machine is divided into
three parts:
A space for the globals and the code of the program
The stack, for the locals
The heap, for the dynamic variables
The division between 1 and 2 is only logical:
physically the locals and the code are (usually)
placed at the base of the stack.

35
The Segments

36
 Managing the Information
One of the steps in creating a process is to load
its information into main memory, creating the
necessary segments.
Information comes from a file that gives the
size and contents of each segment.
The file is called an object file.

37
 Dynamic Memory Allocation
Q. Why is not static allocation sufficient for
everything?
A. Unpredictability: cannot predict ahead of time how
much memory, or in what form, will be needed:
Recursive procedures.
OS does not know how many jobs there will be or which
programs will be run.
Complex data structures, e.g. linker symbol table. If all
storage must be reserved in advance (statically), then it will
be used inefficiently (enough will be reserved to handle the
worst possible case).
38
Dynamic Memory Allocation Cont.
Dynamic allocation can be handled in one of
two general ways:
Stack allocation (hierarchical): restricted, but
simple and efficient.
Heap allocation: more general, but less efficient,
more difficult to implement.

39
 Stack-Based Allocation
Memory allocation and freeing are partially
predictable (as usual, we do better when we
can predict the future).
Allocation is hierarchical: memory is freed in
opposite order from allocation.
If alloc(A) then alloc(B) then alloc(C), then it
must be free(C) then free(B) then free(A).

40
 Example
Procedure call:
Program calls Y, which calls X. Each call pushes
another stack frame on top of the stack. Each stack
frame has space for variable, parameters, and
return addresses.
Stacks are also useful for lots of other things:
tree traversal, top-down recursive descent
parsers, etc.

41
 Stack-Based Organization
A stack-based organization keeps all the free space
together in one place.

42
 Handling the Stack
Let us consider the various operations that take place when a
procedure is called:
1. Caller processes actual parameters (evaluation, address
calculation) and stores them
2. Caller stores some control information (e.g., return address)
3. Control transferred from Caller to Callee
4. Callee allocates storage for locals
5. Callee executes
6. Callee deallocates storage for locals
7. Callee stores return value (if there is any)
8. Control transferred back to Caller
9. Caller deallocates storage used for control information and
actual parameters 43
 Heap-based Allocation
Allocation and release are unpredictable.
Heaps are used for arbitrary list structures,
complex data organizations.
Example: payroll system. Do not know when
employees will join and leave the company,
must be able to keep track of all them using the
least possible amount of storage.

44
 Heap-based Organization

Inevitably end up with lots of holes.

Goal: reuse the space in holes to keep the number of holes
small, their size large.
Fragmentation: inefficient use of memory due to
holes that are too small to be useful. In stack
allocation, all the holes are together in one big chunk.45
 The Free List
Typically, heap allocation schemes use a free list to
keep track of the storage that is not in use.
Algorithms differ in how they manage the free list:
Best fit: keep linked list of free blocks, search the
whole list on each allocation, choose block that
comes closest to matching the needs of the allocation,
save the excess for later. During release operations,
merge adjacent free blocks.
First fit: just scan list for the first hole that is large
enough. Also merge on releases.
46
 Bit Map Allocation
Used for allocation of storage that comes in fixed-
size chunks (e.g. disk blocks, or 32-byte chunks).
Keep a large array of bits, one for each chunk. If bit
is 0 it means chunk is in use, if bit is 1 it means
chunk is free.

47
 Reclamation Methods
how do we know when memory can be freed?
It is easy when a chunk is only used in one
place.
Reclamation is hard when information is
shared: it cannot be recycled until all of the
sharers are finished.
Sharing is indicated by the presence of
pointers to the data. Without a pointer, cannot
access (cannot find it).
48
 Problems in reclamation
There are two problems:
Dangling pointers: better not recycle storage while
it is still being used.
Core leaks: Better not "lose" storage by forgetting
to free it even when it cannot ever be used again.

49
 Reference Counts
keep track of the number of outstanding
pointers to each chunk of memory.
When this goes to zero, free the memory.
Example: file descriptors in Unix. Works fine
for hierarchical structures. The reference
counts must be managed automatically (by the
system) so no mistakes are made in
incrementing and decrementing them.

50
Example

51
 Garbage Collection
Storage is not freed explicitly (using free
operation), but rather implicitly: just delete
pointers.
When the system needs storage, it searches
through all of the pointers (must be able to find
them all!) and collects things that are not used.
Makes life easier on the application
programmer, but garbage collectors are
incredibly difficult to program and debug.
52
How does garbage collection work?
Must be able to find all objects.
Must be able to find all pointers to objects.
Pass 1: mark. Go through all pointers that are
known to be in use. Mark each object pointed
to, and recursively mark all objects it points to.
Pass 2: sweep. Go through all objects, free up
those that are not marked.

53
Garbage Collection

54