OPERATING SYSTEM

LAB MANUAL
OPERATING SYSTEMS LAB MANUAL

INDEX
S.No Name of the Experiment Page No.

1 Course Outcomes i

Write C programs to simulate the following CPU scheduling algorithms:

a) FCFS
1
2 b) SJF
4
c) Round Robin
8
d) Priority
12
Write programs using the I/O system calls of UNIX/LINUX operating
3 system 17
Write a C program to simulate Bankers Algorithm for Deadlock Avoidance
4 34
and Prevention.
Write a C program to implement the Producer – Consumer problem using
5 38
semaphores using UNIX/LINUX system calls

Write C programs to illustrate the following IPC mechanisms

a) Pipes
42
6 b) FIFOs
44
c) Message Queues
48
d) Shared Memory
53
Write C programs to simulate the following memory management
techniques:

7 a) Paging
56
b) Segmentation
59

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

 OPERATING SYSTEMS LAB MANUAL

S.No Page No.

Simulate the following memory allocation algorithms

a) First-Fit 63
8
b) Best-Fit 66
c) Worst-fit 69
Simulate the following memory allocation algorithms

a) FCFS 72
9
b) SCAN 74
c) SSTF 78
7

Simulate page replacement Algorithms.

7
7 7

a) FIFO

b) LRU

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

OPERATING SYSTEMS LAB MANUAL

Course Objectives:

 To implement the scheduling algorithms.

 To write programs in Linux environment using the I/O system calls of

UNIX/LINUX operating system.

 To implement deadlock avoidance

 To implement synchronization problems using semaphores using UNIX/LINUX

system calls.
 To implement IPC mechanism using Pipes.FIFOs , Message Queues , Shared Memory

 To implement memory management techniques.

Course Outcomes:

1. Able to implement c programs for different CPU scheduling algorithms.

2. Able to implement c programs for file and directory I/O system calls
3. Able to implement c programs for prevention and avoidance of deadlocks.
4. Able to implement c programs for process synchronization using semaphore and IPC
mechanisms Using system calls.
5. Able to develop c programs for paging and segmentation technique

i
 Operating systems

1. Write C programs to simulate the following CPU Scheduling algorithms:

a) FCFS CPU SCHEDULING ALGORITHM

DESCRIPTION:

For FCFS scheduling algorithm, read the number of processes/jobs in

the system, their CPU burst times. The scheduling is performed on the
basis of arrival time of the processes irrespective of their other
parameters. Each process will be executed according to its arrival time.
Calculate the waiting time and turnaround time of each of the processes
accordingly.

ALGORITHM:

Step 1: Start
Step 2: Define a structure process with elements p,bt,wt,tat.
Step 3: Read the Processes details p, & bt
Step 4: Initialize
wt[0]=avgwt=0;
avgtat=tat[0]=bt[0];
Step 5: for i=1 to i<n do till step6
Step 6: wt[i]=wt[i-1]+bt[i-1];
tat[i]=wt[i]+bt[i];
avgwt=avgwt+wt[i];
avgtat=avgtat+tat[i];
Step7: for i=0 to n do step 8
Step8: Print the output with the FCFS Fashion and Calculating
bt,wt,&tat
Step 9: End

Department of Computer Science and Engineering Page 1

 Operating systems

PROGRAM: FCFS CPU SCHEDULING ALGORITHM

#include<stdio.h>
int main( )
{
char p[10][10];
int bt[10],wt[10],tat[10],i,n;
float avgwt,avgtat;
printf("enter no of processes:");
scanf("%d",&n); for(i=0;i<n;i+
+)
{
printf("enter process %d name:\t",i+1);
scanf("%s",p[i]);
printf("enter burst time\t");
scanf("%d",&bt[i]);
}
wt[0]=avgwt=0;
avgtat=tat[0]=bt[0];
for(i=1;i<n;i++)
{
wt[i]=wt[i-1]+bt[i-1];
tat[i]=wt[i]+bt[i];
avgwt=avgwt+wt[i];
avgtat=avgtat+tat[i];
}
printf("p_name\t B_time\t w_time\t turnarounftime\n");
for(i=0;i<n;i++) printf("%s\t%d\t%d\t%d\
n",p[i],bt[i],wt[i],tat[i]); printf("\navg waiting time=%f",
avgwt/n);
printf("\navg tat time=%f\n", avgtat/n);
return 0; }

Department of Computer Science and Engineering Page 2

 Operating systems

OUTPUT:

enter no of processes: 3

enter process 1 name:

P1 enter

burst time 24

enter process 2 name:

P2 enter

burst time 3

enter process 3 name:

P3 enter

burst time 3

p_name B_time w_time turnarounftime

P1 24 0 24

P2 3 24 27

P3 3 27 30

avg waiting time=17.000000

avg tat time=27.000000

Department of Computer Science and Engineering Page 3

 Operating systems

b) SJF CPU SCHEDULING ALGORITHM

DESCRIPTION:

For SJF(Shortest Job First) scheduling algorithm, read the number

of processes/jobs in the system, their CPU burst times. Arrange all the
jobs in order with respect to their burst times. There may be two jobs in
queue with the same execution time, and then FCFS approach is to be
performed. Each process will be executed acco ding to the length of its
burst time. Then calculate the waiting time and turnaround time of each
of the processes accordingly.

ALGORITHM:

Step 1: Start
Step 2: Define a structure process with elements p,bt,wt,tat
Step3: Read process name P,burst time bt of the process
Step4: for i=0 to n go to step 6
Step:5 for j=0;j< i do
if(bt[i]<bt[j])
{
temp=bt[i];
bt[i]=bt[j];
bt[j]=temp;
k=p[i];
p[i]=p[j];
p[j]=k;
}
Step6: else avgwt=wt[0]=0;
avgtat=tat[0]=bt[0];
Step 7: for i=1;i<n do
wt[i]=wt[i-1]+bt[i-1];
tat[i]=wt[i]+bt[i];

Department of Computer Science and Engineering Page 4

 Operating systems

avgwt=avgwt+wt[i];
avgtat=avgtat+tat[i];
Step 8: Print the output with the SJF Fashion and Calculating
Pid,bt,wt,&tat
Step 9: End

PROGRAM: SJF CPU SCHEDULING ALGORITHM

#include<stdio.h>
int main()
{
int i,j,k,n,temp;
int p[10],bt[10],wt[10],tat[10];
float avgtat,avgwt;
printf("enter no of processes: \t");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("enter process name:\t");
scanf("%d",&p[i]);
printf("enter burst time \t");
scanf("%d",&bt[i]);
}
for(i=0;i<n;i++)
{
for(j=0;j<i;j++)
{
if(bt[i]<bt[j])
{
temp=bt[i];
bt[i]=bt[j];
bt[j]=temp;

Department of Computer Science and Engineering Page 5

 Operating systems

k=p[i];
p[i]=p[j];
p[j]=k;
}
}
}
avgwt=wt[0]=0;
avgtat=tat[0]=bt[0];
for(i=1;i<n;i++)
{
wt[i]=wt[i-1]+bt[i-1];
tat[i]=wt[i]+bt[i];
avgwt=avgwt+wt[i];
avgtat=avgtat+tat[i];
}
printf("p_name\t B_time\t w_time\t turnarounftime\n");
for(i=0;i<n;i++) printf("%d\t%d\t%d\t%d\
n",p[i],bt[i],wt[i],tat[i]); printf("\navg waiting time=%f\
n", avgwt/n);
printf("avg tat time=%f\n", avgtat/n);
}

OUTPUT:

enter no of processes: 4

enter process name: 1

enter burst time 6

enter process name: 2

enter burst time 8

Department of Computer Science and Engineering Page 6

 Operating systems

enter process name: 3

enter burst time 7

enter process name: 4

enter burst time 3

p_name B_time w_time turnarounftime

4 3 0 3

1 6 3 9

3 7 9 16

2 8 16 24

avg waiting time=7.000000

avg tat time=13.000000

Department of Computer Science and Engineering Page 7

 Operating systems

c) ROUND ROBIN CPU SCHEDULING ALGORITHM

DESCRIPTION:
For round robin scheduling algorithm, read the number of processes/
jobs in the system, their CPU burst times, and the size of the time slice.
Time slices are assigned to each process in equal portions and in circular
order, handling all processes execution. This allows every process to get
an equal chance.

ALGORITHM:
Step 1: Start
Step 2: Define a structure process with elements st,bt,wt,tat,n,tq
Step 3: Read i,n.tq
Step 4: Read the Processes details n & bt
Step 5: for i=0 to i<n do st[i]=bt[i]
Step 6: for i=0,count=0;i<n; do till step
7 Step 7: check if(st[i]>tq)
st[i]=st[i]-tq;
else
if(st[i]>=0)
{
temp=st[i];
st[i]=0;
}
sq=sq+temp;
tat[i]=sq;
Step 8: if (n= =count) break;
Step 9: else wt[i]=tat[i]-bt[i];
avgwt=avgwt+wt[i];
avgtat=avgtat+tat[i];
Step 10: Print the output with the RoundRobin Fashion and
Calculating Pid,bt,wt,&tat
Step 11: End

Department of Computer Science and Engineering Page 8

 Operating systems

PROGRAM: ROUND ROBIN CPU SCHEDULING ALGORITHM

#include<stdio.h>
#include<stdlib.h>
int main()
{
int p[10],st[10],bt[10],wt[10],tat[10],n,tq;
int i,count=0,temp,sq=0;
float avgwt=0.0,avgtat=0.0;
system("clear");
printf("Enter number of processes:\t");
scanf("%d",&n);

for(i=0;i<n;i++)
{
printf("enter process number:\t");
scanf("%d",&p[i]);
printf("enter burst time:\t");
scanf("%d",&bt[i]);
st[i]=bt[i];
}

printf("Enter time quantum:");

scanf("%d",&tq);
while(1)
{
for(i=0,count=0;i<n;i++)
{
temp=tq;
if(st[i]==0)
{
count++;

Department of Computer Science and Engineering Page 9

 Operating systems

continue;
}
if(st[i]>tq)
st[i]=st[i]-tq;
else
if(st[i]>=0)
{
temp=st[i];
st[i]=0;
}
sq=sq+temp;
tat[i]=sq;
}
if(n==count)
break;
}
for(i=0;i<n;i++)
{
wt[i]=tat[i]-bt[i];
avgwt=avgwt+wt[i];
avgtat=avgtat+tat[i];
}
printf("P_NO\t B_T\t W_T\t TAT\n");
for(i=0;i<n;i++)
printf("%d\t %d\t %d\t %d\t\n",i+1,bt[i],wt[i],tat[i]);
printf("Avg wait time is %f\n Avg turn around time is
%f\n",avgwt/n,avgtat/n);
}

Department of Computer Science and Engineering Page 10

 Operating systems

OUTPUT:

Enter number of processes: 3

enter process number: 1

enter burst time: 24

enter process number: 2

enter burst time: 3

enter process number: 3

enter burst time: 3

Enter time quantum:4

P_NO B_T W_T TAT

1 24 6 30

2 3 4 7

3 3 7 10

Avg wait time is 5.666667

Avg turn around time is 15.666667

Department of Computer Science and Engineering Page 11

 Operating systems

d) PRIORITY CPU SCHEDULING ALGORITHM

DESCRIPTION:

For priority scheduling algorithm, read the number of processes/jobs in

the system, their CPU burst times, and the priorities. Arrange all the jobs
in order with respect to their priorities. There may be two jobs in queue
with the same priority, and then FCFS approach is to be performed.
Each process will be executed according to its priority. Calculate the
waiting time and turnaround time of each of the processes accordingly.

ALGORITHM:

Step1: Start
Step2: Define a structure process with elements p,bt,wt,tatSte
Step3: Read the Processes details pid, & bt
Step4: for i=0 to i<n do still step5
Step5: for j=0 to j<n do till step 6
Step6: if(pr[i]>pr[j])
temp=p[i];
p[i]=p[j];
p[j]=temp;
temp=bt[i];
bt[i]=bt[j];
bt[j]=temp;
temp=pr[i];
pr[i]=pr[j];
pr[j]=temp;
Step7: initialize avgwt=wt[0]=0;
avgtat=tat[0]=bt[0];
Step8: for i=1;i<n do till step 9
Step9: wt[i]=wt[i-1]+bt[i-1];
tat[i]=wt[i]+bt[i];

Department of Computer Science and Engineering Page 12

 Operating systems

avgwt=avgwt+wt[i];
avgtat=avgtat+tat[i];
Step10: Print the output with the FCFS Fashion and Calculating
Pid,bt,wt,&tat
Step11 : End

PROGRAM: PRIORITY CPU SCHEDULING ALGORITHM

#include<stdio.h>
#include<stdlib.h>
int main()
{
int i,j,n,temp;
int p[10],pr[10],bt[10],wt[10],tat[10];
float avgtat,avgwt;
system ("clear");
printf("enter no of processes:\t");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("enter process number:\t");
scanf("%d",&p[i]);
printf("enter burst time:\t");
scanf("%d",&bt[i]);
printf("enter priority:\t");
scanf("%d",&pr[i]);
}
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
if(pr[i]<pr[j])

Department of Computer Science and Engineering Page 13

 Operating systems

{
temp=p[i];
p[i]=p[j];
p[j]=temp;
temp=bt[i];
bt[i]=bt[j];
bt[j]=temp;
temp=pr[i];
pr[i]=pr[j];
pr[j]=temp;
}
}
}
avgwt=wt[0]=0;
avgtat=tat[0]=bt[0];
for(i=1;i<n;i++)
{
wt[i]=wt[i-1]+bt[i-1];
tat[i]=wt[i]+bt[i];
avgwt=avgwt+wt[i];
avgtat=avgtat+tat[i];
}
printf("p_name\t B_time\t w_time\t turnarounftime\n");
for(i=0;i<n;i++) printf("%d\t%d\t%d\t%d\
n",p[i],bt[i],wt[i],tat[i]); printf("\navg waiting time=%f\
n", avgwt/n);
printf("avg tat time=%f\n", avgtat/n);
}

Department of Computer Science and Engineering Page 14

 Operating systems

OUTPUT:
5
enter no of processes:
enter process number: 1

enter burst time: 10

enter priority: 3

enter process number: 2

enter burst time: 1

enter priority: 1

enter process number: 3

enter burst time: 2

enter priority: 4

enter process number: 4

enter burst time: 1

enter priority: 5

enter process number: 5

enter burst time: 5

enter priority: 2

p_name B_time w_time turnarounftime

4 1 0 1

3 2 1 3

1 10 3 13

5 5 13 18

2 1 18 19

Department of Computer Science and Engineering Page 15

 Operating systems

avg waiting time=7.000000

avg tat time=10.800000

Department of Computer Science and Engineering Page 16

 Operating systems

2. Write programs using the I/O system calls of UNIX/LINUX operating

system
a) open ( ) system call

DESCRIPTION:
Used to open the file for reading, writing or both. This function returns
the file descriptor or in case of an error -1. The number of arguments
that this function can have is two or three. The third argument is used
only when creating a new file. When we want to open an existing file only
two arguments are used.

PROGRAM: using open ( ) system call

//using open() system call

#include<stdio.h>
#include<fcntl.h>
#include<errno.h>
extern int errno;
int main()
{
int fd=open("f3.txt",O_RDONLY | O_CREAT); printf("fd=%d\
n",fd);
if (fd==-1)
{
printf("error Number %d\n",errno);
perror("program");
}
return 0;
}
OUTPUT:

fd=3

Department of Computer Science and Engineering Page 17

 Operating systems

b) read ( ) system call

DESCRIPTION:

size_t read (int fd, void* buf, size_t cnt);

From the file indicated by the file descriptor fd, the read() function reads
cnt bytes of input into the memory area indicated by buf. A successful
read() updates the access time for the file.

PROGRAM: using read ( ) system call

// read system Call read.c file

#include<stdio.h>
#include <fcntl.h>
#include<stdlib.h>
#include <unistd.h>
int main()
{
int fd,sz;
char *c = (char *) calloc(100, sizeof(char));

fd = open("f3.txt", O_RDONLY);
if (fd==-1)
{
perror("r1");
exit(1);
}
sz=read(fd,c,13);
printf("called read(%d, c, 10). returned that" " %d bytes were read.\n",
fd, sz);
c[sz] = '\0';
printf("Those bytes are as follows: %s\n", c);
return 0; }

Department of Computer Science and Engineering Page 18

 Operating systems

OUTPUT:

ca> f3.txt
From the file indicated by the file descriptor fd, the read() function reads
cnt bytes of input into the memory area indicated by buf.

called read(3, c, 10). returned that 13 bytes were read.

Those bytes are as follows: From the file

Department of Computer Science and Engineering Page 19

 Operating systems

c) write ( ) system call

DESCRIPTION:

size_t write (int fd, void* buf, size_t cnt);

Writes cnt bytes from buf to the file or socket associated with fd. If cnt is
zero, write ( ) simply returns 0 without attempting any other action.

PROGRAM: using write ( ) system call

// C program to illustrate
// write system Call
#include<stdio.h>
#include <fcntl.h>
#include<stdlib.h>
#include <unistd.h>
#include<string.h>
int main( )
{
int sz;

int fd = open("f4.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);

if (fd ==-1)
{
perror("r1");
exit(1);
}
sz = write(fd, "hello linux", strlen("hello linux"));
printf("called write(%d, \"hello linux\", %d). It returned %d\n", fd,
strlen("hello linux"), sz);
close(fd);
return 0;
}

Department of Computer Science and Engineering Page 20

 Operating systems

OUTPUT:

called write(3, "hello linux", 11). It returned 11

f4.txt

hello linux

Department of Computer Science and Engineering Page 21

 Operating systems

d) close ( ) system call

DESCRIPTION:

int close(int fd);

Tells the operating system you are done with a file descriptor and Close
the file which pointed by fd.

PROGRAM: using close ( ) system call

// C program to illustrate close system Call

#include<stdio.h>

#include <fcntl.h>

#include<stdlib.h>

#include <unistd.h>

int main()

int fd1 = open("f3.txt", O_RDONLY);

if (fd1==-1)

perror("c1");

exit(1);

printf("opened the fd = % d\n", fd1);

// Using close system Call

if (close(fd1)==-1)

perror("c1");

exit(1);

Department of Computer Science and Engineering Page 22

 Operating systems

printf("closed the fd.\n");

return 0;

OUTPUT:

opened the fd = 3

closed the fd.

Department of Computer Science and Engineering Page 23

 Operating systems

e) fcntl ( ) system call

DESCRIPTION:

The fcntl system call is the access point for several advanced operations
on file descriptors. The first argument to fcntl is an open file descriptor,
and the second is a value that indicates which operation is to be
performed. For some operations, fcntl takes an additional argument.
We'll describe here one of the most useful fcntl operations, file locking

PROGRAM: using fcntl ( ) system call

#include <fcntl.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

int main (int argc, char* argv[])

char* file = argv[1];

int fd;

struct flock lock;

printf ("opening %s\n", file);

/* Open a file descriptor to the file. */

fd = open (file, O_WRONLY);

printf ("locking\n");

/* Initialize the flock structure. */

memset (&lock, 0, sizeof(lock));

lock.l_type = F_WRLCK;

Department of Computer Science and Engineering Page 24

 Operating systems

/* Place a write lock on the file. */

fcntl (fd, F_SETLKW, &lock);

printf ("locked; hit Enter to unlock... ");

/* Wait for the user to hit Enter. */

getchar ();

printf ("unlocking\n");

/* Release the lock. */

lock.l_type = F_UNLCK;

fcntl (fd, F_SETLKW, &lock);

close (fd);

return 0;

Department of Computer Science and Engineering Page 25

 Operating systems

OUTPUT:

Terminal-1

f4.txt
opening f4.txt
locking
locked; hit Enter to unlock...
unlocking
student@NNRG310:~/oslab$

Terminal-2

f4.txt
opening f4.txt
locking
locked; hit Enter to unlock...

Department of Computer Science and Engineering Page 26

 Operating systems

f ) seek ( ) system call

DESCRIPTION:

The lseek() function allows the file offset to be set beyond the end of the
file (but this does not change the size of the file). If data is later written at
this point, subsequent reads of the data in the gap (a "hole") return null
bytes (’\0’) until data is actually written into the gap.

PROGRAM: using seek ( ) system call

#include <unistd.h>

#include <fcntl.h>

#include <sys/types.h>

#include<stdio.h>

int main()

int file=0;

if((file=open("f4.txt",O_RDONLY)) < -1)

return 1;

char buffer[19];

if(read(file,buffer,19) != 19) return 1;

printf("%s\n",buffer);

if(lseek(file,10,SEEK_SET) < 0) return 1;

if(read(file,buffer,19) != 19) return 1; printf("%s\

n",buffer);

return 0;

Department of Computer Science and Engineering Page 27

 Operating systems

OUTPUT:

lseek is a system call that is used to change the location of the

read/write pointer of a file descriptor. The location can be set either in
absolute or relative terms.

lseek is a system c

system call that i

Department of Computer Science and Engineering Page 28

 Operating systems

g ) stat ( ) system call

DESCRIPTION:

int stat(const char *path, struct stat *buf);

These functions return information about a file. No permissions are

required on the file itself, but — in the case of stat() and lstat() — execute
(search) permission is required on all of the directories in path that lead
to the file.

PROGRAM: using stat ( ) system call

#include <unistd.h>

#include <stdio.h>

#include <sys/stat.h>

#include <sys/types.h>

int main(int argc, char **argv)

if(argc!=2)

return 1;

struct stat fileStat;

if(stat(argv[1],&fileStat) < 0)

return 1;

printf("Information for %s\n",argv[1]);

printf(" -\n");

printf("File Size: \t\t%ld bytes\n",fileStat.st_size);

printf("Number of Links: \t%d\n",fileStat.st_nlink);

printf("File inode: \t\t%lu\n",fileStat.st_ino);

Department of Computer Science and Engineering Page 29

 Operating systems

printf("File Permissions: \t");

printf( (S_ISDIR(fileStat.st_mode)) ? "d" : "-");

printf( (fileStat.st_mode & S_IRUSR) ? "r" : "-");

printf( (fileStat.st_mode & S_IWUSR) ? "w" : "-");

printf( (fileStat.st_mode & S_IXUSR) ? "x" : "-");

printf( (fileStat.st_mode & S_IRGRP) ? "r" : "-");

printf( (fileStat.st_mode & S_IWGRP) ? "w" : "-");

printf( (fileStat.st_mode & S_IXGRP) ? "x" : "-");

printf( (fileStat.st_mode & S_IROTH) ? "r" : "-");

printf( (fileStat.st_mode & S_IWOTH) ? "w" : "-");

printf( (fileStat.st_mode & S_IXOTH) ? "x" :

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

return 0;

Department of Computer Science and Engineering Page 30

 Operating systems

OUTPUT:

Information for read.c

- -

File Size: 455 bytes

Number of Links: 1

File inode: 794292

File Permissions: -rw-rw-r--

Department of Computer Science and Engineering Page 31

 Operating systems

h ) opendir ( ), readdir ( )system calls

DESCRIPTION:

The opendir( ) function opens a directory stream corresponding to the

directory named by the d_name argument. The directory stream is
positioned at the first entry. The readdir( ) function returns a pointer to a
structure representing the directory entry at the current position in the
directory stream specified by the argument dir, and positions the
directory stream at the next entry

PROGRAM: using opendir ( ), readdir ( ) system calls

#include <dirent.h>

#include <stdio.h>

int main(void)

DIR *d;

struct dirent *dir;

d = opendir(".");

if (d)

while ((dir = readdir(d)) != NULL)

printf("%s\n", dir->d_name);

closedir(d);

return(0);

Department of Computer Science and Engineering Page 32

 Operating systems

OUTPUT:

f1.txt

f2.txt

fcfs.c

system calls programs.docx

sjf.c

a.out

.~lock.system calls programs.docx#

read.c

write.c

close.c

rr.c

dirsystemcalls.c

priority.c

f4.txt

f3.txt

..

open.c

Department of Computer Science and Engineering Page 33

 Operating systems

3. Write a C program to simulate Bankers Algorithm for Deadlock

Avoidance and Prevention.

ALGORITHM:

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
a. Finish[i] =False
b. 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.

PROGRAM:

#include<stdio.h>
int main()
{
int process,resource,instance,j,i,k=0,count1=0,count2=0;
int avail[10] , max[10][10], allot[10][10],need[10][10],completed[10];

printf("\n\t\t Enter No. of Process: ");

scanf("%d",&process); printf("\n\t\
tEnter No. of Resources: ");
scanf("%d",&resource);
for(i=0;i<process;i++)
completed[i]=0;
printf("\n\t Enter No. of Available Instances: ");
for(i=0;i<resource;i++)
{

Department of Computer Science and Engineering Page 34

 Operating systems

scanf("%d",&instance);
avail[i]=instance;
}
printf("\n\tEnter Maximum No. of instances of resources that a
Process need:\n");
for(i=0;i<process;i++)
{
printf("\n\t For P[%d]",i);
for(j=0;j<resource;j++)
{
printf("\t");
scanf("%d",&instance); max[i]
[j]=instance;
}
}
printf("\n\t Enter no. of instances already allocated to process of a
resource:\n");
for(i=0;i<process;i++)
{
printf("\n\t For P[%d]\t",i);
for(j=0;j<resource;j++)
{
scanf("%d",&in
stance); allot[i]
[j]=instance;
proce need[i][j]=max[i][j]-allot[i][j]; //calculating Need of each
ss
} }
printf("\n\n \t Safe Sequence is:- \t");
while(count1!=process)
{
count2=count1;

Department of Computer Science and Engineering Page 35

 Operating systems
for(i=0;i<process;i++)

Department of Computer Science and Engineering Page 36

 {
for(j=0;j<resource;j++)
{
if(need[i][j]<=avail[j])
{
k++;
}
}
if(k==resource && completed[i]==0 )
{
printf("P[%d]\t",i);
completed[i]=1;
for(j=0;j<resource;j++)
{
avail[j]=avail[j]+allot[i][j];
}
count1++;
}
k=0; }

if(count1==count2)
{
printf("\t\t Stop ..After this.....Deadlock \n");
break;

}
}
return 0;
}
OUTPUT:

Enter number of processes: 3

Enter process number: 1
Enter burst time: 24
Enter process number: 2
Enter burst time: 3
Enter process number: 3
Enter burst time: 3
Enter time quantum: 4
P_NO B_T W_T TAT
1 24 6 30
2 3 4 7
3 3 7 10
Avg wait time is 5.666667
Avg turnaround time is 15.666667
4. Write a C program to implement the Producer – Consumer
problem using semaphores using UNIX/LINUX system calls

DESCRIPTION:

The producer consumer problem is a synchronization problem. There is a fixed

size buffer and the producer produces items and enters them into the buffer.

The consumer removes the items from the buffer and consumes them. A

producer should not produce items into the buffer when the consumer is

consuming an item from the buffer and vice versa. So the buffer should

only be accessed by the producer or consumer at a time.

PROGRAM: Producer – Consumer problem using semaphores

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

} it

} (

);

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

}
OUTPUT:

1.Producer

2.Consumer

3.Exit

Enter your choice:1

Producer produces the item 1

Enter your choice:2

Consumer consumes item 1

Enter your choice:2

Buffer is empty!!

Enter your choice:1

Producer produces the item 1

Enter your choice:1

Producer produces the item 2

Enter your choice:2

Consumer consumes item 2

Enter your choice:2

Consumer consumes item 1

Enter your choice:2

Buffer is empty!!

Enter your choice:3

5. Write C programs to illustrate the following IPC mechanisms

a) Pipes b) FIFOs c) Message Queues d) Shared Memory

a) Pipes

DESCRIPTION:

Pipe is a communication medium between two or more related or

interrelated processes. It can be either within one process or a
communication between the child and the parent processes.
Communication can also be multi-level such as communication between
the parent, the child and the grand-child, etc. Communication is
achieved by one process writing into the pipe and other reading from the
pipe. To achieve the pipe system call, create two files, one to write into
the file and another to read from the file.

PROGRAM:

#include<stdio.h>

#include<unistd.h>

int main() {

int pipefds[2];

int returnstatus;

char writemessages[2][20]={"Hi", "Hello"};

char readmessage[20];

returnstatus = pipe(pipefds);

if (returnstatus == -1) {

printf("Unable to create pipe\n");

return 1;

printf("Writing to pipe - Message 1 is %s\n", writemessages[0]);

write(pipefds[1], writemessages[0], sizeof(writemessages[0]));

 read(pipefds[0], readmessage, sizeof(readmessage));

printf("Reading from pipe – Message 1 is %s\n", readmessage);

printf("Writing to pipe - Message 2 is %s\n", writemessages[1]);

write(pipefds[1], writemessages[1], sizeof(writemessages[0]));

read(pipefds[0], readmessage, sizeof(readmessage));

printf("Reading from pipe – Message 2 is %s\n", readmessage);

return 0;

OUTPUT:

Writing to pipe - Message 1 is Hi

Reading from pipe – Message 1 is Hi

Writing to pipe - Message 2 is Hello

Reading from pipe – Message 2 is Hello

b) FIFOs

DESCRIPTION:

Pipes were meant for communication between related processes. Can we

use pipes for unrelated process communication, say, we want to execute
client program from one terminal and the server program from another
terminal? The answer is No. Then how can we achieve unrelated
processes communication, the simple answer is Named Pipes. Even
though this works for related processes, it gives no meaning to use the
named pipes for related process communication.

PROGRAM:

fifoclient.c

#include<stdio.h>
#include<fcntl.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{
FILE *file1;
int fifo_server,fifo_client;
char str[256];
char *buf;
int choice=1;
printf("Choose the request to be sent to server from options below"); printf("\
n\t\t Enter 1 for O.S.Name \n \
Enter 2 for Distribution \n \
Enter 3 for Kernel version \n");
scanf("%d",&choice);
fifo_server=open("fifo_server",O_RDWR);
if(fifo_server < 0) {
printf("Error in opening file");
 exit(-1);
}

write(fifo_server,&choice,sizeof(int));

fifo_client=open("fifo_client",O_RDWR);

if(fifo_client < 0) {
printf("Error in opening file");
exit(-1);
}

buf=malloc(10*sizeof(char));
read (fifo_client,buf,10*sizeof(char));
printf("\n ***Reply from server is %s***\n",buf);
close(fifo_server);
close(fifo_client);
return 0;
}
fifoserver.c

PROGRAM:

#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
int main( )
{
FILE *file1;
int fifo_server,fifo_client;
int choice;
char *buf;
fifo_server = open("fifo_server",O_RDWR);
if(fifo_server<1) {
printf("Error opening file");
}
read(fifo_server,&choice,sizeof(int));
sleep(10);
fifo_client = open("fifo_client",O_RDWR);
if(fifo_server<1) {
printf("Error opening file");
}
switch(choice) {
case 1:
buf="Linux";
write(fifo_client,buf,10*sizeof(char));
printf("\n Data sent to client \n");
break;
case 2:

buf="Fedora";
write(fifo_client,buf,10*sizeof(char));
 printf("\nData sent to client\n");
break;
case 3:
buf="2.6.32";
write(fifo_client,buf,10*sizeof(char));
printf("\nData sent to client\n");
}
close(fifo_server);
close(fifo_client);
}

OUTPUT:

TERMINAL-I

Choose the request to be sent to server from options below

Enter 1 for O.S.Name

Enter 2 for Distribution

Enter 3 for Kernel version

***Reply from server is Linux***

TERMINAL-II

Data sent to client

c) Message Queues:

DESCRIPTION:

A message queue is a linked list of messages stored within the kernel and
identified by a message queue identifier. A new queue is created or an
existing queue opened by msgget().New messages are added to the end of
a queue by msgsnd(). Every message has a positive long integer type
field, a non-negative length, and the actual data bytes (corresponding to
the length), all of which are specified to msgsnd() when the message is
added to a queue. Messages are fetched from a queue by msgrcv(). We
don’t have to fetch the messages in a first-in, first-out order. Instead, we
can fetch messages based on their type field.

PROGRAM:

Sender.c

#include<stdio.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<sys/types.h>
#include<stdlib.h>
#define SIZE 2000
void main()
{
int mfd,mfd2,mfd3;
struct
{
double mtype;
char mtext[2000];
}s1,s2,s3; if((mfd=msgget(1000,IPC_CREAT|
0666))==-1)
{
perror("msgget:");
exit(1);
}
s1.mtype=1;
sprintf(s1.mtext,"%s","Hi friends... My name is message1");
if(msgsnd(mfd,&s1,1000,0)==-1)
{
perror("msgsnd");
exit(1);
}
if((mfd2=msgget(1000,IPC_CREAT|0666))==-1)
{
perror("msgget:");
exit(1);
}
s2.mtype=1;
sprintf(s2.mtext,"%s","Hi friends... My name is message2");
if(msgsnd(mfd2,&s2,1000,0)==-1)
{
perror("msgsnd");
exit(1);
}

if((mfd3=msgget(1000,IPC_CREAT|0666))==-1)
{
perror("msgget:");
exit(1);
}
s3.mtype=1;
sprintf(s3.mtext,"%s","Hi friends... My name is message3");
if(msgsnd(mfd3,&s3,1000,0)==-1)
{
perror("msgsnd");
exit(1);
}
printf("Your message has been sent successfully...\n");
printf("Please visit another (receiver's) terminal...\n");
printf("Thank you.... For using LINUX\n");
}
Output:

Your message has been sent successfully...

Please visit another (receiver's) terminal...

Thank you.... For using LINUX

Receiver.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<sys/types.h>
#define SIZE 40
void main()
{
int mfd,mfd2,mfd3;
struct
{
long mtype;
char mtext[6];
}s1,s2,s3;
if((mfd=msgget(1000,0))==-1)
{
perror("msgget");
exit(1);
}
if(msgrcv(mfd,&s1,SIZE,0,IPC_NOWAIT|MSG_NOERROR)==-1)
{
perror("msgrcv");
exit(1);
}
printf("Message from client is :%s\n",s1.mtext);
if((mfd2=msgget(1000,0))==-1)
{
perror("msgget");
exit(1);
}
if(msgrcv(mfd2,&s2,SIZE,0,IPC_NOWAIT|MSG_NOERROR)==-1)
{
perror("msgrcv");
exit(1);
}
printf("Message from client is :%s\n",s2.mtext);
if((mfd3=msgget(1000,0))==-1)
{
perror("msgget");
exit(1);
}
if(msgrcv(mfd3,&s3,SIZE,0,IPC_NOWAIT|MSG_NOERROR)==-1)
{
perror("msgrcv");
exit(1);
}
printf("Message from sender is :%s\n",s3.mtext);
}

Output:

Message from client is :Hi friends... My name is message1

Message from client is :Hi friends... My name is message2

Message from client is :Hi friends... My name is message3

d) Shared Memory:

DESCRIPTION:

Inter Process Communication through shared memory is a concept

where two or more process can access the common memory. And
communication is done via this shared memory where changes made by
one process can be viewed by another process.
The problem with pipes, fifo and message queue – is that for two process
to exchange information. The information has to go through the kernel.

 Server reads from the input file.

 The server writes this data in a message using either a pipe, fifo or
message queue.
 The client reads the data from the IPC channel,again requiring the
data to be copied from kernel’s IPC buffer to the client’s buffer.
 Finally the data is copied from the client’s buffer.

PROGRAM:

shwriter.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main ( )
{
int segment_id;
char bogus;
char* shared_memory;
struct shmid_ds shmbuffer;
int segment_size;
const int shared_segment_size = 0x6400;
 /* Allocate a shared memory segment. */
segment_id = shmget (IPC_PRIVATE, shared_segment_size, IPC_CREAT
| IPC_EXCL | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
/* Attach the shared memory segment. */
printf("Shared memory segment ID is %d\n", segment_id);
shared_memory = (char*) shmat (segment_id, 0, 0);
printf ("shared memory attached at address %p\n", shared_memory);
/* Determine the segment's size. */
/*
shmctl (segment_id, IPC_STAT, &shmbuffer);
segment_size = shmbuffer.shm_segsz;
printf ("segment size: %d\n", segment_size);
*/
/* Write a string to the shared memory segment. */
sprintf (shared_memory, "Hello, world.");
/* Detach the shared memory segment. */
shmdt (shared_memory);
printf("Wrote Hello World to the segment\n");
}

PROGRAM:

shreader.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main ()
{
int segment_id;
char bogus;
char* shared_memory;
struct shmid_ds shmbuffer;
 int segment_size;
const int shared_segment_size = 0x6400;
printf("Enter the shared memory id: ");
scanf("%d", &segment_id);
/* Reattach the shared memory segment, at a different address. */
shared_memory = (char*) shmat (segment_id, (void*) 0x5000000, 0);
printf ("shared memory reattached at address %p\n", shared_memory);
/* Print out the string from shared memory. */
printf ("The contents of the shared memory is:\n%s\n",
shared_memory);
/* Detach the shared memory segment. */
shmdt (shared_memory);
return 0;
}
OUTPUT:

Terminal-I

Shared memory segment ID is 3047442

shared memory attached at address 0xb7f2a000
Wrote Hello World to the segment

Terminal-II
Enter the shared memory id: 3047442
shared memory reattached at address 0x5000000
The contents of the shared memory is:
Hello, world.
6. Write C programs to simulate the following memory management
techniques
a) Paging b) Segmentation

a) Paging

PROGRAM:

#include<stdio.h>
int main()
{
int ms, ps, nop, np, rempages, i, j, x, y, pa, offset;
int s[10], fno[10][20];

printf("\nEnter the memory size -- ");

scanf("%d",&ms);
printf("\nEnter the page size -- ");
scanf("%d",&ps);
nop = ms/ps;
printf("\nThe no. of pages available in memory are -- %d ",nop); printf("\
nEnter number of processes -- ");
scanf("%d",&np);
rempages = nop;
for(i=1;i<=np;i++)
{
printf("\nEnter no. of pages required for p[%d]-- ",i);
scanf("%d",&s[i]);
if(s[i] >rempages)
{
printf("\nMemory is Full");
break;
}
rempages = rempages - s[i];
printf("\nEnter pagetable for p[%d] --- ",i);
for(j=0;j<s[i];j++)
scanf("%d",&fno[i][j]); }
printf("\nEnter Logical Address to find Physical Address ");
printf("\nEnter process no. and pagenumber and offset -- ");
scanf("%d %d %d",&x,&y, &offset);

if(x>np || y>=s[i] || offset>=ps)

printf("\nInvalid Process or Page Number or offset");
else
{
pa=fno[x][y]*ps+offset;
printf("\nThe Physical Address is -- %d",pa);
}
return 0;
}

OUTPUT:

Enter the memory size -- 1000

Enter the page size -- 100

The no. of pages available in memory are -- 10

Enter number of processes -- 3

Enter no. of pages required for p[1]-- 4

Enter pagetable for p[1] --- 8 6 9 5

Enter no. of pages required for p[2]-- 5

Enter pagetable for p[2] --- 1 4 5 7 3

Enter no. of pages required for p[3]-- 5

Memory is Full

Enter Logical Address to find Physical Address

Enter process no. and pagenumber and offset -- 2 3 60

The Physical Address is – 760

a) Segmentation

ALGORITHM:

Step1: Start the program.

Step2: Read the base address, number of segments, size of each
segment, memorylimit.
Step3: If memory address is less than the base address display “invalid
memorylimit”.
Step4: Create the segment table with the segment number and segment
address and display it.
Step5: Read the segment number and displacement.
Step6: If the segment number and displacement is valid compute the
real address and display the same.
Step7: Stop the program.
PROGRAM:
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

int main()
{
int b[20],l[20],n,i,pa,s,a,d; printf("\
nProgram for segmentation"); printf("\
nEnter the number of segments:");
scanf("%d",&n);
printf("\nEnter the base address and limit register:");
for(i=1;i<=n;i++)
{
scanf("%d",&b[i]);

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

printf("\nEnter the logical address:");

scanf("%d",&d);

printf("\nEnter segment number:");

scanf("%d",&s);

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

if(i==s)

if(d<l[i])

{
pa=b[i]+d;

a=b[i];

printf("\nPageNo.\t BaseAdd. PhysicalAdd. \n %d \t %d \t %d

\n",s,a,pa);

exit(0);

else

printf("\nPage size exceeds");

exit(0);

printf("\nInvalid segment");

return 0;

}
OUTPUT

Program for segmentation

Enter the number of segments: 3

Enter the base address and limit register:

100 50

150 20

130 34

Enter the logical address: 25

Enter segment number:1

PageNo. BaseAdd. PhysicalAdd.

1 100 125
1. Simulate the following memory allocation algorithms

a) First-Fit b) Best-Fit c) Worst-fit

a) First-Fit

PROGRAM:

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main()
{
static int block[10],process[10];
int frags[10], b[10], p[10];
int i, j, nob, nop, temp;
printf("\nEnter the Total Number of Blocks:\t");
scanf("%d", &nob);
printf("Enter the Total Number of process:\t");
scanf("%d", &nop);
printf("\nEnter the Size of the Blocks:\n");
for(i = 0; i < nob; i++)
{
printf("Block size.:\t");
scanf("%d", &b[i]);
}
printf("Enter the Size of the proces:\n");
for(i = 0; i < nop; i++)
{
printf("proces size\t" );
scanf("%d", &p[i]);
}
for(i = 0; i < nop; i++)
{
 for(j = 0; j < nob; j++)
{
if(block[j] != 1)
{
temp=abs(b[j]-p[i]);
if(temp >= 0)
{
process[i] = j;
break;
}
}
}

frags[i] = temp;
block[process[i]] = 1;
}
printf("\n process Number\tBlock Number\tBlock Size\tProcess Size\
tFragment");
for(i = 0; i < nop; i++)
{
printf("\n%d\t\t%d\t\t%d\t\t%d\t\t%d", i, process[i],
b[process[i]],p[i], frags[i]);
}
printf("\n");
return 0;
}
Output:

Enter the Total Number of Blocks: 5

Enter the Total Number of process: 4

Enter the Size of the Blocks:

Block size: 100
Block size: 500
Block size: 200
Block size: 300
Block size: 600
Enter the Size of the proces:
Process Size 212

Process Size 417

Process Size 112
Process Size 426

process Number Block Number Block Size Process Size Fragment

0 0 100 212 112
1 1 500 417 83
2 2 200 112 88
3 3 300 426 126
b) Best-Fit

PROGRAM:

#include<stdio.h>
int main()
{
int frags[20],b[20],p[20],i,j,nob,nop,temp,lowest=9999;
static int block[20],process[20];
printf("\n\t\t\tMemory Management Scheme - Best Fit");
printf("\nEnter the number of blocks:\t");
scanf("%d",&nob);
printf("Enter the number of processes:\t");
scanf("%d",&nop);
printf("\nEnter the size of the blocks:-\n");
for(i=0;i<nob;i++)
{
printf("Block size:\t");
scanf("%d",&b[i]);
}
printf("\nEnter the size of the processes :-\n");
for(i=0;i<nop;i++)
{
printf("Process size:\t");
scanf("%d",&p[i]);
}
for(i=0;i<nop;i++)
{
for(j=0;j<nob;j++)
{
if(block[j]!=1)
{
temp=b[j]-p[i];
 if(temp>=0)
if(lowest>temp)
{
process[i]=j;
lowest=temp;
}
}
}
frags[i]=lowest;
block[process[i]]=1;
lowest=10000;
}
printf("\nProcess_no\tProcess_size\tBlock_no\tBlock_size\tFragment");
for(i=0;i<nop && process[i]!=0;i++) printf("\n%d\t\t%d\t\t%d\t\t%d\t\t
%d",i,p[i],process[i],b[process[i]],fra
gs[i]);
}
Output:

Memory Management Scheme - Best Fit

Enter the number of blocks: 5

Enter the number of processes: 4

Enter the size of the blocks:-

Block size: 100

Block size: 500

Block size: 200

Block size: 300

Block size: 600

Enter the size of the processes:-

Process size: 212

Process size: 417

Process size: 112

Process size: 426

Process_no Process_size Block_no Block_size Fragment

0 212 3 300 88

1 417 1 500 83

2 112 2 200 88

3 426 4 600 174

c) Worst-fit

PROGRAM:

#include<stdio.h>

#define max 25
int main()
{
int frags[20],b[20],p[20],i,j,nob,nop,temp,highest=0;
static int block[20],process[20];
printf("\n\tMemory Management Scheme - Worst Fit");
printf("\nEnter the number of blocks:");
scanf("%d",&nob);
printf("Enter the number of files:");
scanf("%d",&nop);
printf("\nEnter the size of the blocks:-\n");
for(i=0;i<nob;i++)
{
printf("Block size :\t");
scanf("%d",&b[i]);
}
printf("Enter the size of the processes :-\n");
for(i=0;i<nop;i++)
{
printf("File %d:\t",i);
scanf("%d",&p[i]);
}

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

for(j=0;j<nob;j++)
{
if(block[j]!=1) //if bf[j] is not allocated
{
temp=b[j]-p[i];
if(temp>=0)
if(highest<temp)
{
process[i]=j;
highest=temp;
}
}
}
frags[i]=highest;
block[process[i]]=1;
highest=0;
}
printf("\nProcess_no:\tProcess_size
:\tBlock_no:\tBlock_size:\tFragement");
for(i=0;i<nop;i++)
printf("\n%d\t\t%d\t\t%d\t\t%d\t\t%d",i,p[i],process[i],b[process[i]],frags
[i]);
return 0;
}
 Output

Memory Management Scheme - Worst Fit

Enter the number of blocks: 5
Enter the number of files: 4

Enter the size of the blocks:-

Block size : 100
Block size : 500
Block size : 200
Block size : 300
Block size : 600
Enter the size of the processes: -
File 0: 212
File 1: 417
File 2: 112
File 3: 426

Process_no: Process_size : Block_no: Block_size: Fragement

0 212 4 600 388
1 417 1 500 83
2 112 3 300 188
3 426 0 100 0
2. Simulate the following memory allocation algorithms

a) FCFS b) SCAN c) SSTF

a) FCFS

PROGRAM:

#include<stdio.h>

int main()
{
int a[20],b[20],n,i,thm[20],tot=0;
float avgthm;

printf("Enter head pointer position:\t");

scanf("%d",&a[0]);
b[0]=a[0];
printf("\nEnter number of processes:\t");
scanf("%d",&n);
printf("\nEnter processes in request order\n");
for(i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
for(i=0;i<n;i++)
{
thm[i]=(a[i+1]-a[i]);
if(thm[i]<0)
thm[i]=thm[i]*(-1);
}
for(i=0;i<n;i++)
{
 b[i]=thm[i];
tot=tot+thm[i];
}
avgthm=(float)tot/n;
printf("\n\tTrack traversed \t Difference between tracks \n");
for(i=0;i<n;i++)
printf("\t%d\t%d\t=\t\t%d\n",a[i],a[i+1],b[i]);
printf("\nTotal heam movents\t=%d \n Average Head
Movement\t=:%f",tot,avgthm);
return 0;
}
Output:

Enter head pointer position: 53

Enter number of processes: 8
Enter processes in request order
98 183 37 122 14 124 65 67
Track traversed Difference between tracks
53 98 = 45
98 183 = 85
183 37 = 146
37 122 = 85
122 14 = 108
14 124 = 110
124 65 = 59
65 67 = 2

Total head movements =640

Average Head Movement =:80.000000
b) SCAN

PROGRAM:

#include<stdio.h>

int main()
{
int a[20],b[20],n,i,j,temp,p,s,m,x,t=0;

printf("Enter head pointer position:");

scanf("%d",&a[0]);
s=a[0];
printf("\nEnter previous head position:");
scanf("%d",&p);
printf("\nEnter max track limit:");
scanf("%d",&m);
printf("\nEnter number of processes:");
scanf("%d",&n);
printf("\nEnter processes in request order");
for(i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
a[n+1]=m;
a[n+2]=0;
for(i=n+1;i>=0;i--)
{
for(j=0;j<=i;j++)
{
if(a[j]>a[j+1])
{
temp=a[j];
 a[j]=a[j+1];
a[j+1]=temp;
}
}
}
for(i=1;i<=n+1;i++)
{
if(s==a[i])
x=i;
}
j=0;
if(s<p)
{
for(i=x;i>0;i--)
{
t+=(a[i]-a[i-1]);
b[j++]=a[i];
}
t+=a[x+1]-a[0];
b[j++]=a[0];
for(i=x+1;i<n+1;i++)
{
t+=(a[i+1]-a[i]);
b[j++]=a[i];
}
b[j++]=a[i];
}
else
{
for(i=x;i<n+2;i++)
{
t+=(a[i+1]-a[i]);
 b[j++]=a[i];
}
t+=a[n+2]-a[x-1];
b[j++]=a[n+2];
for(i=x-1;i>1;i--)
{
t+=(a[i]-a[i-1]);
b[j++]=a[i];
}
b[j++]=a[i];
}
printf("\nProcessing order:");
for(i=0;i<=n+1;i++)
printf("%d->",b[i]);
printf("\n\nTotal Head Movement:%d",t);
return 0;
}

Output- 01

Enter head pointer position: 53

Enter previous head position: 60

Enter max track limit: 199

Enter number of processes:8

Enter processes in request order

98 183 37 122 14 124 65 67

Processing order: 53->37->14->0->65->67->98->122->124->183->

Total Head Movement: 236

Output- 02

Enter head pointer position: 53

Enter previous head position: 40

Enter max track limit: 199

Enter number of processes:8

Enter processes in request order

98 183 37 122 14 124 65 67

Processing order: 53->65->67->98->122->124->183->199->37->14->

Total Head Movement: 331

c) SSTF

PROGRAM:

#include<stdio.h>
struct di
{
int num;
int flag;
};
int main()
{
int i,j,sum=0,n,min,loc,x,y;
struct di d[20];
int disk;
int ar[20],a[20];

printf("enter size of queue\t");

scanf("%d",&n);
printf("enter position of head\t");
scanf("%d",&disk);
printf("enter elements of disk queue:\t");
for(i=0;i<n;i++)
{
scanf("%d",&d[i].num); d[i]. flag=0;
}
for(i=0;i<n;i++)
{ x=0; min=0;loc=0;
for(j=0;j<n;j++)
{
if(d[j].flag==0)
{
 if(x==0)
{
ar[j]=disk-d[j].num;
if(ar[j]<0){ ar[j]=d[j].num-disk;}
min=ar[j];loc=j;x++; }
else
{
ar[j]=disk-d[j].num;
if(ar[j]<0){ ar[j]=d[j].num-disk;}
}
if(min>ar[j]){ min=ar[j]; loc=j;}
}
}
d[loc].flag=1;
a[i]=d[loc].num-disk;
if(a[i]<0){a[i]=disk-d[loc].num;}

disk=d[loc].num;
}

for(i=0;i<n;i++)
{
sum=sum+a[i];
}
printf("\nmovement of total cylinders %d",sum);

return 0;
}
Output:

enter size of queue 8

enter position of head 53
enter elements of disk queue: 98 183 37 122 14 124 65 67

movement of total cylinders 236

7. Simulate the following memory allocation algorithms

a)FIFO b) LRU

a) FIFO Program:

#include<stdio.h>
int main()
{
int incomingStream[] = {4, 1, 2, 4, 5};
int pageFaults = 0;
int frames = 3;
int m, n, s, pages;

pages = sizeof(incomingStream)/sizeof(incomingStream[0]);

printf("Incoming \t Frame 1 \t Frame 2 \t Frame 3");

int temp[frames];
for(m = 0; m < frames; m++)
{
temp[m] = -1;
}

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

{
s = 0;

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

{
if(incomingStream[m] == temp[n])
{
s++;
pageFaults--;
}
}
pageFaults++;
 if((pageFaults <= frames) && (s == 0))
{
temp[m] = incomingStream[m];
}
else if(s == 0)
{
temp[(pageFaults - 1) % frames] = incomingStream[m];
}

printf("\n");
printf("%d\t\t\t",incomingStream[m]);
for(n = 0; n < frames; n++)
{
if(temp[n] != -1)
printf(" %d\t\t\t", temp[n]);
else
printf(" - \t\t\t");
}
}

printf("\nTotal Page Faults:\t%d\n", pageFaults);

return 0;
}
Output –
Incoming Frame 1 Frame 2 Frame 3
4 4 - -
1 4 1 -
2 4 1 2
4 4 1 2
5 5 1 2
Total Page Faults: 4
b) LRU Program:

#include<stdio.h>
#include<limits.h>

int checkHit(int incomingPage, int queue[], int occupied){

for(int i = 0; i < occupied; i++){

if(incomingPage == queue[i])
return 1;
}

return 0;
}

void printFrame(int queue[], int occupied)

{
for(int i = 0; i < occupied; i++)
printf("%d\t\t\t",queue[i]);
}

int main()
{

// int incomingStream[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1};

// int incomingStream[] = {1, 2, 3, 2, 1, 5, 2, 1, 6, 2, 5, 6, 3, 1, 3, 6, 1, 2, 4, 3};
int incomingStream[] = {1, 2, 3, 2, 1, 5, 2, 1, 6, 2, 5, 6, 3, 1, 3};

int n = sizeof(incomingStream)/sizeof(incomingStream[0]);
int frames = 3;
int queue[n];
int distance[n];
int occupied = 0;
int pagefault = 0;

printf("Page\t Frame1 \t Frame2 \t Frame3\n");

for(int i = 0;i < n; i++)
{
printf("%d: \t\t",incomingStream[i]);
// what if currently in frame 7
// next item that appears also 7
// didnt write condition for HIT

if(checkHit(incomingStream[i], queue, occupied)){

printFrame(queue, occupied);
}

// filling when frame(s) is/are empty

else if(occupied < frames){
queue[occupied] = incomingStream[i];
pagefault++;
occupied++;

printFrame(queue, occupied);
}
else{

int max = INT_MIN;

int index;
// get LRU distance for each item in frame
for (int j = 0; j < frames; j++)
{
distance[j] = 0;
// traverse in reverse direction to find
// at what distance frame item occurred last
for(int k = i - 1; k >= 0; k--)
{
++distance[j];

if(queue[j] == incomingStream[k])
break;
}
 // find frame item with max distance for LRU
// also notes the index of frame item in queue
// which appears furthest(max distance)
if(distance[j] > max){
max = distance[j];
index = j;
}
}
queue[index] = incomingStream[i];
printFrame(queue, occupied);
pagefault++;
}

printf("\n");
}

printf("Page Fault: %d",pagefault);

return 0;
}

Output:

Page Frame1 Frame2 Frame3

1: 1
2: 1 2
3: 1 2 3
2: 1 2 3
1: 1 2 3
5: 1 2 5
2: 1 2 5
1: 1 2 5
6: 1 2 6
2: 1 2 6
5: 5 2 6
6: 5 2 6
3: 5 3 6
1: 1 3 6
3: 1 3 6

Page Fault: 8