SYSTEM CALLS
LISTING THE FILES IN A DIRECTORY
Aim:
To write and execute a C Program to list the files in a directory with the use of exec () system calls.
Algorithm:
- Using function fork (), create a new process and its return value is stored in a variable called pid.
- If pid is equal to 0, then it is the child process and using execp activities command.
- else, it is parent process, do the following.
- Wait until the child process stop its execution.
- Print that the parent process completed its execution.
- Stop the program.
Program:
#include
#include
int main()
{
int pid;
if(pid==0)//CHILD PROCESS
{
else//PARENT PROCESS
{
printf(“\nParent process”);
wait(pid);
printf(“completed\n”);
exit(0);
}}
Output:
[user13@ws002~]$ cc sys3.c
[user13@ws002~]$. /a.out
a.out fork.c loop.c loop3.sh
sys.c file.c lexp1.sh open.c
add.c
Parent process completed.
[user13@ws002~]$
Result:
Thus the C program in LINUX to illustrate the use of exec() system call was executed successfully.
I/O SYSTEM CALLS
COPYING ONE CONTENT FROM ONE FILE TO ANOTHER
Aim:
To write and execute a C Program in LINUX, using the I/O system calls namely open (), read (), write () and close ().
Algorithm:
1. Open a file, sample is read-only using open ().
2. Open a file, output is write-only (or) truncated mode using open().
3. Read the Content of the file using read()
4. Write input file content the output file using write ().
5. Display the numbers of bytes read and write successfully.
Program:
#include
#include
int main()
{
int fp,fd,sz,I;
char *c;
c=(char *)calloc(50,sizeof(char));
fp=open(“output”,O-WRONLY|O_TRUNC);
fd=open(“Sample”,O_RDONLY);
sz=read(fd,c,20);
i=write(fp,c,strlen©);
printf(“\n number of bytes read=%d\n”,sz);
printf(“\n number of byted written=%d\n”,i);
close(fd);
close(fp);
}
OUTPUT
[user13@ws002~]$ cc io.c
[user13@ws002~]$ ./a.out
Number of bytes read=-1
Number of bytes written=0
Result:
Thus the C Program in LINUX, Using the I/O system calls namely open (), read (), write (), close () was executed successfully.
SIMULATION OF UNIX COMMAND
STIMULATION OF LS COMMAND
Aim:
To write and execute a c program in LINUX, to stimulate the LS the command.
Algorithm:
- Get the current working directory and store in the variable, path name.
- scan the directory in the path specified in the path name and sort the directory content alphabetically
- Display the directory content.
- Stop
Program:
#include
main ()
{
struct dirent **namelist;
int n,I;
char *pathname;
getcwd(pathname);
n=scandir(pathname,&namelist,o,alphasort);
if(n<0)
perror(“scandir”);
else
{
for(i=0;i
{
printf(“%s\n”,namlist[i]->d_name);
free(namelist[i]);
}
free(namelist);
}}
OUTPUT:
[user46@ws002~]$cc sim1.c
[user46@ws002~]$ ./a.out
Desktop
a.out
arith.sh
b
big.sh
c
cmd.sh
command
dir.c
for.sh
input.c
input.txt
io.c
lex.1
list.c
pat.sh
pattern.sh
p
Result:
thus the c program in linux, to stimulate a LS command was executed successfully.
SIMULATION OF GRED COMMAND
Aim:
To write and execute a C Program in LINUX, to stimulate the grep command.
Algorithm:
- Initialize count and occurrence as 0.
- If the no. of command line argument is not equal to 3, then print the error message and exit.
- Open the i/p in read mode.
- Read a max of 1024 characters from the o/p line and store in error line until end of error.
- if end of file (or) error message
- Increment the count by one.
- Scan the string is forward direction looking for a line character and return the pointer value to newline.
- If line not equal to NULL, the initialize newline as NULL string.
- Find the first occurrence of the substring into the string fline and print the substring and increment occurrence by 1.
- goto step 4.
- Stop the program.
Program:
#include
#include
#define max 1024
int main(int argc,char *argv[])
{
File *fp;
char fline[max];
char *newline;
int count=0;
int occurrences =0;
if(!(fp=fopen(argv[1],”r”)))
{
printf(“grep:could not open file:%s\n”,argv[1]);
exit(1);
}
while(fgets(fline,max,fp)!=NULL)
{
count++;
if(newline=strchr(fline,’\n’)
*newline=’\0’;
if(strstr(fline,argv[2])!=NULL)
{
printf(“%s:%d%s\n”,argv[1],count,fline);
occurrences++;
}
OUTPUT:
[user13@ws002~]$ cc six1.c
[user13@ws002~]$. /a.out sankar1 operating
Sankar: 1an operating system is layer of software takes care of technical aspects of a computer’s operating.
Sankar: 4UNIX is a operating system designed for multiprocessing, multitasking and multi-user.
Result:
Thus the c Program in LINUX to stimulate grep command is executed successfully.
SCHEDULING ALGORITHMS
FIRST COME FIRST SERVED SCHEDULING
Aim:
To write and excute a c program to implement the first come first served scheduling algorithm
Algorithm:
- call getdata() to get process name, burst time and arrival time from the user
- call fcfs() to perform the first come first served scheduling algorithm
getdata()
- get the number of processes from the user
- for each process get the process name, burst time and arrival time from the user
fcfs()
- swap the process according to the arrival time
- call calculate()
- call ganttchart()
ganttchart()
- Display the process names
- Display the waiting time of each process
calculate()
- initialize the waiting time and turn around time and time of first process as 0
- for each process do the following
/ calculate the wait time of each process
/ calculate total wait time
/ calculate total turn around time
- calculate the average wait time and average turn around time.
- Display the output
Program:
#include
#include
#include
int n,Bu[20],Twt,Ttt,A[10],Wt[10],w;
float Awt,Att;
char pname[20][20],c[20][20];
void getdata();
void ganttchart();
void calculate()
void fcfs();
void getdata()
{
int I;
printf(“Enter the number of process”);
scanf(“%d”,&n);
for(i=1;i<=n;i++)
{
fflush(stdin);
printf(“enter the process name”);
scanf(“%s”,&pname[i]);
printf(“Enter the burst time process %s”,pname[i]);
scanf(“%d”,&Bu[i]);
printf(“Enter the arrival time process %s”,pname[i]);
scanf(“%d”,A[i});
}
}
void gantt_chart()
{
int I;
printf(“Gauntchart”);
for(i=1;i<=n;i++)
printf(“%s”,pname[i]);
for(i=1;i<=n;i++)
printf(“%d”,Wt[i});
printf(“%d”,Wt[n]+Bu[n]);
}
void calculate()
{
int I;
Wt[1]=0;
for(i=2;i<=n;i++)
{
Twt=Twt+(Wt[i]-A[i]);
Ttt=Ttt+((Wt[i]+Bu[i])-A[i]);
Att=(float)Ttt/n;
Awt=(float)Twt/n;
printf(“Average Turn Around Time=%3.2f ms”,Att);
printf(“Average waiting time=3.2f ms”,Awt);
}
}
void fcfs()
{
int I, temp,temp1;
Twt=0;
Ttt=0;
for(i=1;i<=n;j++)
{
for(j=i+1;j<=n;j++)
{
if(A[i]>;j<=n;j++)
{
if(A[i]>A[j])
{
temp=Bu[i];
temp1=A[i];
Bu[i]=Bu[j];
A[i]=A[j];
Bu[j]=temp;
A[j]=temp1;
strcpy(c[i],pname[j]);
strcpy(pname[i],pname[j]);
strcpy(pname[j],c[i]);
}
}
}
calculate();
ganttchart();
}
main()
{
int ch;
clrscr()
printf(FIRST COME FIRST SERVED ALGORITHM);
getdata();
fcfs();
getch();
}
Output:
Enter the number of processes: 3
Enter the process name: a
Enter the burst time for process a: 12
Enter the arrival time for process a: 0
Enter the process name: b
Enter the burst time for process b: 24
Enter the arrival time for process b: 2
Enter the process name: c
Enter the burst time for process a: 2
Enter the arrival time for process a: 1
Average Turn around time= 20.33 ms
Average waiting time=7.67 ms
GANTT CHART
A B C
0 12 14 38
Result
Thus the c program for FFS algorithm was executed successfully.
SHORTEST JOB FIRST SCHEDULING
Aim:
To write and execute a C Program to implement the Shortest job first scheduling algorithm.
Algorithm:
- Call getdata () to get process name, burst time and arrival time from the user.
- call sjf() to perform the sjf scheduling algorithm
getdata ()
- Get the number of process from the user.
- For each process get the process name, burst time and arrival time for the user.
sjf ()
- Store the burst time for each process in a temporary arry.
- Swap the process according to their burst time and calculate it as sum of it and burst time.
- Initialize s[i] for each process as ‘7’
- Initialize wait time and turn around time of first process as 0.
- Set w as WTB[1] and s[1] as F
(i)While w
Set I as 2
While i<=n do the following
(ii) if s[i] =’T’ and A[i] <=t, do the following
- Set waiting time of I ith process as w and s[i] as ‘F’
- Set w as w+B[i] and t as w.
- Set I as 2.
- Else increment I by 1.
- For each process, do the following steps.
- Calculate total waiting time, twt, as the sum of bwt and the difference between the wait time and arrival time of current process.
- calculate the total sum around time, Ttt as the difference between sum of Ttt, wait time and burst time and the arrival time of the current process
- Calculate the average wait time.
- Calculate the average turn around time.
- Display the average waiting and turn around time.
- cal Gantt-chart()
Ganttchart ()
- Display the all process times
- Display the waiting time of each process.
Program:
#include
#include
int n,bu[20],twt,ttt,a[20],b[20];
float awt,att;
char pname[20][20];
void getdata();
void gantt_chart();
void sjf();
void getdata()
{
int I;
printf(“\n Enter the number of procesors:”);
scanf(“%d”,&n);
for(i=1;i<=n;i++)
{
fflush(stdin);
printf(“\n\n Enter the process name:”);
scanf(“%s”,&pname[i]);
printf(“\n Enter burst time for process %s”,pname[i]);
scanf(“%d”,&bu[i]);
printf(“\n Enter arrival time for process %s”,pname[i]);
scanf(“%d”,&a[i]);
}
}
void gantt_chart()
{
int I;
printf(“\n \n\t\t\t GANTT CHART\n”);
printf(“\n-------------------------------\n”);
for(i=1;i<=n;i++)
printf(“\t%s\t”,pname[i]);
printf(“\t\n”);
printf(“\n--------------------------------\n”);
printf(“\n”);
for(i=1;i<=n;i++)
printf(“%d\t\t”,wt[i]);
printf(“%d”,wt[n]+b[n]);
printf(“\n----------------------------------\n”);
printf(“\n”);
}
void sjf()
{
int w,t,I,tt=0,temp,j;
char s[10],c[20][20];
int temp1;
twt=ttt=0;
w=0;
for(i=1;i<=n;i++)
{
b[i]=bu[i];
s[i]=’T’;
tt=tt+b[i];
}
for(i=1;i<=n;i++)
{
for(j=3;j<=n;j++)
{
if(b[j-1]>b[j])
{
temp=b[j-1];
temp1=a[j-1];
b[j-1]=b[j];
a[j-1]=a[j];
b[j]=temp;
a[j]=temp1;
strcpy(c[j-1],pname[j-1]);
strcpy(pname[j-1],pname[j]);
strcpy(pname[j],c[j-1]);
}
}
}
wt[1]=0;
w=w+b[1];
t=w;
s[1]=’F’;
while(w
{
i=2;
while(i<=n)
{
if(s[i]==’T’&&a[i]<=t)
{
wt[i]=w;
s[i]=’F’;
w=w+b[i];
t=w;
i=2;
}
else
i++;
}
}
for(i=1;i<=n;i++)
{
twt=twt+([i]-a[i]);
ttt=ttt+(wt[i]+bu[i]-a[i]);
}
att=(float)ttt/n;
awt=(float)twt/n;
printf(“\n\nAvg Turnaround time :%3.2f ms”,att);
printf(“\n\n Avg waiting time :%3.2f ms”awt);
gantt_chart();
}
void main()
{
printf(“\n\n shortest job first \n\n”);
getdata();
sjf();
}
Output:
Shortest job first Algorithm
Enter number of processors:3
Enter the process name:aa
Enter burst Time for process aa: 56
Enter arrival time for process aa: 1
Enter the process name:bb
Enter burst time for process bb: 77
Enter arrival time for process bb: 3
Enter the process name:cc
Enter burst Time for process cc: 89
Enter arrival time for process cc: 5
Avg Turn around time: 134.00 ms
Avg waiting time: 60.00 ms
GANTT CHART
-------------------------------
| aa | bb | cc |
---------------------------------
0 56 133 222
-------------------------------
Result:
Thus the C program to implement the shortest Job First algorithm was executed successfully.
PRIORITY SCHEDULING ALGORITHM
Aim:
To write and execute a c program to implement the priority scheduling algorithm.
Algorithm:
1. Call getdata () to get process name, burst time and arrival time for the user.
2 Call prior () to perform the priority scheduling algorithm.
getdata ()
- Get the number of process from the user.
- For each process get the process name, burst time and arrival time from the user.
- For each process get the process name, burst time and arrival time from the user.
prior ()
1. Start the burst time of each process in temp array.
2. Swap the processes according to their priorities and calculate it has sum of Tt and burst time of the current process.
3. Initialize s[i] for each process as ‘T’.
Initialize the wait time and turn around time of first process as 0.
4. set w as w+B[i] and S[i] as F
While w
i) Set i as 2.
ii)) until i<=n do the following
1)if s[i]=’T’ and T[i] <=t,do the following
a) Set waiting time of ith process as w and s[i] as f
b) Set w as w+B[i] and t as w
c) Set I as 2
ii) Else increment I by 1.
8. For each process do the following steps
a) Calculate total wait time twt as the sum of twt and the difference between the wait time and the arrival time of the current process.
b) Calculate total turn around time ttt and the difference between sum of the Ttt wait time and burst time and arrival time of current process.
9. Calculate the average turn around time
10. Display the average waiting turn around time
11. Call Gantt chart
Program:
#include
#include
#include
int n,bu[20],twt,ttt,a[20],wt[20],p[20],b[20];
float awt,att;
char pname[20[20];
void getdata();
void ganttchart();
void prior();
void getdata()
{
int I;
printf(“\n enter the no of the processes”);
scanf(“%d”,&n);
for(i=1;i
{
fflush(stdin);
printf(“\n\n enter the process name”);
scanf(“%d”,&pname);
printf(“\n\n enter the burst time for process %s”,pname[i]);
scanf(“%d”,&bu[i]);
printf(“\n\n enter the arrival time for process %s”,pname[i]);
scanf(“%d”,&a[i]);
}}
void gantt_chart()
{
int I;
printf(“\n\n Gant chart”);
printf(\n------------------------------\n”);
for(i=0;i
printf(“/t %s \t”,pname[i]);
printf(“\t\n”);
printf(\n------------------------------\n”);
printf(“\t\n”);
for(i=0;i
printf(“/t %d \t”wt[i]);
printf(“%d”,wt[n]+b[n]);
printf(\n------------------------------\n”);
printf(“/n”);
}
void prior()
{
int w,t,tt=0,temp,j
char s[10],c[20][20];
int temp1;
twt =ttt=0;
w=0;
for(i=1;i<=n;i++)
{
b[i]=bu[i];
s[i]=’T’;
tt=tt+b[i];
}
for(i=1;i<=n;i++)
{
for(j=3;j<=n;j++)
{
if(b[j-1]>b[j])
{
temp=b[j-1];
temp1=a[j-1];
b[j-1]=b[j];
a[j-1]=a[j];
b[j]=temp;
a[j]=temp1;
temp=p[j-1];
p[j-1]=p[j];
p[j]=temp;
strcpy(c[j-1),pname[j-1});
strcpy(pname[j-1],pname[j]);
strcpy(pname[j],c[j-1]);
}
}
}
wt[1]=0;
w=w+b[l];
t=w;
s[l]=’F’;
while(w
{
i=2;
while(i<=n)
{
if(s[i]==’T’ && a[i]<=t)
{
wt[i]=w;
s[i]=’F’;
w=w+b[i];
t=w;
i=2;
}
else
i++;
}
}
for(i=1;i<=n;i++)
{
twt=twt+(wt[i]-a[i]);
ttt=ttt+((wt[i]+bu[i]-a[i]);
}
att=(float)ttt/n;
awt=(float)twt/n;
printf(“\n\n Avg turn around time:%3.2f ms”,att);
printf(“\n \n avg waiting time :%3.2f ms”,awt);
gantt_chart();
}
void main()
{
clrscr();
printf(“\n \n priority scheduling algorithm”);
pruior();
getdata();
}
Output:
Priority scheduling algorithm:
Enter the number of processors: 3
Enter burst time for process a: 12
Enter arrival time for process a: 0
Enter the priority for process a: 1
Enter the process name:a
Enter burst time for process a: 12
Enter arrival time for process a: 0
Enter the priority for process a: 1
Enter the process name:a
Enter burst time for process a: 12
Enter arrival time for process a: 0
Enter the priority for process a: 1
Avg Turn around time=9.00ms
Avg waiting time=4.00ms
Result:
Thus the C program to implement the priority scheduling algorithm was executed successfully.
ROUND ROBIN SCHEDULING ALGORITHM
Aim:
To write and execute a C Program to implement the Round Robin Scheduling.
Algorithm:
- Call getdata() to get process name, burst time and arrival time from the user.
- Call rr() to perform the RRS algorithm.
get data()
- Get the number of processor from the user.
- For each process get the process name and burst time from the user.
- Get the time quantum from the user.
rr ()
- Synchronize the process such that each process is allocated with cpu for a time slice.
- If process time is less than time slice means assigns the number of slice as 1.
- Similarly calculate the number of slice for each process.
- Display the result.
- Call calculates ().
Calculate ()
- Calculate the wait time and turnaround time.
- Calculate the average wait time and average time around.
- Display the average a wait time and average turn around.
Program:
#include
#include
int Bu[15],a[15][15],pname[15][15],I,j,n,k=0,q,Tu=0,Twt=0;
float Att,Awt;
void getdata();
void rr();
void calculate();
void getdata()
{
printf(“\n\n Enter the number of process”);
scanf(“%d”,&n);
for(i=0;i
{
j=0;
printf(“\n\n Enter the process name”);
scanf(“%s”,&pname[i]);
printf(“\n Enter the Burst Time for Process %s”,pname[i]);
scanf(“%d”,&Bu[i][j]);
}
}
void cal;cuate()
{
for(j=0;j
{
i=1;
while(a[i][j]!=0)
i+=1;
Ttt+a[i-1][j];
}
Att=(float)Ttt/n;
printf(“\n\n Average Turn around time=%3.2f ms”,Att);
for(i=0;i
Twt+=a[0][i];
for(i=0;i
for(j=1;j<15;j++)
if((a[j][i]!=0)&&(a[j+1][i]!=0)&&((j+1)%2==0))
Awt=(float)Twt/n;
printf(“\n\n average Waiting Time=%3.2f ms”,Awt);
}
void rr()
{
printf(“\n\n”);
for(j=0;j<15;j++)
{
A[2*j][i]=k;
if((Bu[i][j]<=q)&&(Bu[i][j]!=0)
{
Bu[i][j+1]=G;
printf(“%d\t%s\t%d\n”,K,pname[i],K+bu[i][j]);
K+=Bu[i][j];
A[2*j+1][i]=k;
}
else if([i][j]!=0
{
Bu[i][j+1]=Bu[i][j]-q;
printf(“5d\t%s\t%d\n”,K,pname[i],(k+q));
K+=q;
A[2*j+1][i]=k;
}
else
{
A[2*j][i]=0;
A[2*j+1][i]=0;
}
}
calculate();
}
void main()
{
clrscr();
printf(“\n\n Round Robin Scheduling Algorithm\n\n”);
getdate();
rr();
getch();
}
OUTPUT:
ROUND ROBIN SCHEDULING ALGORITHM
Enter the number of processes: 3
Enter the process name: A
Enter the burst Time for Process: 24
Enter the Process name: B
Enter the Burst Time for the Process: 3
Enter the process name: C
Enter the burst Time for the Process: 3
Enter the Time Quantum: 4
0 A 4
4 B 7
7 C 10
10 A 14
14 A 18
18 A 22
22 A 26
26 A 30
Average Turn Around time=15.67ms
Average Waiting Time=5.67ms
Result:
Thus the C program to implement the Round Robin Scheduling algorithm was executed.
INTER PROCESS COMMUNICATION USING PIPES
Aim
To write a C program for implementation of pipes.
Algorithm
- Initialize the feildes vector.
- Call the fork()
- Check the value of k
i) If the value of k is equal to zero , then execute the placement process.
ii) Parent process gets the total number.
4. i) If the value of k is !equal to -1, then execute the child process.
ii) Get the number from parent process and divide the number by 2. if the remainder value is not equal to zero, then it is consider as odd number.
iii) Repeat the step 2 for all the numbers in parent process.
5. Display the odd number.
Program
#include
#include
main()
{
int k,n,n2,a[15]={0},b[15]={0},I,j=0,p,feildes[2];
p=pipe(feildes);
k=fock();
if(k==0)
{
printf(“Parent process”);
printf(“the parent process ID is %d”,getpid());
printf(“Enter the total number”);
scanf(%d”,&n);
write(feildes[1],&n,sizeof(n));
printf(“Enter the total number”);
for(i=0;i
{
scanf(%d”,&a[i]);
write(feildes[1],&a[i],sizeof(n));
}
}
else if(k!=-1)
{
printf(“the child process ID is : %d”,getpid());
read(feildes[1],&n2,sizeof(n));
for(i=0;i
{
read(feildes[0],&b[i],sizeof(n2));
if((b[i]%2)!=0)
{
c[j]=b[i];
j++;
}
}
printf(“Odd numers are”)
for(i=0;i
printf(“%d”,c[i]);
}
else
printf(“error infoking”);
}
Output
Parent process
the parent process ID is 2755
the child process ID is 2754
Enter the total number 5
Enter the total numbers 1 3 4 6 7
Odd numers are 1 3 7
Result
Thus the program for pipes are implemented and verified successfully.
PRODUCER CONSUMER PROBLEM
Aim:
To write and execute a c program to implement producer consumer relationship.
Algorithm:
- Read the buffer length from the user.
2. Repeat the following steps,until a key stroke is not available.
3. if the buffer is empty the items is producer and is store in the buffer.
4. the buffer is not empty the item is consumed from the buffer
5. Stop the program.
Program:
#include
int n,flag=1,f=0,kbhit;
void producer()
{
n=n+1;
f=f+1;
printf(“\n Producer has produced %d\n”,f);
}
void consumer()
{
printf(“\n consumer has consumed %d\n”,f);
n=n+1;
}
void main()
{
char s;
printf(“\n Enter the buffer state”);
scanf(“%c”,&s);
if(s==’e’)
n=0;
else
n=1;
while(!kbhit)
{
if(n==0)
{
producer();
if(n==1
consumer();
}
}
}
Output:
Enter the Buffer state:e
Producer has produced 1
Consumer has consumed 1
Producer has produced 2
Consumer has consumed 2
Producer has produced 3
Consumer has consumed 3
Producer has produced 4
Consumer has consumed 4
Result:
Thus the C Program to implement Producer consumer relationship was executed successfully.
FIRST FIT ALGORITHM
Aim:
To write and execute a c program to stimulate placement technique of first fit algorithm.
Algorithm
1 Consider a matrix and assume itself as it is maintain the no of pages from user.
2 Fill element in each page randomly to the wish of the user.
3 Get the element to be placed in main memory.
4 Depending upon the element size place is first phase display it.
Program
#include
#include
void main ()
{
int c,a[10][10],I,j,k=0,n[10],m,size3=0,small;
clrscr();
printf(“Simulation of paging”);
printf(“……………………..”);
printf(“Enter the max size”);
scanf(“%d”,&m);
for(i=0;i
for(j=0;j
a[i][j]=0;
for(i=0;i
{
printf(“Enter the number of elements to be inserted in page %d”,i+1);
scanf(“%d”,&k);
n[i]=k;
}
for(i=0;i
for(j=0;j
a[i][j]=n[i];
printf(“APPEARANCE OF MAIN MEMORY”);
printf(“………………………………………..”);
for(i=0;i
printf(“page %d”,i+1);
for(i=0;i
{
for(j=0;j
printf(“%d”,a[i][j]);
}
printf(“FIRST FIT ALGORITHM”);
printf(“Enter the element size”);
scanf(“%d”,&size3);
for(i=0;i
{
if(size3<=(m-n[i])
{
for(j=n[i];j<(size3+n[i]);j++)
{
a[i][j]=i+1;
}
break;
}
}
for(i=0;i
printf(“page %d”,i+1);
for(i=0;i
{
for(j=0;j
printf(“%d”,a[i][j]);
}
getch();
}
Output
SIMULATION OF PAGING
Enter the maximum size 4
Enter the number of elements to be inserted in page 1=1
Enter the number of elements to be inserted in page 2=2
Enter the number of elements to be inserted in page 3=3
Enter the number of elements to be inserted in page 4=4
APPEARENCES OF MAIN MEMORY
PAGE1 PAGE2 PAGE3 PAGE4
1 2 3 4
0 2 3 4
0 0 3 4
0 0 0 4
FIRST FIT ALGORITHM
Enter the element size 2
PAGE1 PAGE2 PAGE3 PAGE4
1 2 3 4
1 2 3 4
1 0 3 4
0 0 0 4
Result
Thus the c program in Linux to stimulate the placement technique is executed and output verified successfully.
BEST FIT ALGORITHM
Aim
To write and execute a c program in Linux to stimulate the placement technique in best fit algorithm.
Algorithm
1 Consider the matrix and assume the matrix itself as if maintain the pages from user.
2 Fill element in each page randomly.
3 Cut the element to be placed in main memory.
4 Depending upon the element size.
5 Display it.
Program
#include
#include
void main ()
{
int c,a[10][10],I,j,k=0,n[10],m,z,size3=0,p=i;
clrscr();
printf(“Simulation of paging”);
printf(“……………………..”);
printf(“Enter the max size”);
scanf(“%d”,&m);
for(i=0;i
for(j=0;j
a[i][j]=0;
for(i=0;i
{
printf(“Enter the number of elements to be inserted in page %d”,i+1);
scanf(“%d”,&k);
n[i]=k;
}
for(i=0;i
for(j=0;j
a[i][j]=n[i];
printf(“APPEARANCE OF MAIN MEMORY”);
printf(“………………………………………..”);
for(i=0;i
printf(“page %d”,i+1);
for(i=0;i
{
for(j=0;j
printf(“%d”,a[i][j]);
}
printf(“BEST FIT ALGORITHM”);
printf(“Enter the element size”);
scanf(“%d”,&size3);
for(z=m;z>0;z--)
{
for(i=0;i<10;i++)
{
if(size3<=(z-n[i])
{
c=n[i];
for(j=z-size3;j<(size3+n[i]);j++)
a[i][j]=size3;
for(i=0;i
printf(“page %d”,i+1);
for(i=0;i
{
for(j=0;j
printf(“%d”,a[j][i]);
}
getch();
}
Output
SIMULATION OF PAGING
Enter the maximum size 4
Enter the number of elements to be inserted in page 1=1
Enter the number of elements to be inserted in page 2=2
Enter the number of elements to be inserted in page 3=3
Enter the number of elements to be inserted in page 4=4
APPEARENCES OF MAIN MEMORY
PAGE1 PAGE2 PAGE3 PAGE4
1 2 3 4
0 2 3 4
0 0 3 4
0 0 0 4
BEST FIT ALGORITHM
Enter the element size 2
PAGE1 PAGE2 PAGE3 PAGE4
1 2 3 4
0 2 3 4
0 2 3 4
0 2 0 4
Result
Thus the c program in Linux to stimulate the placement technique is executed successfully.
WORST FIT ALGORITHM
Aim
To write and execute a c program in Linux to stimulate the worst fit algorithm.
Algorithm
1 Consider a matrix and assume the matrix itself as it maintains the pages.
2 Fill element in each page randomly.
3 Cut the element to be placed in it.
4 Depending upon the element size and place.
5 Display it.
Program
#include
#include
void main ()
{
int c,a[10][10],I,j,k=0,q=0,n[10],m,z,size3=0,small;
clrscr();
printf(“Simulation of paging”);
printf(“……………………..”);
Printf(“Enter the max size”);
scanf(“%d”,&m);
for(i=0;i
for(j=0;j
a[i][j]=0;
for(i=0;i
{
printf(“Enter the number of elements to be inserted in page %d”,i+1);
scanf(“%d”,&k);
n[i]=k;
}
for(i=0;i
for(j=0;j
a[i][j]=n[i];
printf(“APPEARANCE OF MAIN MEMORY”);
printf(“………………………………………..”);
for(i=0;i
printf(“page %d”,i+1);
for(i=0;i
{
for(j=0;j
printf(“%d”,a[i][j]);
}
printf(“WORST FIT ALGORITHM”);
printf(“Enter the element size”);
scanf(“%d”,&size3);
small=n[0];
for(i=1;i
{
if(n[i]
{
q=i;
}
for(j=n[q];j<(size3+n[q]);j++)
a[q][j]=q+1;
}
for(i=0;i
printf(“page %d”,i+1);
for(i=0;i
{
for(j=0;j
printf(“%d”,a[i][j]);
}
getch();
}
Output
SIMULATION OF PAGING
Enter the maximum size 4
Enter the number of elements to be inserted in page 1=1
Enter the number of elements to be inserted in page 2=2
Enter the number of elements to be inserted in page 3=3
Enter the number of elements to be inserted in page 4=4
APPEARENCES OF MAIN MEMORY
PAGE1 PAGE2 PAGE3 PAGE4
1 2 3 4
0 2 3 4
0 0 3 4
0 0 0 4
WORST FIT ALGORITHM
Enter the element size 2
PAGE1 PAGE2 PAGE3 PAGE4
1 2 3 4
1 2 3 4
1 0 3 4
0 0 0 4
Result
Thus the c program to stimulate the technique of worst fit algorithm is executed successfully.
FIFO PAGE REPLACEMENT ALGORITHM
Aim:
To write and execute a C++ Program of Page Replacement algorithm
Algorithm:
1. start
2. get the page frame and reference string from the user.
3. initialize rfstr[25],pgfrm[5]
4. check rfstr=pgfrm then
5. continue the loop
6. find the page faults
7. Display the pgfrm.
8. stop
Program
#include
#include
void main()
{
int i, j, k, npgfrm, nrfstr, pgflt;
int pgfrm[5], rfstr[25];
clrscr();
cout << "\n FIFO PAGE REPLACEMT TECHNIQUE";
cout << "\nEnter the Number of Page Frames : ";
cin >> npgfrm;
cout << "\nEnter the Number of Reference String : ";
cin >> nrfstr;
for(i=0; i
{
cout << "\n Enter the reference String - " << i << " : ";
cin >> rfstr[i];
}
for(i=0; i
pgfrm[i] = -1;
pgflt=0;
for(i=0; i
{
for(j = 0 ; j < npgfrm && i < nrfstr; ++i )
{
for(k=0; k
if(pgfrm[k] == rfstr[i])
++i;
if(pgfrm[j] != rfstr[i])
{
pgfrm[j++] = rfstr[i];
++pgflt;
}
}
--i;
for(j=0; j
cout << endl << pgfrm[j];
cout << "\n Press Any key to Continue...\n\n"; getch();
}
cout << "\nNumber of Page Faults = " << pgflt;getch();
}
Output
Enter the Number of page Frames : 3
Enter the Number of Reference String : 20
FIFO PAGE REPLACEMENT TECHNIQUE
Enter the reference String - 0 : 7
Enter the reference String - 1 : 0
Enter the reference String - 2 : 1
Enter the reference String - 3 : 2
Enter the reference String - 4 : 0
Enter the reference String - 5 : 3
Enter the reference String - 6 : 0
Enter the reference String - 7 : 4
Enter the reference String - 8 : 2
Enter the reference String - 9 : 3
Enter the reference String - 10 : 0
Enter the reference String - 11 : 3
Enter the reference String - 12 : 2
Enter the reference String - 13 : 1
Enter the reference String - 14 : 2
Enter the reference String - 15 : 0
Enter the reference String - 16 : 1
Enter the reference String - 17 : 7
Enter the reference String - 18 : 0
Enter the reference String - 19 : 1
7 0 1
Press Any Key To Continue...
2 3 0
Press Any Key To Continue...
4 2 3
Press Any Key To Continue...
0 1 2
Press Any Key To Continue...
7 0 1
Number of Page Faults = 15
Result:
Thus the c++ program to page replacement algorithm is executed successfully.
No comments:
Post a Comment