Sat. Mar 2nd, 2024
    priority scheduling algorithm in hindi

    विषय-सूचि

    प्रायोरिटी शेड्यूलिंग क्या है? (priority scheduling in hindi)

    प्रायोरिटी शेड्यूलिंग ऑपरेटिंग सिस्टम में एक नॉन-preemptive अल्गोरिथम है और ये सबसे सामान्य शेड्यूलिंग अल्गोरिथम में से एक है। इसमें हरेक प्रोसेस को रक प्रायोरिटी दी जाती है।

    जिस प्रोसेस की प्रायोरिटी सबसे ज्यादा होगी उसे एक्सीक्यूट किया जाता है और ऐसा चलता रहता है।

    अगर दो प्रोसेस की प्रायोरिटी समान हो तब उनमे से फर्स्ट कम फर्स्ट सर्व के आधार पर चयन किया जाता है। प्रायोरिटी का निर्णय मेमोरी, टाइम या अन्य चीजों के जरूरत के हिसाब से हो सकता है।

    इम्प्लीमेंटेशन कैसे करें?

    1- सबसे पहले प्रोसेस को उनके बर्स्ट टाइम और प्रायोरिटी के साथ इनपुट करें।
    2- रोसेस, बर्स्ट टाइम और प्रायोरिटी को उनके प्रायोरिटी के आधार पर सॉर्ट करें।
    3- सब सिम्पली FCFS अल्गोरिथम को अप्लाई करें।

    prior

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

    एजिंग एक ऐसा तकनीक है जिसे ऐसे प्रोसेस जो लम्बे समय से क्यू में इन्तजार कर रहे हैं उनकी प्रायोरिटी को धीरे-धीरे बढाते हैं।

    प्रायोरिटी शेड्यूलिंग कोड (priority scheduling code in hindi)

    C++ प्रोग्राम FCFS के इम्प्लीमेंटेशन के लिए
    // शेड्यूलिंग
    #include<bits/stdc++.h>
    using namespace std;
    struct Process
    {
        int pid;  // प्रोसेस ID
        int bt;   // CPUबरत टाइम की जरुरत
        int priority; // इस प्रोसेस की प्रायोरिटी
    };
    // प्रोसेस को प्रायोरिटी के आधार पर सॉर्ट करने के लिए फंक्शन
    bool comparison(Process a, Process b)
    {
        return (a.priority > b.priority);
    }
    // सारे प्रोसेस के लिए वेटिंग टाइम पता करने का
    //प्रोसेस
    void findWaitingTime(Process proc[], int n,
                         int wt[])
    {
        // पहले प्रोसेस के लिए वेटिंग टाइम है 0
        wt[0] = 0;
        // वेटिंग टाइम का कैलकुलेशन
        for (int  i = 1; i < n ; i++ )
            wt[i] =  proc[i-1].bt + wt[i-1] ;
    }
    // टर्न अराउंड टाइम पता करने का कैलकुलेशन
    void findTurnAroundTime( Process proc[], int n,
                             int wt[], int tat[])
    {
        // टर्न अराउंड टाइम कैलकुलेट करने के लिए जोड़ें:
        // bt[i] + wt[i]
        for (int  i = 0; i < n ; i++)
            tat[i] = proc[i].bt + wt[i];
    }
    //एवरेज टाइम कैलकुलेट करने के लिए फंक्शन
    void findavgTime(Process proc[], int n)
    {
        int wt[n], tat[n], total_wt = 0, total_tat = 0;
        //सारे प्रोसेस के वेटिंग टाइम को पता करने का प्रोसेस
        findWaitingTime(proc, n, wt);
        //सभी प्रोसेस के टर्न अराउंड टाइम पता करने का प्रोसेस
        findTurnAroundTime(proc, n, wt, tat);
        //प्रोसेस को उसके डिटेल के साथ दिखाएँ
        cout << "\nProcesses  "<< " 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 << "   " << proc[i].pid << "\t\t"
                 << proc[i].bt << "\t    " << wt[i]
                 << "\t\t  " << tat[i] <<endl;
        }
        cout << "\nAverage waiting time = "
             << (float)total_wt / (float)n;
        cout << "\nAverage turn around time = "
             << (float)total_tat / (float)n;
    }
    void priorityScheduling(Process proc[], int n)
    {
        // प्रोसेस को प्रायोरिटी के आधार पर सॉर्ट करें
        sort(proc, proc + n, comparison);
        cout<< "Order in which processes gets executed \n";
        for (int  i = 0 ; i <  n; i++)
            cout << proc[i].pid <<" " ;
        findavgTime(proc, n);
    }
    // Driver code
    int main()
    {
        Process proc[] = {{1, 10, 2}, {2, 5, 0}, {3, 8, 1}};
        int n = sizeof proc / sizeof proc[0];
        priorityScheduling(proc, n);
        return 0;
    }
    इस प्रोग्राम का आउटपुट ऐसे आयेगा:
    Order in which processes gets executed 
    1 3 2 
    Processes  Burst time  Waiting time  Turn around time
     1        10     0         10
     3        8     10         18
     2        5     18         23
    
    Average waiting time = 9.33333
    Average turn around time = 17

    यहाँ प्रोसेस का अर्रिवल टाइम 0 लिया गया है।

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

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

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

    One thought on “ऑपरेटिंग सिस्टम में प्रायोरिटी शेड्यूलिंग एल्गोरिथ्म; परिभाषा, उदाहरण, कोड”

    Leave a Reply

    Your email address will not be published. Required fields are marked *