csc541 midterm chapter 10
CSCAN
instead of reversing direction, immediately goes back to beginning (Circular scanning works just like the elevator to some extent. It begins its scan toward the nearest end and works it way all the way to the end of the system. Once it hits the bottom or top it jumps to the other end and moves in the same direction. Keep in mind that the huge jump doesn't count as a head movement., but still this isn't the most sufficient.)
Bandwidth
is (total number of bytes transferred) / (total time between first request and completion of last transfer)
1-dimensional array
is mapped into the sectors of the disk sequentially
Positioning time (random-access time)
is time to move disk arm to desired cylinder (seek time) and time for desired sector to rotate under the disk head (rotational latency)
RAID1
just mirroring/redundancy, good reliability
Disk drives addressed as 1-dimensional arrays of
logical blocks
Striped mirrors (RAID 1+0)
or mirrored striped (RAID 0+1) provides high performance/reliability
RAID 1+0
other mirrored disks still available if one disk fails
Magnetic disks
provide bulk of secondary storage - rotate at 60 to 250 times per second
OS maintains
queue of requests, per disk or device
Transfer rate
rate at which data flows between drive and computer
Ch.10 - Mass-Storage Systems
(10.1-10.7)
Drive attached to computer's I/O bus
- EIDE, ATA, SATA, USB, etc.
Mirroring/shadowing (RAID 1)
- keeps duplicate of each disk
Access latency
= Average access time = average seek time + average latency (fast ~5ms, slow ~14.5ms)
Average I/O time
= avg. access time + (amount to transfer / transfer rate) + controller overhead
LOOK/CLOOK
Arm only goes as far as the last request in each directions, then reverses immediately (CLOOK: This is just an enhanced version of C-SCAN. In this the scanning doesn't go past the last request in the direction that it is moving. It too jumps to the other end but not all the way to the end. Just to the furthest request)( LOOK: It is similar to the SCAN disk scheduling algorithm except the difference that the disk arm in spite of going to the end of the disk goes only to the last request to be serviced in front of the head and then reverses its direction from there only. Thus it prevents the extra delay which occurred due to unnecessary traversal to the end of the disk)
RAID(redundant array of independent disks)
Multiple disk drives provide reliability via redundancy - increases mean time to failure
Sources of disk I/O requests
OS, system processes, user processes
SCAN/elevator
arm starts at one end and moves towards other end servicing requests as it goes, then reverses direction(This approach works like an elevator does. It scans down towards the nearest end and then when it hits the bottom it scans up servicing the requests that it didn't get going down. If a request comes in after it has been scanned it will not be serviced until the process comes back down or moves back up. Once again this is more optimal than the previous algorithm, but it is not the best.)
RAID2
bit-striping, striping of bytes across disks, less disk overhead than RAID1
RAID0
block striping, no mirroring/redundancy, good performance
RAID5
block-level-striping, distributed parity, avoid overusing single parity disk, tolerate one disk failure
RAID4
block-level-striping, one dedicated parity disk
RAID3
byte-level-striping, less disk overhead than RAID2
RAID 0+1
combines RAID 0 and RAID1, used in environments where both performance and reliability are important, one disk failures results in an entire stripe inaccessible
Head crash
disk head making contact with disk surface
Several algorithms exist
to schedule the servicing of disk I/O requests
Ex
to transfer a 4KB block on a 7200 RPM disk with a 5ms average seek time, 1Gb/sec transfer rate with a .1ms controller overhead = 5ms + 4.17ms??? + 4KB / 1Gb/sec + 0.1ms = 9.27ms + .12ms = 9.39ms
RAID6
tolerate multiple disk failures
Host controller
uses bus to talk to disk controller
Disk striping
uses group of disks as one storage unit
Block interleaved parity (RAID 4, 5, 6)
uses much less redundancy