11.

I/O Systems
11.1 Basic Issues in Device Management
11.2 A Hierarchical Model
11.3 I/O Devices
11.4 Device Drivers
Memory-Mapped vs Explicit Device Interfaces
Programmed I/O with Polling
Programmed I/O with Interrupts
Direct Memory Access (DMA)
11.5 Device Management
Buffering and caching
Error Handling
Disk Scheduling

Operating Systems 1
Basic Issues
I/O devices:
Communication devices
Input only (keyboard, mouse, joystick, light pen)
Output only (printer, visual display, voice
synthesizers)
Input/output (network card)
Storage devices
Input/output (disk, tape, writeable optical disks)
Input only (CD-ROM)

Operating Systems 2
Basic Issues
Every device type/model is different
input/output/both, block/char oriented, speed, errors,
Main tasks of I/O system:
Present logical (abstract) view of devices
Hide details of hardware interface
Hide error handling
Facilitate efficient use
Overlap CPU and I/O
Support sharing of devices
Protection when device is shared (disk)
Scheduling when exclusive access needed (printer)

Operating Systems 3
Hierarchical Model of the I/O System

Operating Systems 4
I/O System Interface

Operating Systems 6
 I/O System Interface
Block-Oriented Device Interface
direct access
contiguous blocks
usually fixed block size
Operations:
Open: verify device is ready, prepare it for access
Read: Copy a block into main memory
Write: Copy a portion of main memory to a block
Close: Release the device
Note: these are lower level than those of the FS
Used by File System and Virtual Memory System
Applications typically go through the File System
Operating Systems 7
 I/O System Interface
Stream-Oriented Device Interface
character-oriented
sequential access
Operations:
Open: reserve exclusive access
Get: return next character of input stream
Put: append character to output stream
Close: release exclusive access
Note: these too are different from those of the FS
but some systems try to present a uniform view of
files and devices

Operating Systems 8
 I/O System Interface
Network Interface
key abstraction: socket
endpoints of a line between two processes
once established, use protocol to communicate
Connection-less protocols
send messages, called datagrams
Operations: send, receive (to/from sockets)
Connection-based protocols
establish a connection called virtual circuit
Operations: connect, accept, read, write

Operating Systems 9
I/O Devices

Operating Systems 10
 I/O Devices Output
Display monitors
character or
graphics oriented
Different data rates:
25 x 80 characters vs
800 x 600 pixels (1B
allows 256 colors)
Refresh 30-60 times/s
for video
Printers (ink jet, laser)
Interface
write to controller
buffer
wait for completion
handle errors
Operating Systems 11
I/O Devices Input
Keyboards
most common: QWERTY
Pointing devices
Mouse
Trackball
Joystick
Scanners
Interface
device generates interrupt when data is ready
read data from controller buffer
low data rates, not time-critical

Operating Systems 12
I/O Devices Storage
Disks
Surface, tracks/surface, sectors/track, bytes/sector
All sectors numbered sequentially 0..(n-1)
(device controller provides mapping)

Operating Systems 13
 I/O Devices Storage
Track skew
Account for seek-to-next-track to minimize rotational delay

Operating Systems 14
 I/O Devices Storage
Double-sided or multiple surfaces
Tracks with same diameter = cylinder
Sectors are numbered within cylinder consecutively to
minimize seek time

Operating Systems 15
I/O Devices Storage
Optical disks
CD-ROM, CD-R (WORM), CD-RW
Originally designed for music
Data stored as continuous spiral,
subdivided into sectors
Higher storage capacity: 0.66 GB/surface
Constant linear speed (200-530 rpm), high data rate

Operating Systems 16
I/O Devices Storage
Critical issue: data transfer rates of disks
Sustained rate: continuous data delivery
Peek rate: transfer once read/write head is in place
depends on rotation speed and data density
Example:
7200 rpm, 100 sectors/track, 512 bytes/sector.
What is the peak transfer rate?
7200 rpm: 60,000/7200=8.3 ms/rev
8.3/100 = 0.083 ms/sector
512 bytes transferred in 0.083 ms: ~6.17 MB/s
What is the Sustained rate?Depends on file organization

Operating Systems 17
Hierarchical Model of the I/O System

Operating Systems 19
 Device Drivers
accept command from
application
get/put character
read/write block
send/receive
packet
interact with device
controller (hardware)
to carry out command
driver-controller
interface:
set of registers

Operating Systems 20
Device Drivers: Interface to Controller
How does driver
read/write registers?
Explicit: special
I/O instruction:
io_store
cpu_reg,
dev_no,
dev_reg
Memory-mapped:
CPU instruction:
store cpu_reg, n
(n is memory
address)
Operating Systems 21
Programmed I/O with Polling
Who moves the data?
How does driver know when device is ready?
CPU is responsible for
moving every character to/from controller buffer
detecting when I/O operation completed
Protocol to input a character/block:

Operating Systems 22
Programmed I/O with Polling
Driver operation to input sequence of characters or blocks:
i = 0;
do {
write_reg(opcode, read);
while (busy_flag == true) {??...}; //waiting
mm_in_area[i] = data_buffer;
increment i;
compute;
} while ()

Operating Systems 23
Programmed I/O with Polling
Driver operation to output sequence of characters or
blocks:
i = 0;
do {
compute;
data_buffer = mm_out_area[i];
increment i;
write_reg(opcode, write);
while (busy_flag == true) {??...};
} while (data_available)

Operating Systems 24
Programmed I/O with Polling
What to do while waiting?
Idle (busy wait)
Some other computation (what?)
How frequently to poll?

Give up CPU
Device may remain unused for a long time
Data may be lost
Operating Systems 25
Programmed I/O with Interrupts
CPU is responsible for moving data, but
Interrupt signal informs CPU when I/O operation completes
Protocol to input a character/block:

Operating Systems 26
 Programmed I/O with Interrupts
Compare Polling with Interrupts:
i = 0;
do { write_reg(opcode, read);
while (busy_flag == true) {}; //active wait
mm_in_area[i] = data_buffer;
increment i;
compute;
} while ()

i = 0;
do { write_reg(opcode, read);
block to wait for interrupt;
mm_in_area[i] = data_buffer;
Operating Systems 27
Programmed I/O with Interrupts
Example: Keyboard driver

do { block to wait for interrupt;

mm_in_area[i] = data_buffer;
increment i;
compute(mm_in_area[]);
} while (data_buffer != ENTER)

Note:
there is no write_reg command, pressing a key generates interrupt
compute depends on type of input: raw/cooked
E.g. trying to type text but with typos
raw: t e s t BS x
cooked: t e x t

Operating Systems 28
Programmed I/O with Interrupts
I/O with interrupts: more complicated, involves OS
Example: sequence of reads

More overhead (OS) but better device utilization

Operating Systems 29
 Direct Memory Access (DMA)
CPU does not transfer data, only initiates operation
DMA controller transfers data directly to/from main memory
Interrupts when transfer completed
Input protocol:

Operating Systems 31
 DMA
Driver (CPU) operation to input sequence of bytes:
write_reg(mm_buf, m); // give parameters
write_reg(count, n);
write_reg(opcode, read); // start op
block to wait for interrupt;
Writing opcode triggers DMA controller
DMA controller issues interrupt after n chars in memory
Cycle Stealing
DMA controller competes with CPU for memory access
generally not a problem because:
Memory reference would have occurred anyway
CPU is frequently referencing data in registers or
cache, bypassing main memory
Operating Systems 32
Device Management

Operating Systems 34
Device Management
Device-independent techniques:
Buffering/caching
Error Handling
Device Scheduling/Sharing

Operating Systems 35
Buffering
Reasons for buffering
Allows asynchronous operation of producers and
consumers
Allows different granularities of data
Consumer or producer can be swapped out while
waiting for buffer fill/empty

Operating Systems 36
Buffering
Single buffer operation
Double buffer (buffer swapping)
Increases overlap
Ideal when: time to fill = time to empty = constant
When times differ, benefits diminish

Operating Systems 37
Buffering
Circular Buffer (bounded buffer from Ch. 2)
Producer and consumer each use an index
nextin gives position of next input
nextout gives position of next output
Both are incremented modulo n at end of operation
When average times to fill/empty are comparable but
vary over time: circular buffer absorbs bursts
Buffer Queue
Variable size buffer to prevent producer blocking
Implement as linked list
needs dynamic memory management
Buffer Cache: pool of buffers for repeated access

Operating Systems 38
Error Handling
Types of error
Persistent vs Transient
SW vs HW
Persistent SW error
Repair/reinstall program
Transient SW/HW errors:
Error detecting/correcting codes
e.g., Hamming code (separate lecture)
Retry operation, e.g. disk seek/read/write
Persistent HW errors:
Redundancy in storage media

Operating Systems 39
 Bad block detection/handling
Block may be bad as a manufacturing fault or during use
Parity bit is used to detect faulty block
The controller bypasses faulty block by renumbering
A spare block is used instead

Two possible
re-mappings:
a) simple
b) preserves
contiguity
of allocation

Operating Systems 45
Stable storage
Some applications cannot tolerate any loss of data (even
temporarily)
Stable storage protocols:
Use 2 independent disks, A and B
Write: write to A; if successful, write to B; if either
fails, go to recovery
Read: read from A and B; if A!=B, go to Recovery
Recovery from Media Failure: A or B contains correct
data (parity); remap failed disk block
Recovery from Crash:
if while reading, just repeat the read
if while writing A, B is correct; if while writing B, A
is correct; recover from whichever is correct
Operating Systems 46
 RAID
RAID = Redundant Array of Independent Disks
Increased performance through parallel access
Increased reliability through redundant data
Maintain exact replicas of all disks
most reliable but wasteful
Maintain only partial recovery information
(e.g. error correcting codes)

Operating Systems 47
Device Management
Disk Scheduling
Requests for different blocks
arrive concurrently from
different processes
Minimize rotational delay:
re-order requests to blocks on
each track to access in one
rotation
Minimize seek time:
Conflicting goals:
Minimize total travel
distance
Guarantee fairness
Operating Systems 48
Device Management
Algorithms
FIFO: requests are processed in the order of arrival
simple, fair, but inefficient
SSTF (Shortest Seek Time First): always go to the
track thats nearest to the current positions
most efficient but prone to starvation
Scan (Elevator):
maintain a direction of travel
always proceed to the nearest track in the current
direction of travel
if there is no request in the current direction,
reverse direction
fair, acceptable performance
Operating Systems 49
 Device Management
Example: assume moving from 0 to 5; then 12,4,7 arrive

Operating Systems 50