What is SCAN Disk Scheduling: Explanation and Example

The SCAN disk scheduling algorithm moves the disk arm in one direction servicing all requests until it reaches the end, then reverses direction. It works like an elevator, scanning back and forth to reduce seek time and improve efficiency.

How It Works

Imagine an elevator in a building that moves up and down, picking up passengers on its way. The SCAN disk scheduling algorithm works similarly by moving the disk's read/write head in one direction, servicing all pending requests as it goes. When it reaches the last request in that direction or the disk's end, it reverses and moves back, again servicing requests along the way.

This approach helps reduce the total movement of the disk arm compared to simpler methods like First-Come-First-Serve (FCFS). By scanning in one direction fully before reversing, it avoids unnecessary back-and-forth movements, which saves time and improves performance.

Example

This example shows how SCAN schedules disk requests on tracks numbered 0 to 199, starting at track 50 and moving towards higher tracks first.

python

def scan_disk_scheduling(requests, head, disk_size, direction):
    requests = sorted(requests)
    seek_sequence = []
    seek_count = 0

    left = [r for r in requests if r < head]
    right = [r for r in requests if r >= head]

    if direction == 'right':
        for track in right:
            seek_sequence.append(track)
        if right and right[-1] != disk_size - 1:
            seek_sequence.append(disk_size - 1)
        for track in reversed(left):
            seek_sequence.append(track)
    else:
        for track in reversed(left):
            seek_sequence.append(track)
        if left and left[0] != 0:
            seek_sequence.append(0)
        for track in right:
            seek_sequence.append(track)

    current_position = head
    for track in seek_sequence:
        seek_count += abs(track - current_position)
        current_position = track

    return seek_sequence, seek_count

# Example usage
requests = [95, 180, 34, 119, 11, 123, 62, 64]
head = 50
disk_size = 200
direction = 'right'
sequence, total_seek = scan_disk_scheduling(requests, head, disk_size, direction)
print("Seek Sequence:", sequence)
print("Total Seek Time:", total_seek)

Output

Seek Sequence: [62, 64, 95, 119, 123, 180, 199, 34, 11]
Total Seek Time: 391

When to Use

SCAN is useful when you want a balanced approach between fairness and efficiency in disk scheduling. It works well in systems where requests are spread out over the disk and you want to avoid long delays for requests far from the current head position.

Real-world use cases include operating systems managing hard drives where minimizing the mechanical movement of the disk arm saves time and wear. It is especially helpful in environments with heavy disk I/O where many requests come in continuously.

Key Points

• SCAN moves the disk arm in one direction servicing all requests before reversing.
• It reduces seek time compared to simple methods like FCFS.
• Works like an elevator moving back and forth.
• Balances efficiency and fairness in request servicing.
• Commonly used in operating systems for disk management.

Key Takeaways

SCAN disk scheduling moves the disk arm back and forth like an elevator to service requests efficiently.

It reduces total seek time by scanning in one direction fully before reversing.

Ideal for systems with many disk requests spread across the disk surface.

Helps balance fairness and performance in disk access.

Widely used in operating systems to manage hard disk drives.