Scribd Logo
Upload

Welcome to Scribd!

  • 349 views

    Priority CPU Scheduling With Different Arrival Time

    Uploaded by

    Magarsa Bedasa
    This document discusses priority CPU scheduling with different arrival times. It provides an example of input data with process IDs, arrival times, burst times, and priorities. It then outlines the steps to implement priority scheduling: 1) sort by arrival time, breaking ties by priority, 2) apply first-come first-served scheduling within priority groups. The code provided implements this algorithm, calculating waiting times, turnaround times, and average metrics. It outputs the Gantt chart with start and completion times for each process.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    Priority CPU Scheduling With Different Arrival Time

    Uploaded by

    Magarsa Bedasa
    349 views11 pages
    This document discusses priority CPU scheduling with different arrival times. It provides an example of input data with process IDs, arrival times, burst times, and priorities. It then outlines the steps to implement priority scheduling: 1) sort by arrival time, breaking ties by priority, 2) apply first-come first-served scheduling within priority groups. The code provided implements this algorithm, calculating waiting times, turnaround times, and average metrics. It outputs the Gantt chart with start and completion times for each process.

    Original Description:

    vvvvvvvvvvvvvvvvvvvvvvvv

    Original Title

    Priority CPU Scheduling with different arrival time

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    This document discusses priority CPU scheduling with different arrival times. It provides an example of input data with process IDs, arrival times, burst times, and priorities. It then outlines the steps to implement priority scheduling: 1) sort by arrival time, breaking ties by priority, 2) apply first-come first-served scheduling within priority groups. The code provided implements this algorithm, calculating waiting times, turnaround times, and average metrics. It outputs the Gantt chart with start and completion times for each process.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    349 views11 pages

    Priority CPU Scheduling With Different Arrival Time

    Uploaded by

    Magarsa Bedasa
    This document discusses priority CPU scheduling with different arrival times. It provides an example of input data with process IDs, arrival times, burst times, and priorities. It then outlines the steps to implement priority scheduling: 1) sort by arrival time, breaking ties by priority, 2) apply first-come first-served scheduling within priority groups. The code provided implements this algorithm, calculating waiting times, turnaround times, and average metrics. It outputs the Gantt chart with start and completion times for each process.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    You are on page 1of 11

    Priority CPU Scheduling with different

    arrival time – Set 2


     Difficulty Level : Easy
     Last Updated : 08 Dec, 2021

    Prerequisite – Program for Priority Scheduling – Set 1


    Priority scheduling is a non-preemptive algorithm and one of the most common
    scheduling algorithms in batch systems. Each process is assigned first arrival time (less
    arrival time process first) if two processes have same arrival time, then compare to
    priorities (highest process first). Also, if two processes have same priority then compare
    to process number (less process number first). This process is repeated while all process
    get executed.
    Implementation – 
    1. First input the processes with their arrival time, burst time and priority.
    2. First process will schedule, which have the lowest arrival time, if two or more
    processes will have lowest arrival time, then whoever has higher priority will
    schedule first.
    3. Now further processes will be schedule according to the arrival time and priority of
    the process. (Here we are assuming that lower the priority number having higher
    priority). If two process priority are same then sort according to process number.
    Note: In the question, They will clearly mention, which number will have higher
    priority and which number will have lower priority.
    4. Once all the processes have been arrived, we can schedule them based on their
    priority.
    Gantt Chart – 

    Examples – 
    Input :
    process no-> 1 2 3 4 5
    arrival time-> 0 1 3 2 4
    burst time-> 3 6 1 2 4
    priority-> 3 4 9 7 8
    Output :
    Process_no arrival_time Burst_time Complete_time
    Turn_Around_Time Waiting_Time
    1 0 3 3 3
    0
    2 1 6 9 8
    2
    3 3 1 16 13
    12
    4 2 2 11 9
    7
    5 4 4 15 11
    7
    Average Waiting Time is : 5.6
    Average Turn Around time is : 8.8
    Recommended: Please try your approach on {IDE} first, before moving on to the
    solution.

     C++
     Java
     Python3

    // C++ implementation for Priority Scheduling with

    //Different Arrival Time priority scheduling

    /*1. sort the processes according to arrival time


    2. if arrival time is same the acc to priority

    3. apply fcfs

    */

    #include <bits/stdc++.h>

    using namespace std;

    #define totalprocess 5

    // Making a struct to hold the given input

    struct process

    int at,bt,pr,pno;

    };

    process proc[50];
    /*

    Writing comparator function to sort according to priority if

    arrival time is same

    */

    bool comp(process a,process b)

    if(a.at == b.at)

    return a.pr<b.pr;

    else

        return a.at<b.at;

    // Using FCFS Algorithm to find Waiting time

    void get_wt_time(int wt[])

    {
    // declaring service array that stores cumulative burst time

    int service[50];

    // Initialising initial elements of the arrays

    service[0] = proc[0].at;

    wt[0]=0;

    for(int i=1;i<totalprocess;i++)

    service[i]=proc[i-1].bt+service[i-1];

    wt[i]=service[i]-proc[i].at;

    // If waiting time is negative, change it into zero

        if(wt[i]<0)

        {

        wt[i]=0;
        }

    void get_tat_time(int tat[],int wt[])

    // Filling turnaroundtime array

    for(int i=0;i<totalprocess;i++)

        tat[i]=proc[i].bt+wt[i];

    void findgc()

    //Declare waiting time and turnaround time array


    int wt[50],tat[50];

    double wavg=0,tavg=0;

    // Function call to find waiting time array

    get_wt_time(wt);

    //Function call to find turnaround time

    get_tat_time(tat,wt);

    int stime[50],ctime[50];

    stime[0] = proc[0].at;

    ctime[0]=stime[0]+tat[0];

    // calculating starting and ending time

    for(int i=1;i<totalprocess;i++)

        {

            stime[i]=ctime[i-1];

            ctime[i]=stime[i]+tat[i]-wt[i];
        }

    cout<<"Process_no\tStart_time\tComplete_time\tTurn_Around_Time\
    tWaiting_Time"<<endl;

        // display the process details

    for(int i=0;i<totalprocess;i++)

        {

            wavg += wt[i];

            tavg += tat[i];

            cout<<proc[i].pno<<"\t\t"<<

                stime[i]<<"\t\t"<<ctime[i]<<"\t\t"<<

                tat[i]<<"\t\t\t"<<wt[i]<<endl;

        }

            // display the average waiting time

            //and average turn around time


        cout<<"Average waiting time is : ";

        cout<<wavg/(float)totalprocess<<endl;

        cout<<"average turnaround time : ";

        cout<<tavg/(float)totalprocess<<endl;

    int main()

    int arrivaltime[] = { 1, 2, 3, 4, 5 };

    int bursttime[] = { 3, 5, 1, 7, 4 };

    int priority[] = { 3, 4, 1, 7, 8 };

    for(int i=0;i<totalprocess;i++)

        proc[i].at=arrivaltime[i];

        proc[i].bt=bursttime[i];

        proc[i].pr=priority[i];

        proc[i].pno=i+1;

        }
        //Using inbuilt sort function

        sort(proc,proc+totalprocess,comp);

        //Calling function findgc for finding Gantt Chart

        findgc();

        return 0;

    // This code is contributed by Anukul Chand.

    Output: 
    Process_no Start_time Complete_time Turn_Around_Time Waiting_Time
    1 1 4 3 0
    2 5 10 8 3
    3 4 5 2 1
    4 10 17 13 6
    5 17 21 16 12
    Average Waiting Time is : 4.4
    Average Turn Around time is : 8.4
    Time Complexity: O(N * logN), where N is the total number of processes. 
    Auxiliary Space: O(N) 
    This article is contributed by Amit Verma . If you like GeeksforGeeks and would like to
    contribute, you can also write an article using contribute.geeksforgeeks.org or mail your
    article to contribute@geeksforgeeks.org. See your article appearing on the
    GeeksforGeeks main page and help other Geeks.
    Please write comments if you find anything incorrect, or you want to share more
    information about the topic discussed above.

    You might also like