S.I.E.

S College of Arts, Science and Commerce,

Sion(W), Mumbai – 400 022.

CERTIFICATE

This is to certify that Mr./ Miss. Rohit Sarvjeet Yadav has successfully completed

the necessary course of experiments in the subject of

Operating System during the academic year 2020 – 2021 complying with the

requirements of University of Mumbai, for the course of S.Y.BSc. Computer

Science [Semester-III ]

Head of the Department Prof. In-Charge (Computer

Science)

Date: 11/12/2020

College Seal
Sr. Practica Aim Date Page
No. l number
Number
1 1 Write a program to implement the 04/09/2020 03
 concept of Remote Method
Invocation(RMI)
2 2 Programs to implement the concept 11/09/2020 05
of Multithreading
a. Program to display Summation of
numbers using thread
3 2 b. Program to display the prime 11/09/2020 07
numbers using thread
4 2 c. Program to display the Fibonacci 11/09/2020 08
series using thread
5 3 Write a program to implement 18/09/2020 09
Bounded Buffer to solve Producer
-Consumer problem with and without
Semaphore.
6 4 Write a program to simulate FCFS 09/10/2020 12
algorithm and calculate average
waiting time and average turnaround
time
7 5 Write a program to simulate SJF 16/10/2020 14
algorithm (Non pre-emptive) and
calculate average waiting time and
average turnaround time
8 6 Write a program to solve readers- 23/10/2020 16
writers problem.
9 7 Write a Python program that 06/11/2020 19
implements the banker’s algorithm.

Name: Rohit Yadav

Roll No: SCS2021103

Subject: Operating System

PRACTICAL NO-1

AIM: Write a program to implement the concept of Remote Method Invocation(RMI)

DESCRIPTION:

The Remote Method Invocation mechanism lets you do something that sounds simple. If
you have access to an object on a different machine, you can call methods of the remote
object. Of course, the method parameters must somehow be shipped to the other
machine, the object must be informed to execute the method, and the return value must
be shipped back. In RMI terminology, the object whose method makes the remote call is
called the client object. The remote object is called the server object. It is important to
remember that the client/server terminology applies only to a single method call. The
computer running the code in the Java programming language that calls the remote method
is the client for that call, and the computer hosting the object that processes the call is
the server for that call. It is entirely possible that the roles are reversed somewhere
down the road. The server of a previous call can itself become the client when it invokes a
remote method on an object residing on another computer.

CODE: INTERFACE FOR REMOTE OBJECT

import java.rmi.*;

interface Methodimpl extends Remote

double getSqrt(double dbl) throws RemoteException;

CODE FOR SEVER APPLICATION

import java.rmi.*;

import java.rmi.registry.*;

import java.rmi.server.*;

class RMIServer extends UnicastRemoteObject implements

Methodimpl

public RMIServer() throws RemoteException

System.out.println("The server is instantiated");

}

public double getSqrt(double dbl)

return Math.sqrt(dbl);

public static void main(String[] arguments)

try

RMIServer server = new RMIServer();

Naming.rebind("//localhost/call1", server);

catch (Exception exec)

System.out.println("Error -- " +exec.toString());

exec.printStackTrace();

CODE FOR CLIENT APPLICATION

import java.rmi.*;

import java.rmi.registry.*;

class RMIClient

public static void main(String[] arguments)

try

Methodimpl mthdIp =
(Methodimpl)Naming.lookup("//localhost/call1");

double dbl = mthdIp.getSqrt(100);

System.out.println("SQRT:" + dbl);

catch (Exception exce)

System.out.println("Error -- " + exce.toString());

exce.printStackTrace();

Output:
Practical no:-2

Aim:

a. Program to display Summation of numbers using thread

Description: Thread often called light-weight process because

operating system generally requires fewer resources to create or
manage threads than to create manage processes. python programs can
define threads by inheriting from class threading. Thread and
overriding its functionality.

Code:

import threading
import logging
def summation(number,name):
logging.info (f'Thread{name} : starting')
sum=0
for i in range(1,number+1):
sum+=i
print(f'sum of {number} is {sum}')
logging.info(f'Thread{name} : stopping')
format="%(asctime)s:%(message)s"
logging.basicConfig(format=format,level=logging.INFO,datefmt="%H:
%M: %S")
logging.info("main: before creating thread")
x=threading.Thread(target= summation, args=(30,1))
logging.info("main: before running thread")
x.start()
logging.info("main: waiting for the thread to finish")
x.join()
logging.info("main: all done")
Output:
Practical:2

Aim:

b. Program to display the prime numbers using thread

Code:

import threading
import logging
def prime(n,name):
logging.info(f' Thread{name} started')
print(f'The prime numbers are upto {n} are')
for i in range(1,n):
if i>1:
for j in range(2,i):
if(i % j==0):
break
else:
print(i)
logging.info(f'Thread{name} stopping')
format=("%(asctime)s:%(message)s")
logging.basicConfig(format=format,level=logging.INFO,datefm
t="%H:%M:%S")
logging.info("Main: before creating thread")
x=threading.Thread(target=prime,args=(25,1))
logging.info("Main: before starting thread")
x.start()
logging.info("Main: waiting thread to finish")
x.join()
logging.info("Main: All done")

Output:
Practical no: 2

Aim:

c. Program to display the Fibonacci series using thread

Code:

import threading
import logging
def febonacci(num,name):
logging.info(f'the thread{name} has started')
i=3
a=0
b=1
print(f'The {num} Fibonacci series generated are')
print(a)
print(b)
for i in range(i,num+1):
c=b
b=a+b
a=c
print(b)
logging.info(f'the thread{name} has stopped')
format="%(asctime)s:%(message)s"
logging.basicConfig(format=format,level=logging.INFO,datefmt="%H:%M:%S")
logging.info("Main: before creating thread ")
feb=threading.Thread(target=febonacci,args=(7,1))
logging.info("Main : before running the thread")
feb.start()
logging.info("main: waiting for the thread to finish")
feb.join()
logging.info("main: all done")
Output:
Practical No: 3

Aim: Program to implement a counted buffer Producer-Consumer

problem without Semaphore.

Code:

import threading

import time

N=4

buf=[None]*N

item=0

counter=0

def produce():

global item

item+=1

print(f"{item}Produced!\n")

return item

def producer():

front=0

global counter

while counter <= N:

x=produce()
 counter+=1

buf[front]=x

front=(front+1)%N

time.sleep(2)

def consume(y):

print(f"{item}consumed\n")

def consumer():

rear=0

global counter

while counter!=0:

y=buf[rear]

counter-=1

consume(y)

rear=(rear+1)%N

time.sleep(5)

producer_thread=threading.Thread(target=producer)

consumer_thread=threading.Thread(target=consumer)

consumer_thread.start()

producer_thread.start()
Output:
Aim: program to implement a counted buffer Produced-
Consumer problem with Semaphore.
Code:
import threading
import time
N=4
buf=[None]*N
item=0
fill_count=threading.Semaphore(0)
empty_count=threading.Semaphore(N)
def produce():
global item
item+=1
print(f"{item}Produced!\n")
return item
def producer():
front=0
while True:
 x=produce()
empty_count.acquire()
buf[front]=x
fill_count.release()
front=(front+1)%N
time.sleep(2)
def consume(y):
print(f"{item}consumed\n")
def consumer():
rear=0
while True:
fill_count.acquire()
y=buf[rear]
empty_count.release()
consume(y)
rear=(rear+1)%N
time.sleep(10)
producer_thread=threading.Thread(target=producer)
consumer_thread=threading.Thread(target=consumer)
consumer_thread.start()
producer_thread.start()

0utput:
Practical No: 4

Aim : Program to simulate FCFS algorithm and calculate average waiting

and average turnaround time. 
 
def getwaitingtime(n,bt,at,wt): 
    st=[0]*n               
    for i in range(1,n): 
        st[i]=st[i-1]+bt[i-1] 
        wt[i]=st[i]-at[i] 
 
def gettat(n,bt,wt,tat):    
    for i in range(n): 
        tat[i]=wt[i]+bt[i] 
         
def getaverage(n,p,bt,at): 
    wt=[0]*n 
    tat=[0]*n 
    getwaitingtime(n,bt,at,wt) 
    gettat(n,bt,wt,tat) 
    totwt=0                
    tottat=0               
    print("Processes\tBT\tAT\tWt\tTAT") 
    for i in range(n): 
        totwt+=wt[i] 
        tottat+=tat[i] 
        print("\tP",p[i],"\t",bt[i],"\t",at[i],"\t",wt[i],"\t",tat[i]) 
    avgwt=totwt/n 
    avgtat=tottat/n 
    print("Average Waiting time is ",round(avgwt,2)) 
    print("Average Turnaround time is ",round(avgtat,2)) 
               
         
n=int(input("Enter the Number of processes: ")) 

processes=list(map(int,input("Enter processes separated by

space").split())) 

bursttime=list(map(int,input("Enter Burst time for processes

separated by space").split())) 

arrivaltime=list(map(int,input("Enter Arrival time for processes

separated by space").split()))  
              
getaverage(n,processes,bursttime,arrivaltime) 

Output:
Practical No:5

Aim: Write a program to simulate SJF algorithm (Non pre-

emptive) and calculate average waiting time and average
turnaround time

Code:
finallist=[]

def getwt(n,plist):

runtime=[0]*n

for i in range(1,n):

finallist.append(plist[0])

prevbt=plist[0][2]

plist.pop(0)

runtime[i]=runtime[i-1]+prevbt

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

if runtime[i]<plist[0][1]:

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

plist[0][3]=runtime[i]-plist[0][1]

if plist[0][3]<0:

plist[0][3]=0

finallist.append(plist[0])

def gettat(n,plist):
 for i in range(n):

plist[i][4]=plist[i][3]+plist[i][2]

def getaveragetime(n,plist):

getwt(n,plist)

plist=finallist

gettat(n,plist)

print("Process BT AT WT TAT \n")

total_wt=0

total_tat=0

for i in range(n):

total_wt+=plist[i][3]

total_tat+=plist[i][4]

print(f"P{plist[i][0]}\t{plist[i][2]}\t{plist[i][1]}\t{plist[i]
[3]}\t{plist[i][4]}")

avgwt=total_wt/n

avgtat=total_tat/n

print(f"Average waiting Time:{round(avgwt,2)}")

print(f"Average turnaround Time:{avgtat}")

process_list=[]

n=int(input("Enter number of processes"))

for i in range(n):
 process=list(map(int,input(f"Enter process no Arrival time and Burst
time separated by space").split(' ')))

process.extend([0,0])

process_list.append(process)

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

print(process_list)

getaveragetime(n,process_list)

Output:
Practical No: 6

Aim: Write a program to solve readers-writers problem

Code:
import threading
import time
class ReaderWriter():
def __init__(self):
self.rd=threading.Semaphore()
self.rw=threading.Semaphore()
self.readcount=0
def reader(self):
while True:
self.rd.acquire()
self.readcount+=1
if self.readcount==1:
self.rw.acquire()
self.rd.release()
print(f"Reader {self.readcount} is reading\n")
 self.rd.acquire()
self.readcount-=1
if self.readcount==0:
self.rw.release()
self.rd.release()
time.sleep(3)
def writer(self):
while True:
self.rw.acquire()
print("Writing Data------------")
self.rw.release()
time.sleep(3)
def main(self):
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()
t5=threading.Thread(target=self.writer)
t5.start()
t6=threading.Thread(target=self.reader)
t6.start()
c=ReaderWriter()
c.main()

Output:
Practical No: 7
Aim: Write a Python program that implements the banker’s
algorithm.

Code:

n=int(input("Enter the number of processes "))

m=int(input("Enter the number of resources:"))

Allocation=[]

Max=[]

Need=[]

print("Enter the Allocation Matrix: ")

for i in range(n):

theinputs=[]

for j in range(m):

x=int(input())

theinputs.append(x)

Allocation.append(theinputs)

print("Enter the Max Matrix: ")

for i in range(n):

theinputs=[]

for j in range(m):
 x=int(input())

theinputs.append(x)

Max.append(theinputs)

for i in range(n):

theinputs=[]

for j in range(3):

x=Max[i][j]-Allocation[i][j]

theinputs.append(x)

Need.append(theinputs)

print(Need)

Resources=[]

print("Enter the Total Resources: ")

for i in range(m):

x=int(input())

Resources.append(x)

print(Resources)

Available=[]

for j in range(m):

x=0
 for i in range(n):

x+=Allocation[i][j]

x=Resources[j]-x

Available.append(x)

print(Available)

Work=Available.copy()

Finish=[0]*n

Sequence=[]

alldone=False

attempt=0

while alldone==False:

attempt+=1

for i in range(n):

if(Finish[i]==0) and (Need[i]<=Work):

for k in range(m):

Work[k]+=Allocation[i][k]

Finish[i]=1

Sequence.append(i)

for i in range(n):

if(Finish[i]==0):
 break

else:

alldone=True

if attempt>2:

break

if(alldone==True):

print("Granted!")

print("The Process Sequence:")

print(Sequence)

else:

print("Not Granted!")
Output: