Transcript Chapter 7 Notes

Memory management
Instruction execution cycle
•
•
•
•
•
Fetch instruction from main memory
Decode instruction
Fetch operands (if needed0
Execute instruction
Store result in memory if needed
• At least one memory access per instruction!
Process of compiling, linking and
loading
• Compiling: Take program high level
language and convert into object programs
• Linker: Take several object programs,
resolve external references and perform
relocation; result: load module
• Loader: loads load module in memory
Kinds of addresses
• Source program
• Symbolic addresses
• Object module
• Relocatable addresses
• Running program
• Absolute address
I. Simple memory allocation
• Only 1 user.
• Partition into two parts--OS part and user
part
• Have bounds register (has smallest
permitted address for user program)
• OS can access entire memory; user can
access only user part (except through some
trap instructions)
II. Static partitioned allocation
• Memory is divided into a fixed number of
user partitions (plus an OS partition).
• Number and size of individual partitions do
not change.
• Managing storage
• Allocation/De-allocation
Managing storage
• Maintain a table
• Location, size and status (in use or free)
• Deallocation: Set status to free
– Executed when a process terminates and its
memory is to be freed
Allocation
• Search for the partition that is free and is
big enough for the program that needs it.
• Two searching schemes
– First-fit: Search table equentially for the first
free partition of sufficient size
– Best-search: Search for the smallest free
partition of sufficient size
Dynamic partitioned allocation
• Number of size of partitions will vary with
time.
• Initially, one big free partition.
• Issues:
– Managing memory
– Deallocate
– Allocate
Managing memory
• Maintain a linked list of free space.
• Update the list when doing deallocation or
allocation
Deallocation
• Insert the partition into the free list.
• Merge with adjacent free partition(s) if
possible.
Allocation
• First fit allocation
– Search list and find the first free partition that is
sufficiently large for the requested process
• Best fit allocation algorithm
– Find the smallest free partition that is sifficient
• Worst fit
– Find the largest free partition (not good in
practice)
External fragmentation
• Free memory is partitioned into large
number of small spaces; cannot allocate to a
process that needs it.
• In terms of the extent of external
fragmentation, there is no clear choice
between first fit and best fit; There are
instances when one is better than the other
Compaction
• Move free memory together to make one
large free partition
• Moving programs is expensive (moving
time is proportional to program size)
• Determining the optimal way to move
programs: NP-hard problem
Segmentation
• Break the program into modules (based on
how the program is written; use compiler
help).
• Allocate each module separately.
• Fragmentation problem is smaller since we
do not have large program sizes
Dynamic address translation in
segmentation
• Each address is of the form (s,o) where s is
the segment number and o is the offset.
• At run time, find the beginning absolute
address of segment s, check that offset o is
less than or equal to segment size and
– absolute address = starting address+o
Dynamic address translation
• Use the segment table
– if there are n segments (modules) for a
program, the table has n rows
– Each row has two components: size and starting
address of that segment in main memory