Question

Implement the CPU scheduling algorithm SJF non-preemptive in python. Have the program answer the table.

Simulate and evaluate with the set of eight processes below.

Assumptions:

1. All processes are activated at time 0
2. Assume that no process waits on I/O devices.
3. After completing an I/O event, a process is transferred to the ready queue.
4. Waiting time is accumulated while a process waits in the ready queue.
5. Turnaround time is a total of (Waiting time) + (CPU burst time) + (I/O time)
6. Response time is the first measure of waiting time from arrival at time 0 until the first time on the CPU.

Process Data:

process goes {CPU burst, I/O time, CPU burst, I/O time, CPU burst, I/O time,…….., last CPU burst}

P1 {5, 27, 3, 31, 5, 43, 4, 18, 6, 22, 4, 26, 3, 24, 4}

P2 {4, 48, 5, 44, 7, 42, 12, 37, 9, 76, 4, 41, 9, 31, 7, 43, 8}

P3 {8, 33, 12, 41, 18, 65, 14, 21, 4, 61, 15, 18, 14, 26, 5, 31, 6}

P4 {3, 35, 4, 41, 5, 45, 3, 51, 4, 61, 5, 54, 6, 82, 5, 77, 3}

P5 {16, 24, 17, 21, 5, 36, 16, 26, 7, 31, 13, 28, 11, 21, 6, 13, 3, 11, 4}

P6 {11, 22, 4, 8, 5, 10, 6, 12, 7, 14, 9, 18, 12, 24, 15, 30, 8}

P7 {14, 46, 17, 41, 11, 42, 15, 21, 4, 32, 7, 19, 16, 33, 10}

P8 {4, 14, 5, 33, 6, 51, 14, 73, 16, 87, 6}

	SJF   CPU utilization:
	Tw	Ttr	Tr
P1
P2
P3
P4
P5
P6
P7
P8
Avg

	SJF
CPU utilization
Avg Waiting time (Tw)
Avg Turnaround time (Ttr)
Avg Response time (Tr)

Answer 1

# Python3 program to implement Shortest Remaining Time First
# Shortest Remaining Time First (SRTF)

# Function to find the waiting time
# for all processes
def findWaitingTime(processes, n, wt):
   rt = [0] * n

   # Copy the burst time into rt[]
   for i in range(n):
       rt[i] = processes[i][1]
   complete = 0
   t = 0
   minm = 999999999
   short = 0
   check = False

   # Process until all processes gets
   # completed
   while (complete != n):
      
       # Find process with minimum remaining
       # time among the processes that
       # arrives till the current time`
       for j in range(n):
           if ((processes[j][2] <= t) and
               (rt[j] < minm) and rt[j] > 0):
               minm = rt[j]
               short = j
               check = True
       if (check == False):
           t += 1
           continue
          
       # Reduce remaining time by one
       rt[short] -= 1

       # Update minimum
       minm = rt[short]
       if (minm == 0):
           minm = 999999999

       # If a process gets completely
       # executed
       if (rt[short] == 0):

           # Increment complete
           complete += 1
           check = False

           # Find finish time of current
           # process
           fint = t + 1

           # Calculate waiting time
           wt[short] = (fint - proc[short][1] -  
                               proc[short][2])

           if (wt[short] < 0):
               wt[short] = 0
      
       # Increment time
       t += 1

# Function to calculate turn around time
def findTurnAroundTime(processes, n, wt, tat):
  
   # Calculating turnaround time
   for i in range(n):
       tat[i] = processes[i][1] + wt[i]

# Function to calculate average waiting
# and turn-around times.
def findavgTime(processes, n):
   wt = [0] * n
   tat = [0] * n

   # Function to find waiting time
   # of all processes
   findWaitingTime(processes, n, wt)

   # Function to find turn around time
   # for all processes
   findTurnAroundTime(processes, n, wt, tat)

   # Display processes along with all details
   print("Processes Burst Time   Waiting",
                   "Time   Turn-Around Time")
   total_wt = 0
   total_tat = 0
   for i in range(n):

       total_wt = total_wt + wt[i]
       total_tat = total_tat + tat[i]
       print(" ", processes[i][0], "\t\t",
               processes[i][1], "\t\t",
               wt[i], "\t\t", tat[i])

   print("\nAverage waiting time = %.5f "%(total_wt /n) )
   print("Average turn around time = ", total_tat / n)
  
# Driver code
if __name__ =="__main__":
  
   # Process id's
   proc = [[1, 6, 1], [2, 8, 1],
           [3, 7, 2], [4, 3, 3]]
   n = 4
   findavgTime(proc, n)
  

Output:

Processes  Burst time  Waiting time  Turn around time
 1        6         3        9
 2        8         16        24
 3        7         8        15
 4        3         0        3
Average waiting time = 6.75
Average turn around time = 12.75

Note: Plzzz don' t give dislike.....Plzzz comment if u have any problem i will try to resolve it.......