Shortest Seek Time First [SSTF] Algorithm क्या है ? [Source Code]

शीर्ष खोज समय प्रथम [Shortest Seek Time First: SSTF] एल्गोरिथम: आपकी हार्ड डिस्क को गति दें!

कभी सोचा है कि आपका कंप्यूटर इतनी तेजी से डेटा तक क्यों पहुंच पाता है? हां, इसके पीछे कई चीजें काम करती हैं, जिनमें से एक है डिस्क शेड्यूलिंग एल्गोरिथम। आज हम “शीर्ष खोज समय प्रथम” (Shortest Seek Time First -SSTF) एल्गोरिथम के बारे में सीखेंगे, जो हार्ड डिस्क के Read/Write Head को कुशलतापूर्वक Transferred करने में मदद करता है, जिससे आपकी फाइलें और Applications तेजी से खुल पाते हैं!

Shortest Seek Time First क्या है?

SSTF (Shortest Seek Time First) यह देखता है कि हार्ड डिस्क का Read/Write Head कहां है और फिर सबसे निकटतम फाइल मे Read या Write का काम करता है।

कल्पना कीजिए कि आप पुस्तकालय में हैं और आपको कई पुस्तकों की आवश्यकता है। पुस्तकालय घूमने के बजाय, SSTF एल्गोरिथम की तरह सोचें, जो यह तय करेगा कि पहले कौन सी पुस्तक लाए:

  1. आप कहाँ हैं: सबसे पहले, यह देखता है कि आप वर्तमान में पुस्तकालय के किस Part में हैं।
  2. निकटतम पुस्तक: फिर, यह उन सभी पुस्तकों की पहचान करता है जिनकी आपको आवश्यकता है।
  3. पहले निकटतम को चुनें: यह उन पुस्तकों में से सबसे निकटतम पुस्तक को चुनता है, जिससे आप कम से कम चलते हैं।
  4. पुस्तक प्राप्त करें: आप चुनी हुई पुस्तक को लेते हैं और उसे पढ़ते हैं।
  5. दोहराएं: आप Step 2 से 4 तब तक दोहराते हैं जब तक आपको सभी आवश्यक पुस्तकें न मिल जाएं।

इसी तरह, जब आपके कंप्यूटर को कई फाइलों की आवश्यकता होती है, तो SSTF (Shortest Seek Time First) यह देखता है कि हार्ड डिस्क का Read/Write Head कहां है और फिर सबसे निकटतम फाइल मे Read या Write का काम करता है। यह हेड को कम से कम हिलाने की कोशिश करता है, जिससे डेटा एक्सेस तेज हो जाता है।

Shortest Seek Time First [SSTF] Algorithm क्या है ?

Shortest Seek Time First

Shortest Seek Time First :SSTF कैसे काम करता है?

  1. हेड की वर्तमान स्थिति: सबसे पहले, यह पता लगाता है कि Read/Write हेड डिस्क पर किस ट्रैक (डेटा का एक Storage Area) पर मौजूद है।
  2. निकटतम Request की पहचान: फिर, यह उन सभी Data Access Request की पहचान करता है जो Pending हैं।
  3. निकटतम (nearby) को प्राथमिकता: पहचाने गए Request में से, यह उस Request को चुनता है जो वर्तमान हेड की स्थिति से सबसे Near Track पर है।
  4. Selected Request को पूरा करें: हेड उस ट्रैक पर जाता है और डेटा को Read या Write करता है।
  5. प्रक्रिया को दोहराएं: यह प्रक्रिया तब तक चलती रहती है जब तक सभी Pending Request को पूरा नहीं कर लिया जाता है।

उदाहरण:

मान लीजिए कि आपकी हार्ड डिस्क पर Track नंबर 34, 12, 50, 19, और 85 हैं, और हेड वर्तमान में Track 34 पर है। SSTF एल्गोरिथम इस क्रम में डेटा तक पहुंचेगा:

  1. ट्रैक 19 (Near by)
  2. ट्रैक 12 (Next Near by)
  3. ट्रैक 34 (Current Position)
  4. ट्रैक 50 (Next Near by)
  5. ट्रैक 85 (सबसे दूर, अंतिम रूप से Access किया जाएगा)

शीर्ष खोज समय प्रथम (SSTF) के फायदे:

  • Fast डेटा एक्सेस: हेड को कम दूरी तय करने की ज़रूरत होती है, जिससे डेटा तक पहुंचने का समय कम हो जाता है, जिससे आपका कंप्यूटर तेज़ महसूस होता है।
  • सरल कार्यान्वयन: SSTF एल्गोरिथम को समझना और लागू करना आसान है।

SSTF [शीर्ष खोज समय प्रथम ] की सीमाएं:

  • दूर के अनुरोधों की उपेक्षा: दूर के ट्रैकों पर मौजूद अनुरोधों को लंबे समय तक इंतजार करना पड़ सकता है, खासकर जब कई अनुरोध लंबित हों।
  • उच्च विचरण: कभी-कभी, हेड को दूर के ट्रैक पर जाना पड़ सकता है, भले ही कई निकटतम अनुरोध हों।
SSTF Hard Disk

Shortest Seek Time First Scheduling Algorithm का स्यूडोकोड (Pseudocode)

SSTF (Shortest Seek Time First) डिस्क शेड्यूलिंग एल्गोरिद्म एक ऐसी तकनीक है जो डिस्क हेड की गति को कम करते हुए I/O अनुरोधों को पूरा करने का प्रयास करता है। यह अगले अनुरोध का चयन करता है जो वर्तमान डिस्क हेड स्थिति से सबसे कम दूरी पर स्थित है।

स्यूडोकोड: [Python]

Python

def SSTF(requests):
  """
  Shortest Seek Time First Disk Scheduling Algorithm
  """

  # डिस्क हेड की Starting Position को 0 पर सेट करें।
  head = 0

  # Request को उनकी दूरी के आधार पर Sort करें।

  requests.sort(key=lambda request: abs(request - head))

  # Request को क्रम में पूरा करें।.

  for request in requests:

    # डिस्क हेड को अगले अनुरोध की स्थिति में ले जाएं।
    head = request

    # Request को पूरा करें।

  # Return a list of sorted request
  return requests


Explanation:

  • requests: डिस्क Request की एक List
  • head: डिस्क हेड की वर्तमान स्थिति।
  • sort(): List को key फ़ंक्शन द्वारा Define क्रम में Sort करता है।
  • lambda: एक Anonymous function को Define करता है जो Request और डिस्क हेड के बीच की दूरी को Return है।
  • for: Requests की List में प्रत्येक Request के लिए Loop चलाता है।
  • abs(): दो Numbers के बीच की Distance को Integer Value में लौटाता है।

उदाहरण:

मान लीजिए कि हमारे पास डिस्क Request की निम्नलिखित सूची है:

[176, 79, 34, 60, 92, 11, 41, 114]

और डिस्क हेड की प्रारंभिक स्थिति 50 है।

Shortest Seek Time First Algorithm Request को निम्नलिखित Order में पूरा करेगा:

[11, 34, 60, 79, 92, 114, 176, 41]

SSTF के लाभ:

  • यह डिस्क हेड की गति को कम करता है, जिससे I/O समय कम होता है।
  • यह औसतन सबसे कम Waiting Time प्रदान करता है।

SSTF के नुकसान:

  • यह starvation का कारण बन सकता है, जब कुछ Requests को लगातार अनदेखा किया जाता है।
  • यह Thresholding प्रभाव का अनुभव कर सकता है, जब डिस्क हेड एक छोटे से क्षेत्र में बार-बार आगे-पीछे होता है।

SSTF का उपयोग:

SSTF का उपयोग आमतौर पर ऑपरेटिंग सिस्टम में डिस्क I/O Requests को Schedule करने के लिए किया जाता है। यह उन सिस्टमों में विशेष रूप से उपयोगी है जिनमें उच्च I/O प्रदर्शन की आवश्यकता होती है, जैसे कि सर्वर और डेटाबेस।

C Program Source Code of Shortest Seek Time First Scheduling Algorithm

दोस्तों यह नीचे मैंने आपको SSTF [Shortest Seek Time First] एल्गोरिथम का Source Code जो C language मे लिखा गया है :-

#include <stdio.h>
#include <stdbool.h>
#include <math.h>

#define MAX_REQUESTS 100

void swap(int *a, int *b) {
  int temp = *a;
  *a = *b;
  *b = temp;
}

int abs_diff(int a, int b) {
  return abs(a - b);
}

void SSTF(int requests[], int n, int head) {
  bool visited[MAX_REQUESTS];
  int min_index, temp;

  // Initialize all visited flags to false
  for (int i = 0; i < n; i++) {
    visited[i] = false;
  }

  // Process all requests
  for (int i = 0; i < n - 1; i++) {
    min_index = i;
    for (int j = i + 1; j < n; j++) {
      if (!visited[j] && abs_diff(requests[j], head) < abs_diff(requests[min_index], head)) {
        min_index = j;
      }
    }

    // Swap the request with the closest one
    swap(&requests[min_index], &requests[i]);
    visited[i] = true;

    // Simulate head movement
    head = requests[i];

    // Print the processed request
    printf("Processed request: %d\n", requests[i]);
  }
}

int main() {
  int requests[MAX_REQUESTS], n, head;

  printf("Enter the number of requests: ");
  scanf("%d", &n);

  printf("Enter the head position: ");
  scanf("%d", &head);

  printf("Enter the disk requests: ");
  for (int i = 0; i < n; i++) {
    scanf("%d", &requests[i]);
  }

  printf("SSTF Sequencing:\n");
  SSTF(requests, n, head);

  return 0;
}

code inspire from "GeeksforfGeek"

Explanation:

  1. Header Files: ये फाइल्स कोड को कार्य करने के लिए आवश्यक Working Capacity प्रदान करती हैं:
    • stdio.h:Input/Output के लिए।
    • stdbool.h: Boolean Value के लिए (True/False)।
    • math.h: Absolute Value (abs) Function के लिए।
  2. MAX_REQUESTS Constant: यह अधिकतम Allowed Request की संख्या को Define करता है।
  3. swap Function: यह दो Integer Pointers के Values को Swap करता है।
  4. abs_diff Function: यह दो Integer के बीच के Absolute Difference की Calculations करता है।
  5. SSTF Function:
    • यह Request की एक Array(requests), उनकी Value(n), और Initial Head Position(head) लेता है।
    • यह visited नामक एक Boolean Array को Initialized करता है जो ट्रैक करता है कि कौन से Request को पहले ही Process किया जा चुका है।
    • यह सभी Request को Loop करता है, (Last को छोड़कर):
      • यह min_index का उपयोग करके सबसे निकटतम UNPROCESSED Request का Index ढूंढता है।
      • यह swap Function का उपयोग करके Current Request को सबसे निकटतम के साथ Swap करता है।
      • यह Processed Request को visited Array में Marked करता है।
      • यह Head Position को Update करता है।
    • main Function:
      • यह Users से Request की Number, Head Position और Personal Request के लिए Input लेता है।
      • यह Request को Schedule करने के लिए SSTF Function को Call करता है।
    • यह Code SSTF Algorithm को Apply करता है और दिखाता है कि इसे C Lang में कैसे उपयोग किया जाता है।

निष्कर्ष:

SSTF [Shortest Seek Time First] एल्गोरिथम हार्ड डिस्क Efficiency को बेहतर बनाने और डेटा एक्सेस को तेज करने में एक प्रभावी तरीका है। हालांकि, इसकी सीमाओं को ध्यान में रखना महत्वपूर्ण है। अन्य डिस्क शेड्यूलिंग एल्गोरिथम भी मौजूद हैं, जिनका उपयोग विशिष्ट स्थितियों के लिए किया जा सकता है। जैसे FCFS [First Come First Serve]

How useful was this post?

Click on a star to rate it!

Average rating 5 / 5. Vote count: 1

No votes so far! Be the first to rate this post.

As you found this post useful...

Follow us on social media!

We are sorry that this post was not useful for you!

Let us improve this post!

Tell us how we can improve this post?

1 thought on “Shortest Seek Time First [SSTF] Algorithm क्या है ? [Source Code]”

Leave a Comment