दा इंडियन वायर » टैकनोलजी » ऑपरेटिंग सिस्टम में राउंड रोबिन शेड्यूलिंग अल्गोरिथम
टैकनोलजी

ऑपरेटिंग सिस्टम में राउंड रोबिन शेड्यूलिंग अल्गोरिथम

राउंड रोबिन शेड्यूलिंग अल्गोरिथम - round robin scheduling algorithm in hindi, examples, operating system

क्या है राउंड रोबिन शेड्यूलिंग अल्गोरिथम? (round robin scheduling algorithm in hindi)

राउंड रोबिन ऑपरेटिंग सिस्टम में एक CPU शेड्यूलिंग अल्गोरिथम है जहां हर एक प्रोसेस को एक निश्चित समयावधि असाइन किया जाता है और ये साइक्लिक तरीके से होता है।

  • ये सिंपल, इमप्लेमेंट करने में आसान, starvation फ्री है क्योंकि सभी प्रोसेस CPU में एक सही हिस्सा पाते हैं।
  • ये CPU शेड्यूलिंग में कोर कि तरह एक बहुत ही ज्यादा प्रयोग किये जाने वाले अल्गोरिथम में से एक है।
  • है क्योंकि हर प्रोसेस को CPU एक निश्चित समय के लिए ही असाइन किया जाता है।
  • इसकी खामी यह है कि ये स्विचिंग के कॉन्टेक्स्ट में देखा जाए तो ज्यादा ओवरहेड है।

राउंड रोबिन शेड्यूलिंग अल्गोरिथम के उदाहरण (round robin scheduling algorithm example in hindi)

round-robin

राउंड रोबिन में इन सब को कैसे कैलकुलेट करें?

  1. कम्पलीशन टाइम: वो समय जब प्रोसेस का execution पूरा होता है।
  2. टर्न अराउंड टाइम: कम्पलीशन टाइम और अर्रिवल टाइम के बीच की समयावधि,टर्न अराउंड टाइम = कम्पलीशन टाइम –अर्रिवल टाइम
  3. वेटिंग टाइम(W.T): टर्न अराउंड टाइम और बर्स्ट टाइम के बीच की समयावधि,
    वेटिंग टाइम= टर्न अराउंड टाइम  –बर्स्ट टाइम

इस उदाहरण में हमने अर्रिवल टाइम को 0 माना है जबकि टर्न अराउंड टाइम और कम्पलीशन टाइम समान है।

इसमें सबसे ट्रिकी भाग ये है कि वेटिंग टाइम को कैसे कंप्यूट किया जाए। एक बार जब वेटिंग टाइम कम्पलीट हो जाता है तब टर्न अराउंड टाइम तेजी से कंप्यूट किया जा सकता है।

सभी प्रोसेस में वेटिंग टाइम कैसे निकालें?

ऐरे rem_bt[] को बनाएं ताकि सभी प्रोसेस के बचे हुए बर्स्ट टाइम का ट्रैक रखा जा सके। ये ऐरे शुरू में
ऐरे bt[] का कॉपी होगा। (बर्स्ट टाइम ऐरे)
2- एक दूसरा ऐरे  wt[] बनाये जिसमे सारे प्रोसेस के वेटिंग टाइम को रखा जा सके।
 इस ऐरे को 0 से शुरू करें।
3- समय को इनिशियलाइज़ करें : t = 0
4- जबतक सारा प्रोसेस पूरा न हो जाये तब तक उन सारे प्रोसेस को traverse करते रहें।
 i'th प्रोसेस अगर है तो उसके लिए ऐसा करें:
   अभी पूरा नहीं हुआ।
    a- If rem_bt[i] > क्वांटम
       (i)  t = t + क्वांटम
       (ii) bt_rem[i] -= क्वांटम;
    c- Else // इस प्रोसेस का अंतिम साइकिल
       (i)  t = t + bt_rem[i];
       (ii) wt[i] = t - bt[i]
       (ii) bt_rem[i] = 0; // ये प्रोसेस खत्म हो गया

अगर हमारे पास वेटिंग टाइम है तो हम टर्न अराउंड टाइम tat[i] को कंप्यूट कर सकते हैं जो कि वेटिंग और बर्स्ट टाइम का जोड़ होगा;wt[i] + bt[i]

इस स्टेप को ऐसे implement करें:

C/C++ कोड:

// C++ प्रोग्राम, राउंड रोबिन के इम्प्लीमेंटेशन के लिए
#include<iostream>
using namespace std;
//सभी के लिए वेटिंग टाइम पता करने का फंक्शन
//सारे प्रोसेस
void findWaitingTime(int processes[], int n,
int bt[], int wt[], int quantum)
{
//बर्स्ट टाइम bt[]की कॉपी बनाने के लियी ताकि बांकी बचे हुए को स्टोर किया जा सके
//बर्स्ट टाइम
int rem_bt[n];
for (int i = 0 ; i < n ; i++)
rem_bt[i] =  bt[i];
int t = 0; //करंट टाइम
//प्रोसेस को राउंड रोबिन तरीके से traverse करते रहे
//जब तक पूरा का पूरा कम्पलीट न हो जाये
while (1)
{
bool done = true;
//सभी प्रोसेस को एक-एक कर के बार-बार traverse करें
for (int i = 0 ; i < n; i++)
{
//अगर प्रोसेस का बर्स्ट टाइम 0 से ज्यादा है
// तभी आगे प्रोसेस करने की जरूरत है
if (rem_bt[i] > 0)
{
done = false; // एक पेंडिंग प्रोसेस है
if (rem_bt[i] > quantum)
{
// t कि वैल्यू को बढ़ाएं जो दिखाता है
//किसी प्रोसेस को कितनी बार प्रोसेस किया गया।
t += quantum;
//अभी के प्रोसेस के लिए बर्स्ट टाइम घटाएं
//क्वांटम से
rem_bt[i] -= quantum;
}
//अगर बर्स्ट टाइम क्वांटम से छोटा या बराबर है तो
// इस साइकिल का अंतिम प्रोसेस
else
{
// t कि वैल्यू बढ़ाएं जो यह दिखता है कि
//कितने समय के लिए एक प्रोसेस को किया गया
t = t + rem_bt[i];
// वेटिंग टाइम होगा अभी का वेटिंग टाइम माइनस
// इस प्रोसेस द्वारा प्रयोग किया गया
wt[i] = t - bt[i];
// प्रोसेस पूरी तरह से एक्सीक्यूट हो गया
// इसीलिए बचा हुआ बर्स्ट टाइम= 0
rem_bt[i] = 0;
}
}
}
// सभी प्रोसेस पूरा हो गया
if (done == true)
break;
}
}
//टर्न अराउंड टाइम कैलकुलेट करने कि प्रक्रिया
void findTurnAroundTime(int processes[], int n,
int bt[], int wt[], int tat[])
{
//ऐड कर के टर्न अराउंड टाइम कैलकुलेट करें
// bt[i] + wt[i]
for (int i = 0; i < n ; i++)
tat[i] = bt[i] + wt[i];
}
//एवरेज टाइम कैलकुलेट करने के लिए फंक्शन
void findavgTime(int processes[], int n, int bt[],
int quantum)
{
int wt[n], tat[n], total_wt = 0, total_tat = 0;
//सभी प्रोसेस का वेटिंग टाइम पता करने के लिए प्रोसेस
findWaitingTime(processes, n, bt, wt, quantum);
//सभी प्रोसेस का टर्न अराउंड टाइम पता करने के लिए प्रोसेस
findTurnAroundTime(processes, n, bt, wt, tat);
//सभी प्रोसेस को डिटेल के साथ डिस्प्ले करे
cout << "Processes "<< " Burst time "
<< " Waiting time " << " Turn around time\n";
//टोटल वेटिंग टाइम और टर्न अराउंड टाइम
//कैलकुलेट करें।
for (int i=0; i<n; i++)
{
total_wt = total_wt + wt[i];
total_tat = total_tat + tat[i];
cout << " " << i+1 << "\t\t" << bt[i] <<"\t "
<< wt[i] <<"\t\t " << tat[i] <<endl;
}
cout << "Average waiting time = "
<< (float)total_wt / (float)n;
cout << "\nAverage turn around time = "
<< (float)total_tat / (float)n;
}
// ड्राईवर कोड
int main()
{
// process id's
int processes[] = { 1, 2, 3};
int n = sizeof processes / sizeof processes[0];
//सारे प्रोसेस के लिए बर्स्ट टाइम
int burst_time[] = {10, 5, 8};
// टाइम क्वांटम
int quantum = 2;
findavgTime(processes, n, burst_time, quantum);
return 0;
}
इस कोड का आउटपुट निम्न आयेगा:
प्रोसेस उर्स्त टाइम  वेटिंग टाइम  टर्न अराउंड टाइम
 1        10     13         23
 2        5     10         15
 3        8     13         21
औसत वेटिंग टाइम = 12
औसत टर्न अराउंड टाइम = 19.6667

इस तरह से राउंड रोबिन शेड्यूलिंग अल्गोरिथम का प्रयोग कर के आप इन चीजों को कैलकुलेट कर सकते हैं।

इस लेख से सम्बंधित यदि आपका कोई भी सवाल या सुझाव है, तो आप उसे नीचे कमेंट में लिख सकते हैं।

About the author

अनुपम कुमार सिंह

बीआईटी मेसरा, रांची से कंप्यूटर साइंस और टेक्लॉनजी में स्नातक। गाँधी कि कर्मभूमि चम्पारण से हूँ। समसामयिकी पर कड़ी नजर और इतिहास से ख़ास लगाव। भारत के राजनितिक, सांस्कृतिक और भौगोलिक इतिहास में दिलचस्पी ।

Add Comment

Click here to post a comment

फेसबुक पर दा इंडियन वायर से जुड़िये!

Want to work with us? Looking to share some feedback or suggestion? Have a business opportunity to discuss?

You can reach out to us at [email protected]