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;
increment i;
compute;
} while (…)

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
Six Step Process to Perform DMA Transfer
 Device Management

Operating Systems 35
 Device Management
• Device-independent techniques:
– Buffering/caching
– Error Handling
– Device Scheduling/Sharing

Operating Systems 36
 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 37
 No Buffering

• Without a buffer, OS directly accesses the

device as and when it needs
• A data area within the address space of
the user process is used for I/O
 No Buffering
• Process must wait for I/O to complete
before proceeding
– busy waiting (like programmed I/O)
– process suspension on an interrupt (like
interrupt-driven I/O or DMA)
• Problems
– the program is hung up waiting for the
relatively slow I/O to complete
– interferes with swapping decisions by OS
 No Buffering
– It is impossible to swap the process out
completely because the data area must be
locked in main memory before I/O
– Otherwise, data may be lost or single-process
deadlock may happen
• the suspended process is blocked waiting on the
I/O event, and the I/O operation is blocked waiting
for the process to be swapped in
 I/O Buffering
• It may be more efficient to perform input
transfers in advance of requests being
made and to perform output transfers
some time after the request is made.
 Block-oriented Buffering
• For block-oriented I/O devices such
as
– disks and
– USB drives
• Information is stored in fixed sized
blocks
• Transfers are made a block at a
time
• Can reference data by block
number
 Stream-Oriented
Buffering
• For stream-oriented I/O devices such as
– terminals
– printers
– communication ports
– mouse and other pointing devices, and
– most other devices that are not secondary
storage
• Transfer information as a stream of
bytes
 Single Buffer

• OS assigns a buffer in the system portion

of main memory for an I/O request
 Block Oriented
Single Buffer
• Input transfers are made to system
buffer
• Block moved to user space when
needed
• The next block is immediately
requested, expecting that the block will
eventually be needed
– Read ahead or Anticipated Input
• A reasonable assumption as data is
usually accessed sequentially
 Block Oriented
Single Buffer
•  Provide a speedup
– User process can be processing one block of
data while the next block is being read in
•  OS is able to swap the process out
because the I/O operation is taking place
in system memory
 Block Oriented
Single Buffer
•  Complicate the logic in OS
– OS must keep track of the assignment of
system buffers to user processes
•  Affect the swapping logic
– Consider both the I/O operation and swapping
involve the same disk
• Does it make sense to swap the process out after
the I/O operation finishes?
 Stream-oriented
Single Buffer
• Line-at-time or Byte-at-a-time
• Terminals often deal with one line at a time with
carriage return signaling the end of the line
– Also line printer
• Byte-at-a-time suits devices where a single
keystroke may be significant
– Also sensors and controllers
– Interaction between OS and user process follows the
producer/consumer model
 Double Buffer
• Use two system buffers instead of one
• A process can transfer data to or from
one buffer while OS empties or fills the
other buffer
 Circular Buffer
• More than two buffers are used
• Each individual buffer is one unit in a circular
buffer
• Used when I/O operation must keep up with
process
• Follows the bounded-buffer
producer/consumer model
 Buffer Limitations
• Buffering smoothes out peaks in I/O
demand
– But with enough demand eventually all
buffers become full and their advantage is
lost
• In multiprogramming environment,
buffering can increase the efficiency of
OS and the performance of individual
processes
 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 52
 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 53
 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 54
 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 60
 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 61
 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 62
 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 63
 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 that’s 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 64
 Device Management
Example: assume moving from 0 to 5; then 12,4,7 arrive

Operating Systems 65