सी++ प्रोग्राम फॉर शॉर्टेस्ट जॉब फर्स्ट (एसजेएफ) शेड्यूलिंग (नॉन-प्रीमेप्टिव)

प्रक्रिया को देखते हुए, क्रमशः एक प्रक्रिया का फटने का समय और एक क्वांटम सीमा; काम शॉर्टेस्ट जॉब फर्स्ट शेड्यूलिंग नॉन-प्रीमेप्टिव पद्धति का उपयोग करके प्रतीक्षा समय, टर्नअराउंड समय और उनके संबंधित औसत समय को ढूंढना और प्रिंट करना है।

सबसे छोटा कार्य पहले शेड्यूलिंग क्या है?

सबसे छोटा जॉब फर्स्ट शेड्यूलिंग जॉब या प्रोसेस शेड्यूलिंग एल्गोरिथम है जो नॉनप्रीमेप्टिव शेड्यूलिंग अनुशासन का पालन करता है। इसमें शेड्यूलर कम से कम समय के साथ प्रतीक्षा कतार से प्रक्रिया का चयन करता है और उस कार्य या प्रक्रिया को सीपीयू आवंटित करता है। शॉर्टेस्ट जॉब फर्स्ट फीफो एल्गोरिथम की तुलना में अधिक वांछनीय है क्योंकि एसजेएफ अधिक इष्टतम है क्योंकि यह औसत प्रतीक्षा समय को कम करता है जो थ्रूपुट को बढ़ाएगा।

बदलाव का समय, प्रतीक्षा समय और पूरा होने का समय क्या है?

• समापन समय प्रक्रिया को इसके निष्पादन को पूरा करने के लिए आवश्यक समय है

• टर्नअराउंड समय किसी प्रक्रिया को प्रस्तुत करने और उसके पूरा होने के बीच का समय अंतराल है।

  टर्नअराउंड समय =एक प्रक्रिया का पूरा होना - एक प्रक्रिया प्रस्तुत करना

• वेटिंग टाइम टर्नअराउंड टाइम और बर्स्ट टाइम के बीच का अंतर है

  वेटिंग टाइम =टर्नअराउंड टाइम - बर्स्ट टाइम

उदाहरण

हमें P1, P2, P3, P4 और P5 प्रक्रियाओं के साथ दिया गया है, जिनका बर्स्ट टाइम नीचे दिया गया है

चूंकि प्रक्रिया का बर्स्ट टाइम P4 सभी प्रक्रियाओं में न्यूनतम है, इसलिए इसे पहले CPU आवंटित किया जाएगा। उसके बाद, P2 फिर P1, P3 और P5 कतार में आ जाएगा।

औसत प्रतीक्षा समय की गणना गैंट चार्ट के आधार पर की जाती है। P1 को 3 की प्रतीक्षा करनी है, P2 को 1 के लिए प्रतीक्षा करनी है, P3 को 7 के लिए प्रतीक्षा करनी है, P4 को 0 के लिए प्रतीक्षा करनी है और P5 को 15 के लिए प्रतीक्षा करनी है। तो, उनका औसत प्रतीक्षा समय होगा -

एल्गोरिदम

Start
Step 1-> In function swap(int *a, int *b)
   Set temp = *a
   Set *a = *b
   Set *b = temp
Step 2-> In function arrangeArrival(int num, int mat[][3])
   Loop For i=0 and i<num and i++
      Loop For j=0 and j<num-i-1 and j++
         If mat[1][j] > mat[1][j+1] then,
            For k=0 and k<5 and k++
            Call function swap(mat[k][j], mat[k][j+1])
Step 3-> In function completionTime(int num, int mat[][3])
   Declare temp, val
   Set mat[3][0] = mat[1][0] + mat[2][0]
   Set mat[5][0] = mat[3][0] - mat[1][0]
   Set mat[4][0] = mat[5][0] - mat[2][0]
    Loop For i=1 and i<num and i++
      Set temp = mat[3][i-1]
      Set low = mat[2][i]
      Loop For j=i and j<num and j++
         If temp >= mat[1][j] && low >= mat[2][j] then,
            Set low = mat[2][j]
            Set val = j
            Set mat[3][val] = temp + mat[2][val]
            Set mat[5][val] = mat[3][val] - mat[1][val]
            Set mat[4][val] = mat[5][val] - mat[2][val]
            Loop For  k=0; k<6; k++
            Call function swap(mat[k][val], mat[k][i])
Step 4-> In function int main()
   Declare and set num = 3, temp
   Declare and set mat[6][3] = {1, 2, 3, 3, 6, 4, 2, 3, 4}
   Print Process ID, Arrival Time, Burst Time
   Loop For i=0 and i<num and i++
      Print the values of mat[0][i], mat[1][i], mat[2][i]
      Call function arrangeArrival(num, mat)
      Call function completionTime(num, mat)
      Print Process ID, Arrival Time, Burst Time, Waiting Time, Turnaround Time
      Loop For i=0 and i<num and i++  
      Print the values of  mat[0][i], mat[1][i], mat[2][i], mat[4][i], mat[5][i]
Stop

उदाहरण

// C++ program to implement Shortest Job first with Arrival Time
#include<iostream>
using namespace std;
void swap(int *a, int *b) {
   int temp = *a;
   *a = *b;
   *b = temp;
}
void arrangeArrival(int num, int mat[][3]) {
   for(int i=0; i<num; i++) {
      for(int j=0; j<num-i-1; j++) {
         if(mat[1][j] > mat[1][j+1]) {
            for(int k=0; k<5; k++) {
               swap(mat[k][j], mat[k][j+1]);
            }
         }
      }
   }
}
void completionTime(int num, int mat[][3]) {
   int temp, val;
   mat[3][0] = mat[1][0] + mat[2][0];
   mat[5][0] = mat[3][0] - mat[1][0];
   mat[4][0] = mat[5][0] - mat[2][0];
    for(int i=1; i<num; i++) {
      temp = mat[3][i-1];
      int low = mat[2][i];
      for(int j=i; j<num; j++) {
         if(temp >= mat[1][j] && low >= mat[2][j]) {
            low = mat[2][j];
            val = j;
         }
      }
      mat[3][val] = temp + mat[2][val];
      mat[5][val] = mat[3][val] - mat[1][val];
      mat[4][val] = mat[5][val] - mat[2][val];
      for(int k=0; k<6; k++) {
         swap(mat[k][val], mat[k][i]);
      }
   }
}
int main() {
   int num = 3, temp;
   int mat[6][3] = {1, 2, 3, 3, 6, 4, 2, 3, 4};
   cout<<"Before Arrange...\n";
   cout<<"Process ID\tArrival Time\tBurst Time\n";
   for(int i=0; i<num; i++) {
      cout<<mat[0][i]<<"\t\t"<<mat[1][i]<<"\t\t"<<mat[2][i]<<"\n";
   }
   arrangeArrival(num, mat);
   completionTime(num, mat);
   cout<<"Final Result...\n";
   cout<<"Process ID\tArrival Time\tBurst Time\tWaiting Time\tTurnaround Time\n";
   for(int i=0; i<num; i++) {
      cout<<mat[0][i]<<"\t\t"<<mat[1][i]<<"\t\t"<<mat[2][i]<<"\t\t"<<mat[4][i]<<"\t\t"<<mat[5][i]<<"\n";
   }
}

आउटपुट