Practicals

Practical – 1

Objective:
Write a program to implement CPU scheduling for first come first serve.

Code:

# Function to find the waiting

# time for all processes
def 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 time

def 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 time

def 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))

if __name__ =="__main__":

# process id's
n = int(input("Enter number of Processes: "))
processes = [i for i in range(1, n+1)]

# Burst time of all processes

burst_time = []
for i in range(1,n+1):
inp = int(input(f"Enter Burst Time For Process {i}: "))
burst_time.append(inp)
findavgTime(processes, n, burst_time)

Output:
 Practical – 2

Objective:
Write a program to implement CPU scheduling for Shortest Job First(SJF).

Code:

def main():
# Taking the number of processes
n = int(input("Enter number of process: "))
# Matrix for storing Process Id, Burst Time, Average Waiting Time & Average Turn Around
Time.
A = [[0 for j in range(4)] for i in range(100)]
total, avg_wt, avg_tat = 0, 0, 0
print("Enter Burst Time:")
for i in range(n): # User Input Burst Time and alloting Process Id.
A[i][1] = int(input(f"P{i+1}: "))
A[i][0] = i + 1

for i in range(n): # Sorting process according to their Burst Time.

index = i
for j in range(i + 1, n):
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 in range(1, n):
A[i][2] = 0
for j in range(i):
A[i][2] += A[j][1]
total += A[i][2]
avg_wt = total / n
total = 0
# Calculation of Turn Around Time and printing the data.
print("P BT WT TAT")
 for i in range(n):
A[i][3] = A[i][1] + A[i][2]
total += A[i][3]
print(f"P{A[i][0]} {A[i][1]} {A[i][2]} {A[i][3]}")

avg_tat = total / n
print(f"Average Waiting Time= {avg_wt}")
print(f"Average Turnaround Time= {avg_tat}")

if __name__ == "__main__":
main()

Output:
 Practical – 3

Objective:
Write a program to perform priority scheduling.

Code:

"""1. sort the processes according to arrival time

2. if arrival time is same the acc to priority
3. apply fcfs """

proc = []
for i in range(5):
l = []
for j in range(4):
l.append(0)
proc.append(l)

# Using FCFS Algorithm to find Waiting time

def get_wt_time( wt):

# declaring service array that stores

# cumulative burst time
service = [0] * 5

# Initialising initial elements

# of the arrays
service[0] = 0
wt[0] = 0

for i in range(1, totalprocess):

service[i] = proc[i - 1][1] + service[i - 1]
wt[i] = service[i] - proc[i][0] + 1

# If waiting time is negative,

# change it o zero
if(wt[i] < 0) :
wt[i] = 0

def get_tat_time(tat, wt):

# Filling turnaroundtime array

for i in range(totalprocess):
tat[i] = proc[i][1] + wt[i]
def findgc():

# Declare waiting time and

# turnaround time array
wt = [0] * 5
tat = [0] * 5

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)

stime = [0] * 5
ctime = [0] * 5
stime[0] = 1
ctime[0] = stime[0] + tat[0]

# calculating starting and ending time

for i in range(1, totalprocess):
stime[i] = ctime[i - 1]
ctime[i] = stime[i] + tat[i] - wt[i]

print("Process_no\tStart_time\tComplete_time",
"\tTurn_Around_Time\tWaiting_Time")

# display the process details

for i in range(totalprocess):
wavg += wt[i]
tavg += tat[i]

print(proc[i][3], "\t\t", stime[i],

"\t\t", end = " ")
print(ctime[i], "\t\t", tat[i], "\t\t\t", wt[i])

# display the average waiting time

# and average turn around time
print("Average waiting time is : ", end = " ")
print(wavg / totalprocess)
print("average turnaround time : " , end = " ")
print(tavg / totalprocess)
if __name__ =="__main__":
arrivaltime = []
bursttime = []
priority = []

totalprocess = int(input("Enter no. of processes: "))

for i in range(1, totalprocess+1):

arrivaltime.append(int(input(f"Enter arrival time for p{i}:")))

print()

for i in range(1, totalprocess+1):

bursttime.append(int(input(f"Enter burst time for p{i}:")))

print()

for i in range(1, totalprocess+1):

priority.append(int(input(f"Enter priority for p{i}:")))

print()

for i in range(totalprocess):

proc[i][0] = arrivaltime[i]
proc[i][1] = bursttime[i]
proc[i][2] = priority[i]
proc[i][3] = i + 1

# Using inbuilt sort function

proc = sorted (proc, key = lambda x:x[2])
proc = sorted (proc)

# Calling function findgc for

# finding Gantt Chart
findgc()
Output:
 Practical – 4

Objective:
Write a program to implement CPU scheduling for Round Robin.

Code:

def findWaitingTime(processes, n, bt, wt, quantum):

rem_bt = [0] * n

# Copy the burst time into rt[]

for i in range(n):
rem_bt[i] = bt[i]
t = 0 # Current time

# Keep traversing processes in round

# robin manner until all of them are
# not done.
while(1):
done = True

# Traverse all processes one by

# one repeatedly
for i in range(n):

# If burst time of a process is greater

# than 0 then only need to process further
if (rem_bt[i] > 0) :
done = False # There is a pending process

if (rem_bt[i] > quantum) :

# Increase the value of t i.e. shows

# how much time a process has been processed
t += quantum

# Decrease the burst_time of current

# process by quantum
rem_bt[i] -= quantum

# If burst time is smaller than or equal

# to quantum. Last cycle for this process
else:
 # Increase the value of t i.e. shows
# how much time a process has been processed
t = t + rem_bt[i]

# Waiting time is current time minus

# time used by this process
wt[i] = t - bt[i]

# As the process gets fully executed

# make its remaining burst time = 0
rem_bt[i] = 0

# If all processes are done

if (done == True):
break

# Function to calculate turn around time

def findTurnAroundTime(processes, n, bt, wt, tat):

# Calculating turnaround time

for i in range(n):
tat[i] = bt[i] + wt[i]

# Function to calculate average waiting

# and turn-around times.
def findavgTime(processes, n, bt, quantum):
wt = [0] * n
tat = [0] * n

# Function to find waiting time

# of all processes
findWaitingTime(processes, n, bt, wt, quantum)

# 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")
total_wt = 0
total_tat = 0
for i in range(n):

total_wt = total_wt + wt[i]

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

print("\nAverage waiting time = %.5f "%(total_wt /n) )

print("Average turn around time = %.5f "% (total_tat / n))

if __name__ =="__main__":

# Process id's
n = int(input("Enter no. of processes: "))

processes = [i for i in range(1, n+1)]

# Burst time of all processes

burst_time = []

for i in range(1, n+1):

burst_time.append(int(input(f"Enter burst time for p{i}: ")))

# Time quantum
quantum = int(input("Enter the time quantum for this scheduling: "));
print()
findavgTime(processes, n, burst_time, quantum)
print()

Output:
 Practical – 5

Objective:
Write a program to simulate the concept of dining philosopher problem.

Code:
import threading
import time
import random

# Define the number of philosophers and forks

num_philosophers = int(input("Enter number of Philosophers: "))
num_forks = num_philosophers

# Define semaphores for the forks and the mutex

forks = [threading.Semaphore(1) for i in range(num_forks)]
mutex = threading.Semaphore(1)

# Define the philosopher thread function

def philosopher(index):
while True:
print(f"Philosopher {index} is thinking...")
time.sleep(random.randint(1, 5))

mutex.acquire()
left_fork_index = index
right_fork_index = (index + 1) % num_forks

forks[left_fork_index].acquire()
forks[right_fork_index].acquire()

mutex.release()
print(f"Philosopher {index} is eating...")
time.sleep(random.randint(1, 5))

forks[left_fork_index].release()
forks[right_fork_index].release()

# Create a thread for each philosopher

philosopher_threads = []

for i in range(num_philosophers):
philosopher_threads.append(threading.Thread(target=philosopher, args=(i,)))

# Start the philosopher threads

for thread in philosopher_threads:
thread.start()

# Wait for the philosopher threads to complete

for thread in philosopher_threads:
thread.join()

Output:

As we can see from the output, each philosopher takes turns thinking and eating, and there is no
deadlock or starvation.
 Practical – 5

Objective:
Write a program to implement reader/writer problem using semaphore.

Code:

import threading
import time

class ReaderWriter():
def __init__(self):
self.rd = threading.Semaphore() #initializing semaphores using Semaphore class in
threading module for reading and wrting
self.wrt = threading.Semaphore()

self.readCount = 0 #initializing number of reader present

def reader(self):
while True:
self.rd.acquire() #wait on read semaphore

self.readCount+=1 #increase count for reader by 1

if self.readCount == 1: #since reader is present, prevent writing on data

self.wrt.acquire() #wait on write semaphore

self.rd.release() #sinal on read semaphore

print(f"Reader {self.readCount} is reading")

self.rd.acquire() #wait on read semaphore

self.readCount-=1 #reading performed by reader hence decrementing readercount

if self.readCount == 0: #if no reader is present allow writer to write the data

self.wrt.release() # signal on write semphore, now writer can write

self.rd.release() #sinal on read semaphore

time.sleep(3)

def writer(self):
while True:
 self.wrt.acquire() #wait on write semaphore

print("Wrting data.....") # write the data

print("-"*20)

self.wrt.release() #sinal on write semaphore

time.sleep(3)

def main(self):
# calling mutliple readers and writers
t1 = threading.Thread(target = self.reader)
t1.start()
t2 = threading.Thread(target = self.writer)
t2.start()
t3 = threading.Thread(target = self.reader)
t3.start()
t4 = threading.Thread(target = self.reader)
t4.start()
t6 = threading.Thread(target = self.writer)
t6.start()
t5 = threading.Thread(target = self.reader)
t5.start()

if __name__=="__main__":
c = ReaderWriter()
c.main()
Output:

Thus, the semaphore ‘wrt‘ is queued on both readers and writers in a manner such that preference is
given to readers if writers are also there. Thus, no reader is waiting simply because a writer has
requested to enter the critical section.