10.lab Experiments Manual
10.lab Experiments Manual
Aim: Write a C program to implement the various process scheduling mechanisms such
Algorithm for RR
Step 2: Accept the number of processes in the ready Queue and time quantum (or) time slice
Step 3: For each process in the ready Q, assign the process id and accept the CPU burst time
Step 4: Calculate the no. of time slices for each process where
Step 5: If the burst time is less than the time slice then the no. of time slices =1.
(a) Waiting time for process(n) = waiting time of process(n-1)+ burst time of process(n-1 ) + the
time difference in getting the CPU from process(n-1)
(b) Turn around time for process(n) = waiting time of process(n) + burst time of process(n)+ the
time difference in getting CPU from process(n).
Step 7: Calculate
#include<stdio.h>
#include<conio.h>
void main()
int ts,pid[10],need[10],wt[10],tat[10],i,j,n,n1;
int bt[10],flag[10],ttat=0,twt=0;
float awt,atat;
clrscr();
scanf("%d",&n);
n1=n;
scanf("%d",&ts);
for(i=1;i<=n;i++)
scanf("%d",&pid[i]);
scanf("%d",&bt[i]);
need[i]=bt[i];
for(i=1;i<=n;i++)
{
flag[i]=1;
wt[i]=0;
while(n!=0)
for(i=1;i<=n;i++)
if(need[i]>=ts)
for(j=1;j<=n;j++)
if((i!=j)&&(flag[i]==1)&&(need[j]!=0))
wt[j]+=ts;
need[i]-=ts;
if(need[i]==0)
flag[i]=0;
n--;
else
for(j=1;j<=n;j++)
if((i!=j)&&(flag[i]==1)&&(need[j]!=0))
wt[j]+=need[i];
need[i]=0;
n--;
flag[i]=0;
for(i=1;i<=n1;i++)
tat[i]=wt[i]+bt[i];
twt=twt+wt[i];
ttat=ttat+tat[i];
awt=(float)twt/n1;
atat=(float)ttat/n1;
for(i=1;i<=n1;i++)
printf("\n %5d \t %5d \t\t %5d \t\t %5d \t\t %5d \n", i,pid[i],bt[i],wt[i],tat[i]);
OUTPUT:
1 5 10 15 25
2 6 15 25 40
3 7 20 25 45
4 8 25 20 45
Aim: Write a C program to implement the various process scheduling mechanisms such
as SJF Scheduling .
Step 3: For each process in the ready Q, assign the process id and accept the CPU burst time
Step 4: Start the Ready Q according the shortest Burst time by sorting according to lowest to
Step 5: Set the waiting time of the first process as ‘0’ and its turnaround time as its burst time.
(a) Waiting time for process(n)= waiting time of process (n-1) + Burst time of process(n-1)
(b) Turn around time for Process(n)= waiting time of Process(n)+ Burst time for process(n)
Step 6: Calculate
#include<stdio.h>
void main()
int i,j,k,n,sum,wt[10],tt[10],twt,ttat;
int t[10],p[10];
float awt,atat;
clrscr();
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("\n %d",&t[i]);
for(i=0;i<n;i++)
p[i]=i;
for(i=0;i<n;i++)
for(k=i+1;k<n;k++)
{
if(t[i]>t[k])
int temp;
temp=t[i];
t[i]=t[k];
t[k]=temp;
temp=p[i];
p[i]=p[k];
p[k]=temp;
wt[0]=0;
for(i=0;i<n;i++)
sum=0;
for(k=0;k<i;k++)
wt[i]=sum+t[k];
sum=wt[i];
for(i=0;i<n;i++)
{
tt[i]=t[i]+wt[i];
for(i=0;i<n;i++)
twt=0;
ttat=t[0];
for(i=1;i<n;i++)
twt=twt+wt[i];
ttat=ttat+tt[i];
awt=(float)twt/n;
atat=(float)ttat/n;
getch();
}
OUTPUT:
1 3 0 3
0 4 3 7
2 5 7 12
Aim: Write a C program to implement the various process scheduling mechanisms such
Step 3: For each process in the ready Q, assign the process id and accept the CPU burst time
Step 4: Set the waiting of the first process as ‘0’ and its burst time as its turn around time
(c) Waiting time for process(n)= waiting time of process (n-1) + Burst time of process(n-1)
(d) Turn around time for Process(n)= waiting time of Process(n)+ Burst time for process(n)
Step 6: Calculate
#include<stdio.h>
void main()
int i,n,sum,wt,tat,twt,ttat;
int t[10];
float awt,atat;
clrscr();
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("\n %d",&t[i]);
sum=0;
twt=0;
ttat=t[0];
for(i=1;i<n;i++)
sum+=t[i-1];
wt=sum;
tat=sum+t[i];
twt=twt+wt;
ttat=ttat+tat;
printf("\n\n");
awt=(float)twt/n;
atat=(float)ttat/n;
getch();
OUTPUT:
1 0 2
2 2 7
3 7 11
Aim: Write a C program to implement the various process scheduling mechanisms such
as Priority Scheduling.
Step 3: For each process in the ready Q, assign the process id and accept the CPU burst time
Step 5: Set the waiting of the first process as ‘0’ and its burst time as its turn around time
(e) Waiting time for process(n)= waiting time of process (n-1) + Burst time of process(n-1)
(f) Turn around time for Process(n)= waiting time of Process(n)+ Burst time for process(n)
Step 7: Calculate
#include <stdio.h>
#include <conio.h>
void main()
int i,j,n,tat[10],wt[10],bt[10],pid[10],pr[10],t,twt=0,ttat=0;
float awt,atat;
clrscr();
printf("\n-----------PRIORITY SCHEDULING--------------\n");
scanf("%d", &n);
for (i=0;i<n;i++)
pid[i] = i;
scanf("%d",&bt[i]);
scanf ("%d",&pr[i]);
// Sorting start
for (i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
if (pr[i] > pr[j] )
t = pr[i];
pr[i] = pr[j];
pr[j] = t;
t = bt[i];
bt[i] = bt[j];
bt[j] = t;
t = pid[i];
pid[i] = pid[j];
pid[j] = t;
// Sorting finished
tat[0] = bt[0];
wt[0] = 0;
for (i=1;i<n;i++)
printf("\n---------------------------------------------------------------\n");
printf("\n--------------------------------------------------------------\n");
for(i=0;i<n;i++)
{
printf("\n%d\t\t%d\t%d\t\t%d\t\t%d",pid[i],pr[i],bt[i],wt[i],tat[i]);
for(i=0;i<n;i++)
ttat = ttat+tat[i];
awt = (float)twt / n;
atat = (float)ttat / n;
getch();
OUTPUT:
-----------PRIORITY SCHEDULING--------------
----------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------
2 1 4 0 4
1 2 6 4 10
0 3 2 10 12
3 7 5 12 17
ALGORITHM:
Step 3: Get the number of processes and values of block size for each process.
Step 4: First fit algorithm searches all the entire memory block until a hole which is
big enough is encountered. It allocates that memory block for the requesting
process.
Step 5: Best-fit algorithm searches the memory blocks for the smallest hole which can
Step 6: Worst fit algorithm searches the memory blocks for the largest hole and
Step 7: Analyses all the three memory management techniques and display the best
#include<stdio.h>
#include<conio.h>
main()
int n,i,j,b[20],sb[20],t[20],x,c[20][20];
clrscr();
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d",&b[i]);
scanf("%d",&sb[i]);
t[i]=sb[i];
for(j=0;j<b[i];j++)
c[i][j]=sb[i]++;
printf("Filename\tStart block\tlength\n");
for(i=0;i<n;i++)
printf("%d\t %d \t%d\n",i+1,t[i],b[i]);
scanf("%d",&x);
printf("File name is:%d",x);
printf("length is:%d",b[x-1]);
printf("blocks occupied:");
for(i=0;i<b[x-1];i++)
printf("%4d",c[x-1][i]);
getch();
OUTPUT:
1 2 4
2 5 10
Algorithm:
Step 1: Start.
Step 7: Check there is any cosumer.If yes check whether the buffer is empty
Step 10: Repeat checking for the producer and consumer till required
#include<stdio.h>
#include<conio.h>
main()
int n,m[20],i,j,sb[20],s[20],b[20][20],x;
clrscr();
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d",&sb[i],&s[i]);
scanf("%d",&m[i]);
for(j=0;j<m[i];j++)
scanf("%d",&b[i][j]);
} printf("\nFile\t index\tlength\n");
for(i=0;i<n;i++)
printf("%d\t%d\t%d\n",i+1,sb[i],m[i]);
}
printf("\nEnter file name:");
scanf("%d",&x);
i=x-1;
printf("Index is:%d",sb[i]);
for(j=0;j<m[i];j++)
printf("%3d",b[i][j]);
getch();
2 5 4 6 7 2 6 4 7
1 2 10
2 3 5
ALGORITHM:
Step 2: When the page is required replace the page at the head of the queue
Step 3: Now the new page is inserted at the tail of the queue
Step 5: When the page fault occurs replace page present at the bottom of the stack
#include<stdio.h>
#include<conio.h>
struct file
char fname[10];
int start,size,block[10];
}f[10];
main()
int i,j,n;
clrscr();
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%s",&f[i].fname);
scanf("%d",&f[i].start);
f[i].block[0]=f[i].start;
scanf("%d",&f[i].size);
for(j=1;j<=f[i].size;j++)
{
scanf("%d",&f[i].block[j]);
printf("File\tstart\tsize\tblock\n");
for(i=0;i<n;i++)
printf("%s\t%d\t%d\t",f[i].fname,f[i].start,f[i].size);
for(j=1;j<=f[i].size-1;j++)
printf("%d--->",f[i].block[j]);
printf("%d",f[i].block[j]);
printf("\n");
getch();
OUTPUT:
12
15
45
32
25
venkat 20 6 4--->12--->15--->45--->32--->25
rajesh 12 5 6--->5--->4--->3--->2
Exp. No: 3(a) MULTIPROGRAM VARIABLE TASK
Algorithm:
#include<stdio.h>
#include<conio.h>
main()
int i,m,n,tot,s[20];
clrscr();
scanf("%d",&tot);
scanf("%d",&n);
scanf("%d",&m);
for(i=0;i<n;i++)
scanf("%d",&s[i]);
tot=tot-m;
for(i=0;i<n;i++)
if(tot>=s[i])
tot=tot-s[i];
}
else
getch();
OUTPUT:
External Fragmentation is = 2
Exp. No: 3(b) MULTIPROGRAM FIXED TASK
Algorithm:
#include<stdio.h>
#include<conio.h>
main()
int ms,i,ps[20],n,size,p[20],s,intr=0;
clrscr();
scanf("%d",&ms);
scanf("%d",&s);
ms-=s;
scanf("%d",&n);
size=ms/n;
for(i=0;i<n;i++)
scanf("%d%d",&p[i],&ps[i]);
if(ps[i]<=size)
intr=intr+size-ps[i];
printf("process%d is allocated\n",p[i]);
else
printf("process%d is blocked",p[i]);
}
getch();
OUTPUT:
Internal Fragmentation is = 4
Ex. No: 4 BANKER’S ALGORITHM
Banker’s Algorithm:
When a new process enters a system, it must declare the maximum number of instances of each
resource type it needed. This number may exceed the total number of resources in the system. When the
user request a set of resources, the system must determine whether the allocation of each resources will
leave the system in safe state. If it will the resources are allocation; otherwise the process must wait until
some other process release the resources.
Data structures
n-Number of process, m-number of resource types.
Available: Available[j]=k, k – instance of resource type Rj is available.
Max: If max[i, j]=k, Pi may request at most k instances resource Rj.
Allocation: If Allocation [i, j]=k, Pi allocated to k instances of resource Rj
Need: If Need[I, j]=k, Pi may need k more instances of resource type Rj,
Need[I, j]=Max[I, j]-Allocation[I, j];
Safety Algorithm
1. Work and Finish be the vector of length m and n respectively, Work=Available and Finish[i]
=False.
2. Find an i such that both
Finish[i] =False
Need<=Work
If no such I exists go to step 4.
Let Request i be request vector for the process Pi, If request i=[j]=k, then process Pi wants k
instances of resource type Rj.
1. if Request<=Need I go to step 2. Otherwise raise an error condition.
2. if Request<=Available go to step 3. Otherwise Pi must since the resources are available.
3. Have the system pretend to have allocated the requested resources to process Pi by modifying the
state as follows;
Available=Available-Request I;
Allocation I =Allocation+Request I;
If the resulting resource allocation state is safe, the transaction is completed and process Pi is allocated its
resources. However if the state is unsafe, the Pi must wait for Request i and the old resource-allocation
state is restored.
ALGORITHM:
#include<stdio.h>
#include<conio.h>
struct da
int max[10],a1[10],need[10],before[10],after[10];
}p[10];
void main()
int i,j,k,l,r,n,tot[10],av[10],cn=0,cz=0,temp=0,c=0;
clrscr();
scanf("%d",&n);
scanf("%d",&r);
for(i=0;i<n;i++)
printf("PROCESS %d \n",i+1);
for(j=0;j<r;j++)
scanf("%d",&p[i].max[j]);
for(j=0;j<r;j++)
p[i].need[j]=p[i].max[j]-p[i].a1[j];
for(i=0;i<r;i++)
scanf("%d",&tot[i]);
for(i=0;i<r;i++)
for(j=0;j<n;j++)
temp=temp+p[j].a1[i];
av[i]=tot[i]-temp;
temp=0;
for(i=0;i<n;i++)
for(j=0;j<r;j++)
printf("%d",p[i].max[j]);
printf("\t");
for(j=0;j<r;j++)
printf("%d",p[i].a1[j]);
printf("\t");
for(j=0;j<r;j++)
printf("%d",p[i].need[j]);
printf("\t");
for(j=0;j<r;j++)
if(i==0)
printf("%d",tot[j]);
printf(" ");
for(j=0;j<r;j++)
if(i==0)
printf("%d",av[j]);
for(l=0;l<n;l++)
for(i=0;i<n;i++)
for(j=0;j<r;j++)
if(p[i].need[j] >av[j])
cn++;
if(p[i].max[j]==0)
cz++;
}
for(j=0;j<r;j++)
p[i].before[j]=av[j]-p[i].need[j];
p[i].after[j]=p[i].before[j]+p[i].max[j];
av[j]=p[i].after[j];
p[i].max[j]=0;
printf("\n P %d \t",i+1);
for(j=0;j<r;j++)
printf("%d",p[i].before[j]);
printf("\t");
for(j=0;j<r;j++)
printf("%d",p[i].after[j]);
cn=0;
cz=0;
c++;
break;
else
cn=0;cz=0;
}
}
if(c==n)
else
getch();
OUTPUT:
//TEST CASE 1:
PROCESS 1
PROCESS 2
PROCESS 3
PROCESS 4
P2 010 623
P1 401 723
P3 620 934
P4 514 936
//TEST CASE:2
PROCESS 1
PROCESS 2
PROCESS 3
PROCESS 4
DEADLOCK OCCURED
Ex. No: 5(a) FIFO PAGE REPLACEMENT ALGORITHM
ALGORITHM:
FIFO:
Step 2: When the page is required replace the page at the head of the queue
Step 3: Now the new page is inserted at the tail of the queue
/* FIFO Page Replacement Algorithm */
#include<stdio.h>
#include<conio.h>
int i,j,nof,nor,flag=0,ref[50],frm[50],pf=0,victim=-1;
void main()
clrscr();
scanf("%d",&nof);
scanf("%d",&nor);
for(i=0;i<nor;i++)
scanf("%d",&ref[i]);
for(i=0;i<nor;i++)
printf("%4d",ref[i]);
for(i=1;i<=nof;i++)
frm[i]=-1;
printf("\n");
for(i=0;i<nor;i++)
flag=0;
if(frm[j]==ref[i])
flag=1;
break;
}}
if(flag==0)
pf++;
victim++;
victim=victim%nof;
frm[victim]=ref[i];
for(j=0;j<nof;j++)
printf("%4d",frm[j]);
getch();
OUTPUT:
6
Enter the reference string..
564123
...................................... 5 6 4 1 2 3
Reference np5-> 5 -1 -1 -1
Reference np6-> 5 6 -1 -1
Reference np4-> 5 6 4 -1
Reference np1-> 5 6 4 1
Reference np2-> 2 6 4 1
Reference np3-> 2 3 4 1
Here we select the page that has not been used for the longest period of time.
ALGORITHM:
Step 2: When the page is required replace the page at the head of the queue
Step 3: Now the new page is inserted at the tail of the queue
Step 5: When the page fault occurs replace page present at the bottom of the stack
#include<conio.h>
int i,j,nof,nor,flag=0,ref[50],frm[50],pf=0,victim=-1;
int recent[10],lrucal[50],count=0;
int lruvictim();
void main()
clrscr();
scanf("%d",&nof);
scanf("%d",&nor);
for(i=0;i<nor;i++)
scanf("%d",&ref[i]);
printf("\n………………………………..");
for(i=0;i<nor;i++)
printf("%4d",ref[i]);
for(i=1;i<=nof;i++)
{
frm[i]=-1;
lrucal[i]=0;
for(i=0;i<10;i++)
recent[i]=0;
printf("\n");
for(i=0;i<nor;i++)
flag=0;
for(j=0;j<nof;j++)
if(frm[j]==ref[i])
flag=1;
break;
if(flag==0)
count++;
if(count<=nof)
victim++;
else
victim=lruvictim();
pf++;
frm[victim]=ref[i];
for(j=0;j<nof;j++)
printf("%4d",frm[j]);
recent[ref[i]]=i;
getch();
int lruvictim()
int i,j,temp1,temp2;
for(i=0;i<nof;i++)
temp1=frm[i];
lrucal[i]=recent[temp1];
temp2=lrucal[0];
for(j=1;j<nof;j++)
if(temp2>lrucal[j])
temp2=lrucal[j];
for(i=0;i<nof;i++)
if(ref[temp2]==frm[i])
return i;
return 0;
OUTPUT:
654231
…………………. 6 5 4 2 3 1
Reference NO 6-> 6 -1 -1
Reference NO 5-> 6 5 -1
Reference NO 4-> 6 5 4
Reference NO 2-> 2 5 4
Reference NO 3-> 2 3 4
Reference NO 1-> 2 3 1
ALGORITHM:
Optimal algorithm
Here we select the page that will not be used for the longest period of time.
OPTIMAL:
Step 2: When the page fault occurs replace page that will not be used for the longest
period of time
#include<conio.h>
int i,j,nof,nor,flag=0,ref[50],frm[50],pf=0,victim=-1;
int recent[10],optcal[50],count=0;
int optvictim();
void main()
clrscr();
printf("\n.................................");
scanf("%d",&nof);
scanf("%d",&nor);
for(i=0;i<nor;i++)
scanf("%d",&ref[i]);
clrscr();
printf("\n................................");
printf("\n....................\n");
for(i=0;i<nor;i++)
printf("%4d",ref[i]);
for(i=0;i<nof;i++)
{
frm[i]=-1;
optcal[i]=0;
for(i=0;i<10;i++)
recent[i]=0;
printf("\n");
for(i=0;i<nor;i++)
flag=0;
printf("\n\tref no %d ->\t",ref[i]);
for(j=0;j<nof;j++)
if(frm[j]==ref[i])
flag=1;
break;
if(flag==0)
count++;
if(count<=nof)
victim++;
else
victim=optvictim(i);
pf++;
frm[victim]=ref[i];
for(j=0;j<nof;j++)
printf("%4d",frm[j]);
getch();
int i,j,temp,notfound;
for(i=0;i<nof;i++)
notfound=1;
for(j=index;j<nor;j++)
if(frm[i]==ref[j])
notfound=0;
optcal[i]=j;
break;
if(notfound==1)
return i;
temp=optcal[0];
for(i=1;i<nof;i++)
if(temp<optcal[i])
temp=optcal[i];
for(i=0;i<nof;i++)
if(frm[temp]==frm[i])
return i;
return 0;
OUTPUT:
654231
…………………. 6 5 4 2 3 1
Reference NO 6-> 6 -1 -1
Reference NO 5-> 6 5 -1
Reference NO 4-> 6 5 4
Reference NO 2-> 2 5 4
Reference NO 3-> 2 3 4
Reference NO 1-> 2 3 1
Algorithm:
#include <conio.h>
struct pstruct
int fno;
int pbit;
}ptable[10];
int pmsize,lmsize,psize,frame,page,ftable[20],frameno;
void info()
scanf("%d",&pmsize);
scanf("%d",&lmsize);
scanf("%d",&psize);
void assign()
{
int i;
for (i=0;i<page;i++)
ptable[i].fno = -1;
ptable[i].pbit= -1;
for(i=0; i<frame;i++)
ftable[i] = 32555;
for (i=0;i<page;i++)
scanf("%d",&frameno);
ftable[frameno] = i;
if(ptable[i].pbit == -1)
ptable[i].fno = frameno;
ptable[i].pbit = 1;
getch();
// clrscr();
printf("\n\nPAGE TABLE\n\n");
for (i=0;i<page;i++)
printf("%d\t\t%d\t\t%d\n",i,ptable[i].fno,ptable[i].pbit);
printf("\n\n\n\tFRAME TABLE\n\n");
printf("FrameAddress PageNo\n\n");
for(i=0;i<frame;i++)
printf("%d\t\t%d\n",i,ftable[i]);
void cphyaddr()
int laddr,paddr,disp,phyaddr,baddr;
getch();
// clrscr();
scanf("%d",&baddr);
scanf("%d",&laddr);
if(ptable[paddr].pbit == 1 )
void main()
clrscr();
info();
assign();
cphyaddr();
getch();
OUTPUT:
PAGE TABLE
PageAddress FrameNo. PresenceBit
0 5 1
1 6 1
2 7 1
3 2 1
FRAME TABLE
0 32555
1 32555
2 3
3 32555
4 32555
5 0
6 1
7 2
ALGORITHM:
Step 3: get the base address and length for each segment.
Step 5: check whether the segment number is within the limit, if not display the error
message.
Step 6: Check whether the byte reference is within the limit, if not display the error
message.
#include <conio.h>
#include <math.h>
int sost;
void gstinfo();
void ptladdr();
struct segtab
int sno;
int baddr;
int limit;
int val[10];
}st[10];
void gstinfo()
int i,j;
scanf("%d",&sost);
for(i=1;i<=sost;i++)
st[i].sno = i;
printf("\n\tEnter the base Address: ");
scanf("%d",&st[i].baddr);
scanf("%d",&st[i].limit);
for(j=0;j<st[i].limit;j++)
scanf("%d",&st[i].val[j]);
void ptladdr()
int i,swd,d=0,n,s,disp,paddr;
clrscr();
for(i=1;i<=sost;i++)
printf("\t\t%d \t\t%d\t\t%d\n\n",st[i].sno,st[i].baddr,st[i].limit);
scanf("%d",&swd);
n=swd;
while (n != 0)
n=n/10;
d++;
s = swd/pow(10,d-1);
disp = swd%(int)pow(10,d-1);
if(s<=sost)
else
else
void main()
char ch;
clrscr();
gstinfo();
do
ptladdr();
flushall();
scanf("%c",&ch);
getch();
OUTPUT:
SEGMENT TABLE
1 4 5
2 5 4
3 3 4
Do U want to Continue(Y/N)
SEGMENT TABLE
1 4 5
2 5 4
3 3 4
Do U want to Continue(Y/N)