Operating Systems

1
Operating Systems

• Memory Management
• (Ch 8.1 - 8.6)

2
Overview

• Provide Services (done)
• processes (done)
• files (done after memory)
• Manage Devices
• processor (done)
• memory (next!)
• disk (done after files)

3
Simple Memory Management

• One process in memory, using it all
• each program needs I/O drivers
• until 1960

I/O drivers
User Prog
RAM
4
Simple Memory Management

• Small, protected OS, drivers
• DOS

Device Drivers
OS
ROM
ROM
User Prog
User Prog
RAM
RAM
User Prog
RAM
OS
OS

• Mono-programming -- No multiprocessing!
• - Early efforts used Swapping, but slooooow

5
Multiprocessing w/Fixed Partitions
Simple!
Partion 4
Partion 4
900k
Partion 3
Partion 3
500k
Partion 2
Partion 2
300k
Partion 1
Partion 1
200k
OS
OS
(a)
(b)

• Waste large partition
• Skip small jobs

• Unequal queues

Hey, processes can be in different memory
locations!
6
Address Binding

• Compile Time
• maybe absolute binding (.com)
• Link Time
• dynamic or static libraries
• Load Time
• relocatable code
• Run Time
• relocatable memory segments
• overlays
• paging

Compile
Link
Load
Run
7
Logical vs. Physical Addresses

• Compile-Time Load Time addresses same
• Run time addresses different

Relocation Register
Logical Address
Physical Address
CPU
Memory
14000
346
14346

MMU

• User goes from 0 to max
• Physical goes from R0 to Rmax

8
Relocatable Code Basics

• Allow logical addresses
• Protect other processes

Limit Reg
Reloc Reg
Memory
yes
lt

CPU
physical address
no
error

• Addresses must be contiguous!

9
Design Technique Static vs. Dynamic

• Static solutions
• compute ahead of time
• for predictable situations
• Dynamic solutions
• compute when needed
• for unpredictable situations
• Some situations use dynamic because static too
  restrictive (malloc)
• ex memory allocation, type checking

10
Variable-Sized Partitions

• Idea want to remove wasted memory that is not
  needed in each partition
• Definition
• Hole - a block of available memory
• scattered throughout physical memory
• New process allocated memory from hole large
  enough to fit it

11
Variable-Sized Partitions
OS
OS
OS
OS
process 5
process 5
process 5
process 9
process 9
8 done
9 arrv
10 arrv
process 8
process 10
5 done
process 2
process 2
process 2
process 2

• OS keeps track of
• allocated partitions
• free partitions (holes)
• queues!

12
Variable-Sized Partitions

• Given a list of free holes

• How do you satisfy a request of sizes?
• 20k, 130k, 70k

13
Variable-Sized Partitions

• Requests 20k, 130k, 70k
• First-fit allocate first hole that is big enough
• Best-fit allocate smallest hole that is big
  enough
• Worst-fit allocate largest hole (say, 120k)

14
Variable-Sized Partitions

• First-fit might not search the entire list
• Best-fit must search the entire list
• Worst-fit must search the entire list
• First-fit and Best-ft better than Worst-fit in
  terms of speed and storage utilization

15
Memory Request?

• What if a request for additional memory?

OS
process 3
malloc(20k)?
process 8
process 2
16
Internal Fragmentation

• Have some empty space for each processes

A stack
Room for growth
Allocated to A
A data
A program
OS

• Internal Fragmentation - allocated memory may be
  slightly larger than requested memory and not
  being used.

17
External Fragmentation

• External Fragmentation - total memory space
  exists to satisfy request but it is not contiguous

OS
50k
process 3
?
Process 9
125k
process 8
100k
process 2
18
Analysis of External Fragmentation

• Assume
• system at equilibrium
• process in middle
• if N processes, 1/2 time process, 1/2 hole
• gt 1/2 N holes!
• Fifty-percent rule
• Fundamental
• adjacent holes combined
• adjacent processes not combined

19
Compaction

• Shuffle memory contents to place all free memory
  together in one large block
• Only if relocation dynamic!
• Same I/O DMA problem

(a)
(b)
OS
OS
OS
50k
process 3
process 3
90k
process 8
Process 9
125k
60k
process 8
process 8
100k
process 3
process 2
process 2
process 2
20
Cost of Compaction
process 1
process 1
50k
process 3
process 3
90k
process 8
process 2
process 8
60k
100k
process 2

• 128 MB RAM, 100 nsec/access
• ? 1.5 seconds to compact!
• Disk much slower!

21
Solution?

• Want to minimize external fragmentation
• Large Blocks
• But internal fragmentation!
• Tradeoff
• Sacrifice some internal fragmentation for reduced
  external fragmentation
• Paging

22
Analysis of External Fragmentation

• Assume
• system at equilibrium
• process in middle
• if N processes, 1/2 time process, 1/2 hole
• gt 1/2 N holes!
• Fifty-percent rule
• Fundamental
• adjacent holes combined
• adjacent processes not combined

23
Compaction

• Shuffle memory contents to place all free memory
  together in one large block
• Only if relocation dynamic!
• Same I/O DMA problem

(a)
(b)
OS
OS
OS
50k
process 3
process 3
90k
process 8
Process 9
125k
60k
process 8
process 8
100k
process 3
process 2
process 2
process 2
24
Cost of Compaction
process 1
process 1
50k
process 3
process 3
90k
process 8
process 2
process 8
60k
100k
process 2

• 128 MB RAM, 100 nsec/access
• ? 1.5 seconds to compact!
• Disk much slower!

25
Solution?

• Want to minimize external fragmentation
• Large Blocks
• But internal fragmentation!
• Tradeoff
• Sacrifice some internal fragmentation for reduced
  external fragmentation
• Paging

26
Where Are We?

• Memory Management
• fixed partitions (done)
• linking and loading (done)
• variable partitions (done)
• Paging ?
• Misc

27
Paging

• Logical address space noncontiguous process gets
  memory wherever available
• Divide physical memory into fixed-size blocks
• size is a power of 2, between 512 and 8192 bytes
• called Frames
• Divide logical memory into bocks of same size
• called Pages

28
Paging

• Address generated by CPU divided into
• Page number (p) - index to page table
• page table contains base address of each page in
  physical memory (frame)
• Page offset (d) - offset into page/frame

CPU
p
d
f
d
physical memory
f
page table
29
Paging Example
0

• Page size 4 bytes
• Memory size 32 bytes (8 pages)

1
2
3
0
4
1
5
2
6
3
7
Page Table
Logical Memory
Physical Memory
30
Paging Example
Offset
000
000
Page 0
001
001
0
0
1
0
1
1
010
010
Page
Frame
Page 1
011
011
00
100
100
01
Page 2
101
101
10
110
110
11
Page 3
111
111
Page Table
Physical Memory
Logical Memory
31
Paging Hardware

• address space 2m
• page size 2n
• page offset 2m-n

phsical memory 2m bytes
page number
page offset
p
d
m-n
n

• note not losing any bytes!

32
Paging Example

• Consider
• Physical memory 128 bytes
• Physical address space 8 frames
• How many bits in an address?
• How many bits for page number?
• How many bits for page offset?
• Can a logical address space have only 2 pages?
  How big would the page table be?

33
Page Table Example
b7
0
1
2
3
4
5
6
7
Physical Memory
34
Paging Tradeoffs

• Advantages
• no external fragmentation (no compaction)
• relocation (now pages, before were processes)
• Disadvantages
• internal fragmentation
• consider 2048 byte pages, 72,766 byte proc
• 35 pages 1086 bytes 962 bytes
• avg 1/2 page per process
• small pages!
• overhead
• page table / process (context switch space)
• lookup (especially if page to disk)

35
Another Paging Example

• Consider
• 8 bits in an address
• 3 bits for the frame/page number
• How many bytes (words) of physical memory?
• How many frames are there?
• How many bytes is a page?
• How many bits for page offset?
• If a process page table is 12 bits, how many
  logical pages does it have?

36
Implementation of Page Table

• Page table kept in registers
• Fast!
• Only good when number of frames is small
• Expensive!

Registers
Memory
Disk
37
Implementation of Page Table

• Page table kept in main memory
• Page Table Base Register (PTBR)

0
1
4
1
0
2
1
PTBR
3
Logical Memory
Page Table
Physical Memory

• Page Table Length
• Two memory accesses per data/inst access.
• Solution? Associative Registers

38
Associative Registers
logical address
10-20 mem time
hit
physical address
miss
39
Associative Register Performance

• Hit Ratio - percentage of times that a page
  number is found in associative registers
• Effective access time
• hit ratio x hit time miss ratio x miss time
• hit time reg time mem time
• miss time reg time mem time 2
• Example
• 80 hit ratio, reg time 20 nanosec, mem time
  100 nanosec
• .80 120 .20 220 140 nanoseconds

40
Protection

• Protection bits with each frame
• Store in page table
• Expand to more perms

Protection Bit
0
0
1
1
2
2
3
3
Logical Memory
Page Table
Physical Memory
41
Large Address Spaces

• Typical logical address spaces
• 4 Gbytes gt 232 address bits (4-byte address)
• Typical page size
• 4 Kbytes 212 bits
• Page table may have
• 232 / 212 220 1million entries
• Each entry 3 bytes gt 3MB per process!
• Do not want that all in RAM
• Solution? Page the page table
• Multilevel paging

42
Multilevel Paging
...
Logical Memory
Outer Page Table
Page Table
43
Multilevel Paging Translation
page number
page offset
p1
d
p2
p1
p2
d
outer page table
desired page
inner page table
44
Inverted Page Table

• Page table maps to physical addresses

CPU
pid
d
p
i
d
i
search
Physical Memory
pid
p

• Still need page per process --gt backing store
• Memory accesses longer! (search swap)

45
Memory View

• Paging lost users view of memory
• Need logical memory units that grow and contract

subroutine
ex stack, shared library
main
stack

• Solution?
• Segmentation!

symbol table
46
Segmentation

• Logical address ltsegment, offsetgt
• Segment table - maps two-dimensional user defined
  address into one-dimensional physical address
• base - starting physical location
• limit - length of segment
• Hardware support
• Segment Table Base Register
• Segment Table Length Register

47
Segmentation
logical address
main
limit
base

lt
physical address
stack
yes
no
error
physical memory
(Er, what have we gained?) ? Paged segments!
48
Memory Management Outline

• Basic (done)
• Fixed Partitions (done)
• Variable Partitions (done)
• Paging (done)
• Basic (done)
• Enhanced (done)
• Specific ?
• WinNT
• Linux
• Virtual Memory

49
Memory Management in WinNT

• 32 bit addresses (232 4 GB address space)
• Upper 2GB shared by all processes (kernel mode)
• Lower 2GB private per process
• Page size is 4 KB (212, so offset is 12 bits)
• Multilevel paging (2 levels)
• 10 bits for outer page table (page directory)
• 10 bits for inner page table
• 12 bits for offset

50
Memory Management in WinNT

• Each page-table entry has 32 bits
• only 20 needed for address translation
• 12 bits left-over
• Characteristics
• Access read only, read-write
• States valid, zeroed, free
• Inverted page table
• points to page table entries
• list of free frames

51
Memory Management in Linux

• Page size
• Alpha AXP has 8 Kbyte page
• Intel x86 has 4 Kbyte page
• Multilevel paging (3 levels)
• Makes code more portable
• Even though no hardware support on x86!
• middle-layer defined to be 1

52
Memory Management in Linux

• Buddy-heap
• Buddy-blocks are combined to larger block
• Linked list of free blocks at each size
• If not small enough, broken down

8 KB
8 KB
16 KB
8 KB
4 KB
4 KB
53
Object Module

• Information required to load into memory
• Header Information
• Machine Code
• Initialized Data
• Symbol Table
• Relocation Information
• (see SOS sample)

54
Linking an Object Module

• Combines several object modules into load module
• Resolve external references
• Relocation - each object module assumes starts at
  0. Must change.
• Linking - modify addresses where one object
  refers to another (example - external)

55
Loading an Object

• Resolve references of object module

On Disk
In Memory
Header
Executable Code
Executable Code
Initialized Data
Initialized Data
Uninitialized Data
56
Normal Linking and Loading
Printf.c
Main.c
gcc
gcc
Printf.o
Main.o
Linker
X Window code - 500K minimum - 450K libraries
ar
a.out
Static Library
Loader
Memory
57
Load Time Dynamic Linking
Printf.c
Main.c
gcc
gcc
Printf.o
Main.o

• Save disk space.
• Libraries move?
• Moving code?
• Library versions?
• Load time still the same.

Linker
ar
a.out
Dynamic Library
Loader
Memory
58
Run-Time Dynamic Linking
Printf.c
Main.c
gcc
gcc
Printf.o
Main.o
Linker
Save disk space. Startup fast. Might not need
all.
ar
a.out
Dynamic Library
Loader
Run-time Loader
Memory
59
Memory Linking Performance Comparisons