CS414 Review Session

Address Translation

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

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-11=16)• 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)

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

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

Translation Look-aside Buffer

• Just an Associative Cache

• Number of entries (pre fixed size)

• Width of each entry (sum of)– Key: segment#+page# = 3 + 18 = 21 bits

• Some TLBs may also use process IDs

– Value: page frame# = 14 bits

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

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

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

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.

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)

1

23

4

5

6

7

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

Storage Hierarchy

Register

Level 1 Cache

Level 2 Cache

Main Memory

Hard Disk

Tertiary Storage

Network

nsec

100 nsec

usec

msec

sec

10-1000 usec

B

KB+

500 KB+

100 MB+

GB+

TB

??

Paging vs Segmentation

• Fixed size partitions

• Internal Fragmentation (average=page 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.

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…)

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.

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 (< fixed interrupt overhead).

• Ex: Fast Networks

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)

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.

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)

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.

Routing StrategiesFixed• Permanent path between A and B

• Congestion independent of paths.

• No set-up costs.

• Sequential delivery.

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.

Connection StrategiesCircuit Switch• Permanent link between A and B(hardware)

• Congestion independent of paths.

• No set-up costs.

• Sequential delivery.

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.