Professional Documents
Culture Documents
OS File PDF
OS File PDF
int main()
{
int n,bt[20],wt[20],tat[20],avwt=0,avtat=0,i,j;
printf("Enter total number of processes(maximum 20):");
scanf("%d",&n);
avwt/=i;
avtat/=i;
printf("\n\nAverage Waiting Time:%d",avwt);
printf("\nAverage Turnaround Time:%d",avtat);
return 0;
}
Output
2. A Program to implement SJF CPU
scheduling algorithm
#include<stdio.h>
void main()
{
int bt[20],p[20],wt[20],tat[20],i,j,n,total=0,pos,temp;
float avg_wt,avg_tat;
printf("Enter number of process:");
scanf("%d",&n);
temp=bt[i];
bt[i]=bt[pos];
bt[pos]=temp;
temp=p[i];
p[i]=p[pos];
p[pos]=temp;
}
total+=wt[i];
}
#include<stdio.h>
int main()
{
int bt[20],p[20],wt[20],tat[20],pr[20],i,j,n,total=0,pos,temp,avg_wt,avg_tat;
printf("Enter Total Number of Process:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
pos=i;
for(j=i+1;j<n;j++)
{
if(pr[j]<pr[pos])
pos=j;
}
temp=pr[i];
pr[i]=pr[pos];
pr[pos]=temp;
temp=bt[i];
bt[i]=bt[pos];
bt[pos]=temp;
temp=p[i];
p[i]=p[pos];
p[pos]=temp;
}
wt[0]=0; //waiting time for first process is zero
for(i=1;i<n;i++)
{
wt[i]=0;
for(j=0;j<i;j++)
wt[i]+=bt[j];
total+=wt[i];
}
return 0;
}
Output
4. A Program to implement Round
Robin CPU scheduling algorithm
#include<stdio.h>
int main()
{
int count,j,n,time,remain,flag=0,time_quantum;
int wait_time=0,turnaround_time=0,at[10],bt[10],rt[10];
printf("Enter Total Process:\t ");
scanf("%d",&n);
remain=n;
for(count=0;count<n;count++)
{
printf("Enter Arrival Time and Burst Time for Process Process Number %d
:",count+1);
scanf("%d",&at[count]);
scanf("%d",&bt[count]);
rt[count]=bt[count];
}
printf("Enter Time Quantum:\t");
scanf("%d",&time_quantum);
printf("\n\nProcess\t|Turnaround Time|Waiting Time\n\n");
for(time=0,count=0;remain!=0;)
{
if(rt[count]<=time_quantum && rt[count]>0)
{
time+=rt[count];
rt[count]=0;
flag=1;
}
else if(rt[count]>0)
{
rt[count]-=time_quantum;
time+=time_quantum;
}
if(rt[count]==0 && flag==1)
{
remain--;
printf("P[%d]\t|\t%d\t|\t%d\n",count+1,time-at[count],time-at[count]-
bt[count]);
wait_time+=time-at[count]-bt[count];
turnaround_time+=time-at[count];
flag=0;
}
if(count==n-1)
count=0;
else if(at[count+1]<=time)
count++;
else
count=0;
}
printf("\nAverage Waiting Time= %f\n",wait_time*1.0/n);
printf("Avg Turnaround Time = %f",turnaround_time*1.0/n);
return 0;
}
Output
5. Program to compare various CPU Scheduling algorithms over different
criteria
#include<stdio.h>
void FCFS(){
int wt[20],tat[20],avwt=0,avtat=0,i,j;
avwt/=i;
avtat/=i;
printf("\n\nAverage Waiting Time:%d",avwt);
printf("\nAverage Turnaround Time:%d",avtat);
}
void SJF(){
int p[20],wt[20],tat[20],i,j,total=0,pos,temp;
float avg_wt,avg_tat;
for(i=0;i<n;i++)
{
p[i]=i+1; //contains process number
}
temp=bt[i];
bt[i]=bt[pos];
bt[pos]=temp;
temp=p[i];
p[i]=p[pos];
p[pos]=temp;
}
total+=wt[i];
}
void Priority(){
int p[20], wt[20],tat[20],i,j,total=0,pos,temp,avg_wt,avg_tat;
for(i=0;i<n;i++)
{
p[i]=i+1; //contains process number
}
//sorting burst time, priority and process number in ascending order using selection sort
for(i=0;i<n;i++)
{
pos=i;
for(j=i+1;j<n;j++)
{
if(pr[j]<pr[pos])
pos=j;
}
temp=pr[i];
pr[i]=pr[pos];
pr[pos]=temp;
temp=bt[i];
bt[i]=bt[pos];
bt[pos]=temp;
temp=p[i];
p[i]=p[pos];
p[pos]=temp;
}
total+=wt[i];
}
void RoundRobin(){
int count,j,time,remain,flag=0,time_quantum;
int wait_time=0,turnaround_time=0,rt[10];
remain=n;
for(count=0;count<n;count++)
{
rt[count]=bt[count];
}
printf("Enter Time Quantum:\t");
scanf("%d",&time_quantum);
printf("\n\nProcess\t|Turnaround Time|Waiting Time\n\n");
for(time=0,count=0;remain!=0;)
{
if(rt[count]<=time_quantum && rt[count]>0)
{
time+=rt[count];
rt[count]=0;
flag=1;
}
else if(rt[count]>0)
{
rt[count]-=time_quantum;
time+=time_quantum;
}
if(rt[count]==0 && flag==1)
{
remain--;
printf("P[%d]\t|\t%d\t|\t%d\n",count+1,time-at[count],time-at[count]-bt[count]);
wait_time+=time-at[count]-bt[count];
turnaround_time+=time-at[count];
flag=0;
}
if(count==n-1)
count=0;
else if(at[count+1]<=time)
count++;
else
count=0;
}
int main()
{
for(int count=0;count<n;count++)
{
printf("Enter Arrival Time and Burst Time, and priority for process number %d :",count+1);
scanf("%d",&at[count]);
scanf("%d",&bt[count]);
scanf("%d",&pr[count]);
}
return 0;
}
OUPUT: Compare Scheduling algorithms
6. Write a program to implement classical inter process
communication problem (producer consumer)
#include<stdio.h>
#include<stdlib.h>
int mutex=1,full=0,empty=3,x=0;
int main()
{
int n;
void producer();
void consumer();
int wait(int);
int signal(int);
printf("\n1.Producer\n2.Consumer\n3.Exit");
while(1)
{
printf("\nEnter your choice:");
scanf("%d",&n);
switch(n)
{
case 1: if((mutex==1)&&(empty!=0))
producer();
else
printf("Buffer is full!!");
break;
case 2: if((mutex==1)&&(full!=0))
consumer();
else
printf("Buffer is empty!!");
break;
case 3:
exit(0);
break;
}
}
return 0;
}
int wait(int s)
{
return (--s);
}
int signal(int s)
{
return(++s);
}
void producer()
{
mutex=wait(mutex);
full=signal(full);
empty=wait(empty);
x++;
printf("\nProducer produces the item %d",x);
mutex=signal(mutex);
}
void consumer()
{
mutex=wait(mutex);
full=wait(full);
empty=signal(empty);
printf("\nConsumer consumes item %d",x);
x--;
mutex=signal(mutex);
}
7. A program to implement classical inter process communication
problem (Reader Writers)
#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
sem_t mutex,writeblock;
int data = 0,rcount = 0;
main()
{
int i,b;
pthread_t rtid[5],wtid[5];
sem_init(&mutex,0,1);
sem_init(&writeblock,0,1);
for(i=0;i<=2;i++)
{
pthread_create(&wtid[i],NULL,writer,(void *)i);
pthread_create(&rtid[i],NULL,reader,(void *)i);
}
for(i=0;i<=2;i++)
{
pthread_join(wtid[i],NULL);
pthread_join(rtid[i],NULL);
}
}
8. Program to implement inter-process communication problem(Dining
Philosophers)
#include<stdio.h>
#define n 4
struct fork{
int taken;
}ForkAvil[n];
struct philosp{
int left;
int right;
}Philostatus[n];
void goForDinner(int philID){ //same like threads concept here cases implemented
if(otherFork== -1)
otherFork=(n-1);
compltedPhilo++;
if(philID==(n-1)){
ForkAvil[philID].taken = Philostatus[philID].right = 1;
}else{
philID-=1;
if(philID== -1)
philID=(n-1);
if(ForkAvil[philID].taken == 0){
ForkAvil[philID].taken = Philostatus[dupphilID].right = 1;
}else{
if(philID==(n-1)){
}else{
if(ForkAvil[philID].taken == 0){
ForkAvil[philID].taken = Philostatus[philID].left = 1;
}else{
}else{}
int main(){
for(i=0;i<n;i++)
ForkAvil[i].taken=Philostatus[i].left=Philostatus[i].right=0;
while(compltedPhilo<n){
/* Observe here carefully, while loop will run until all philosophers complete dinner
Actually problem of deadlock occur only thy try to take at same time
This for loop will say that they are trying at same time. And remaining status will print by go for
dinner function
*/
for(i=0;i<n;i++)
goForDinner(i);
return 0;
}
OUPUT: Dining Philosophers Problem
9. Program to compare various page replacement algorithms
#include<stdio.h>
void FIFO();
void LRU();
void OPTIMAL();
int main()
int ch;
do
scanf("%d",&ch);
switch(ch)
case 1:
FIFO();
break;
case 2:
LRU();
break;
case 3:
OPTIMAL();
break;
}while(ch!=4);
void FIFO()
int frame[3]={-1,-1,-1},ref[20],cnt=0,i,j,no,flag;
float ratio,hitcnt=0.00;
printf("\n\tEnter length of reference string : ");
scanf("%d",&no);
for(i=0;i<no;i++)
scanf("%d",&ref[i]);
for(i=0;i<no;i++)
flag=0;
for(j=0;j<3;j++)
if(frame[j]==ref[i])
hitcnt++;
flag=1;
break;
if(flag==0)
printf("\n\tPage Miss");
printf("\tBefore :\t");
for(j=0;j<3;j++)
printf(" %d",frame[j]);
frame[cnt]=ref[i];
cnt++;
if(cnt>=3)
cnt=0;
printf("\tAfter :\t");
for(j=0;j<3;j++)
printf(" %d",frame[j]);
}
ratio=hitcnt/no;
void LRU()
int frame[3]={-1,-1,-1},used[3]={-1,-1,-1},cnt=0,ref[20],i,j,flag,no,index,value;
float ratio,hitcnt=0;
scanf("%d",&no);
for(i=0;i<no;i++)
scanf("%d",&ref[i]);
for(i=0;i<no;i++)
flag=0;
for(j=0;j<3;j++)
if(frame[j]==ref[i])
hitcnt++;
flag=1;
used[j]=cnt;
break;
if(flag==0)
printf("\n\tPage Miss");
printf("\tBefore :");
for(j=0;j<3;j++)
printf(" %d",frame[j]);
index=0;
value=used[0];
if(cnt!=0) {
for(j=0;j<3;j++)
if(value>used[j]&&value!=used[j])
index=j;
value=used[j];
//printf("\tVictim is %d ",index);
frame[index]=ref[i];
used[index]=cnt;
printf("\tAfter :");
for(j=0;j<3;j++)
printf(" %d",frame[j]);
cnt++;
ratio=hitcnt/no;
void OPTIMAL()
int frame[3]={-1,-1,-1},used[3]={-1,-1,-1},cnt=0,ref[20],i,j,flag,no,val1,val2,val3,index;
float ratio,hitcnt=0;
scanf("%d",&no);
printf("\n\tEnter reference String with giving space \n\t");
for(i=0;i<no;i++)
scanf("%d",&ref[i]);
for(i=0;i<no;i++)
flag=0;
for(j=0;j<3;j++)
if(frame[j]==ref[i])
flag=1;
printf("\n\tPage Hit");
hitcnt++;
break;
if(flag==0)
printf("\n\tPage Miss");
if(cnt<3)
frame[cnt]=ref[i];
printf("\tStatus :");
for(j=0;j<3;j++)
printf(" %d",frame[j]);
cnt++;
else
printf("\tBefore :");
for(j=0;j<3;j++)
printf(" %d",frame[j]);
//selection of victim
val1=frame[0];
flag=0;
for(j=i;j<no;j++)
if(ref[j]==val1)
val1=j;
flag=1;
break;
if(flag==0)
val1=no;
val2=frame[1];
flag=0;
for(j=i;j<no;j++)
if(ref[j]==val2)
val2=j;
flag=1;
break;
if(flag==0)
val2=no;
val3=frame[2];
flag=0;
for(j=i;j<no;j++)
if(ref[j]==val3)
val3=j;
flag=1;
break;
}
if(flag==0)
val3=no;
if(val1<val2)
if(val3<val2)
index=1;
else
index=2;
else
if(val3<val1)
index=0;
else
index=2;
frame[index]=ref[i];
printf("\tAfter :");
for(j=0;j<3;j++)
printf(" %d",frame[j]);
ratio=hitcnt/no;
}
OUPUT: Page Replacement Algorithms
10. Program to implement and compare various Disk and Drum
Scheduling algorithms
#include <iostream>
#include <cstdlib>
#include <conio.h>
#include <math.h>
for(int i=1;i<=size;i++)
a[i-1]=a[i];
class disk
private :
int request[101];
int sorted_request[101];
int number_of_request;
int max;
int direction;
public :
disk()
{
cout<<"\nEnter maximum disk limit : ";
cin>>max;
void receive_request()
enter_request_number:
cin>>number_of_request;
if(number_of_request>100)
goto enter_request_number;
current_location:
cin>>request[0];
sorted_request[0]=request[0];
if(request[0]>max||request[0]<0)
goto current_location;
current_direction:
cin>>direction;
if(direction!=0&&direction!=1)
goto current_direction;
for(int i=1;i<=number_of_request;i++)
cin>>request[i];
sorted_request[i]=request[i];
if(request[i]>max||request[i]<0)
i--;
qsort(sorted_request+1,number_of_request,sizeof(int),compare);
int fcfs()
int head_movement=0;
for(int i=1;i<=number_of_request;i++)
head_movement+=abs(request[i]-request[i-1]);
return head_movement;
int sstf()
int head_movement=0,flag=0,nor=number_of_request;
int request[101];
request[0]=sorted_request[0];
for(int i=1;i<=number_of_request;i++)
if(sorted_request[i]>sorted_request[0]&&flag==0)
flag=i;
request[i]=sorted_request[i];
while(nor)
if(flag==0)
{
head_movement+=request[0]-request[nor];
request[0]=request[nor];
else if(flag==1)
head_movement+=abs(request[nor]-request[0]);
break;
else if((request[flag]-request[0])>(request[0]-request[flag-1]))
head_movement+=request[0]-request[flag-1];
request[0]=request[flag-1];
flag--;
shift(request+flag,nor-flag);
else
head_movement+=request[flag]-request[0];
request[0]=request[flag];
shift(request+flag,nor-flag);
nor--;
return head_movement;
int SCAN()
int head_movement=0,flag=0;
for(int i=1;i<=number_of_request;i++)
if(sorted_request[i]>sorted_request[0]&&flag==0)
flag=i;
if(direction==1)
if(flag==1)
head_movement+=sorted_request[number_of_request]-sorted_request[0];
else
head_movement+=max-sorted_request[0];
head_movement+=max-sorted_request[1];
else
if(flag==0)
head_movement+=abs(sorted_request[number_of_request]-sorted_request[0]);
else
head_movement+=sorted_request[0];
head_movement+=sorted_request[number_of_request];
return head_movement;
int CSCAN()
int head_movement=0,flag=0;
for(int i=1;i<=number_of_request;i++)
if(sorted_request[i]>sorted_request[0]&&flag==0)
flag=i;
if(flag==1)
head_movement+=sorted_request[number_of_request]-sorted_request[0];
else
head_movement+=max-sorted_request[0];
head_movement+=max;
head_movement+=max-sorted_request[flag-1];
return head_movement;
int LOOK()
int head_movement=0,flag=0;
for(int i=1;i<=number_of_request;i++)
if(sorted_request[i]>sorted_request[0]&&flag==0)
flag=i;
if(direction==1)
if(flag==1)
head_movement+=sorted_request[number_of_request]-sorted_request[0];
else
{
head_movement+=sorted_request[number_of_request]-sorted_request[0];
head_movement+=sorted_request[number_of_request]-sorted_request[1];
else
if(flag==0)
head_movement+=abs(sorted_request[number_of_request]-sorted_request[0]);
else
head_movement+=sorted_request[1];
head_movement+=sorted_request[number_of_request]-sorted_request[1];
return head_movement;
int CLOOK()
int head_movement=0,flag=0;
for(int i=1;i<=number_of_request;i++)
if(sorted_request[i]>sorted_request[0]&&flag==0)
flag=i;
if(flag==1)
head_movement+=sorted_request[number_of_request]-sorted_request[0];
else
head_movement+=sorted_request[number_of_request]-sorted_request[0];
head_movement+=sorted_request[number_of_request]-sorted_request[1];
head_movement+=sorted_request[flag-1]-sorted_request[1];
return head_movement;
~disk(){}
};
int main()
disk hdd;
hdd.receive_request();
cout<<"FCFS is "<<hdd.fcfs()<<endl;
cout<<"SSTF is "<<hdd.sstf()<<endl;
cout<<"SCAN is "<<hdd.SCAN()<<endl;
cout<<"CSCAN is "<<hdd.CSCAN()<<endl;
cout<<"LOOK is "<<hdd.LOOK()<<endl;
cout<<"CLOOK is "<<hdd.CLOOK()<<endl;
int k;
cin.ignore(255);
cin >> k;
return 0;
}
OUPUT: Disk and Drum Scheduling algorithms
11.Program to implement Banker’s algorithm
#include <stdio.h>
int main()
{
int count = 0, m, n, process, temp, resource;
int allocation_table[5] = {0, 0, 0, 0, 0};
int available[5], current[5][5], maximum_claim[5][5];
int maximum_resources[5], running[5], safe_state = 0;
printf("\nEnter The Total Number Of Processes:\t");
scanf("%d", &process);
for(m = 0; m < process; m++)
{
running[m] = 1;
count++;
}
printf("\nEnter The Total Number Of Resources To Allocate:\t");
scanf("%d", &resource);
printf("\nEnter The Claim Vector:\t");
for(m = 0; m < resource; m++)
{
scanf("%d", &maximum_resources[m]);
}
printf("\nEnter Allocated Resource Table:\n");
for(m = 0; m < process; m++)
{
for(n = 0; n < resource; n++)
{
scanf("%d", ¤t[m][n]);
}
}
printf("\nEnter The Maximum Claim Table:\n");
for(m = 0; m < process; m++)
{
for(n = 0; n < resource; n++)
{
scanf("%d", &maximum_claim[m][n]);
}
}
printf("\nThe Claim Vector \n");
for(m = 0; m < resource; m++)
{
printf("\t%d ", maximum_resources[m]);
}
printf("\n The Allocated Resource Table\n");
for(m = 0; m < process; m++)
{
for(n = 0; n < resource; n++)
{
printf("\t%d", current[m][n]);
}
printf("\n");
}
printf("\nThe Maximum Claim Table \n");
for(m = 0; m < process; m++)
{
for(n = 0; n < resource; n++)
{
printf("\t%d", maximum_claim[m][n]);
}
printf("\n");
}
for(m = 0; m < process; m++)
{
for(n = 0; n < resource; n++)
{
allocation_table[n] = allocation_table[n] + current[m][n];
}
}
printf("\nAllocated Resources \n");
for(m = 0; m < resource; m++)
{
printf("\t%d", allocation_table[m]);
}
for(m = 0; m < resource; m++)
{
available[m] = maximum_resources[m] - allocation_table[m];
}
printf("\nAvailable Resources:");
for(m = 0; m < resource; m++)
{
printf("\t%d", available[m]);
}
printf("\n");
while(count != 0)
{
safe_state = 0;
for(m = 0; m < process; m++)
{
if(running[m])
{
temp = 1;
for(n = 0; n < resource; n++)
{
if(maximum_claim[m][n] - current[m][n] > available[n])
{
temp = 0;
break;
}
}
if(temp)
{
printf("\nProcess %d Is In Execution \n", m + 1);
running[m] = 0;
count--;
safe_state = 1;
for(n = 0; n < resource; n++)
{
available[n] = available[n] + current[m][n];
}
break;
}
}
}
if(!safe_state)
{
printf("\nThe Processes Are In An Unsafe State \n");
break;
}
else
{
printf("\nThe Process Is In A Safe State \n");
printf("\nAvailable Vector\n");
for(m = 0; m < resource; m++)
{
printf("\t%d", available[m]);
}
printf("\n");
}
}
return 0;
}
OUPUT: Banker’s algorithm
12.Program to implement Remote Procedure Call(RPC)
#include"rpc/rpc.h"
#include"square.h"
#include"stdio.h"
#include"stdlib.h"
#include"math.h"
return(&out);
#include"errno.h"
#include"rpc/rpc.h"
#include"square.h"
#include"stdio.h"
#include"stdlib.h"
#include"math.h"
CLIENT *cl;
square_in in;
square_out *outp;
f(argc!=3)
cl=clnt_create(argv[1],SQUARE_PROG,SQUARE_VERS,"tcp");
in.arg1=atol(argv[2]);
if(cl==NULL)
printf("\nerror:%s",strerror(errno));
exit(-1);
if((outp=squareproc_1(&in,cl))==NULL)
printf("\nerror :%s",clnt_sperror(cl,argv[1]));
exit(-1);
exit(0);
// .h FILENAME: square.h
struct square_in
/*input arg*/
long arg1;
};
struct square_out
{
/*op result*/
long res1;
};
program SQUARE_PROG
version SQUARE_VERS
}=0x31230000;/*prog no*/
OUPUT: Remote Procedure Call
13.Program to implement a driver for a device
#include <wdm.h>
#include "example.h"
#define _X86_
UINT uiIndex = 0;
RtlInitUnicodeString(&usDriverName, L"\\Device\\Example");
RtlInitUnicodeString(&usDosDeviceName, L"\\DosDevices\\Example");
if(NtStatus == STATUS_SUCCESS)
pDriverObject->MajorFunction[uiIndex] = Example_UnSupportedFunction;
pDriverObject->MajorFunction[IRP_MJ_CLOSE] = Example_Close;
pDriverObject->MajorFunction[IRP_MJ_CREATE] = Example_Create;
pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = Example_IoControl;
pDriverObject->MajorFunction[IRP_MJ_READ] = Example_Read;
pDriverObject->MajorFunction[IRP_MJ_WRITE] = USE_WRITE_FUNCTION;
pDriverObject->DriverUnload = Example_Unload;
pDeviceObject->Flags |= IO_TYPE;
IoCreateSymbolicLink(&usDosDeviceName, &usDriverName);
return NtStatus;
UNICODE_STRING usDosDeviceName;
RtlInitUnicodeString(&usDosDeviceName, L"\\DosDevices\\Example");
IoDeleteSymbolicLink(&usDosDeviceName);
IoDeleteDevice(DriverObject->DeviceObject);