G L Bajaj Group of Institutions, Mathura

Department of Computer Science and Engineering

Laboratory Manual Session 2020-

21
Operating System lab(KCS-451)

Submitted by: Submitted to:

Mukesh Kumar
Mr. Brijesh Kr. Gupta Sir
1905110100075
Designation: Assistant
Sec – B
Professor
 Experiment No.1

FCFS SCHEDULING

Aim: Write a C program to implement the FCFS SCHEDULING POLICY.

Algorithm for FCFS scheduling:

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 turn around 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 ofprocess(n-1)
b) Turn around time for Process(n)= waiting time of Process(n)+ Burst time forprocess(n)
Step 6: Calculate

a) Average waiting time = Total waiting Time / Number ofprocess

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

FCFS SCHEDULING ALGORITHM: - Implementation in C Language

#include<stdio.h>

void main()

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

int t[10];

float awt,atat;

clrscr();

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

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

getch();

OUTPUT:

Enter number of processors: 3

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

 Experiment No.2

SJF SCHEDULING

Aim:Write a C program to implement SJF SCHEDULING mechanism

Algorithm for SJF

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

(a) Waiting time for process(n)= waiting time of process (n-1) + Burst time ofprocess(n-1)
(b) Turn around time for Process(n)= waiting time of Process(n)+ Burst time forprocess(n)
Step 6: Calculate

(a) Average waiting time = Total waiting Time / Number ofprocess

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

SJF SCHEDULING ALGORITHM :- Implementation in C Language

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

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

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\t5%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;
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 3

Enter the Burst Time of Process 4

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

 Experiment No.3

PRIORITY SCHEDULING

Aim:Write a C program to implement PRIORITY SCHEDULING mechanisms.

Algorithm for Priority Scheduling:

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 turn around time

Step 6: For each process in the Ready Q calculate

(a) Waiting time for process(n)= waiting time of process (n-1) + Burst time ofprocess(n-1)
(b) Turn around time for Process(n)= waiting time of Process(n)+ Burst time forprocess(n)
Step 7: Calculate

(c) Average waiting time = Total waiting Time / Number ofprocess

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

PRIORITY SCHEDULING: Implementation in C Language

#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-----------PRIORITYSCHEDULING -------------- \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];

pid[i] = pid[j];

pid[j] = t;

// Sortingfinished

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

getch();

OUTPUT:

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

Enter the Noof Process: 4

Enter the Burst time of Pid 0 : 2

Enter the Priority of Pid0: 3

Enter the Burst time of Pid 1 : 6

Enter the Priority of Pid1: 2

Enter the Burst time of Pid 2 : 4

Enter the Priority of Pid2: 1

Enter the Burst time of Pid 3 :5

Enter the Priority of Pid3: 7

Pid Priority Bursttime WaitingTime TurnArroundTime

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

 Experiment No.4

ROUND ROBIN SCHEDULING

Aim:Write a C program to implement the ROUND ROBIN SCHEDULINGmechanism.

Algorithm for RR
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 fromprocess(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 fromprocess(n).
Step 7: Calculate

(c) Average waiting time = Total waiting Time / Number ofprocess

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

ROUND ROBIN SCHEDULING ALGORITHM:-Implementation in C Language

#include<stdio.h>

#include<conio.h>

int z[10],b[10],n,m[50],r,q,e=0,avg=0,i,j;

floatf;

main()

clrscr();
printf("\n\tJOB SCHEDULING ALGORITHM[RR]");

printf("\n\t*******************************************************\n");

printf("\nEnter how many jobs:");

scanf("%d",&n);

printf("\nEnter burst time for corresponding job...\n");

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

printf("\nProcess %d: ",i);

scanf("%d",&b[i]); z[i]=b[i];

printf("\nENTER THE TIME SLICE VALUE:");

scanf("%d",&q);

rr();

average();

getch();

return 0;

rr()

int max=0;

max=b[1];

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

if(max<=b[j])

max=b[j];

if((max%q)==0)

r=(max/q);

else

r=(max/q)+1;
for(i=1;i<=r;i++)

printf("\nround %d",i);

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

if(b[j]>0)

b[j]=b[j]-q;

if(b[j]<=0)

b[j]=0;

printf("\nprocess %d is completed",j);

else

printf("\nprocess %d remaining time is %d",j,b[j]);

delay(1000);

return 0;

average()

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

e=0;

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

if(z[i]!=0)

if(z[i]>=q)

{
 m[i+e]=q; z[i]-=q;

else

m[i+e]=z[i]; z[i]=0;

else

m[i+e]=0;
e=e+n;

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

for(j=1;j<=i-1;j++)
avg=avg+m[j];

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

if(m[i]!=0)

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

avg=m[j]+avg;

f=avg/n;

printf("\nTOTAL WATING:%d",avg);
printf("\n\nAVERAGE WAITING TIME:%f\n",f);

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

{ if(m[i]!=0)

if(i%n==0){

printf("P%d",(i%n)+(n)); }

else
printf("P%d",(i%n));
 for(j=1;j<=m[i];j++)

printf("%c",22);

printf("\n");

getch();

return 0;

OUTPUT

JOB SCHEDULING ALGORITHM[RR]

*******************************************************

Enter how many jobs:4

Enter burst time for corresponding job...

Process 1:10

Process 2:15

Process 3:20

Process 4:25

ENTER THE TIME SLICE VALUE:5

round 1

process 1 remaining time is 5

process 2 remaining time is10

process 3 remaining time is15

process 4 remaining time is20

round 2

process 1 is completed

process 2 remaining time is 5

process 3 remaining time is10

process 4 remaining time is15

round 3

process 2 is completed

process 3 remaining time is 5

process 4 remaining time is 10

round 4
process 3 is completed

process 4 remaining time is 5

round 5

process 4 is completed

TOTAL WATING:130

AVERAGE WAITING TIME:32.000000

P1▬▬▬▬▬P2▬▬▬▬▬P3▬▬▬▬▬P4▬▬▬▬▬P1▬▬▬▬▬P2▬▬▬▬▬P3▬▬▬▬▬P4
▬▬▬▬▬P2▬▬▬▬▬P3▬▬▬▬▬P4▬▬▬▬▬P3▬

▬▬▬▬P4▬▬▬▬▬P4▬▬▬▬▬
 Experiment No.5

SEQUENTIAL FILE ALLOCATION

AIM: Write a C Program to implement Sequential File Allocation method.

ALGORITHM:

Step 1: Start the program.

Step 2: Get the number of memory partition and their sizes.

Step 3: Get the number of Files

Step 4: Get number of Partitions allocated to each File

Step 5: Get Starting block of each File

Step 6: Get Name of File

Step 7: Print data in sequential Allocation

Step 8: Stop the program.

PROGRAM:

#include<stdio.h>

#include<conio.h>

main()

int n,i,j,b[20],sb[20],t[20],x,c[20][20];

clrscr();

printf("Enter no.of files:");

scanf("%d",&n);
for(i=0;i<n;i++)

printf("Enter no. of Partitions occupied by file%d",i+1);

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

printf("Enter the starting block of file%d",i+1);

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

printf("Enter file name:");

scanf("%d",&x);

printf("File name is:%d",x);

printf("length is:%d",b[x-1]);

printf("Partitions occupied:");

for(i=0;i<b[x-1];i++)

printf("%4d",c[x-1][i]);

getch();

OUTPUT:

Enter no.of files: 2

Enter no. of Partitions occupied by file1 4

Enter the starting block of file12

Enter no. of Partitions occupied by file2 10

Enter the starting block of file25

Filename Start block length

1 2 4
2 5 10

Enter file name: rajesh

File name is:12803 length is:0Partitions occupied

 Experiment No.6

INDEXED FILE ALLOCATION

AIM: Write a C Program to implement Indexed File Allocation method.

ALGORITHM:

Step 1: Start the program.

Step 2: Get the number of memory partition and their sizes.

Step 3: Get the number of Files

Step 4: Get number of Partitions allocated to each File

Step 5: Get all different Partitions allocated of different files one by one

Step 6: Get Name of File

Step 7: Print data in Indexed Allocation

Step 8: Stop the program.

PROGRAM:

#include<stdio.h>

#include<conio.h>

main()

int n,m[20],i,j,sb[20],s[20],b[20][20],x;

clrscr();

printf("Enter no. of files:");

scanf("%d",&n);

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

{ printf("Enter starting block and size of file%d:",i+1);

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

printf("Enter Partitions occupied by file%d:",i+1);

scanf("%d",&m[i]);
 printf("enter Partitions of file%d:",i+1);

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

printf("file name is:%d\n",x);

i=x-1;

printf("Index is:%d",sb[i]);

printf("Block occupied are:");

for(j=0;j<m[i];j++)

printf("%3d",b[i][j]);

getch();

OUTPUT:

Enter no. of files:2

Enter starting block and size of file1: 2 5

Enter Partitions occupied by file1:10

enter Partitions of file1:3

254672647

Enter starting block and size of file2: 3 4

Enter Partitions occupied by file2:5

enter Partitions of file2: 2 3 4 5 6

File index length

1 2 10
2 3 5

Enter file name: venkat

file name is:12803

Index is:0Block occupied are:

 Experiment No.7

LINKED FILE ALLOCATION

AIM: Write a C Program to implement Linked File Allocation method.

ALGORITHM:

Step 1: Start the program.

Step 2: Get the number of memory partition and their sizes.

Step 3: Get the number of Files

Step 4: Get number of Partitions allocated to each File

Step 5: Get Starting block and all different Partitions allocated of different files one by one

Step 6: Get Name of File

Step 6: Print data in Linked Allocation by starting block

Step 7: Stop the program.

PROGRAM:

#include<stdio.h>

#include<conio.h>

struct file

char fname[10];

int start,size,block[10];

}f[10];

main()

inti,j,n;

clrscr();

printf("Enter no. of files:");

scanf("%d",&n);
for(i=0;i<n;i++)

printf("Enter file name:");

scanf("%s",&f[i].fname);
printf("Enter starting block:");

scanf("%d",&f[i].start);

f[i].block[0]=f[i].start;

printf("Enter no.of Partitions:");

scanf("%d",&f[i].size);

printf("Enter block numbers:");

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:

Enter no. of files:2

Enter file name:venkat

Enter starting block:20

Enter no.of Partitions:6

Enter block numbers: 4

12

15

45

32
25

Enter file name:rajesh

Enter starting block:12

Enter no.of Partitions:5

Enter block numbers:6

File start size block

venkat20 6 4--->12--->15--->45--->32--->25
rajesh12 5 6--->5--->4--->3--->2
 Experiment No.8

MULTIPROGRAM VARIABLE TASK

AIM: Write a program to implement Dynamic allocation of memories in MVT.

Algorithm:

Step1: start the process.

Step2: Declare variables.

Step3: Enter total memory size.

Step4: Allocate memory foros.

Step5: allocate total memory to the pages.

Step6: Display the wastage of memory.

Step7: Stop the process.

Program:-

#include<stdio.h>

#include<conio.h>
main()

int i,m,n,tot,s[20];

clrscr();

printf("Enter total memory size:");

scanf("%d",&tot);
printf("Enter no. of pages:");

scanf("%d",&n);

printf("Enter memory for OS:");

scanf("%d",&m);

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

printf("Enter size of page%d:",i+1);

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

tot=tot-m;
 for(i=0;i<n;i++)

if(tot>=s[i])

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

tot=tot-s[i];

else

printf("process p%d is blocked\n",i+1);

printf("External Fragmentation is=%d",tot);

getch();

OUTPUT:

Enter total memory size : 50

Enterno.ofpages 4

Enter memoryforOS 10

Enter sizeofpage 10

Enter sizeofpage 9

Enter sizeof page 9

Enter sizeofpage 10

External Fragmentation is = 2

Experiment No.9

MULTIPROGRAM FIXED TASK

AIM: Write a program to implement Dynamic allocation of memories in MFT.

Algorithm:

Step1: start the process.

Step2: Declare variables.

Step3: Enter total memory size.

Step4: Allocate memory foros.

Step5: allocate total memory to the pages.

Step6: Display the wastage of memory.

Step7: Stop the process.

PROGRAM:

#include<stdio.h>

#include<conio.h>

main()

int ms,i,ps[20],n,size,p[20],s,intr=0;

clrscr();

printf("Enter size of memory:");

scanf("%d",&ms);

printf("Enter memory for OS:");

scanf("%d",&s);

ms-=s;

printf("Enter no.of partitions to be divided:");

scanf("%d",&n);

size=ms/n;

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

printf("Enter process and process size");

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

printf("total fragmentation is %d",intr);

getch();

OUTPUT:

Enter total memory size : 50

Enter memoryforOS :10

Enter no.of partitions to be divided:4

Enter size of page : 10

Enter size of page : 9

Enter size of page : 9

Enter size of page : 8

Internal Fragmentation is = 4

Experiment No.10

BANKER’S ALGORITHM

AIM: To implement deadlock avoidance & Prevention by using Banker’sAlgorithm.

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.

 n-Number of process, m-number of resourcetypes.

 Available: Available[j]=k, k – instance of resource type Rj isavailable.
 Max: If max[i, j]=k, Pi may request at most k instances resourceRj.
 Allocation: If Allocation [i, j]=k, Pi allocated to k instances of resourceRj
 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 andFinish[i]
=False.
2. Find an i such thatboth
 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 safestate.

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

2. if Request<=Available go to step 3. Otherwise Pi must since the resources areavailable.
3. Have the system pretend to have allocated the requested resources to process Pi by
modifying the state asfollows;
Available=Available-Request I;

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 theprogram.
2. Get the values of resources andprocesses.
3. Get the availvalue.
4. After allocation find the needvalue.
5. Check whether its possible toallocate.
6. If it is possible then the system is in safestate.
7. Else system is not in safetystate.
8. If the new request comes then check that the system is insafety.
9. or not if we allow therequest.
10. stop theprogram.

Bankers Algorithm Description: To determine if a sequence is a safe sequence.

Program:-

#include<stdio.h>

char res[10]={'A','B','C','D','E','F','G','H','I','J'};

void disp(int m,int n,int alloc[5][5],int max[5][5],int avble[5],int need[5][5]);

void safesq(int m,int n,int alloc[5][5],int avble[5],int need[5][5]);

void resreq(int m,int n,int alloc[5][5],int avble[5],int need[5][5]);

void main()

int i,j,ch,n,m,work1[5];

int avble[5],alloc[5][5],max[5][5],need[5][5];

printf("\nENTER THE NUMBER OF PROCESSES : \t");

scanf("%d",&n);

printf("\nENTER THE NUMBER OF RESOURCES : \t");

scanf("%d",&m);

printf("\nENTER THE MAXIMUM INSTANCES OF EACH RESOURCE\n");

for(i=0;i<m;i++)
{

printf("\n\tRESOURCE %c:\t",res[i]);

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

printf("\nENTER THE MAXIMUM DEMAND OF EACH PROCESS FOR A RESOURCE\n");

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

printf("\n\tFOR PROCESS P%d \n",i);

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

printf("\n\tRESOURCE %c : \t",res[j]);
scanf("%d",&max[i][j]);

printf("\nENTER THE MAX NO. OF INSTANCES OF A RESOURCE ALLOCATED TO");

printf(" A PROCESS.\n");

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

printf("\n\tFOR PROCESS P%d \n",i);

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

printf("\n\tRESOURCE %c : \t",res[j]);

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

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

work1[i]=0;

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

work1[i]+=alloc[j][i];

avble[i]=avble[i] -work1[i];

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

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

need[i][j]=max[i][j]-alloc[i][j];

while(1)

printf("\n\n\tMENU:\n\t1]DISPLAY DATA\n\t2]GENERATE SAFE SEQUENCE");

printf("\n\t3]RESOURCE REQUEST\n\t4]EXIT\n\tENTER YOUR CHOICE:\t");

scanf("%d",&ch);

switch(ch)

case1:

disp(m,n,alloc,max,avble,need);

break;

case2:

safesq(m,n,alloc,avble,need);
 break;

case3:

resreq(m,n,alloc,avble,need);

break;

case4:
exit(0);

default:

printf("\n\tINVALID CHOICE ENTERED.\n");

void disp(int m,int n,int alloc[5][5],int max[5][5],int avble[5],int need[5][5])

int i,j;

printf("\n\t\tALLOCATION\tMAX\tNEED\t AVAILABLE");

printf("\t\t");

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

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

printf("%c ",res[j]);

printf(" ");

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

printf("\n\tP%d\t",i);

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

printf("%d ",alloc[i][j]);

printf(" ");

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

printf("%d ",max[i][j]);

printf("\t");

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

printf("%d ",need[i][j]);

printf(" ");
 if(i==0)

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

printf("%d ",avble[j]);

void safesq(int m,int n,int alloc[5][5],int avble[5],int need[5][5])

int i,j,k=0,l,work[5],work1[5],fin[5],flag=0,flag1=0,safesq[6];

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

work[i]=avble[i];

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

fin[i]=0;

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

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

flag1=0;

if(fin[i]==0)

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

if(need[i][j] > work[j])

flag1=1;

break;

if(flag1==0)

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

work[j]=work[j]+alloc[i][j];

fin[i]=1;
 safesq[k]=i;

k++;

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

if(fin[i]==0)

printf("\n\tFOR THE GIVEN REQUIREMENT THE SYSTEM IS");

printf(" NOT IN A SAFE STATE.\n");

flag=1;

break;
}

if(flag==0)

printf("\n\tTHE SAFE SEQUENCE IS:\t");

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

printf("P%d ",safesq[i]);

void resreq(int m,int n,int alloc[5][5],int avble[5],int need[5][5])

int i,j,num,alloc1[5][5],avble1[5],req[5],flag=0,flag1=0;

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

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

alloc1[i][j] = alloc[i][j];

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

avble1[j]=avble[j];

printf("\n\tENTER THE PROCESS NO. THAT REQUIRES EXTRA RESOURCES:\t");

scanf("%d",&num);

printf("\n\tENTER THE INSTANCE REQUIREMENT OF PROCESS P%d\n",num);

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

printf("\n\tRESOURCE %c:\t",res[i]);

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

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

if(req[i]>need[num][i])

flag=1;

break;

if(flag==0)

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

if(req[i] > avble1[i])

flag1=1;

break;

if(flag1==0)

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

avble1[i]=avble1[i]-req[i];

alloc1[num][i]=alloc1[num][i]+req[i];

need[num][i]=need[num][i]-req[i];

safesq(m,n,alloc1,avble1,need);

else
 {

printf("\n\tTHE PROCESS P%d HAS TO WAIT AS RESOURCES ");

printf("ARE NOT AVAILABLE.\n");

else

printf("\n\t REQUIREMENT EXCEEDS MAXIMUM CLAIM.\n");

OUTPUT:

//TEST CASE 1:

ENTER THE NO. OF PROCESSES:4

ENTER THE NO. OF RESOURCES:3

PROCESS1

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

PROCESS2

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

PROCESS3
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 TOTALAVAIL

P1 322 100 222 936 112

P2 613 511 102

P3 314 211 103

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

PROCESS1

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

PROCESS2

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

PROCESS3

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

PROCESS4

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 TOTALAVAIL

P1 322 101 221 936 110

P2 613 511 102

P3 314 212 102

P4 422 002 420

AVAIL BEFORE AVAIL AFTER

DEADLOCK OCCURED
 Experiment No.11

FIFO PAGE REPLACEMENT ALGORITHM

AIM: To implement page replacement algorithms

FIFO (First In FirstOut)

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

FIFO Page Replacement Algorithm

#include<stdio.h>

#include<conio.h>

int fr[3];

void main()

void display();

int i,j,page[12]={2,3,2,1,5,2,4,5,3,2,5,2};

int flag1=0,flag2=0,pf=0,frsize=3,top=0;

clrscr();

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

fr[i]=-1;

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

flag1=0;

flag2=0;

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

if(fr[i]==page[j])

{
flag1=1;

flag2=1;

break;

if(flag1==0)

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

if(fr[i]==-1)

fr[i]=page[j];

flag2=1;

break;

if(flag2==0)

fr[top]=page[j];

top++;

pf++;
if(top>=frsize)

top=0;

display();

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

getch();

void display()

int i;

printf("\n");
for(i=0;i<3;i++)

printf("%d\t",fr[i]);

OUTPUT:

Enterno.of frames .... 4

Enter number of reference string 6

Enter the reference string..

564123

The given reference string:...................................... 5 6 412 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.ofpagesfaults .... 6
 Experiment No.12

LRU PAGE REPLACEMENT ALGORITHM

AIM: To implement page replacementalgorithm

LRU (Least RecentlyUsed)

LRU (Lease Recently Used)

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

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

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 fr[3];

void main()

void display();

int p[12]={2,3,2,1,5,2,4,5,3,2,5,2},i,j,fs[3];

int index,k,l,flag1=0,flag2=0,pf=0,frsize=3;

clrscr();

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

fr[i]=-1;

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

{
flag1=0,flag2=0;

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

if(fr[i]==p[j])

flag1=1;

flag2=1;

break;
}

if(flag1==0)

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

if(fr[i]==-1)

fr[i]=p[j];

flag2=1;

break;

if(flag2==0)

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

fs[i]=0;

for(k=j-1,l=1;l<=frsize-1;l++,k--)

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

if(fr[i]==p[k])

fs[i]=1;

}
for(i=0;i<3;i++)

if(fs[i]==0)

index=i;

fr[index]=p[j];

pf++;

display();

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

getch();

void display()

int i;

printf("\n");

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

printf("\t%d",fr[i]);

OUTPUT:

Enter no.of Frames ... 3

Enter no.of reference string 6

Enter reference string. 6 5 4 2 3 1

The given reference string:…………………. 6 5 423 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
 Experiment No.13

OPTIMAL (LFU) PAGE REPLACEMENT ALGORITHM

AIM: To implement page replacementalgorithms

Optimal (The page which is not used for longest time)

ALGORITHM:

Optimal algorithm

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

OPTIMAL:

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

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

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

clrscr();

printf("\n OPTIMAL PAGE REPLACEMENTALGORITHM");

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)

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)

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:

Enter no.of Frames ... 3

Enter no.of reference string 6

Enter reference string 6 5 4 2 3 1

The given reference string:…………………. 6 5 423 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

 Experiment No.14

PAGING

Aim: To implement the Memory management policy-Paging.

Algorithm:

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

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

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

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

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)

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

voidcphyaddr()

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

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

PAGE TABLE

PageAddress FrameNo. PresenceBit

0 5 1

1 6 1

2 7 1
3 2 1

FRAME TABLE

FrameAddress PageNo

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 theLogical Address: 3

The Physical Address where the instruction present: 1013

 Experiment No.15

SEGMENTATION

AIM:

To implement the memory management policy-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.

/*MEMORY SEGMENT TABLE*/

#include <stdio.h>

#include <conio.h>

#include <math.h>

int sost;

void gstinfo();

voidptladdr();

structsegtab

int sno;

int baddr;
int limit;
 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();

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

printf("\n\t SEG.NO\tBASEADDRESS\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 ishigh\n\n",s);

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

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

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)
 Experiment No.16

First Fit Memory Allocation Scheme

Aim:- To implement First Fit Memory Allocation Scheme

#include<stdio.h>

#include<process.h>

void main()

int partition[20],process[20],i,j,n,m;

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

scanf("%d",&n);

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

printf("Enter the %dst Partition size:",i);

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

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

scanf("%d",&m);

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

printf("Enter the size of %dst Process:",i);

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

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

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

if(process[j]<=Partition[i])

printf("The Process %d allocated to %d\n",j,partition[i]);

process[j]=10000;

break;

}}}
for(j=0;j<m;j++)

if(process[j]!=10000)

printf("The Process %d is not allocated\n",j);}}

getch();}

Output:

Enter no of Partitions.

Enter the 0st Partition size:210

Enter the 1st Partition size:345

Enter the 2st Partition size:237

Enter the 3st Partition size:450

Enter the 4st Partition size:321

Enter no of Process.

Enter the size of 0st Process:432

Enter the size of 1st Process:342

Enter the size of 2st Process:56

Enter the size of 3st Process:321

Enter the size of 4st Process:105

The Process 2 allocated to210

The Process 1 allocated to345

The Process 4 allocated to237

The Process 0 allocated to450

The Process 3 allocated to321