Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 38 views

    Preemptive or Non-Preemptive.: Program For Shortest Job First (Or SJF) CPU Scheduling - Set 1 (Non-Preemptive)

    Uploaded by

    Varob
    The shortest job first (SJF) CPU scheduling algorithm selects the waiting process with the shortest execution time to execute next. It aims to minimize average waiting times. SJF can be preemptive or non-preemptive. It has advantages like minimum average waiting time but may cause starvation if shorter processes arrive frequently. Estimating execution times accurately is needed for SJF to be practical.

    Copyright:

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

    Preemptive or Non-Preemptive.: Program For Shortest Job First (Or SJF) CPU Scheduling - Set 1 (Non-Preemptive)

    Uploaded by

    Varob
    38 views4 pages
    The shortest job first (SJF) CPU scheduling algorithm selects the waiting process with the shortest execution time to execute next. It aims to minimize average waiting times. SJF can be preemptive or non-preemptive. It has advantages like minimum average waiting time but may cause starvation if shorter processes arrive frequently. Estimating execution times accurately is needed for SJF to be practical.

    Original Title

    SJF

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The shortest job first (SJF) CPU scheduling algorithm selects the waiting process with the shortest execution time to execute next. It aims to minimize average waiting times. SJF can be preemptive or non-preemptive. It has advantages like minimum average waiting time but may cause starvation if shorter processes arrive frequently. Estimating execution times accurately is needed for SJF to be practical.

    Copyright:

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

    Preemptive or Non-Preemptive.: Program For Shortest Job First (Or SJF) CPU Scheduling - Set 1 (Non-Preemptive)

    Uploaded by

    Varob
    The shortest job first (SJF) CPU scheduling algorithm selects the waiting process with the shortest execution time to execute next. It aims to minimize average waiting times. SJF can be preemptive or non-preemptive. It has advantages like minimum average waiting time but may cause starvation if shorter processes arrive frequently. Estimating execution times accurately is needed for SJF to be practical.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    of 4

    Program for Shortest Job First (or SJF) CPU Scheduling | Set 1 (Non- preemptive)

    The shortest job first (SJF) or shortest job next, is a scheduling policy that selects the waiting process
    with the smallest execution time to execute next. SJN, also known as Shortest Job Next (SJN), can
    be preemptive or non-preemptive.  

    Characteristics of SJF Scheduling:

     Shortest Job first has the advantage of having a minimum average waiting time among
    all scheduling algorithms.

     It is a Greedy Algorithm.

     It may cause starvation if shorter processes keep coming. This problem can be solved using
    the concept of ageing.

     It is practically infeasible as Operating System may not know burst times and therefore may
    not sort them. While it is not possible to predict execution time, several methods can be
    used to estimate the execution time for a job, such as a weighted average of previous
    execution times. 

     SJF can be used in specialized environments where accurate estimates of running time are
    available.

    Algorithm: 

     Sort all the processes according to the arrival time. 

     Then select that process that has minimum arrival time and minimum Burst time. 

     After completion of the process make a pool of processes that arrives afterward till the
    completion of the previous process and select that process among the pool which is having
    minimum Burst time. 

     
    How to compute below times in SJF 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 Time

     Waiting Time(W.T): Time Difference between turn around time and burst time. 
    Waiting Time = Turn Around Time – Burst Time

    Advantages of SJF:

     SJF is better than the First come first serve(FCFS) algorithm as it reduces the average waiting
    time.

     SJF is generally used for long term scheduling

     It is suitable for the jobs running in batches, where run times are already known.

     SJF is probably optimal in terms of average turnaround time.

    Disadvantages of SJF: 

     SJF may cause very long turn-around times or starvation.

     In SJF job completion time must be known earlier, but sometimes it is hard to predict.

     Sometimes, it is complicated to predict the length of the upcoming CPU request.

     It leads to the starvation that does not reduce average turnaround time.
    #include <stdio.h>

    int main()

        int A[100][4]; // Matrix for storing Process Id, Burst

                       // Time, Average Waiting Time & Average

                       // Turn Around Time.

        int i, j, n, total = 0, index, temp;

        float avg_wt, avg_tat;

        printf("Enter number of process: ");

        scanf("%d", &n);

        printf("Enter Burst Time:\n");

        // User Input Burst Time and alloting Process Id.

        for (i = 0; i < n; i++) {

            printf("P%d: ", i + 1);

            scanf("%d", &A[i][1]);

            A[i][0] = i + 1;

        }

        // Sorting process according to their Burst Time.

        for (i = 0; i < n; i++) {

            index = i;

            for (j = i + 1; j < n; j++)

                if (A[j][1] < A[index][1])

                    index = j;

            temp = A[i][1];

            A[i][1] = A[index][1];

            A[index][1] = temp;

            temp = A[i][0];

            A[i][0] = A[index][0];

            A[index][0] = temp;

        }
        A[0][2] = 0;

        // Calculation of Waiting Times

        for (i = 1; i < n; i++) {

            A[i][2] = 0;

            for (j = 0; j < i; j++)

                A[i][2] += A[j][1];

            total += A[i][2];

        }

        avg_wt = (float)total / n;

        total = 0;

        printf("P     BT     WT     TAT\n");

        // Calculation of Turn Around Time and printing the

        // data.

        for (i = 0; i < n; i++) {

            A[i][3] = A[i][1] + A[i][2];

            total += A[i][3];

            printf("P%d     %d     %d      %d\n", A[i][0],

                   A[i][1], A[i][2], A[i][3]);

        }

        avg_tat = (float)total / n;

        printf("Average Waiting Time= %f", avg_wt);

        printf("\nAverage Turnaround Time= %f", avg_tat);

    You might also like