CS414 Review Session

1
CS414 Review Session
2
Address Translation
3
Example

• Logical Address 32 bits
• Number of segments per process 8
• Page size 2 KB
• Page table entry size 2B
• Physical Memory 32MB
• Paged Segmentation
• 2 level paging

4
Logical Address Space

• Total Number of bits 32
• Page Offset 11 bits (2KB 211B)
• Segment Number 3 bits (8 23)
• Number of pages per segment 218 (32-3-1116)
• Number of page table entries in one page of page
  table 1K (2KB/2B)
• Page number in inner page table 10 bits (1K
  210)
• Page number in outer page table 8 bits (18-10)

5
Segment Table

• Number of entries 8
• Width of each entry (sum of)
• Base Address of outer page table 14 bits
• Number of page frames 16K (32MB/2KB)
• Length of Segment 29 bits (32 3)
• Miscellaneous items

6
Page Table

• Outer Page Table
• Number of entries 28
• Width of entry (sum of)
• Page frame number of inner page table 14 bits
• Miscellaneous bits (total 2B specified)
• Inner Page Table
• Number of entries 210
• Width same as outer page table

7
Translation Look-aside Buffer

• Just an Associative Cache
• Number of entries (pre fixed size)
• Width of each entry (sum of)
• Key segmentpage 3 18 21 bits
• Some TLBs may also use process IDs
• Value page frame 14 bits

8
The Page Size Issue

• With a very small page size, each page matches
  the code that is actually used ? page faults are
  low
• Increased page size causes each page to contain
  code that is not used ? Fewer pages in memory ?
  Page faults rise. (Thrashing)
• Small pages ? large page tables ? costly
  translation
• 2KB to 8KB

9
Load Control

• Determines the number of processes that will be
  resident in main memory (i.e. multiprogramming
  level)
• Too few processes often all processes will be
  blocked and the processor will be idle
• Too many processes the resident size of each
  process will be too small and flurries of page
  faults will result thrashing

10
Handling Interrupts and Traps

• Terminate current instruction (instructions)
• Pipeline flush.
• Save state
• Registers, PC, may need to repeat instructions.
• Invoke Interrupt Handling Routine
• Interrupt vector table
• User space to Kernel space context switch
• Execute the interrupt handling routine
• Invoke the scheduler to schedule a ready process.
• Kernel space to user space context switch

11
Disk Optimizations

• Seek Time (biggest overhead)
• Disk Scheduling Algorithms
• SSTF, SCAN, C-SCAN, LOOK, C-LOOK
• Contiguous file allocation
• Place contiguous block on same cylinder
• Same track, if not same numbered track on another
  disk.
• Organ Pipe Distribution
• Place most used blocks (I-nodes, directory
  structure) closer to the middle of the disk.
• Place the head in the middle of the disk
• Use multiple heads.

12
Disk Optimizations

• Rotational Latency (next biggest)
• Interleaving
• Adjacent sectors are actually not adjacent on the
  disk.
• Disk Cache
• Cache all sectors on the track. (2 rotations)

6
3
2
5
7
1
4
13
Redundant Array of Inexpensive Disks

• Mirroring or Shadowing
• Expensive, small gain in read time, reliable
• Striping
• Inexpensive, faster access time, not reliable
• Striping Parity
• Inexpensive, small performance gain, reliable
• Interleaving Parity Striping
• Inexpensive, faster access time, reliable

14
Storage Hierarchy
B
Register
nsec
Level 1 Cache
KB
100 nsec
Level 2 Cache
500 KB
usec
100 MB
Main Memory
msec
10-1000 usec
GB
Hard Disk
??
Network
sec
Tertiary Storage
TB
15
Paging vs Segmentation

• Fixed size partitions
• Internal Fragmentation (averagepage size/2)
• No External Fragmentation.
• Small chunk of memory. ( 4 KB)
• Linear address space, invisible to programmer.

• Variable size partition
• No Internal Fragmentation
• External Fragmentation (compaction, page segs)
• Large chunk of memory. ( 1 MB)
• Logical address space, visible to programmer.

16
Demand-paging vs Pre-paging

• Pages swapped in on demand.
• More page faults (especially initially).
• No wastage of page frames.
• No such overhead.

• Pages swapped in before use in anticipation.
• Reduce future page faults.
• Pages may not be used (wastage of memory space).
• Good strategies to pre-page. (working set,
  contiguous pages, etc)

17
Local vs Global Page Replacement.

• Only swap out current process pages.
• Page frame allocation strategies required. (page
  fault frequency)
• Thrashing affects only current process.
• Admission control required.
• Can use different page replacement algorithms for
  each process.

• Swap out any page in memory.
• No explicit allocation of page frames.
• Can affect performance of other processes.
• Admission control required.
• Single page replacement algorithm.

18
Interrupt driven IO vs Polling

• Each interrupt has a fixed processing time
  overhead (context switches).
• Other processes can execute while waiting for
  response.
• Good for long and indefinite response time.
• Ex Printer

• The response time on polling is variable. (device
  and request specific)
• No other process can execute while waiting for
  response.
• Good for short and predictable response time (lt
  fixed interrupt overhead).
• Ex Fast Networks

19
Contiguous vs Indexed Allocation

• All blocks of the file in contiguous disk
  locations.
• No additional index overhead. (Disk addresses can
  be computed)
• Disk fragmentation is a major problem.
  (compaction overhead)
• Smart allocation strategies required.
• Low average latency for sequential access. (only
  one long seek, smart block layouts)

• Blocks of the file randomly distributed
  throughout the disk.
• Each access involves a search in the index.
  (Involves fetching additional blocks from the
  disk)
• No Fragmentation on the disk.
• No allocation strategies required.
• High average latency (disk scheduling algorithms)

20
Contiguous vs Linked Allocation

• All blocks are in contiguous disk addresses.
• Disk addresses can be computed for each access.
• Suffers from fragmentation of disk.
• Bad sectors affect contiguity of blocks.

• Blocks are arranged in a link list fashion.
• Each access involves browsing the entire list.
• No disk fragmentation.
• All bad blocks can be hidden away as a file.

21
Hard Disks vs Tapes

• Small capacity (few GB)
• Subject to various failures (disk crashes, bad
  sectors, etc)
• Random access latency is very small (msec)

• Huge capacity per unit volume (TB)
• Permanent storage (no corruption for long time.)
• Very high random access latency (sec) (need to
  read the tape from the beginning)

22
Unix FS vs Log FS

• Index used to map I-nodes to physical blocks.
• Same read latency as indexed allocation.
• Writes take place on the same block where data is
  read from.
• Write latency equals is dominated by seek time.
• No garbage collection required.
• Crash recovery is extremely difficult.

• Index used to map I-nodes to physical blocks.
• Same read latency as UNIX FS
• Writes are bunched together and done on
  sequential blocks.
• Write latency is small because of amortized seek
  time.
• Garbage collection required to free old blocks.
• Checkpoints enable efficient recovery from
  crashes.

23
Routing Strategies

• Virtual Circuit
• Per session path between A and B
• Some attempt to uniform congestion.
• Per session set-up cost.
• Sequential delivery.

• Dynamic
• Different path per message between A and B
• Uniform congestion across paths.
• Per message set-up cost.
• Out of order delivery.

• Fixed
• Permanent path between A and B
• Congestion independent of paths.
• No set-up costs.
• Sequential delivery.

24
Connection Strategies

• Message Switch
• Per message link between A and B
• Some attempt to uniform congestion.
• Initial set-up cost.
• Sequential delivery.

• Packet Switch
• Different link per packet between A and B
• Uniform congestion across links. (best link)
• No set-up cost.
• Out of order delivery.

• Circuit Switch
• Permanent link between A and B
• (hardware)
• Congestion independent of paths.
• No set-up costs.
• Sequential delivery.