C प्रोग्राम फॉर FCFS शेड्यूलिंग (FCFS Scheduling)

हमें n संख्या में प्रक्रियाएं दी गई हैं यानी P1, P2, P3,.......,Pn और उनके संबंधित बर्स्ट टाइम। कार्य FCFS CPU शेड्यूलिंग एल्गोरिदम का उपयोग करके औसत प्रतीक्षा समय और औसत टर्नअराउंड समय ढूंढना है।

प्रतीक्षा समय और टर्नअराउंड समय क्या है?

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

  टर्नअराउंड टाइम = प्रक्रिया का पूरा होना - प्रक्रिया का सबमिशन

• प्रतीक्षा समय टर्नअराउंड टाइम और बर्स्ट टाइम के बीच का अंतर है।

  प्रतीक्षा समय = टर्नअराउंड टाइम - बर्स्ट टाइम

FCFS शेड्यूलिंग क्या है?

फर्स्ट कम, फर्स्ट सर्व्ड (FCFS) जिसे फर्स्ट इन, फर्स्ट आउट (FIFO) के नाम से भी जाना जाता है, वह CPU शेड्यूलिंग एल्गोरिदम है जिसमें CPU को रेडी क्यू में कतारबद्ध प्रक्रियाओं को उस क्रम में आवंटित किया जाता है जिस क्रम में वे कतारबद्ध हैं।

FCFS नॉन-प्रीमेप्टिव शेड्यूलिंग का पालन करता है जिसका अर्थ है कि एक बार CPU किसी प्रक्रिया को आवंटित हो जाने पर यह तब तक CPU नहीं छोड़ता जब तक कि प्रक्रिया समाप्त नहीं हो जाती या किसी I/O इंटरप्ट के कारण रुक नहीं जाती।

उदाहरण

मान लीजिए, चार प्रक्रियाएं P2, P3, P1 के क्रम में आ रही हैं जिनके संबंधित निष्पादन समय तालिका में नीचे दिखाए गए हैं। साथ ही, उनके आगमन समय को 0 मान लें।

प्रणाली में प्रक्रियाओं P1, P2 और P3 के प्रतीक्षा समय को दर्शाता गैंट चार्ट

ऊपर दिखाए अनुसार,

प्रक्रिया P2 का प्रतीक्षा समय 0 है

प्रक्रिया P3 का प्रतीक्षा समय 3 है

प्रक्रिया P1 का प्रतीक्षा समय 6 है

औसत समय = (0 + 3 + 6) / 3 = 3 मिसेक।

चूंकि हमने आगमन समय को 0 माना है इसलिए टर्नअराउंड टाइम और कंप्लीशन टाइम समान होंगे।

उदाहरण

Input-: processes = P1, P2, P3   Burst time = 5, 8, 12
Output-: Processes  Burst  Waiting  Turn around
1        5        0        5
2        8        5        13
3        12       13       25
Average Waiting time = 6.000000
Average turn around time = 14.333333

एल्गोरिदम

Start
Step 1 -> फंक्शन int waitingtime(int proc[], int n, int burst_time[], int wait_time[])
    wait_time[0] = 0 सेट करें
    Loop For i = 1 and i < n and i++
        wait_time[i] = burst_time[i-1] + wait_time[i-1] सेट करें
    End For

Step 2 -> फंक्शन int turnaroundtime(int proc[], int n, int burst_time[], int wait_time[], int tat[])
    Loop For i = 0 and i < n and i++
        tat[i] = burst_time[i] + wait_time[i] सेट करें
    End For

Step 3 -> फंक्शन int avgtime(int proc[], int n, int burst_time[])
    wait_time[n], tat[n], total_wt = 0, total_tat = 0 घोषित और आरंभ करें
    waitingtime(proc, n, burst_time, wait_time) कॉल करें
    turnaroundtime(proc, n, burst_time, wait_time, tat) कॉल करें
    Loop For i=0 and i int main() में
    इनपुट इंट proc[] = {1, 2, 3} घोषित करें
    n = sizeof proc / sizeof proc[0] घोषित और आरंभ करें
    burst_time[] = {10, 5, 8} घोषित और आरंभ करें
    avgtime(proc, n, burst_time) कॉल करें
Stop

उदाहरण

#include <stdio.h>

// सभी प्रक्रियाओं के लिए प्रतीक्षा समय खोजने का फंक्शन
int waitingtime(int proc[], int n, int burst_time[], int wait_time[]) {
    // पहली प्रक्रिया के लिए प्रतीक्षा समय 0 है
    wait_time[0] = 0;
    // प्रतीक्षा समय की गणना
    for (int i = 1; i < n; i++)
        wait_time[i] = burst_time[i-1] + wait_time[i-1];
    return 0;
}

// टर्नअराउंड टाइम गणना करने का फंक्शन
int turnaroundtime(int proc[], int n, int burst_time[], int wait_time[], int tat[]) {
    // burst_time[i] + wait_time[i] जोड़कर टर्नअराउंड टाइम की गणना
    int i;
    for (i = 0; i < n; i++)
        tat[i] = burst_time[i] + wait_time[i];
    return 0;
}

// औसत समय गणना करने का फंक्शन
int avgtime(int proc[], int n, int burst_time[]) {
    int wait_time[n], tat[n], total_wt = 0, total_tat = 0;
    int i;
    // सभी प्रक्रियाओं के प्रतीक्षा समय खोजने का फंक्शन
    waitingtime(proc, n, burst_time, wait_time);
    // सभी प्रक्रियाओं के लिए टर्नअराउंड टाइम खोजने का फंक्शन
    turnaroundtime(proc, n, burst_time, wait_time, tat);
    // सभी विवरणों के साथ प्रक्रियाओं को प्रदर्शित करें
    printf("Processes  Burst  Waiting Turn around \n");
    // कुल प्रतीक्षा समय और कुल टर्नअराउंड टाइम की गणना
    for (i = 0; i < n; i++) {
        total_wt = total_wt + wait_time[i];
        total_tat = total_tat + tat[i];
        printf(" %d\t %d\t\t %d \t%d\n", i+1, burst_time[i], wait_time[i], tat[i]);
    }
    printf("Average waiting time = %f\n", (float)total_wt / (float)n);
    printf("Average turn around time = %f\n", (float)total_tat / (float)n);
    return 0;
}

// मुख्य फंक्शन
int main() {
    // प्रोसेस IDs
    int proc[] = {1, 2, 3};
    int n = sizeof proc / sizeof proc[0];
    // सभी प्रक्रियाओं का बर्स्ट टाइम
    int burst_time[] = {5, 8, 12};
    avgtime(proc, n, burst_time);
    return 0;
}

आउटपुट

Processes  Burst  Waiting Turn around
1        5        0        5
2        8        5        13
3        12       13       25
Average Waiting time = 6.000000
Average turn around time = 14.333333