Given an array of disk track numbers and initial head position, our task is to find the total number of seek operations done to access all the requested tracks if Shortest Seek Time First (SSTF) is a disk scheduling algorithm is used.
The basic idea is the tracks that are closer to the current disk head position should be serviced first in order to minimize the seek operations is basically known as Shortest Seek Time First (SSTF).
Advantages of Shortest Seek Time First (SSTF)
- Better performance than the FCFS scheduling algorithm.
- It provides better throughput.
- This algorithm is used in Batch Processing systems where throughput is more important.
- It has a less average response and waiting time.
Disadvantages of Shortest Seek Time First (SSTF)
- Starvation is possible for some requests as it favours easy-to-reach requests and ignores the far-away processes.
- There is a lack of predictability because of the high variance of response time.
- Switching direction slows things down.
Algorithm
Step 1: Let the Request array represents an array storing indexes of tracks that have been requested. ‘head’ is the position of the disk head.
Step 2: Find the positive distance of all tracks in the request array from the head.
Step 3: Find a track from the requested array which has not been accessed/serviced yet and has a minimum distance from the head.
Step 4: Increment the total seek count with this distance.
Step 5: Currently serviced track position now becomes the new head position.
Step 6: Go to step 2 until all tracks in the request array have not been serviced.Â
Example:
Request sequence = {176, 79, 34, 60, 92, 11, 41, 114}Â
Initial head position = 50Â
The following chart shows the sequence in which requested tracks are serviced using SSTF.
Therefore, the total seek count is calculated as:Â
SSTF (Shortest Seek Time First)
= (50-41)+(41-34)+(34-11)+(60-11)+(79-60)+(92-79)+(114-92)+(176-114)
= 204
which can also be directly calculated as: (50-11) + (176-11)
Implementation
The implementation of SSTF is given below. Note that we have made a node class having 2 members. ‘distance’ is used to store the distance between the head and the track position. ‘accessed’ is a boolean variable that tells whether the track has been accessed/serviced before by the disk head or not.Â
C++
// C++ program for implementation of // SSTF disk scheduling#include <bits/stdc++.h>using namespace std;Â
// Calculates difference of each // track number with the head position void calculatedifference(int request[], int head,                         int diff[][2], int n){    for(int i = 0; i < n; i++)    {        diff[i][0] = abs(head - request[i]);    }}Â
// Find unaccessed track which is // at minimum distance from head int findMIN(int diff[][2], int n){Â Â Â Â int index = -1;Â Â Â Â int minimum = 1e9;Â Â Â Â Â Â Â for(int i = 0; i < n; i++)Â Â Â Â {Â Â Â Â Â Â Â Â if (!diff[i][1] && minimum > diff[i][0])Â Â Â Â Â Â Â Â {Â Â Â Â Â Â Â Â Â Â Â Â minimum = diff[i][0];Â Â Â Â Â Â Â Â Â Â Â Â index = i;Â Â Â Â Â Â Â Â }Â Â Â Â }Â Â Â Â return index;}Â
void shortestSeekTimeFirst(int request[],                            int head, int n){    if (n == 0)    {        return;    }         // Create array of objects of class node       int diff[n][2] = { { 0, 0 } };         // Count total number of seek operation      int seekcount = 0;         // Stores sequence in which disk access is done     int seeksequence[n + 1] = {0};         for(int i = 0; i < n; i++)    {        seeksequence[i] = head;        calculatedifference(request, head, diff, n);        int index = findMIN(diff, n);        diff[index][1] = 1;                 // Increase the total count         seekcount += diff[index][0];                  // Accessed track is now new head         head = request[index];    }    seeksequence[n] = head;         cout << "Total number of seek operations = "         << seekcount << endl;    cout << "Seek sequence is : " << "\n";         // Print the sequence     for(int i = 0; i <= n; i++)     {        cout << seeksequence[i] << "\n";    }}Â
// Driver codeint main(){Â Â Â Â int n = 8;Â Â Â Â int proc[n] = { 176, 79, 34, 60, 92, 11, 41, 114 };Â Â Â Â Â Â Â Â Â shortestSeekTimeFirst(proc, 50, n);Â Â Â Â Â Â Â Â Â return 0;}Â
// This code is contributed by manish19je0495 |
Java
// Java program for implementation of // SSTF disk schedulingclass node {         // represent difference between     // head position and track number    int distance = 0;          // true if track has been accessed    boolean accessed = false; }Â
public class SSTF {         // Calculates difference of each     // track number with the head position    public static void calculateDifference(int queue[],                                         int head, node diff[])                                             {        for (int i = 0; i < diff.length; i++)            diff[i].distance = Math.abs(queue[i] - head);    }Â
    // find unaccessed track     // which is at minimum distance from head    public static int findMin(node diff[])    {        int index = -1, minimum = Integer.MAX_VALUE;Â
        for (int i = 0; i < diff.length; i++) {            if (!diff[i].accessed && minimum > diff[i].distance) {                                 minimum = diff[i].distance;                index = i;            }        }        return index;    }Â
    public static void shortestSeekTimeFirst(int request[],                                                      int head)                                                          {        if (request.length == 0)            return;                     // create array of objects of class node           node diff[] = new node[request.length];                  // initialize array        for (int i = 0; i < diff.length; i++)                      diff[i] = new node();                 // count total number of seek operation           int seek_count = 0;                  // stores sequence in which disk access is done        int[] seek_sequence = new int[request.length + 1];                  for (int i = 0; i < request.length; i++) {                         seek_sequence[i] = head;            calculateDifference(request, head, diff);                         int index = findMin(diff);                         diff[index].accessed = true;                         // increase the total count            seek_count += diff[index].distance;                          // accessed track is now new head            head = request[index];         }                 // for last accessed track        seek_sequence[seek_sequence.length - 1] = head;                  System.out.println("Total number of seek operations = "                                                     + seek_count);                                                              System.out.println("Seek Sequence is");                 // print the sequence        for (int i = 0; i < seek_sequence.length; i++)             System.out.println(seek_sequence[i]);    }Â
    public static void main(String[] args)    {        // request array        int arr[] = { 176, 79, 34, 60, 92, 11, 41, 114 };         shortestSeekTimeFirst(arr, 50);    }} |
Python3
# Python3 program for implementation of # SSTF disk scheduling Â
# Calculates difference of each # track number with the head positiondef calculateDifference(queue, head, diff):Â Â Â Â for i in range(len(diff)):Â Â Â Â Â Â Â Â diff[i][0] = abs(queue[i] - head) Â Â Â Â Â # find unaccessed track which is # at minimum distance from head def findMin(diff): Â
    index = -1    minimum = 999999999Â
    for i in range(len(diff)):        if (not diff[i][1] and                minimum > diff[i][0]):            minimum = diff[i][0]            index = i    return index      def shortestSeekTimeFirst(request, head):                    if (len(request) == 0):             return                 l = len(request)         diff = [0] * l                 # initialize array         for i in range(l):            diff[i] = [0, 0]                 # count total number of seek operation            seek_count = 0                 # stores sequence in which disk         # access is done         seek_sequence = [0] * (l + 1)                  for i in range(l):             seek_sequence[i] = head             calculateDifference(request, head, diff)             index = findMin(diff)                          diff[index][1] = True                         # increase the total count             seek_count += diff[index][0]                          # accessed track is now new head             head = request[index]              # for last accessed track         seek_sequence[len(seek_sequence) - 1] = head                  print("Total number of seek operations =",                                        seek_count)                                                                  print("Seek Sequence is")                  # print the sequence         for i in range(l + 1):            print(seek_sequence[i])      # Driver code if __name__ =="__main__":         # request array     proc = [176, 79, 34, 60,             92, 11, 41, 114]    shortestSeekTimeFirst(proc, 50)     # This code is contributed by# Shubham Singh(SHUBHAMSINGH10) |
C#
// C# program for implementation of // SSTF disk schedulingusing System;     public class node{         // represent difference between     // head position and track number    public int distance = 0;          // true if track has been accessed    public Boolean accessed = false; }Â
public class SSTF {         // Calculates difference of each     // track number with the head position    public static void calculateDifference(int []queue,                                         int head, node []diff)                                             {        for (int i = 0; i < diff.Length; i++)            diff[i].distance = Math.Abs(queue[i] - head);    }Â
    // find unaccessed track     // which is at minimum distance from head    public static int findMin(node []diff)    {        int index = -1, minimum = int.MaxValue;Â
        for (int i = 0; i < diff.Length; i++)        {            if (!diff[i].accessed && minimum > diff[i].distance)            {                                 minimum = diff[i].distance;                index = i;            }        }        return index;    }Â
    public static void shortestSeekTimeFirst(int []request,                                                     int head)    {        if (request.Length == 0)            return;                     // create array of objects of class node         node []diff = new node[request.Length];                  // initialize array        for (int i = 0; i < diff.Length; i++)                      diff[i] = new node();                 // count total number of seek operation         int seek_count = 0;                  // stores sequence in which disk access is done        int[] seek_sequence = new int[request.Length + 1];                  for (int i = 0; i < request.Length; i++)        {                         seek_sequence[i] = head;            calculateDifference(request, head, diff);                         int index = findMin(diff);                         diff[index].accessed = true;                         // increase the total count            seek_count += diff[index].distance;                          // accessed track is now new head            head = request[index];         }                 // for last accessed track        seek_sequence[seek_sequence.Length - 1] = head;                  Console.WriteLine("Total number of seek operations = "                                                    + seek_count);                                                             Console.WriteLine("Seek Sequence is");                 // print the sequence        for (int i = 0; i < seek_sequence.Length; i++)             Console.WriteLine(seek_sequence[i]);    }Â
    // Driver code    public static void Main(String[] args)    {        // request array        int []arr = { 176, 79, 34, 60, 92, 11, 41, 114 };         shortestSeekTimeFirst(arr, 50);    }}Â
// This code contributed by Rajput-Ji |
Javascript
// Javascript Program for implementation of // SSTF disk schedulingfunction calculatedifference(request, head, diff, n) {Â Â Â Â for (let i = 0; i < n; i++) {Â Â Â Â Â Â Â Â diff[i][0] = Math.abs(head - request[i]);Â Â Â Â }}Â
// Find unaccessed track which is // at minimum distance from head function findMIN(diff, n) {Â Â Â Â let index = -1;Â Â Â Â let minimum = 1e9;Â
    for (let i = 0; i < n; i++) {        if (!diff[i][1] && minimum > diff[i][0]) {            minimum = diff[i][0];            index = i;        }    }    return index;}Â
function shortestSeekTimeFirst(request, head, n) {Â Â Â Â if (n == 0) {Â Â Â Â Â Â Â Â return;Â Â Â Â }Â
    // Create array of objects of class node       let diff = new Array(n);    for (let i = 0; i < n; i++) {        diff[i] = new Array(2);    }Â
    // Count total number of seek operation      let seekcount = 0;Â
    // Stores sequence in which disk access is done     let seeksequence = new Array(n + 1);    seeksequence[0] = head;Â
    for (let i = 0; i < n; i++) {        calculatedifference(request, head, diff, n);        let index = findMIN(diff, n);        diff[index][1] = 1;Â
        // Increase the total count         seekcount += diff[index][0];Â
        // Accessed track is now new head         head = request[index];        seeksequence[i + 1] = head;    }Â
    console.log("Total number of seek operations = " + seekcount);    console.log("Seek sequence is : ");Â
    // Print the sequence     for (let i = 0; i <= n; i++) {        console.log(seeksequence[i]);    }}Â
// Driver codelet n = 8;let proc = [176, 79, 34, 60, 92, 11, 41, 114];Â
shortestSeekTimeFirst(proc, 50, n);Â
//Â This code is contributed by ishankhandelwals. |
Output
Total number of seek operations = 204
Seek Sequence: 50, 41, 34, 11, 60, 79, 92, 114, 176
Time Complexity: O(N^2)
Auxiliary Space: O(N)Â
FAQs on SSTF Disk Scheduling Algorithm
1. Will Starvation occur for some requests in SSTF?
Yes, when a continuos stream of requests are coming then it will lead to starvation.
2. Whether SSTF is suitable for minimizing disk arm movement?
Yes, SSTF is helpful in minimizing disk arm movement and it also helps in reducing seek time.
3. In case of two requests having the same seek time, which request SSTF will follow?
If multiple requests have the same seek time, SSTF can choose any of them, depending on the implementation.
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
