Faculty of Engineering and Technology

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

LAB MANUAL
OPERATING SYSTEM LAB
Session 2019-20

1
 JECRC UNIVERSITY
JAIPUR

Lab Objectives/Aims

Upon successful completion of this lab the student will be able to:

• Implement various process scheduling algorithms.

• Compare and contrast different algorithms
• Understand and implement deadlock avoidance and prevention mechanism.
• Implement various page replacement mechanisms.
• Implement various memory management policies.
• Implement and build algorithms on different tools with suitable simulation

Course Outcome (CO):

CO1. Implement and compare various process scheduling algorithms.

CO2. Implement deadlock avoidance and prevention algorithm
CO3. Implement various page replacement algorithms.
CO4. Implement memory management methods.

MAPPING COURSE OUTCOMES LEADING TO THE ACHIEVEMENT OF PROGRAM OUTCOMES

AND PROGRAM SPECIFIC OUTCOMES:

Course Program Outcome Program

Outcome Specific
Outcome
PO1 PO2 PO3 PO4 PO5 PO6 PO7 PO8 PO9 PO10 PO11 PO12 PSO1 PSO2 PSO3

CO1 H M M M M H H M
CO2 H M M M M H H M
CO3 H M M M M H H M
CO4 H M M M M H H M

H = Highly Related; M = Medium ; L = Low

2
 JECRC UNIVERSITY
JAIPUR

List of Experiments

Experiment No Aim Page No.

1 Write a C program to implement the various process scheduling
4
mechanisms such as FCFS scheduling.
2 Write a C program to implement the various process scheduling
7
mechanisms such as SJF Scheduling.
3 Write a C program to implement the various process scheduling
11
mechanisms such as Round Robin Scheduling.
4 Write a C program to implement the various process scheduling
16
mechanisms such as Priority Scheduling.
5 To implement deadlock avoidance & Prevention by using
20
Banker’s Algorithm.
6 To implement page replacement algorithms FIFO (First In First
29
Out).
7 To implement page replacement algorithm LRU (Least Recently
32
Used).
8 To implement page replacement algorithms Optimal (The page
36
which is not used for longest time)
9 To implement the memory management policy- Paging. 40
10 To implement the memory management policy-segmentation. 45

3
 JECRC UNIVERSITY
JAIPUR

Exp No: 1 Date: _ _/_ _/

Aim: Write a C program to implement the various process scheduling mechanisms such as FCFS
scheduling:

/* FCFS PROCESS SCHEDULING ALGORITHM */

Step 1: Start the process

Step 2: Accept the number of processes in the ready Queue

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

Step 5: for each process in the Ready Q calculate

(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

(a) Average waiting time = Total waiting Time / Number of process

(b) Average Turnaround time = Total Turnaround Time / Number of process
Step 7: Stop the process

/* PROGRAM */

#include<stdio.h>

void main()

int i,n,sum,wt,tat,twt,ttat;

int t[10];

float awt,atat;

4
printf("Enter number of processors:\n");

scanf("%d",&n);

for(i=0;i<n;i++)

printf("\n Enter the Burst Time of the process %d",i+1);

scanf("\n %d",&t[i]);

printf("\n\n FIRST COME FIRST SERVE SCHEDULING ALGORITHM \n");

printf("\n Process ID \t Waiting Time \t Turn Around Time \n");

printf("1 \t\t 0 \t\t %d \n",t[0]);

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 %d \t\t %d \t\t %d",i+1,wt,tat);

printf("\n\n");

awt=(float)twt/n;

atat=(float)ttat/n;

printf("\n Average Waiting Time %4.2f",awt);

5
 printf("\n Average Turnaround Time %4.2f",atat);

getch();

OUTPUT:

Enter number of processors:

Enter the Burst Time of the process 1: 2

Enter the Burst Time of the process 2: 5

Enter the Burst Time of the process 3: 4

FIRST COME FIRST SERVE SCHEDULING ALGORITHM

Process ID Waiting Time Turn Around Time

1 0 2

2 2 7

3 7 11

Average Waiting Time 3.00

Average Turnaround Time 6.67

6
 JECRC UNIVERSITY
JAIPUR

Exp No: 2 Date: _ _/_ _/ _ _

Aim: Write a C program to implement the various process scheduling mechanisms such as SJF
Scheduling.

/* SJF PROCESS SCHEDULING ALGORITHM */

Step 1: Start the process

Step 2: Accept the number of processes in the ready Queue

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 highest burst
time.

Step 5: Set the waiting time of the first process as ‘0’ and its turnaround time as its burst time.

Step 6: For each process in the ready queue, calculate

(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

(c) Average waiting time = Total waiting Time / Number of process

(d) Average Turnaround time = Total Turnaround Time / Number of process
Step 7: Stop the process

/* PROGRAM */

#include<stdio.h>

void main()

int i,j,k,n,sum,wt[10],tt[10],twt,ttat;

int t[10],p[10];

7
float awt,atat;

clrscr();

printf("Enter number of process\n");

scanf("%d",&n);

for(i=0;i<n;i++)

printf("\n Enter the Burst Time of Process %d",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;

} }

printf("\n\n SHORTEST JOB FIRST SCHEDULING ALGORITHM");

8
printf("\n PROCESS ID \t BURST TIME \t WAITING TIME \t TURNAROUND TIME \n\n");

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

printf("%5d \t\t%d \t\t %5d \t\t %5d \n\n",p[i],t[i],wt[i],tt[i]);

twt=0;

ttat=t[0];

for(i=1;i<n;i++)

twt=twt+wt[i];

ttat=ttat+tt[i];

awt=(float)twt/n;

9
 atat=(float)ttat/n;

printf("\n AVERAGE WAITING TIME %4.2f",awt);

printf("\n AVERAGE TURN AROUND TIME %4.2f",atat);

getch();

}}

OUTPUT:

Enter number of process

Enter the Burst Time of Process 04

Enter the Burst Time of Process 13

Enter the Burst Time of Process 25

SHORTEST JOB FIRST SCHEDULING ALGORITHM

PROCESS ID BURST TIME WAITING TIME TURNAROUND TIME

1 3 0 3

0 4 3 7

2 5 7 12

AVERAGE WAITING TIME 3.33

AVERAGE TURN AROUND TIME 7.33

10
 JECRC UNIVERSITY
JAIPUR

Exp No: 3 Date: _ _/_ _/

Aim: Write a C program to implement the various process scheduling mechanisms such as Round Robin
Scheduling.

/* ROUND ROBIN PROCESS SCHEDULING ALGORITHM */

Step 1: Start the process

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

No. of time slice for process(n) = burst time process(n)/time slice

Step 5: If the burst time is less than the time slice then the no. of time slices =1.

Step 6: Consider the ready queue is a circular Q, calculate

(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

(e) Average waiting time = Total waiting Time / Number of process

(f) Average Turnaround time = Total Turnaround Time / Number of process
Step 8: Stop the process

/* PROGRAM */

#include<stdio.h>

#include<conio.h>

11
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();

printf("\t\t ROUND ROBIN SCHEDULING \n");

printf("Enter the number of Processors \n");

scanf("%d",&n);

n1=n;

printf("\n Enter the Timeslice \n");

scanf("%d",&ts);

for(i=1;i<=n;i++)

printf("\n Enter the process ID %d",i);

scanf("%d",&pid[i]);

printf("\n Enter the Burst Time for the process");

scanf("%d",&bt[i]);

need[i]=bt[i];

for(i=1;i<=n;i++)

flag[i]=1;

wt[i]=0;

while(n!=0)

12
{

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;

13
 }}}

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;

printf("\n\n ROUND ROBIN SCHEDULING ALGORITHM \n\n");

printf("\n\n Process \t Process ID \t BurstTime \t Waiting Time \t TurnaroundTime \n ");

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]);

printf("\n The average Waiting Time=4.2f",awt);

printf("\n The average Turn around Time=4.2f",atat);

getch();

OUTPUT:

ROUND ROBIN SCHEDULING

Enter the number of Processors

Enter the Time slice

Enter the process ID 1 5

14
Enter the Burst Time for the process 10

Enter the process ID 2 6

Enter the Burst Time for the process 15

Enter the process ID 3 7

Enter the Burst Time for the process 20

Enter the process ID 4 8

Enter the Burst Time for the process 25

ROUND ROBIN SCHEDULING ALGORITHM

Process Process ID Burst Time Waiting Time Turnaround Time

1 5 10 15 25

2 6 15 25 40

3 7 20 25 45

4 8 25 20 45

The average Waiting Time=4.2f

The average Turnaround Time=4.2f

15
 JECRC UNIVERSITY
JAIPUR

Exp No: 4 Date: _ _/_ _/

Aim: Write a C program to implement the various process scheduling mechanisms such as Priority
Scheduling.

/* PRIORITY PROCESS SCHEDULING ALGORITHM */

Step 1: Start the process

Step 2: Accept the number of processes in the ready Queue

Step 3: For each process in the ready Q, assign the process id and accept the CPU burst time

Step 4: Sort the ready queue according to the priority number.

Step 5: Set the waiting of the first process as ‘0’ and its burst time as its turnaround time

Step 6: For each process in the Ready Q calculate

(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

(g) Average waiting time = Total waiting Time / Number of process

(h) Average Turnaround time = Total Turnaround Time / Number of process
Step 8: Stop the process

/* PROGRAM */

#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;

16
 float awt,atat;

clrscr();

printf("\n-----------PRIORITY SCHEDULING--------------\n");

printf("Enter the No of Process: ");

scanf("%d", &n);

for (i=0;i<n;i++)

pid[i] = i;

printf("Enter the Burst time of Pid %d : ",i);

scanf("%d",&bt[i]);

printf("Enter the Priority of Pid %d : ",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];

17
 pid[i] = pid[j];

pid[j] = t;

} }

// Sorting finished

tat[0] = bt[0];

wt[0] = 0;

for (i=1;i<n;i++)

wt[i] = wt[i-1] + bt[i-1];

tat[i] = wt[i] + bt[i];

printf("\n---------------------------------------------------------------\n");

printf("Pid\t Priority\tBurst time\t WaitingTime\tTurnArroundTime\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];

twt = twt + wt[i];

awt = (float)twt / n;

atat = (float)ttat / n;

printf("\n\nAvg.Waiting Time: %f\nAvg.Turn Around Time: %f\n",awt,atat);

18
 getch();

OUTPUT:

-----------PRIORITY SCHEDULING--------------

Enter the No of Process: 4

Enter the Burst time of Pid 0 : 2

Enter the Priority of Pid 0 : 3

Enter the Burst time of Pid 1 : 6

Enter the Priority of Pid 1 : 2

Enter the Burst time of Pid 2 : 4

Enter the Priority of Pid 2 : 1

Enter the Burst time of Pid 3 : 5

Enter the Priority of Pid 3 : 7

----------------------------------------------------------------------------------------

Pid Priority Burst time Waiting Time Turnaround Time

----------------------------------------------------------------------------------------

2 1 4 0 4

1 2 6 4 10

0 3 2 10 12

3 7 5 12 17

Avg.Waiting Time: 6.500000

Avg.Turn Around Time: 10.750000

19
 JECRC UNIVERSITY
JAIPUR

Exp No: 5 Date: _ _/_ _/

AIM: To implement deadlock avoidance & Prevention by using Banker’s Algorithm Deadlock
avoidance & Dead Lock Prevention

/* 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.

3. work=work+Allocation, Finish[i] =True;

4. if Finish[1]=True for all I, then the system is in safe state.

Resource request algorithm

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;

20
 Allocation I =Allocation+Request I;

Need i=Need i-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:

1. Start the program.

2. Get the values of resources and processes.
3. Get the avail value.
4. After allocation find the need value.
5. Check whether its possible to allocate.
6. If it is possible then the system is in safe state.
7. Else system is not in safety state.
8. If the new request comes then check that the system is in safety.
9. Or not if we allow the request.
10. stop the program.
/* PROGRAM */

#include<stdio.h>

#include<conio.h>

struct da

int max[10],a1[10],need[10],before[10],after[10];

}p[10];

int main()

int i,j,k,l,r,n,tot[10],av[10],cn=0,cz=0,temp=0,c=0;

printf("\n ENTER THE NO. OF PROCESSES:");

scanf("%d",&n);

printf("\n ENTER THE NO. OF RESOURCES:");

scanf("%d",&r);

for(i=0;i<n;i++)

21
{

printf("PROCESS %d \n",i+1);

for(j=0;j<r;j++)

printf("MAXIMUM VALUE FOR RESOURCE %d:",j+1);

scanf("%d",&p[i].max[j]);

for(j=0;j<r;j++)

printf("ALLOCATED FROM RESOURCE %d:",j+1);

scanf("%d",&p[i].a1[j]);

p[i].need[j]=p[i].max[j]-p[i].a1[j];

}}

for(i=0;i<r;i++)

printf("ENTER TOTAL VALUE OF RESOURCE %d:",i+1);

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;

printf("\n\t RESOURCES\t\t ALLOCATED\t\tt NEEDED\t \t TOTAL\t\t AVAIL\t\t");

22
for(i=0;i<n;i++)

printf("\n P%d \t",i+1);

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]);

}}

printf("\n\n\t AVAIL BEFORE\t\t AVAIL AFTER ");

for(l=0;l<n;l++)

23
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++;

if(cn==0 && cz!=r)

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;

24
 c++;

break;

else

cn=0;cz=0;

}}}

if(c==n)

printf("\n THE ABOVE SEQUENCE IS A SAFE SEQUENCE");

else

printf("\n DEADLOCK OCCURED");

getch();

OUTPUT:

//TEST CASE 1:

ENTER THE NO. OF PROCESSES:4

ENTER THE NO. OF RESOURCES:3

PROCESS 1

MAXIMUM VALUE FOR RESOURCE 1:3

MAXIMUM VALUE FOR RESOURCE 2:2

MAXIMUM VALUE FOR RESOURCE 3:2

ALLOCATED FROM RESOURCE 1:1

ALLOCATED FROM RESOURCE 2:0

ALLOCATED FROM RESOURCE 3:0

PROCESS 2

MAXIMUM VALUE FOR RESOURCE 1:6

25
MAXIMUM VALUE FOR RESOURCE 2:1

MAXIMUM VALUE FOR RESOURCE 3:3

ALLOCATED FROM RESOURCE 1:5

ALLOCATED FROM RESOURCE 2:1

ALLOCATED FROM RESOURCE 3:1

PROCESS 3

MAXIMUM VALUE FOR RESOURCE 1:3

MAXIMUM VALUE FOR RESOURCE 2:1

MAXIMUM VALUE FOR RESOURCE 3:4

ALLOCATED FROM RESOURCE 1:2

ALLOCATED FROM RESOURCE 2:1

ALLOCATED FROM RESOURCE 3:1

PROCESS 4

MAXIMUM VALUE FOR RESOURCE 1:4

MAXIMUM VALUE FOR RESOURCE 2:2

MAXIMUM VALUE FOR RESOURCE 3:2

ALLOCATED FROM RESOURCE 1:0

ALLOCATED FROM RESOURCE 2:0

ALLOCATED FROM RESOURCE 3:2

ENTER TOTAL VALUE OF RESOURCE 1:9

ENTER TOTAL VALUE OF RESOURCE 2:3

ENTER TOTAL VALUE OF RESOURCE 3:6

RESOURCES ALLOCATED NEEDED TOTAL AVAIL

P1 322 100 222 936 112

P2 613 511 102

P3 314 211 103

26
P4 422 002 420

AVAIL BEFORE AVAIL AFTER

P2 010 623

P1 401 723

P3 620 934

P4 514 936

THE ABOVE SEQUENCE IS A SAFE SEQUENCE

//TEST CASE:2

ENTER THE NO. OF PROCESSES:4

ENTER THE NO. OF RESOURCES:3

PROCESS 1

MAXIMUM VALUE FOR RESOURCE 1:3

MAXIMUM VALUE FOR RESOURCE 2:2

MAXIMUM VALUE FOR RESOURCE 3:2

ALLOCATED FROM RESOURCE 1:1

ALLOCATED FROM RESOURCE 2:0

ALLOCATED FROM RESOURCE 3:1

PROCESS 2

MAXIMUM VALUE FOR RESOURCE 1:6

MAXIMUM VALUE FOR RESOURCE 2:1

MAXIMUM VALUE FOR RESOURCE 3:3

ALLOCATED FROM RESOURCE 1:5

ALLOCATED FROM RESOURCE 2:1

ALLOCATED FROM RESOURCE 3:1

PROCESS 3

MAXIMUM VALUE FOR RESOURCE 1:3

27
MAXIMUM VALUE FOR RESOURCE 2:1

MAXIMUM VALUE FOR RESOURCE 3:4

ALLOCATED FROM RESOURCE 1:2

ALLOCATED FROM RESOURCE 2:1

ALLOCATED FROM RESOURCE 3:2

PROCESS 4

MAXIMUM VALUE FOR RESOURCE 1:4

MAXIMUM VALUE FOR RESOURCE 2:2

MAXIMUM VALUE FOR RESOURCE 3:2

ALLOCATED FROM RESOURCE 1:0

ALLOCATED FROM RESOURCE 2:0

ALLOCATED FROM RESOURCE 3:2

ENTER TOTAL VALUE OF RESOURCE 1:9

ENTER TOTAL VALUE OF RESOURCE 2:3

ENTER TOTAL VALUE OF RESOURCE 3:6

RESOURCES ALLOCATED NEEDED TOTAL AVAIL

P1 322 101 221 936 110

P2 613 511 102

P3 314 212 102

P4 422 002 420

AVAIL BEFORE AVAIL AFTER

DEADLOCK OCCURED

JECRC UNIVERSITY
JAIPUR

28
Exp No: 6 Date: _ _/_ _/

AIM: To implement page replacement algorithms FIFO (First In First Out)

/* FIFO PAGE REPLACEMENT ALGORITHM */

Step 1: Create a queue to hold all pages in memory

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

/* PROGRAM */

#include<stdio.h>

#include<conio.h>

int i,j,nof,nor,flag=0,ref[50],frm[50],pf=0,victim=-1;

void main()

clrscr();

printf("\n \t\t\t FIFI PAGE REPLACEMENT ALGORITHM");

printf("\n Enter no.of frames....");

scanf("%d",&nof);

printf("Enter number of reference string..\n");

scanf("%d",&nor);

printf("\n Enter the reference string..");

for(i=0;i<nor;i++)

scanf("%d",&ref[i]);

printf("\nThe given reference string:");

for(i=0;i<nor;i++)

printf("%4d",ref[i]);

for(i=1;i<=nof;i++)

29
frm[i]=-1;

printf("\n");

for(i=0;i<nor;i++)

flag=0;

printf("\n\t Reference np%d->\t",ref[i]);

for(j=0;j<nof;j++)

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]);

}}

printf("\n\n\t\t No.of pages faults...%d",pf);

getch(); }

OUTPUT:

FIFO PAGE REPLACEMENT ALGORITHM

30
Enter no.of frames....4

Enter number of reference string..

Enter the reference string..

564123

The given reference string:

...................................... 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

No.of pages faults...6

31
 JECRC UNIVERSITY
JAIPUR

Exp No: 7 Date: _ _/_ _/

AIM: To implement page replacement algorithm LRU (Least Recently Used)

/* LRU PAGE REPLACEMENT ALGORITHM */

Here we select the page that has not been used for the longest period of time.

Step 1: Create a queue to hold all pages in memory

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 4: Create a stack

Step 5: When the page fault occurs replace page present at the bottom of the stack

/* PROGRAM */

#include<stdio.h>

#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();

printf("\n\t\t\t LRU PAGE REPLACEMENT ALGORITHM");

printf("\n Enter no.of Frames....");

scanf("%d",&nof);

32
printf(" Enter no.of reference string..");

scanf("%d",&nor);

printf("\n Enter reference string..");

for(i=0;i<nor;i++)

scanf("%d",&ref[i]);

printf("\n\n\t\t LRU PAGE REPLACEMENT ALGORITHM ");

printf("\n\t The given reference string:");

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;

printf("\n\t Reference NO %d->\t",ref[i]);

for(j=0;j<nof;j++)

if(frm[j]==ref[i])

33
 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;

printf("\n\n\t No.of page faults...%d",pf);

getch(); }

int lruvictim()

int i,j,temp1,temp2;

for(i=0;i<nof;i++)

temp1=frm[i];

lrucal[i]=recent[temp1]; }

34
 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:

LRU PAGE REPLACEMENT ALGORITHM

Enter no.of Frames....3

Enter no.of reference string..6

Enter reference string..

654231

LRU PAGE REPLACEMENT ALGORITHM

The given reference string:

…………………. 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

No.of page faults...6

35
 JECRC UNIVERSITY
JAIPUR

Exp No: 8 Date: _ _/_ _/

AIM: To implement page replacement algorithms Optimal (The page which is not used for longest
time)

/* OPTIMAL (LFU) PAGE REPLACEMENT ALGORITHM */

Here we select the page that will not be used for the longest period of time.

Step 1: Create a array

Step 2: When the page fault occurs replace page that will not be used for the longest period of time

/* PROGRAM */

#include<stdio.h>

#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 OPTIMAL PAGE REPLACEMENT ALGORITHM");

printf("\n.................................");

printf("\nEnter the no.of frames");

scanf("%d",&nof);

printf("Enter the no.of reference string");

scanf("%d",&nor);

printf("Enter the reference string");

for(i=0;i<nor;i++)

36
scanf("%d",&ref[i]);

clrscr();

printf("\n OPTIMAL PAGE REPLACEMENT ALGORITHM");

printf("\n................................");

printf("\nThe given string");

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)

37
 count++;

if(count<=nof)

victim++;

else

victim=optvictim(i);

pf++;

frm[victim]=ref[i];

for(j=0;j<nof;j++)

printf("%4d",frm[j]);

} }

printf("\n Number of page faults: %d",pf);

getch(); }

int optvictim(int index)

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)

38
 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:

OPTIMAL PAGE REPLACEMENT ALGORITHM

Enter no.of Frames....3

Enter no.of reference string..6

Enter reference string..

654231

OPTIMAL PAGE REPLACEMENT ALGORITHM

The given reference string:

…………………. 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

No.of page faults...6

39
 JECRC UNIVERSITY
JAIPUR

Exp No: 9 Date: _ _/_ _/

Aim: To implement the Memory management policy- Paging.

/* MEMORY MANAGEMENT PAGING ALGORITHM */

Step 1: Read all the necessary input from the keyboard.

Step 2: Pages - Logical memory is broken into fixed - sized blocks.

Step 3: Frames – Physical memory is broken into fixed – sized blocks.

Step 4: Calculate the physical address using the following

Physical address = ( Frame number * Frame size ) + offset

Step 5: Display the physical address.

Step 6: Stop the process.

/* PROGRAM */

#include <stdio.h>

#include <conio.h>

struct pstruct

int fno;

int pbit;

}ptable[10];

int pmsize,lmsize,psize,frame,page,ftable[20],frameno;

void info()

printf("\n\nMEMORY MANAGEMENT USING PAGING\n\n");

printf("\n\nEnter the Size of Physical memory: ");

40
 scanf("%d",&pmsize);

printf("\n\nEnter the size of Logical memory: ");

scanf("%d",&lmsize);

printf("\n\nEnter the partition size: ");

scanf("%d",&psize);

frame = (int) pmsize/psize;

page = (int) lmsize/psize;

printf("\nThe physical memory is divided into %d no.of frames\n",frame);

printf("\nThe Logical memory is divided into %d no.of pages",page);

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

printf("\n\nEnter the Frame number where page %d must be placed: ",i);

scanf("%d",&frameno);

ftable[frameno] = i;

if(ptable[i].pbit == -1)

41
 {

ptable[i].fno = frameno;

ptable[i].pbit = 1;

} }

getch();

// clrscr();

printf("\n\nPAGE TABLE\n\n");

printf("PageAddress FrameNo. PresenceBit\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();

printf("\n\n\n\tProcess to create the Physical Address\n\n");

printf("\nEnter the Base Address: ");

scanf("%d",&baddr);

printf("\nEnter theLogical Address: ");

scanf("%d",&laddr);

42
 paddr = laddr / psize;

disp = laddr % psize;

if(ptable[paddr].pbit == 1 )

phyaddr = baddr + (ptable[paddr].fno*psize) + disp;

printf("\nThe Physical Address where the instruction present: %d",phyaddr);

void main()

clrscr();

info();

assign();

cphyaddr();

getch();

OUTPUT:

MEMORY MANAGEMENT USING PAGING

Enter the Size of Physical memory: 16

Enter the size of Logical memory: 8

Enter the partition size: 2

The physical memory is divided into 8 no.of frames

The Logical memory is divided into 4 no.of pages

Enter the Frame number where page 0 must be placed: 5

Enter the Frame number where page 1 must be placed: 6

Enter the Frame number where page 2 must be placed: 7

Enter the Frame number where page 3 must be placed: 2

43
PAGE TABLE

Page Address Frame No. Presence Bit

0 5 1

1 6 1

2 7 1

3 2 1

FRAME TABLE

Frame Address Page No

0 32555

1 32555

2 3

3 32555

4 32555

5 0

6 1

7 2

Process to create the Physical Address

Enter the Base Address: 1000

Enter the Logical Address: 3

The Physical Address where the instruction present: 1013

44
 JECRC UNIVERSITY
JAIPUR

Exp No: 10 Date: _ _/_ _/

AIM: To implement the memory management policy-segmentation.

/* MEMORY MANAGEMENT SEGMENTATION ALGORITHM */

Step 1: Start the program.

Step 2: Get the number of segments.

Step 3: get the base address and length for each segment.

Step 4: Get the logical address.

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.

Step 7: Calculate the physical memory and display it.

Step 8: Stop the program.

/* PROGRAM */

#include <stdio.h>

#include <conio.h>

#include <math.h>

int sost;

void gstinfo();

void ptladdr();

struct segtab

int sno;

int baddr;

int limit;

45
 int val[10];

}st[10];

void gstinfo()

int i,j;

printf("\n\tEnter the size of the segment table: ");

scanf("%d",&sost);

for(i=1;i<=sost;i++)

printf("\n\tEnter the information about segment: %d",i);

st[i].sno = i;

printf("\n\tEnter the base Address: ");

scanf("%d",&st[i].baddr);

printf("\n\tEnter the Limit: ");

scanf("%d",&st[i].limit);

for(j=0;j<st[i].limit;j++)

printf("Enter the %d address Value: ",(st[i].baddr + j));

scanf("%d",&st[i].val[j]);

void ptladdr()

int i,swd,d=0,n,s,disp,paddr;

clrscr();

46
printf("\n\n\t\t\t SEGMENT TABLE \n\n");

printf("\n\t SEG.NO\tBASE ADDRESS\t LIMIT \n\n");

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

printf("\n\nEnter the logical Address: ");

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)

if(disp < st[s].limit)

paddr = st[s].baddr + disp;

printf("\n\t\tLogical Address is: %d",swd);

printf("\n\t\tMapped Physical address is: %d",paddr);

printf("\n\tThe value is: %d",( st[s].val[disp] ) );

else

printf("\n\t\tLimit of segment %d is high\n\n",s);

47
 else

printf("\n\t\tInvalid Segment Address \n");

void main()

char ch;

clrscr();

gstinfo();

do

ptladdr();

printf("\n\t Do U want to Continue(Y/N)");

flushall();

scanf("%c",&ch);

}while (ch == 'Y' || ch == 'y' );

getch();

OUTPUT:

Enter the size of the segment table: 3

Enter the information about segment: 1

Enter the base Address: 4

Enter the Limit: 5

Enter the 4 address Value: 11

Enter the 5 address Value: 12

Enter the 6 address Value: 13

Enter the 7 address Value: 14

48
Enter the 8 address Value: 15

Enter the information about segment: 2

Enter the base Address: 5

Enter the Limit: 4

Enter the 5 address Value: 21

Enter the 6 address Value: 31

Enter the 7 address Value: 41

Enter the 8 address Value: 51

Enter the information about segment: 3

Enter the base Address: 3

Enter the Limit: 4

Enter the 3 address Value: 31

Enter the 4 address Value: 41

Enter the 5 address Value: 41

Enter the 6 address Value: 51

SEGMENT TABLE

SEG.NO BASE ADDRESS LIMIT

1 4 5

2 5 4

3 3 4

Enter the logical Address: 3

Logical Address is: 3

Mapped Physical address is: 3

The value is: 31

Do U want to Continue(Y/N)

SEGMENT TABLE

49
SEG.NO BASE ADDRESS LIMIT

1 4 5

2 5 4

3 3 4

Enter the logical Address: 1

Logical Address is: 1

Mapped Physical address is: 4

The value is: 11

Do U want to Continue(Y/N)

50
 LAB VIVA Questions

1. What is the main purpose of an operating system?

2. What are the different operating systems?
3. What is a socket?
4. What is a real-time system?
5. What is kernel?
6. What is monolithic kernel?
7. What do you mean by a process?
8. What are the different states of a process?
9. What is the difference between micro kernel and macro kernel?
10. What is the concept of reentrancy?
11. What is the difference between process and program?
12. What is the use of paging in operating system?
13. What is the concept of demand paging?
14. What is the advantage of a multiprocessor system?
15. What is virtual memory?
16. What is thrashing?
17. What is a thread?
18. What are the benefits of multithreaded programming?
19. What is FCFS?
20. What is SMP?
21. What is deadlock? Explain.
22. What are the different scheduling algorithms.
23. What is Banker's algorithm?
24. What is the difference between logical address space and physical address space?
25. What is fragmentation?
26. How many types of fragmentation occur in Operating System?
27. What is spooling?
28. What is the difference between internal commands and external commands?

51
29. What is semaphore?
30. What is a binary Semaphore?
31. What is Belady's Anomaly?
32. What is starvation in Operating System?
33. What is aging in Operating System?
34. What are overlays?
35. What is Virtual Memory?
36. What is Thrashing?
37. What is time- sharing system?
38. What is SMP?
39. What is asymmetric clustering?
40. What is RR scheduling algorithm?
41. What factors determine whether a detection-algorithm must be utilized in a deadlock avoidance
system?
42. What is Direct Access Method?
43. What is root partition?
44. What are the primary functions of VFS?
45. What is the purpose of an I/O status information?
46. What is multitasking?
47. Explain pros and cons of a command line interface?
48. What is caching?
49. What is an Assembler?
50. What is GUI?
51. What is preemptive multitasking?
52. What is plumbing/piping?
53. What is NOS?
54. What is the Translation Lookaside Buffer (TLB)?
55. What is cycle stealing?
56. What is meant by arm-stickiness?
57. What is page cannibalizing?
58. What are the four layers that Windows NT have in order to achieve independence?
59. Explain Booting the system and Bootstrap program in operating system.

52
60. What is a command interpreter?
61. What is a daemon?
62. What do you mean by a zombie process?
63. What do you know about a Pipe? When is it used?
64. Explain PCB.
65. What is context switching ?
66. What is EIDE?
67. Explain the execution cycle for a von Neumann architecture.
68. What is DLM?
69. What is RAID and what are its different levels?
70. Explain the different sections of a process.
71. What is IPC?
72. What do you know about mutex?
73. What is the reader-writer lock?
74. What is compaction?

53