Program for FCFS CPU Scheduling | Set 1

19 Apr, 2021
Given n processes with their burst times, the task is to find average waiting time and average turn around time using FCFS scheduling algorithm. First in, first out (FIFO), also known as first come, first served (FCFS), is the simplest scheduling algorithm. FIFO simply queues processes in the order that they arrive in the ready queue. In this, the process that comes first will be executed first and next process starts only after the previous gets fully executed. Here we are considering that arrival time for all processes is 0.How to compute below times in Round Robin using a program?  
Completion Time: Time at which process completes its execution.Turn Around Time: Time Difference between completion time and arrival time. Turn Around Time = Completion Time – Arrival TimeWaiting Time(W.T): Time Difference between turn around time and burst time. Waiting Time = Turn Around Time – Burst Time
Completion Time: Time at which process completes its execution.
Turn Around Time: Time Difference between completion time and arrival time. Turn Around Time = Completion Time – Arrival Time
Waiting Time(W.T): Time Difference between turn around time and burst time. Waiting Time = Turn Around Time – Burst Time
 
In this post, we have assumed arrival times as 0, so turn around and completion times are same. 
Implementation:  
1-  Input the processes along with their burst time (bt).
2-  Find waiting time (wt) for all processes.
3-  As first process that comes need not to wait so 
    waiting time for process 1 will be 0 i.e. wt[0] = 0.
4-  Find waiting time for all other processes i.e. for
     process i -> 
       wt[i] = bt[i-1] + wt[i-1] .
5-  Find turnaround time = waiting_time + burst_time 
    for all processes.
6-  Find average waiting time = 
                 total_waiting_time / no_of_processes.
7-  Similarly, find average turnaround time = 
                 total_turn_around_time / no_of_processes.
 
 
C++
C
Java
Python 3
C#
Javascript
// C++ program for implementation of FCFS// scheduling#include<iostream>using namespace std; // Function to find the waiting time for all// processesvoid findWaitingTime(int processes[], int n,                          int bt[], int wt[]){    // waiting time for first process is 0    wt[0] = 0;     // calculating waiting time    for (int  i = 1; i < n ; i++ )        wt[i] =  bt[i-1] + wt[i-1] ;} // Function to calculate turn around timevoid findTurnAroundTime( int processes[], int n,                  int bt[], int wt[], int tat[]){    // calculating turnaround time by adding    // bt[i] + wt[i]    for (int  i = 0; i < n ; i++)        tat[i] = bt[i] + wt[i];} //Function to calculate average timevoid findavgTime( int processes[], int n, int bt[]){    int wt[n], tat[n], total_wt = 0, total_tat = 0;     //Function to find waiting time of all processes    findWaitingTime(processes, n, bt, wt);     //Function to find turn around time for all processes    findTurnAroundTime(processes, n, bt, wt, tat);     //Display processes along with all details    cout << "Processes  "<< " Burst time  "         << " Waiting time  " << " Turn around time\n";     // Calculate total waiting time and total turn    // around time    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;} // Driver codeint main(){    //process id's    int processes[] = { 1, 2, 3};    int n = sizeof processes / sizeof processes[0];     //Burst time of all processes    int  burst_time[] = {10, 5, 8};     findavgTime(processes, n,  burst_time);    return 0;}
// C program for implementation of FCFS // scheduling#include<stdio.h>// Function to find the waiting time for all // processesvoid findWaitingTime(int processes[], int n,                           int bt[], int wt[]){    // waiting time for first process is 0    wt[0] = 0;       // calculating waiting time    for (int  i = 1; i < n ; i++ )        wt[i] =  bt[i-1] + wt[i-1] ;}   // Function to calculate turn around timevoid findTurnAroundTime( int processes[], int n,                   int bt[], int wt[], int tat[]){    // calculating turnaround time by adding    // bt[i] + wt[i]    for (int  i = 0; i < n ; i++)        tat[i] = bt[i] + wt[i];}   //Function to calculate average timevoid findavgTime( int processes[], int n, int bt[]){    int wt[n], tat[n], total_wt = 0, total_tat = 0;       //Function to find waiting time of all processes    findWaitingTime(processes, n, bt, wt);       //Function to find turn around time for all processes    findTurnAroundTime(processes, n, bt, wt, tat);       //Display processes along with all details    printf("Processes   Burst time   Waiting time   Turn around time\n");       // Calculate total waiting time and total turn     // around time    for (int  i=0; i<n; i++)    {        total_wt = total_wt + wt[i];        total_tat = total_tat + tat[i];        printf("   %d ",(i+1));        printf("       %d ", bt[i] );        printf("       %d",wt[i] );        printf("       %d\n",tat[i] );    }    int s=(float)total_wt / (float)n;    int t=(float)total_tat / (float)n;    printf("Average waiting time = %d",s);    printf("\n");    printf("Average turn around time = %d ",t);}   // Driver codeint main(){    //process id's    int processes[] = { 1, 2, 3};    int n = sizeof processes / sizeof processes[0];       //Burst time of all processes    int  burst_time[] = {10, 5, 8};       findavgTime(processes, n,  burst_time);    return 0;}// This code is contributed by Shivi_Aggarwal
// Java program for implementation of FCFS// scheduling import java.text.ParseException; class GFG {     // Function to find the waiting time for all    // processes    static void findWaitingTime(int processes[], int n,            int bt[], int wt[]) {        // waiting time for first process is 0        wt[0] = 0;         // calculating waiting time        for (int i = 1; i < n; i++) {            wt[i] = bt[i - 1] + wt[i - 1];        }    }     // Function to calculate turn around time    static void findTurnAroundTime(int processes[], int n,            int bt[], int wt[], int tat[]) {        // calculating turnaround time by adding        // bt[i] + wt[i]        for (int i = 0; i < n; i++) {            tat[i] = bt[i] + wt[i];        }    }     //Function to calculate average time    static void findavgTime(int processes[], int n, int bt[]) {        int wt[] = new int[n], tat[] = new int[n];        int total_wt = 0, total_tat = 0;         //Function to find waiting time of all processes        findWaitingTime(processes, n, bt, wt);         //Function to find turn around time for all processes        findTurnAroundTime(processes, n, bt, wt, tat);         //Display processes along with all details        System.out.printf("Processes Burst time Waiting"                       +" time Turn around time\n");         // Calculate total waiting time and total turn        // around time        for (int i = 0; i < n; i++) {            total_wt = total_wt + wt[i];            total_tat = total_tat + tat[i];            System.out.printf(" %d ", (i + 1));            System.out.printf("     %d ", bt[i]);            System.out.printf("     %d", wt[i]);            System.out.printf("     %d\n", tat[i]);        }        float s = (float)total_wt /(float) n;        int t = total_tat / n;        System.out.printf("Average waiting time = %f", s);        System.out.printf("\n");        System.out.printf("Average turn around time = %d ", t);    }     // Driver code    public static void main(String[] args) throws ParseException {        //process id's        int processes[] = {1, 2, 3};        int n = processes.length;         //Burst time of all processes        int burst_time[] = {10, 5, 8};         findavgTime(processes, n, burst_time);     }}// This code is contributed by 29ajaykumar
# Python3 program for implementation# of FCFS scheduling # Function to find the waiting# time for all processesdef findWaitingTime(processes, n,                    bt, wt):     # waiting time for    # first process is 0    wt[0] = 0     # calculating waiting time    for i in range(1, n ):        wt[i] = bt[i - 1] + wt[i - 1] # Function to calculate turn# around timedef findTurnAroundTime(processes, n,                       bt, wt, tat):     # calculating turnaround    # time by adding bt[i] + wt[i]    for i in range(n):        tat[i] = bt[i] + wt[i] # Function to calculate# average timedef findavgTime( processes, n, bt):     wt = [0] * n    tat = [0] * n    total_wt = 0    total_tat = 0     # Function to find waiting    # time of all processes    findWaitingTime(processes, n, bt, wt)     # Function to find turn around    # time for all processes    findTurnAroundTime(processes, n,                       bt, wt, tat)     # Display processes along    # with all details    print( "Processes Burst time " +                  " Waiting time " +                " Turn around time")     # Calculate total waiting time    # and total turn around time    for i in range(n):             total_wt = total_wt + wt[i]        total_tat = total_tat + tat[i]        print(" " + str(i + 1) + "\t\t" +                    str(bt[i]) + "\t " +                    str(wt[i]) + "\t\t " +                    str(tat[i]))     print( "Average waiting time = "+                   str(total_wt / n))    print("Average turn around time = "+                     str(total_tat / n)) # Driver codeif __name__ =="__main__":         # process id's    processes = [ 1, 2, 3]    n = len(processes)     # Burst time of all processes    burst_time = [10, 5, 8]     findavgTime(processes, n, burst_time) # This code is contributed# by ChitraNayal
// C# program for implementation of FCFS// schedulingusing System;     class GFG{     // Function to find the waiting time for all    // processes    static void findWaitingTime(int []processes, int n,                                int []bt, int[] wt)    {        // waiting time for first process is 0        wt[0] = 0;         // calculating waiting time        for (int i = 1; i < n; i++)        {            wt[i] = bt[i - 1] + wt[i - 1];        }    }     // Function to calculate turn around time    static void findTurnAroundTime(int []processes, int n,            int []bt, int []wt, int []tat) {        // calculating turnaround time by adding        // bt[i] + wt[i]        for (int i = 0; i < n; i++)        {            tat[i] = bt[i] + wt[i];        }    }     // Function to calculate average time    static void findavgTime(int []processes, int n, int []bt)    {        int []wt = new int[n];        int []tat = new int[n];        int total_wt = 0, total_tat = 0;         //Function to find waiting time of all processes        findWaitingTime(processes, n, bt, wt);         //Function to find turn around time for all processes        findTurnAroundTime(processes, n, bt, wt, tat);         //Display processes along with all details        Console.Write("Processes Burst time Waiting"                    +" time Turn around time\n");         // Calculate total waiting time and total turn        // around time        for (int i = 0; i < n; i++)        {            total_wt = total_wt + wt[i];            total_tat = total_tat + tat[i];            Console.Write(" {0} ", (i + 1));            Console.Write("     {0} ", bt[i]);            Console.Write("     {0}", wt[i]);            Console.Write("     {0}\n", tat[i]);        }        float s = (float)total_wt /(float) n;        int t = total_tat / n;        Console.Write("Average waiting time = {0}", s);        Console.Write("\n");        Console.Write("Average turn around time = {0} ", t);    }     // Driver code    public static void Main(String[] args)    {        // process id's        int []processes = {1, 2, 3};        int n = processes.Length;         // Burst time of all processes        int []burst_time = {10, 5, 8};         findavgTime(processes, n, burst_time);    }} // This code contributed by Rajput-Ji
<script>     // JavaScript program for implementation of FCFS   // scheduling           // Function to find the waiting time for all  // processes    function findWaitingTime(processes,n,bt,wt)    {        // waiting time for first process is 0        wt[0] = 0;           // calculating waiting time        for (let i = 1; i < n; i++) {            wt[i] = bt[i - 1] + wt[i - 1];        }    }         function findTurnAroundTime(processes,n,bt,wt,tat)    {        // calculating turnaround time by adding        // bt[i] + wt[i]        for (let i = 0; i < n; i++) {            tat[i] = bt[i] + wt[i];        }    }         function findavgTime(processes,n,bt)    {        let wt = new Array(n), tat = new Array(n);        for(let i=0;i<n;i++)        {            wt[i]=0;            tat[i]=0;        }        let total_wt = 0, total_tat = 0;           //Function to find waiting time of all processes        findWaitingTime(processes, n, bt, wt);           //Function to find turn around time for all processes        findTurnAroundTime(processes, n, bt, wt, tat);           //Display processes along with all details        document.write("Processes Burst time Waiting"                       +" time Turn around time<br>");           // Calculate total waiting time and total turn        // around time        for (let i = 0; i < n; i++) {            total_wt = total_wt + wt[i];            total_tat = total_tat + tat[i];            document.write("    ", (i + 1)+" ");            document.write("     "+  bt[i]+" ");            document.write("     "+ wt[i]);            document.write("     "+ tat[i]+"<br>");        }        let s = total_wt / n;        let t = Math.floor(total_tat / n);        document.write("Average waiting time = "+ s);        document.write("<br>");        document.write("Average turn around time = ", t+" ");    }         let processes=[1,2,3];    let  n = processes.length;         let burst_time=[10,5,8];    findavgTime(processes, n, burst_time);         // This code is contributed by rag2127     </script>
Output: 
Processes  Burst time  Waiting time  Turn around time
 1        10     0         10
 2        5     10         15
 3        8     15         23
Average waiting time = 8.33333
Average turn around time = 16
Important Points:  
Non-preemptiveAverage Waiting Time is not optimalCannot utilize resources in parallel : Results in Convoy effect (Consider a situation when many IO bound processes are there and one CPU bound process. The IO bound processes have to wait for CPU bound process when CPU bound process acquires CPU. The IO bound process could have better taken CPU for some time, then used IO devices).
Non-preemptive
Average Waiting Time is not optimal
Cannot utilize resources in parallel : Results in Convoy effect (Consider a situation when many IO bound processes are there and one CPU bound process. The IO bound processes have to wait for CPU bound process when CPU bound process acquires CPU. The IO bound process could have better taken CPU for some time, then used IO devices).
Shivi_Aggarwal
ukasp
29AjayKumar
Rajput-Ji
rag2127
cpu-scheduling
Operating Systems
Operating Systems
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Cache Memory in Computer Organization
LRU Cache Implementation
'crontab' in Linux with Examples
Cd cmd command
Memory Management in Operating System
Last Minute Notes – Operating Systems
Commonly Asked Operating Systems Interview Questions
Preemptive and Non-Preemptive Scheduling
Difference between Internal and External fragmentation
File Access Methods in Operating System