JAWAHARLAL NEHRU TECHNOLOGICAL UNIVERSITY,ANANTAPUR.

III Year B.Tech. CSE -II Sem T P C

0 3 2

OPERATING SYSTEMS AND COMPILER DESIGN LAB

Objective :
• To provide an understanding of the language translation peculiarities by designing a
complete translator for a mini language.
• To provide an understanding of the design aspects of operating system

Recommended Systems/Software Requirements:

• Intel based desktop PC with minimum of 166 MHZ or faster processor with atleast 64 MB
RAM and 100 MB free disk space
• C++ complier and JDK kit

Part-A (OS)
1. Simulate the following CPU scheduling algorithms
a. Round Robin
b. SJF
c. FCFS
d. Priority
2. Simulate all file allocation strategies
a. Sequential
b. Indexed
c. Linked
3. Simulate MVT and MFT
4. Simulate all File Organization Techniques
a. Single level directory
b. Two level
c. Hierarchical
d. DAG
5. Simulate Bankers algorithm for deadlock avoidance
6. Simulate Bankers Algorithm for Deadlock prevention
7. Simulate all page replacement algorithms
a. FIFO
b. LRU
c. LFU Etc. …
8. Simulate Paging Technique of memory management.

Part-B (CD)

1. Lexical Analysis
2. Lexical Analyzer using LEX-tool
3. Compute FIRST() and FOLLOW() functions for the given language
4. Design predictive parser for the given language

1.Aim: Simulate the following CPU scheduling algorithms

a) Round Robin b) SJF c) FCFS d) Priority

Description:
FCFS (first-come-first-serve) Scheduling
 First-come, First served is simplest scheduling algorithm
 Ready queue is a FIFO queue:
 Longest waiting process at the front of queue
 New ready processes join the rear
 Non-preemptive: executes until voluntarily gives up CPU finished or waits
for some event
 Problem: CPU bound process may require a long CPU burst
Other processes, with very short CPU bursts, wait in queue Reduces CPU and I/O
device utilization
SJF (shortest-job-first) Scheduling
 Assume the next burst time of each process is known
 SJF selects process which has the shortest burst time
 Optimal algorithm because it has the shortest average waiting time
 Impossible to know in advance
 OS knows the past burst times- make a prediction using an average
 Non-preemptive Or preemptive
 Shortest remaining time first
 Interrupts running process if a new process enters the queue
 New process must have shorter burst than remaining time

Round Robin Scheduling

 Similar to FCFS, but preemption to switch between processes
 Time quantum(time slice) is a small unit of time (10 to 100 ms)
 Process is executed on the CPU for at most one time quantum
 Implemented by using the ready queue as a circular queue
 Head process gets the CPU
 Uses less than a time quantum implies gives up the CPU voluntary
 Uses full time quantum implies timer will cause an interrupt

 Context switch will be executed

 Process will be put at the tail of queue

Priority Scheduling
 Assume a priority is associated with each process
 Assume all processes arrive at the same time
 Select highest priority process from the ready queue
 Let T be the next CPU burst of a process
 SJF is a special case of priority scheduling
 Equal-priority processes are scheduled in FCFS order
 PRIORITY can be preemptive or Non-preemptive
 Priorities can be defined internally
 Memory requirements, number of open files, burst times
 Priorities can be defined externally
Program: Round Robin Scheduling Algorithm

#include<stdio.h>
#include<conio.h>
struct process
{
int at,ts,st,ft,wait,ts2,ta;
float nta;
}p[20];
main()
{
int i,j,slice,n;
float tamean=0,ntamean=0;
clrscr();
printf("Enter Number of Processes :: ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\nEnter Arrival Time for Process-%c : ",65+i);
scanf("%d",&p[i].at);
printf("\nEnter Service Time for process-%c : ",65+i);
scanf("%d",&p[i].ts);
}
printf("\nEnter Time Slice: ");
scanf("%d",&slice);
for(i=0;i<n+1;i++)
{
if(i==0)
p[i].ts2=n*slice;
else
p[i].ts2=p[i-1].ts2+(p[i-1].ts-slice);
if(i<n)
p[i].st=i*slice;
if(i>=1)
p[i-1].ft=p[i].ts2;
}
for(i=0;i<n;i++)
p[i].wait=(i*slice-p[i].at)+(p[i].ts2-(i+1)*slice);
for(i=0;i<n;i++)
{
p[i].ta=p[i].ft-p[i].at;
p[i].nta=(float)p[i].ta/p[i].ts;
tamean=tamean+p[i].ta;
ntamean=ntamean+p[i].nta;
}
tamean=(float)tamean/n;
ntamean=(float)ntamean/n;
printf("\n Process AT ST StT FT WT TA NTA\n");

for(i=0;i<n;i++)
{
printf("Process-%c%9d%9d%12d%12d%10d%6d
%10.4f",65+i,p[i].at,p[i].ts,p[i].st,p[i].ft,p[i].wait,p[i].ta,p[i].nta);
 printf("\n");
}
printf("\nturn around mean is : %f",tamean);
printf("\nnorm.turn around mean is : %f",ntamean);
getch();
}

Output:

Enter Number of Processes:: 3

Enter Arrival Time for Process -A : 0

Enter Service Time for process-A : 5

Enter Arrival Time for Process -B : 3

Enter Service Time for process-B : 7

Enter Arrival Time for Process -C : 5

Enter Service Time for process-C : 9

Enter Time Slice: 4

Process AT ST StT FT WT TA NTA

Process-A 0 5 0 13 8 13 2.6000
Process-B 3 7 4 16 6 13 1.8571
Process-C 5 9 8 21 7 16 1.7778

turn around mean is : 14.000000

norm.turn around mean is : 2.078307

Program: Shortest Job First Scheduling Algorithm

#include<stdio.h>
#include<conio.h>
main()
{
int [10],sbt[10],swt[10],st[10],stt[10],sft[10],n,i,j,wt,tt,temp;
float avgwt,avgtt;
 wt=0;tt=0;temp=0;st[1]=0;
clrscr();
printf("enter no.of jobs");
scanf("%d",&n);
printf("enter the burst times of jobs");
for(i=1;i<=n;i++)
scanf("%d",&sbt[i]);
for(i=1;i<=(n-1);i++)
for(j=i+1;j<=n;j++)
if((sbt[i]>sbt[j])&&(sbt[i]!=sbt[j]))
{
temp=sbt[i];
sbt[i]=sbt[j];
sbt[j]=temp;
}
for(i=1;i<=n;i++)
{ st[i+1]=st[i]+sbt[i];
sft[i]=st[i]+sbt[i];
if(i==1)
swt[i]=0;
else
swt[i]=swt[i-1]+sbt[i-1];
stt[i]=swt[i]+sbt[i];
wt=wt+swt[i];
tt=tt+stt[i];
}
avgwt=((float)wt/(float)n);
avgtt=((float)tt/(float)n);
printf("\nJOB sert st wt ft turt");
for(i=1;i<=n;i++)
printf("\nJ%d\t%d\t%d\t %d\t%d\t%d\n",i,sbt[i],st[i],sft[i],swt[i],stt[i]);
printf("\navg waiting time=%0.2f,turnover total
time=%0.2f",avgwt,avgtt);
getch();
}
Output:
enter no.of jobs3
enter the burst times of jobs4 6 5

JOB sert st wt ft turt

J1 4 0 4 0 4
J2 5 4 9 4 9
J3 6 9 15 9 15
avg waiting time=4.33,turnover total time=9.33
Program: First-come-First-Served Scheduling Algorithm

#include<stdio.h>
#include<conio.h>
struct process
{
int at,ts,st,ft,ta;
float nta;
};
main()
{
struct process p[20];
int n,i,j;
float tamean=0,ntamean=0;
 clrscr();
printf("\nEnter Number of Processes:: ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\nEnter Arrival Time for Process-%c :: ",65+i);
scanf("%d",&p[i].at);
printf("\nEnter Service Time for Process-%c :: ",65+i);
scanf("%d",&p[i].ts);
}
for(i=0;i<n;i++)
{
if(i==0)
p[i].st=p[i].at;
else
{
p[i].st=0;
for(j=0;j<i;j++)
p[i].st=p[i].st+p[j].ts;
}
p[i].ft=p[i].ts+p[i].st;
p[i].ta=p[i].ft-p[i].at;
p[i].nta=(float)p[i].ta/p[i].ts;
tamean=tamean+p[i].ta;
ntamean=ntamean+p[i].nta;
}
tamean=(float)(tamean/n);
ntamean=(float)(ntamean/n);
printf("\nProcess AT ST StT FT TA NTA");
for(i=0;i<n;i++) printf("\n%3c%12d%10d%10d%10d%10d
%15f",65+i,p[i].at,p[i].ts, p[i].st,p[i].ft,p[i].ta,p[i].nta);
printf("\n\n Mean of Turn-around time : %f",tamean);
printf("\n\n Mean of Normalized turn-around time : %f",ntamean);
getch();
}

Output:

Enter Number of Processes:: 3

Enter Arrival Time for Process-A :: 0

Enter Service Time for Process-A :: 12

Enter Arrival Time for Process-B :: 2

Enter Service Time for Process-B :: 9

Enter Arrival Time for Process-C :: 6

Enter Service Time for Process-C :: 14

Process AT ST StT FT TA NTA

A 0 2 0 12 12 1.000000
 B 2 9 12 21 19 2.111111
C 6 14 21 35 29 2.071429

Mean of Turn-around time: 20.000000

Mean of Normalized turn-around time: 1.727513

Program: Priority Scheduling Algorithm

#include<stdio.h>
#include<conio.h>
struct process
{
int ts,pri,wait,ft;
}p[20];
main()
{
int n,pri1[20],i,j,temp,ft1[25];
clrscr();
printf("\n Enter Number of Processes:: ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\nEnter Service Time for Process-%c : ",65+i);
scanf("%d",&p[i].ts);
printf("\nEnter Priority for Process-%c : ",65+i);
scanf("%d",&p[i].pri);
}
 for(i=0;i<n;i++)
pri1[i]=p[i].pri;
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
if(pri1[i]>pri1[j])
{
temp=pri1[i];
pri1[i]=pri1[j];
pri1[j]=temp;
}
}
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(pri1[i]==p[j].pri)
{
if(i==0)
{
p[j].wait=0;
p[j].ft=p[j].ts;
ft1[i]=p[j].ft;
}
else
{
p[j].ft=ft1[i-1]+p[j].ts;
p[j].wait=ft1[i-1];
ft1[i]=p[j].ft;
}
}
}
}
printf("\nProcess ST PRI FT WT ");
for(i=0;i<n;i++)
{
printf("\nprocess-%c%10d%13d%14d%15d",65+i,p[i].ts,p[i].pri,p[i].ft,p[i].wait);
}
getch();
}

Output:

Enter Number of Processes:: 3

Enter Service Time for Process-A : 5

Enter Priority for Process-A : 2

Enter Service Time for Process-B : 8

Enter Priority for Process-B : 1

Enter Service Time for Process -C : 6

Enter Priority for Process-C : 3

Process ST PRI FT WT
process-A 5 2 13 8
process-B 8 1 8 0
process-C 6 3 19 13

2.Aim: Simulate all file allocation strategies

a) sequential b) indexed c) linked
Description:
Sequential file allocation

1. simplest method is a contiguous (sequential) set of blocks

2. disk address or start(base) block and length (in blocks)
3. sequential access is easy – read next block
4. direct access (seek) is easy
5. logical offset= physical base + offset
6. how to fine space for new file
7. first-fit: first hole that is big enough
8. best fit: smallest hole that is big enough
9. external fragmentation
10.blocks are available but not sequentially
11.internal fragmentation
12.pre-allocation of blocks is too large
13.left-over amount in last block

Indexed Allocation

1. Indexed: direct access and no fragmentation

2. Bring all pointers into one location: the index block(IB)
3. Each file has its own IB
4. Ith entry in the IB points to the ith block
5. Suffers from wasted space(IB may not be full)
Linked Allocation
1. solves external fragmentation: can use any block for any file
2. solves pre-allocation internal fragmentation
3. good for sequential access: chase the pointer
4. not effective for direct access
5. where is the nth block of the file
6. requires space for pointers
7. if a pointer is bad, file is lost

/*Sequential file allocation*/

#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<stdlib.h>

int q=100,b[100],m;
main ()
{ int ch,i,j,no;
char fnm[20], tnm[20]="null";
struct FAT /* declaration of structure*/
{
char name[20];
int start;
int len;
}p[20];
clrscr( );
m=0;
printf("\n SIMULATION OF FILE ALLOCATION METHODS\n\n");
do /* reading choices */
{
printf("\n\n Main Menu\n\n\t1.insertion \t2.deletion\n\t3.retrieval\n\t4.exit \n\nEnter
your choice:");
scanf("%d",&ch);
switch(ch)
{
 case 1:printf("\n enter file name");
scanf("%d",&(p[m].len));
while(1)
{
no=random(q);
if(b[no]==0)
{
for(j=no+1;j<no+p[m].len;j++)
if(b[j]==1)
break;
}
if(j==no+p[m].len)
break;
}
p[m].start=no;
for(i=no;i<no+p[m].len;i++)
b[i]=1;
printf("page table");

for(i=0;i<m;i++) /* printing file name*/

{
printf("\n%s\t%d\t%d",p[i].name,p[i].start,p[i].len);
printf("\n");
}
break;
case2:printf("enter file name you want to delete"); /* deleting file*/
scanf("%s",fnm);
for(i=0;i<m;i++)
{
if(strcmp(p[i].name,fnm)==0)
{
for(j=p[i].start ;j<(p[i].len+p[i].start);j++)
b[j]=0;
strcpy(p[i].name,"null");
p[i].start=-1;
p[i].len=-1;
printf("%s deleted successfully",fnm);
break;
}
}
for(i=0;i<m;i++)
{
printf("%s",p[i].name);
printf("%d\t%d\t",p[i].start,p[i].len);
printf("\n");
}
case 3:printf("enter file name you want to retrieve"); /* file retrieving */
 scanf("%s",fnm);
printf("\nblocks allocated are \n");
for(i=0;i<m;i++)
{
if(strcmp(p[i].name,fnm)==0)
{
for(j=p[i].start;j<(p[i].start+p[i].len);j++)
printf("%d\t",j);
break;
}
}
break;
case 4:exit(0);
default:printf("INVALID CHOICE");
}
}while(1);
}

OUTPUT
SIMULATION OF FILE ALLOCATION METHODS
Main Menu
1.insertion
2.deletion
3.retrieval
4.exit
enter your choice :1
enter file name:q
enter length(in kb):12
page table
qq 46 12
Main Menu
1.insertion
2.deletion
3.retrieval
4.exit
enter your choice :1
enter file name : ww
enter length(in kb):3
page table
qq 46 12
ww 30 3
Main Menu
1.insertion
2.deletion
3.retrieval
4.exit
enter your choice :3
enter file name you want to retrieve ww
blocks allocated are
30 31 32
Main Menu
1.insertion
2.deletion
3.retrieval
4.exit
enter your choice :3
enter file name you want to delete ww
ww is deleted successfully
qq 46 12
null -1 -1
Main Menu
1.insertion 2.deletion 3.retrieval 4.exit enter your choice: 4

/*linked file allocation */

#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<stdlib.h>
main()
{
struct FAT /* declaration of structure */
{
char name[5];
int len,start,arr[10];
}p[20];
int ch,l,i,j,rn,v,m,q=100;
char fnm[5];
int b[100];
clrscr();
for(i=0;i<100;i++)
b[i]=0;
while(1)
{
Printf(" 1.create 2.delete data from file 3.retrive file 4.exit "); /* reading

choices */
Scanf("%d",& ch);
switch(ch)
{
case 1:
printf("enter the file name");
scanf("%s",&p[m].name);
printf("enter the length of the file");
scanf("%d",&p[m].len);
l=0;
for(j=0;j<p[m].len;j++)
 {
do
{
rn=random(q);
if(b[rn]==0)
{
p[m].arr =rn;
l++;
b[rn]=1;
break;
}
}while(b[rn]==1);

p[m].start=p[m].arr[0];
printf(" page table is");
printf("name start length");
for(i=0;i<m;i++)
printf("\n%s %d %d", p[i].name,p[i].start,p[i].len);
break;
case 2: printf("enter the file name that you want to delete"); /* deleting file*/
for(i =0; i<m;i++)
{
if(strcmp(p[i].name,fnm)==0)
{
for(j=0;j< p[i].len;j++)
{
v=p[i].arr[j] ;
b[v]=0;
p[i].arr=0;
}
p[i].len=-1;
p[i].start=-1;
strcmp( p[i].name,NULL);
}
}
printf("the page tableis :\n");
for(i=0;i<=m;i++)
{
printf("%s",p[i].name);
printf("%d %d",p[i].start,p[i].len);
}
break;
case 3: printf("enter the name of the file that you want to retrive"); /*file retrieving*/
scanf("%s",&fnm);
for(i=0; i<=m;i++)
{
if(strcmp(p[i].name,fnm)==0)
{
for (j=0;j<=p[i].len;j++)
printf("%d\t",p[i].arr[j]);
 }
}
break;
case 4:exit(0);
default: printf("invalid");
}
}
getch(); } }
Output:
Enter the choice:
1.create
2.delete data from file
3.retrive file
4.exit
1
Enter the file name : fdhgf
Enter the length of file:12
Page table is
Name start length
fdfgf 46 12
Enter the choice:
1.create
2.delete data from file
3.retrive file
4.exit
1
Enter the file name : kjkl
Enter the length of file:10
Page table is
Name start length
fdfgf 46 12
kjkl 71 10
Enter the choice:
1.create
2.delete data from file
3.retrive file
4.exit
3
enter the name of the file that you want to retrieve kjkl
71 79 60 12 21 63 47 19 41
Enter the choice:
1.create
2.delete data from file
3.retrive file
4.exit
2
Enter the file you want to delete : kjkl
Page table is
Name start length
fdfgf 46 12
 NULL -1 -1
Enter the choice:
1. Create 2.delete data from file 3.retrive file 4.exit
4

3.Aim: Simulate MVT and MFT

Description:
Memory management
• CPU runs program instructions only when program is in memory.
• Programs do I/O sometimes IMPLY CPU wasted.
• Solution : Multiprogramming
• Multiple programs share the memory
• One program at a time gets CPU
• Simultaneous resource possession
• Better performance

Multiple Programming with Fixed Number of Tasks (MFT):

IBM in their Mainframe Operating system OS/MFT implements the MFT concept.
OS/MFT uses fixed partitioning concept to load programs into main memory.
Fixed Partitioning:
• In fixed partitioning concept, RAM is divided into set of fixed partitions of equal
size.
• Programs having the size less than the partition size are loaded into memory
• Programs having size more than the size of partition size is rejected
• The program having the size less than the partition size will lead to internal
fragmentation
• If all partitions are allocated and if a new program is to be loaded, the program
that leads to maximum internal fragmentation can be replaced.

Multi-programming with variable number of tasks (MVT):

IBM in their Mainframe Operating system OS/MVT implements the MVT concept.
OS/MVT uses dynamic partitioning concept to load programs into main memory.

Dynamic Partitioning:
• Initially RAM is portioned according to the size of programs to be loaded into
Memory till such time that no other program can be loaded.
• The left over memory is called a hole which is too small to fit any process
• When a new program is to be loaded into memory look for the partition, which
leads to least external fragmentation and load the program.
• The space that is not used in a partition is called as external fragmentation
Multi-programming with variable number of tasks (MVT):
#include<stdio.h>
#include<conio.h>
main()
{
static int jobs[20][20],flag[10];
int ch;
static int i,k,nj,nb,tms;
clrscr();
printf("Enter time"); /* reading time */
scanf("%d",&tms);
printf("Enter no. of jobs"); /* reading no of jobs */
scanf("%d",&nj);
printf("Enter job information 1.jobid 2.jobsize");
for(i=0;i<nj;i++)
scanf("%d%d",&jobs[i][0],&jobs[i][1]);
for(i=0;i<nj;i++)
{
if(tms>=jobs[i][1])
{
tms=tms-jobs[i][1];
nb=nb+1;
flag[i]=1;
}
}
printf("Total memory space available which is not allocated is:%d\n",tms);
printf("Jobs which are not allocated:");
for(i=0;i<nj;i++)
if(flag[i] == 0)
printf("%d\t%d\n",jobs[i][0],jobs[i][1]);
if(nb!=nj)
{
while(1)
{
printf("enter jobid to deallocate:");
scanf("%d",&k);
for(i=0;i<nj;i++)
{
if(jobs[i][0] == k)
{
if(flag[i] ==1)
{
tms=tms+jobs[i][1];
flag[i]=2;
printf("Deallocated job %d\t%d\n", jobs[i][0],jobs[i][1]);
 }
}
}

for(i=0;i<nj;i++)
{
if (tms>=jobs[i][1])
{
if(flag[i] == 0)
{
tms=tms-jobs[i][1];
flag[i]=1;
}
}
}
printf("Remaining memory is: %d",tms);
printf("Jobs which are not allocated are:");
for( i=0;i<nj;i++) /* dellocating mamory*/
if(flag[i] ==0)
printf("%d\t%d\n", jobs[i][0],jobs[i][1]);
printf("Do you want to deallocate 1.Yes 2.No");
scanf("%d",&ch);
if(ch ==2)
break;
}
}
printf("Allocated jobs are:");
for(i=0;i<nj;i++)
if(flag[i]==1)
printf("%d\t%d\n",jobs[i][0],jobs[i][1]);
getch();
}

Output:
 1) Enter time: 100
Enter no. of jobs: 5
Enter job information 1.jobid 2.jobsize
1 20
2 25
3 15
4 30
5 15
Total memory space available which is not allocated is: 10
Jobs which are not allocated: 5 15
Enter jobid to deallocate: 1
Deallocated job: 1 20
Remaining memory is: 15
Jobs which are not allocated are:
Do you want to deallocate 1.Yes 2.No : 1
Enter jobid to deallocate: 4
Deallocated job: 4 30
Remaining memory is 45
Jobs which are not allocated are:
Do you want to deallocate 1.Yes 2.No : 2
Allocated jobs are
2 25
3 15
5 15
2) Enter time: 100
Enter no. of jobs: 4
Enter job information 1.jobid 2.jobsize
1 25
2 30
3 40
4 25
Total memory space available which is not allocated is: 10
Jobs which are not allocated: 4 25
Enter jobid to deallocate: 3
Deallocated job: 3 40
Remaining memory is: 20
Jobs which are not allocated are:
Do you want to deallocate 1.Yes 2.No : 2
Allocated jobs are
1 25
2 30
3 25

Multiple Programming with Fixed Number of Tasks (MFT):

#include<stdio.h>
#include<conio.h>
void main()
{
int tms,element,nb,i,j,t,index,frag,ch,count=0;
static int jobs[20][20],sz[20][20],nj,s;
clrscr();
printf("enter total memory space"); /* reading memory */
scanf("%d",&tms); /* reading choices */
printf("enter choice\n1.equal partition 2.unequal partition\n");
scanf("%d",&ch);
if(ch==1)
{
printf("enter size of each block");
scanf("%d",&s);
nb=tms/s;
for(i=0;i<nb;i++)
scanf("%d",&sz[i][0]);
}
else
{
printf("enter no. of blocks");
scanf("%d",&nb);
printf("enter size of %d blocks");
for(i=0;i<nb;i++)
scanf("%d",sz[i][0]);
}
printf("enter no. of jobs"); /* reading no of jobs */
scanf("%d",&nj);
printf("enter job information 1.jobid 2.job size\n");
for(i=0;i<nj;i++)
scanf("%d%d",&jobs[i][0],&jobs[i][1]);
frag=0;
for(j=0;j<nj;j++)
{
if(sz[j][0]>=element && sz[i][0]<=t)
{
if(sz[j][1]!=1)
{
t=sz[j][0];
index=j;
}
}
}

if(sz[index][1]!=1)
{
sz[index][1]=1;
jobs[i][2]=2;
frag=frag+(t-element);
count++;
 }

printf("total internal fragmentation : %d", frag);

printf("no. of free blocks: %d" , nb-count);
printf("the jobs which are not allocated");
if(count==nj)
printf(" 0");
for(i=0;i<nj;i++)
{
if(jobs[i][2]!=2)
printf("jobid ------%d\tjob size-----%d\n",jobs[i][0],jobs[i][1]);
}
getch();

Output:
Enter total memory space: 100
enter choice 1. equal partition 2. unequal partition 2
enter no. of blocks: 3
enter size of 3 blocks: 50 25 25
enter no. of jobs 4
enter job information 1.jodid 2. jobsize
1 25
2 30
3 26
4 20
5 25
total internal fragmentation : 9
no. of free blocks : 0
the jobs which are not allocated :
job id----4 jobsize----20
jobid----5 jobsize----25

4.Aim: Simulate all File Organization Techniques

a. Single level directory
b. Two level

Description:

Higher level file organization techniques such as ISAM (Indexed Sequential Access
Method) or VSAM (Virtual System Access Method) could incur large seek times because
of a double of triple access to retrieve one record (index(s) and data).
 Disk optimization is critical in these cases, but is more complex, because data
retrieved from one disk (the index) indicates where the next seek is (data which that
index points to). Data and index portions of data sets are not normally stored next to
each other, and sometimes are stored on different packs.

What might be the impact of placing the index on one pack and the data on
another?
 Major concepts:
• Files are made up of records; records are made up of fields
• Disk blocks are smaller than files and larger than records; files must be split into
disk blocks for storage (and the records in a file must be grouped somehow for
storage on disk blocks, independent of the file organization)
• Fixed-length records
• Variable length records
• Block structure: fixed-packed or slotted page
• File structure: heap, sequential, hashed, or clustered
• Details of the above file structures
• Files are logical units mapped onto physical secondary storage
• File name: logical object
• Physical objects: blocks on disk, tape, optical disk
• One or more sectors: smallest unit to read from or write to disk
• Block: unit of I/o transfer from disk to memory
• Secondary storage: nonvolatile

• File attributes: frequency of additions and deletions

• Activity: percentage of records accessed during time frame
• Directory : keep track of files
• Create the illusion of compartments

Single Level Directory

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<graphics.h>
void main()
{
int gd=DETECT,gm,count,i,j,mid,cir_x;
char fname[10][20];
 clrscr();
initgraph(&gd,&gm,"c:/tc/bgi");
cleardevice();
setbkcolor(GREEN);
printf("enter number of files");
scanf("&d",&count);
if(i<count)
// for(i=0;i<count;i++)
{
cleardevice();
setbkcolor(GREEN);
printf("enter %d file name:",i+1);
scanf("%s",fname[i]);
setfillstyle(1,MAGENTA);
mid=640/count;
cir_x=mid/3;
bar3d(270,100,370,150,0,0);
settextstyle(2,0,4);
settextjustify(1,1);
outtextxy(320,125,"root directory");
setcolor(BLUE);
i++;
for(j=0;j<=i;j++,cir_x+=mid)
{
line(320,150,cir_x,250);
fillellipse(cir_x,250,30,30);
outtextxy(cir_x,250,fname[i]);
}
}
getch();
}

Output:

Enter number of files: 2

Enter file 1 name: it

Root
directory

it
 Two Level Directory:

#include<stdio.h>
#include<graphics.h>
struct tree_element
{
char name[20];
int x,y,ftype,lx,rx,nc,level;
struct tree_element *link[5];
};
typedef struct tree_element node;
void main()
{
int gd=DETECT,gm;
node *root;
root=NULL;
clrscr();
create(&root,0,"null",0,639,320);
 clrscr();
initgraph(&gd,&gm,"c:\tc\bgi");
display(root);
getch();
closegraph();
}
create(node **root,int lev ,char *dname,int lx,int rx,int x)
{
int i, gap;
if(*root==NULL)
{
(*root)=(node*)malloc(sizeof(node));
printf("enter the name of ir file name %s",dname);
fflush(stdin);
gets((*root)->name);
if(lev==0 || lev==1)
(*root)-> ftype=1;
else
(*root)->ftype=2;
(*root)->level=lev;
(*root)->y=50+lev*50;
(*root)->x=x;
(*root)->lx=lx ;
(*root)->rx=rx;
for(i=0;i<5;i++)
(*root)->link[i]=NULL;
if((*root)->ftype==1)
{
if(lev==0 || lev==1)
{
if((*root)->level==0)
printf("how many users");
else
printf(" how many files");
printf("(for %s):",(*root)->name);
scanf("%d",&(*root)->nc);
}
else
(*root)->nc=0;
if((*root)->nc==0)
gap=rx-lx;
else
gap=(rx-lx)/(*root)->nc;
for(i=0;i<(*root)->nc;i++)
create(&((*root)->link[i]),lev+1,(*root)-
>name,lx+gap*i,lx+gap*i+gap,lx+gap*i+gap/2);
}
else
(*root)->nc=0;
}
}
display(node *root)
{
int i;
settextstyle(2,0,4);
settextjustify(1,1);
setfillstyle(1,BLUE);
setcolor(14);
if(root!=NULL)
{
for(i=0;i<root->nc;i++)
{
line(root->x,root->y,root->link[i]->x,root->link[i]->y);
}
if(root->ftype==1)
bar3d(root->x-20, root->y-10,root->x+20,root->y+10,0,0);
else
fillellipse(root->x,root->y,20,20);
outtextxy(root->x,root->y,root->name);
for(i=0;i<root->nc;i++)
{
display(root->link[i]);
}
}
}

Output:
Enter the name of the dir file ROOT
Ho many users :2
Enter the name of the dir file: 007
How many files :2
Enter the name of the dir file007_1
Enter the name of the dir file007_2
Enter the name of the dir file xx
How many files: 2
Enter the name of dir file xx_1
Enter the name of dir file xx_2

ROOT

007 xx

007_ 007_ Xx_1 Xx_2

1 2
5.Aim: To simulate banker’s algorithm for deadlock avoidance
Description:
Deadlock Definition
A set of processes is deadlocked if each process in the set is waiting for an event
that only another process in the set can cause (including itself).

Waiting for an event could be:

• waiting for access to a critical section
• waiting for a resource Note that it is usually a non-preemptable (resource).
Preemptable resources can be yanked away and given to another.

Conditions for Deadlock

• Mutual exclusion: resources cannot be shared.
• Hold and wait: processes request resources incrementally, and hold on to what
they've got.
• No preemption : resources cannot be forcibly taken from processes.
• Circular wait: circular chain of waiting, in which each process is waiting for a
resource held by the next process in the chain.
Strategies for dealing with Deadlock
• ignore the problem altogether
• detection and recovery
• avoidance by careful resource allocation
• prevention by structurally negating one of the four necessary conditions.
Deadlock Avoidance
Avoid actions that may lead to a deadlock. Think of it as a state machine moving
from one state to another as each instruction is executed.

Safe State
Safe state is one where
 It is not a deadlocked state
 There is some sequence by which all requests can be satisfied.
 To avoid deadlocks, we try to make only those transitions that will take you from one
safe state to another. We avoid transitions to unsafe state (a state that is not
deadlocked, and is not safe)
eg.
Total # of instances of resource = 12
(Max, Allocated, Still Needs)
P0 (10, 5, 5) P1 (4, 2, 2) P2 (9, 2, 7) Free = 3 - Safe
The sequence is a reducible sequence
the first state is safe.
What if P2 requests 1 more and is allocated 1 more instance?
- results in Unsafe state

So do not allow P2's request to be satisfied.

BANKERS ALGORITHM FOR DEADLOCK AVOIDANCE

#include<stdio.h>
#include<conio.h>
main()
{
int a[10][10],c[10][10],r[10],av[10],ca[10][10],i,j,k,n,m,temp=0,tem,ch;
clrscr();
printf("enter no processes");
scanf("%d",&m);
printf("enter no of resources");
scanf("%d",&n);
printf("\nenter claim\n");
for(i=0;i<m;i++)
for(j=0;j<n;j++)
scanf("%d",&c[i][j]);
printf("\nenter alocation matrix\n");
for(i=0;i<m;i++)
for(j=0;j<n;j++)
scanf("%d",&a[i][j]);
printf("\nenter resourse vector\n");
for(i=0;i<n;i++)
scanf("%d",&r[i]);
k=0;
do
{
printf("claim\tallocation\tca\n");
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
 printf("%3d",c[i][j]);printf("\t");
for(j=0;j<n;j++)
printf("%3d",a[i][j]);printf("\t\t");
for(j=0;j<n;j++)
{
ca[i][j]=c[i][j]-a[i][j];
printf("%3d",ca[i][j]);
}
printf("\n");
}
temp=0;
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
temp=temp+a[j][i];
av[i]=r[i]-temp;temp=0;
}
printf("\nresource vector: ");
for(i=0;i<n;i++)
printf("%3d",r[i]);
printf("\navailable vector: ");
for(i=0;i<n;i++)
printf("%3d",av[i]);
if(k==0)
printf("\n****initial state****\n");
else
printf("\n***p%d runs to completion*****\n",tem+1);
if(k<n)
{
temp=0;
for(i=0;i<m;i++)
{
lab:for(j=0;j<n;j++)
{
if(ca[i][j]==0)
temp++;
}
if(temp==n)
{
i++; temp=0;goto lab;
}
else
{
for(j=0;j<n;j++)
{
if(ca[i][j]<=av[j])
tem=i;
else
{
if(i>m)
 {
printf("\nunshafe state");goto end;
}
else
{i++;goto lab;}
}
}
}
for(j=0;j<n;j++)
{
a[tem][j]=0;c[tem][j]=0;ca[tem][j]=0;
}
break;
}
}
else
{
printf("\nprocesses are completed");
goto end;
}
k++;
printf("continue press ZERO");
scanf("%d",&ch);
}while(ch==0);
end: getch();
}

Output:
enter no processes 3
enter no of resources 3
enter claim
322
613
314
enter allocation matrix
100
612
211
enter resource vector
936
claim allocation ca
3 2 2 1 0 0 2 2 2
6 1 3 6 1 2 0 0 1
3 1 4 2 1 1 1 0 3

resource vector: 9 3 6
available vector: 0 1 3
****initial state****
continue press ZERO 0
enter allocation matrix
100
612
211
enter resource vector
936

claim allocation ca
3 2 2 1 00 2 2 2
6 1 3 6 1 2 0 0 1
3 1 4 2 1 1 1 0 3
resource vector: 9 3 6
available vector: 0 1 3
****initial state****

continue press ZERO 0

claim allocation ca
3 2 2 1 0 0 2 2 2
0 0 0 0 0 0 0 0 0
3 1 4 2 1 1 1 0 3
resource vector: 9 3 6
available vector: 6 2 5
***p2 runs to completion*****

continue press ZERO 0

claim allocation ca
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
3 1 4 2 1 1 1 0 3
resource vector: 9 3 6
available vector: 7 2 5
***p1 runs to completion*****

continue press ZERO0

claim allocation ca
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
resource vector: 9 3 6
available vector: 9 3 6
***p3 runs to completion*****
processes are completed
6.Aim: To simulate Bankers Algorithm for Deadlock Prevention

Description:

Deadlock Definition
A set of processes is deadlocked if each process in the set is waiting for an event
that only another process in the set can cause (including itself).

Waiting for an event could be:

• waiting for access to a critical section
• waiting for a resource Note that it is usually a non-preemptable (resource).
Preemptable resources can be yanked away and given to another.
•
Conditions for Deadlock
• Mutual exclusion: resources cannot be shared.
• Hold and wait: processes request resources incrementally, and hold on to what
they've got.
• No preemption : resources cannot be forcibly taken from processes.
• Circular wait: circular chain of waiting, in which each process is waiting for a
resource held by the next process in the chain.
Strategies for dealing with Deadlock
• ignore the problem altogether
• detection and recovery
• avoidance by careful resource allocation
• prevention by structurally negating one of the four necessary conditions.

Deadlock Prevention
Difference from avoidance is that here, the system itself is built in such a way that
there are no deadlocks.
Make sure atleast one of the 4 deadlock conditions is never satisfied. This may
however be even more conservative than deadlock avoidance strategy.

• Attacking Mutex condition

o never grant exclusive access. but this may not be possible for several
resources.
• Attacking preemption
o not something you want to do.
• Attacking hold and wait condition
o make a process hold at the most 1 resource at a time.
o make all the requests at the beginning. All or nothing policy. If you feel,
retry. eg. 2-phase locking
• Attacking circular wait
o Order all the resources.
o Make sure that the requests are issued in the correct order so that there are
no cycles present in the resource graph.
Resources numbered 1 ... n. Resources can be requested only in increasing
 order. ie. you cannot request a resource whose no is less than any you may
be holding.

BANKERS ALGORITHM FOR DEADLOCK PREVENTION

#include<stdio.h>
#include<conio.h>
int max[10][10],alloc[10][10],need[10][10],avail[10],i,j,p,r,finish[10]={0},flag=0;
main( )
{
clrscr( );
printf("\n\nSIMULATION OF DEADLOCK PREVENTION");
printf("Enter no. of processes, resources");
scanf("%d%d",&p,&r);
printf("Enter allocation matrix");
for(i=0;i<p;i++)
for(j=0;j<r;j++)
scanf("%d",&alloc[i][j]);
printf("enter max matrix");
for(i=0;i<p;i++) /*reading the maximum matrix and availale matrix*/
for(j=0;j<r;j++)
scanf("%d",&max[i][j]);
printf("enter available matrix");
for(i=0;i<r;i++)
scanf("%d",&avail[i]);
for(i=0;i<p;i++)
for(j=0;j<r;j++)
need[i][j]=max[i][j]-alloc[i][j];
fun(); /*calling function*/
if(flag==0)
{
if(finish[i]!=1)
{
printf("\n\n Failing :Mutual exclusion");
for(j=0;j<r;j++)
{ /*checking for mutual exclusion*/
if(avail[j]<need[i][j])
avail[j]=need[i][j];
}
fun();
printf("\n By allocating required resources to process %d dead lock is prevented ",i);
printf("\n\n lack of preemption");
for(j=0;j<r;j++)
{
if(avail[j]<need[i][j])
avail[j]=need[i][j];
alloc[i][j]=0;
}
fun( );
printf("\n\n daed lock is prevented by allocating needed resources");
printf(" \n \n failing:Hold and Wait condition ");
for(j=0;j<r;j++)
{ /*checking hold and wait condition*/
if(avail[j]<need[i][j])
avail[j]=need[i][j];
}
fun( );
printf("\n AVOIDING ANY ONE OF THE CONDITION, U CAN PREVENT DEADLOCK");
}
}
getch( );
}
fun( )
{
while(1)
{
for(flag=0,i=0;i<p;i++)
{
if(finish[i]==0)
{
for(j=0;j<r;j++)
{
if(need[i][j]<=avail[j])
continue;
else
break;
}
if(j==r)
{
for(j=0;j<r;j++)
avail[j]+=alloc[i][j];
flag=1;
finish[i]=1;
}
}
}
if(flag==0)
break;
}
}
Output:
SIMULATION OF DEADLOCK PREVENTION
Enter no. of processes, resources 3, 2
enter allocation matrix 2 4 5
3 4 5

Enter max matrix4 3 4

5 6 1
Enter available matrix2
5
Failing : Mutual Exclusion
by allocating required resources to process dead is prevented
Lack of no preemption
deadlock is prevented by allocating needed resources
Failing : Hold and Wait condition
BY AVOIDING ONE OF THE ABOVE CONDITION, YOU CAN PREVENT DEADLOCK
7.Aim: To simulate all page replacement algorithms
a. FIFO
b. LRU
c. LFU Etc. …

Description:
FIFO
The first-in, first-out (FIFO) page replacement algorithm is a low-overhead
algorithm that requires little book-keeping on the part of the operating system. The idea
is obvious from the name - the operating system keeps track of all the pages in memory
in a queue, with the most recent arrival at the back, and the earliest arrival in front.
When a page needs to be replaced, the page at the front of the queue (the oldest
page) is selected. While FIFO is cheap and intuitive, it performs poorly in practical
application. Thus, it is rarely used in its unmodified form. This algorithm experiences
Belady's anomaly.

Least Recently Used (LRU)

The least recently used page (LRU) replacement algorithm works on the idea that
pages that have been most heavily used in the past few instructions are most likely to be
used heavily in the next few instructions too. While LRU can provide near-optimal
performance in theory it is rather expensive to implement in practice. There are a few
implementation methods for this algorithm that try to reduce the cost yet keep as much
of the performance as possible.
The most expensive method is the linked list method, which uses a linked list
containing all the pages in memory. At the back of this list is the least recently used
page, and at the front is the most recently used page. The cost of this implementation
lies in the fact that items in the list will have to be moved about every memory
reference, which is a very time-consuming process.
Another method that requires hardware support is as follows: suppose the
hardware has a 64-bit counter that is incremented at every instruction. Whenever a page
is accessed, it gains a value equal to the counter at the time of page access. Whenever a
page needs to be replaced, the operating system selects the page with the lowest
counter

and swaps it out. With present hardware, this is not feasible because the required
hardware counters do not exist.
One important advantage of LRU algorithm is that it is amenable to full statistical
analysis. It has been proved, for example, that LRU can never result in more than N-
times more page faults than OPT algorithm, where N is proportional to the number of
pages in the managed pool.
On the other hand, LRU's weakness is that its performance tends to degenerate
under many quite common reference patterns. For example, if there are N pages in the
LRU pool, an application executing a loop over array of N + 1 pages will cause a page
fault on each and every access. As loops over large arrays are common, much effort has
been put into modifying LRU to work better in such situations.
 FIFO PAGE REPLACEMENT ALGORITHM
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
char prs[40],fp[10],ps;
int fs,i,j,k=0,flg1,flg2,x=5,y,pfc=0;
clrscr();
printf("\n enter page reference string:");
gets(prs);
printf("\n enter the frame size:");
scanf("%d",&fs);
for(i=0;i<fs;i++)
fp[i]='x';
clrscr();
printf("\n page replacement technique :: FIFO algorithm:");
printf("\n .............................................");
printf("\n F-Page Fault \t H- Page Hit \n");
for(i=0;i<strlen(prs);i++,x+=2)
{
flg1=0;
ps='F';
for(j=0;j<fs;j++)
if(fp[j]==prs[i]){
ps='H';
flg1=1;
break;
}
if(flg1==0)
{
flg2=0;
for(j=0;j<fs;j++)
if(fp[j]=='x')
{
fp[j]=prs[i];
pfc++;
flg2=1;
break;
}
if(flg2==0)
{
pfc++;
fp[k]=prs[i];
k++;
if(k==fs)
k=0; } }
y=5;
gotoxy(x,y);
printf("%c",prs[i]);
y++;
gotoxy(x,y);
printf("--");
y++;
for(j=0;j<fs;y++,j++)
{
gotoxy(x,y);
printf("%c",fp[j]);
}
y++;
gotoxy(x,y);
printf("--");
y++;
gotoxy(x,y);
printf("%c",ps);
}
printf("\n \n\n\n\n Total page Faults=%d",pfc);
getch();
}

OUTPUT

enter page reference string : 232152453252

enter the frame size: 3
page replacement technique:: FIFO algorithm
................................................................................
F-page fault H-page hit
2 3 2 1 5 2 4 5 3 2 5 2
----------------------------
2 2 2 2 5 5 5 5 3 3 3 3
x 3 3 3 3 2 2 2 2 2 5 5
x x x 1 1 1 4 4 4 4 4 2
---------------------------
F FHFF F F H F H F F
total page faults=9

LFU PAGE REPLACEMENT ALGORITHM

#include<dos.h>
#include<stdio.h>
#include<conio.h>
#include<string.h>

void main()
{
char prs[40],fp[10],ps;
int fs,i,j,k,flg1,flg2,x=5,y,pfc=0,ru[10],min;
clrscr();
printf("\n ENTER THE PAGE REFERENCE STRING:");
gets(prs);
printf("\n enter the frame size:");
scanf("%d",&fs);
for(i=0;i<fs;i++)
{
fp[i]='X';
ru[i]=0;
}
clrscr();
printf("\n PAGE REPLACEMENT TECHNIQUE ::LFU ALGORITHM \n");
printf("\n .......................................... \n");
printf("F-Page Fault \t H-Page Hit\n");
for(i=0;i<strlen(prs);i++,x+=5)
{
flg1=0;
ps='F';
for(j=0;j<fs;j++)
{
if(fp[j]==prs[i])
{
ps='H';
(ru[j])++;
flg1=1;
break;
}
}
if(flg1==0)
{
pfc++;
flg2=0;

for(j=0;j<fs;j++)
{
if(fp[j]=='X')
{
fp[j]=prs[i];
ru[j]=1;
flg2=1;
break;
}
}
if(flg2==0)
{

min=0;
for(j=1;j<fs;j++)
{
if(ru[min]>=ru[j])
{
if(ru[min]>ru[j])
min=j;
else
{
for(k=0;k<i;k++)
{
if(prs[k]==fp[min])
break;
if(prs[k]==fp[j])
{
min=j;
break;
}}}}}
fp[min]=prs[i];
ru[min]=1;
}
}
y=5;
gotoxy(x,y);
printf("%c",prs[i]);
y++;
gotoxy(x,y);
printf("-----");
y++;
for(j=0;j<fs;y++,j++)
{
gotoxy(x,y);
printf("%c(%d)",fp[j],ru[j]);
}

y++;
gotoxy(x,y);
printf("-----");
y++;
gotoxy(x,y);
printf("%c",ps);
}
printf("\n\n\n\n\n TOTAL PAGE FAULTS =%d",pfc);
getch();
}

OUTPUT

enter the page referrence string :232152453252

enter frame size :3

2 3 2 1 5 2 4 5 3 2 5 2
-----------------------------------------------------------------------------------------------------
2(1) 2(1) 2(2) 2(2) 2(2) 2(3) 2(3) 2(3) 2(3) 2(4) 2(4) 2(5)
X(0) 3(1) 3(1) 3(1) 5(1) 5(1) 5(2) 5(2) 5(2) 5(2) 5(3) 5(3)
X(0) X(0) X(0) 1(1) 1(1) 1(1) 4(1) 4(1) 3(1) 3(1) 3(1) 3(1)
-----------------------------------------------------------------------------------------------------
F F H F F H F H F H H H

TOTAL PAGE FAULTS = 6

LRU PAGE REPLACEMENT ALGORITHM

#include<dos.h>
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
char prs[40],fp[10],ps;
int fs,i,j,k,flg1,flg2,x=5,y,pfc=0,ru[10],min;
clrscr();
printf("enter the page reference string:");
gets(prs);
printf("enter the frame size:");
scanf("%d",&fs);
for(i=0;i<fs;i++)
{
fp[i]='x';
ru[i]=0;
}
clrscr();
printf("PAGE REPLACEMENT TECHNIQUE::LRU algorithm\n");
printf("-----------------------------------\n");
printf("F-Page fault\tH-Page Hit\n");
for(i=0;i<strlen(prs);i++,x+=2)
{
flg1=0;
ps='F';
for(j=0;j<fs;j++)
{
if(fp[j]==prs[i])
{
ps='H';
ru[j]=i;
flg1=1;
break;
} }
if(flg1==0)
{
pfc++;
flg2=0;
for(j=0;j<fs;j++)
{
if(fp[j]=='X')
{
fp[j]=prs[i];
ru[j]=i;
flg2=1;
break;
} }
if(flg2==0)
{
min=0;
for(j=1;j<fs;j++)
{
if(ru[min]>ru[j])
min=j;
}
fp[min]=prs[i];
ru[min]=i;
} }
y=5;
gotoxy(x,y);
printf("%c",prs[i]);
y++;
gotoxy(x,y);
printf("- -");
y++;
for(j=0;j<fs;y++,j++)
{
gotoxy(x,y);
printf("%c",fp[j]);
}
y++;
gotoxy(x,y);
printf("--");
y++;
gotoxy(x,y);
printf("%c",ps);
}
printf("\n\n\n\n\n\n total page faults=%d",pfc);
getch();
}
OUTPUT:
enter the page referrence string :232152453252
enter frame size :3
2 3 2 1 5 2 4 5 3 2 5 2
---------------------------------------------
2 3 3 3 5 5 5 5 5 5 5 5
X X 2 2 2 2 2 2 3 3 3 3
X X X 1 1 1 4 4 4 2 2 2
---------------------------------------------
F F F F F H F H F F H H
TOTAL NO OFPAGE FAULTS=8
8.Aim: Simulate Paging Technique of memory management.

Description:

• Goal: eliminate external fragmentation

• Each process is a set of fixed size pages
• Pages are stored in same size physical memory “frame”
• Page table connects logical pages with physical frames
• May still have internal fragmentation
• Logical Address: page(p) and displacement/offset (d) in page
• Physical address: frame (f) and displacement/offset (d) in frame
• PTBR: page table base register
• PTLR: page table length register
• Byte ‘g’: logical address =
Page size: 2**n
Logical address space : 2**m
Page number: high-order m-n bits
Page offset: low-order n bits
Page fault details:
• Trap to OS –save user registers and process table
 • Determine that interrupt was a page fault check page reference and location in
disk
• Issue read from the disk to a free frame
• Wait in queue for device
• Wait for seek and /or latency
• Begin transfer
• While waiting, allocate CPU to other user
• Interrupt from the disk
• Save registers and process state of other user
• Determine that interrupt was from disk
• Correct page table
• Wait for CPU to be allocated to this process again
• Restore user registers, process state, new page table
• RESUME execution

PAGING
#include<stdio.h>
#include<conio.h>
#include<math.h>
main()
{
int size,m,n,pgno,pagetable[3]={5,6,7},i,j,frameno;
double m1;
int ra=0,ofs;
clrscr();
printf("Enter process size (in KB of max 12KB):");/*reading memeory size*/
scanf("%d",&size);
m1=size/4;
n=ceil(m1);
printf("Total No. of pages: %d",n);
printf("\nEnter relative address (in hexadecimal notation eg.0XRA) \n");
//printf("The length of relative Address is : 16 bits \n\n The size of offset is :12
bits\n");
scanf("%d",&ra);
pgno=ra/1000; /*calculating physical address*/
 ofs=ra%1000;
printf("page no=%d\n",pgno);
printf("page table");
for(i=0;i<n;i++)
printf("\n %d [%d]",i,pagetable[i]);
frameno=pagetable[pgno];
printf("\n Equivalent physical address : %d%d",frameno,ofs);
getch();
}

Output:
Enter process size(in KB of max 12KB) : 12
Total no. of pages : 3
Enter relative address (in hexadecimal notation eg.0XRA): 2643

Page no=2
Page table
0 [5]
1 [6]
2 [7]
Equivalent physical address: 7643

LAXICAL ANALYSIS
9.Aim:To write a program for dividing the given input program into exemes.
#include<stdio.h>
#include<conio.h>
#include<string.h>
main()
{
int i,j,k,p,c;
char s[120],r[100];
char par[6]={'(',')','{','}','[',']'};
char sym[9]={'.',';',':',',','<','>','?','$','#'};
char key[9][10]={"main","if","else","switch","void","do","while","for","return"};
char dat[4][10]={"int","float","char","double"};
char opr[5]={'*','+','-','/','^'};
FILE *fp;
clrscr();
printf("\n\n\t enter the file name");
scanf("%s",s);
fp=fopen(s,"r");
c=0;
do {
fscanf(fp,"%s",r);
 getch();
for(i=0;i<6;i++)
if(strchr(r,par[i])!=NULL)
printf("\n paranthesis :%c",par[i]);
for(i=0;i<9;i++)
if(strchr(r,sym[i])!=NULL)
printf("\n symbol :%c",sym[i]);
for(i=0;i<9;i++)
if(strstr(r,key[i])!=NULL)
printf("\n keyword :%s",key[i]);
for(i=0;i<4;i++)
if((strstr(r,dat[i])&&(!strstr(r,"printf")))!=NULL)
{
printf("\n data type :%s",dat[i]);
fscanf(fp,"%s",r);
printf("\n identifiers :%s",r);
}
for(i=0;i<5;i++)
if(strchr(r,opr[i])!=NULL)
printf("\n operator :%c",opr[i]);
p=c;
c=ftell(fp);
} while(p!=c);
return 0;}

OUTPUT:

Enter the C program

a+b*c

Ctrl-D

The no’s in the program are:

The keywords and identifiers are:

a is an identifier and terminal

b is an identifier and terminal

c is an identifier and terminal

Special characters are:

+*

Total no. of lines are: 1

10)Implement the Lexical Analyzer Using Lex Tool.

/* program name is lexp.l */

%{
/* program to recognize a c program */
int COMMENT=0;
%}
identifier [a-zA-Z][a-zA-Z0-9]*
%%

#.* { printf("\n%s is a PREPROCESSOR DIRECTIVE",yytext);}

int |
float |
char |
double |
while |
for |
do |
if |
break |
continue |
void |
switch |
case |
long |
struct |
const |
typedef |
return |
else |
goto {printf("\n\t%s is a KEYWORD",yytext);}
"/*" {COMMENT = 1;}
/*{printf("\n\n\t%s is a COMMENT\n",yytext);}*/

"*/" {COMMENT = 0;}

/* printf("\n\n\t%s is a COMMENT\n",yytext);}*/
{identifier}\( {if(!COMMENT)printf("\n\nFUNCTION\n\t%s",yytext);}

\{ {if(!COMMENT) printf("\n BLOCK BEGINS");}

\} {if(!COMMENT) printf("\n BLOCK ENDS");}

{identifier}(\[[0-9]*\])? {if(!COMMENT) printf("\n %s IDENTIFIER",yytext);}

\".*\" {if(!COMMENT) printf("\n\t%s is a STRING",yytext);}

[0-9]+ {if(!COMMENT) printf("\n\t%s is a NUMBER",yytext);}

\)(\;)? {if(!COMMENT) printf("\n\t");ECHO;printf("\n");}

\( ECHO;

= {if(!COMMENT)printf("\n\t%s is an ASSIGNMENT OPERATOR",yytext);}

\<= |
\>= |
\< |
== |
\> {if(!COMMENT) printf("\n\t%s is a RELATIONAL OPERATOR",yytext);}

%%

int main(int argc,char **argv)

{
if (argc > 1)
{
FILE *file;
file = fopen(argv[1],"r");
if(!file)
{
printf("could not open %s \n",argv[1]);
exit(0);
}
yyin = file;
}
yylex();
printf("\n\n");
return 0;
}
int yywrap()
{
return 0;
}

Input:

$vi var.c

#include<stdio.h>
main()
{
int a,b;
}

Output:

$lex lex.l
$cc lex.yy.c
$./a.out var.c

#include<stdio.h> is a PREPROCESSOR DIRECTIVE

FUNCTION

main (

BLOCK BEGINS

int is a KEYWORD

a IDENTIFIER
b IDENTIFIER

BLOCK ENDS
11.Aim: Compute FIRST() and FOLLOW() for the given language

Program:
a) Computation of FIRST(x)

#include<stdio.h>
#include<string.h>
char res[10] = {" "},first[10];
int l=0,count=0,j,term=0;
FILE *fp1;
main()
{
FILE *fp;
int i=0,k=0,n,a[10],set,tem[10]={0},t;
char ch,s;
printf("ENTER THE PRODUCTIONS .. \n");
fp = fopen("input.txt","w");
while(( ch = getchar() )!= EOF)
putc(ch,fp);
fclose(fp);
fp = fopen("input.txt","r");
/* calculation of production starting variables */
while(!(feof(fp)))
{
ch = fgetc(fp); if(feof(fp)) break; first[l++] = ch;
count++;
a[i++] = count;
while(ch!='\n') { count++; ch=fgetc(fp); }
count++;
}
rewind(fp);
n=l;
clrscr();
j=0; l=0;
while(!(feof(fp)))
{ ch = fgetc(fp); if(feof(fp)) break;
while(ch != '\n' )
 {
ch =fgetc(fp);
if(count==1) /* it comes the string after > or | */
{ if( ((ch >= 'a')&& ( ch <= 'z')) || ch == '+' || ch== '-' || ch=='*'||ch=='/'||
ch=='^'||ch==')'||ch=='('||(ch=='^')||(ch=='#'))
{
if(term!=1 || ch!='#')
unione(ch,j++);
if( (term==1) && (ch=='#') ) term=2; /* term=1 represents it is a sub-
production,term=2 means that sub-production has nullvalue*/

count=0; }
else
{ tem[++k] = ftell(fp); set=1; } /* if a non-terminal occurs */
}

if( ch == '>' || ch == '|')

{ count =1; }
if(set==1) /* its a non-terminal production */
{
for(i=0;i<n;i++)
{
fseek(fp,a[i]-1,0); s= fgetc(fp);
if(s==ch) { term=1; break; }
}
count=0;
set=0;
}
}/* while loop for ch!='\n' */
if(tem[k]!=0) /* for retrieving previous production */
{ t = tem[k]-1; tem[k--]= 0;
fseek(fp,t,0);
if(term==2) count=1;
fgetc(fp); ch=fgetc(fp);
if( ( k==0 && term==2) && ( ch=='\n' || ch=='|'))
unione('#',j++);
fseek(fp,t,0);
}
else
j=print();
}
getch();
}
unione(char ch,int j) /* for removing duplicates */
{
int i;
for(i=0;i<j;i++)
if(res[i]==ch)
return;
res[++j] = ch;
}
print() /* for the printing */
{
static int k=0;
if(k==0)
{fp1 = fopen("output.txt","w"); k=1; }
printf(" First[%c] ==",first[l]); fputc(first[l++],fp1);

for(j=0;res[j]!='\0';j++)
{ printf("%c",res[j]);
fputc(res[j],fp1); }
printf("\n");

for(j=0;res[j]!='\0';j++)
res[j]=' ';
count=0; /* it indicates the start of another production */
term=0;
fputc('\n',fp1);
return(0);
}

Input:

Enter the no of productions 2

Enter the productions
E  AA
A +

Output:

FIRST(E) = {+}
FIRST(A) = {+}
Program:
b) Computation of FOLLOW(A)

#include<stdio.h>
#include<conio.h>
char ch,first[10],stack[10];
int i,j,k;
main()
{
FILE *fp;
clrscr();
fp=fopen("in.txt","w");
printf("Enter the productions \n");
while(((ch=getchar())!='@'))
putc(ch,fp);
fclose(fp);
fp=fopen("in.txt","r");
i=0;
while(!(feof(fp)))
{
ch=fgetc(fp);
if(feof(fp))
break;
first[i++]=ch;
while(ch!='\n')
ch=fgetc(fp);
}
rewind(fp);
i=0;j=0;
while(first[i]!='\0')
{
ch=fgetc(fp);
if(ch==first[i])
stack[j]='$';
else
while(!(feof(fp)))
{
while(ch!='>')
ch=fgetc(fp);
while(ch!=first[i])
{
if(feof(fp))
goto down;
ch=fgetc(fp);
}
ch=fgetc(fp);
stack[j]=ch;
down:
j++;
}

print();
i++;
}
getch();
}
print()
{
printf("FOLLOW(%c)={",first[i]);
for(k=0;stack[k]!='\0';k++)
printf("%c",stack[k]);
printf("}\n");
}

Input:

Enter the productions

S->aAc
A->b

Output:

FOLLOW(s)={$}
FOLLOW(A)={c}
Aim: Design Predictive Parser for the given language

Program:

/* Execute first.c and follow.c before compiling this */

#include<stdio.h>
char ter[20];
main()
{
FILE *fp,*fp1,*fp2;
char ch,prod[20],ch1,term1[20],ch2;
int i=0,set=0,j,k=0,row=2;;
fp = fopen("input.txt","r");

ch = fgetc(fp);

/* placing the terminals */

while( !(feof(fp)) )
{
if( set==1 )
if( (ch >= 'a')&&(ch<='z')||(ch=='+')||(ch=='-')||(ch=='*')||(ch=='/')||
(ch=='^')||ch==')'||ch=='(')
unione(ch);
ch=fgetc(fp); if(ch=='>') set=1; if(ch=='\n') set=0;
}
clrscr();
/* include $ into terminals */
for(i=0;ter[i]!='\0';i++); ter[i++] = '$'; ter[i] = '\0';

for(i=0,j=10;ter[i]!='\0';i++,j+=10)
{ gotoxy(j,row);
printf("\t%c",ter[i]); }
printf("\n===============================================
================================");
row++;
printf("\n\n"); row++;
rewind(fp);
j=0; set=1;
while( !(feof(fp)) )
{
ch= fgetc(fp); if(feof(fp)) break;

if(set==1) { printf("%c",ch);}
prod[j++] = ch;

k=0;
if(set==2)
{
 if( (ch >= 'a')&&(ch<='z')||(ch=='+')||(ch=='-')||(ch=='*')||(ch=='/')||
(ch=='^')||(ch=='(') || ch==')')
term1[k++] = ch;
/* if # then follow */
else if(ch=='#')
{
fp2 = fopen("cfollow.txt","r");
while(!(feof(fp2)) )
{
ch2 = fgetc(fp2);
if(ch2==prod[0])
{ ch2 = fgetc(fp2);
while(ch2!='\n')
{ term1[k++] = ch2; ch2 = fgetc(fp2); }
}
} /* while */
}
else

{ fp1 = fopen("output.txt","r");
while(!(feof(fp1)) )
{
if( ch == (ch1=fgetc(fp1)) )
{ set =3; fgetc(fp1); }

if( set==3)
{
while( ch1!='\n' && ch1!='|')
{ if(feof(fp1)) break; ch1=fgetc(fp1);
if( ch1!='\n' && ch1!='|') term1[k++] = ch1; }
term1[k]='\0';
break;
}

}
}
while(ch!='\n' && ch!='|' )
{ ch=fgetc(fp); if( ch!='\n' && ch!='|' ) prod[j++]=ch;}
prod[j]='\0';

/* placing the productions in the respect terminals */

for(k=0,row=row+1;term1[k]!='\0';k++)
for(i=0;ter[i]!='\0';i++)
if(term1[k]==ter[i])
{ gotoxy((i+1)*10+5,row);
for(j=0;prod[j]!='\0';j++)
printf("%c",prod[j]); }
printf("\n");
while(k>0)
 { term1[k] = '\0'; k--; }

}
if(ch=='|')
{ while(prod[j]!='>')
prod[j--]='\0';
j++; set=2; }

else if(ch=='\n')
{ while(j>0) prod[j--]='\0';
printf("------------------------------------------------------------------------------\n");
row++; set=1;
}

if(ch=='>') set=2;

unione(char ch)
{
static int i=0;
int j=0;
for(;j<i;j++)
if(ter[j] == ch)
break;
if(j>=i)
{ ter[j]=ch; i++; }

Input:

E->TA
A->+TA|#
T->FB
B->*FB|#
F->(E)|i

Output:

E (i
A +#
T (i
B *#
F (i

follow.txt

E )$
A )$
T +)$
B +)$
F*+)$

+ * ( ) i $
================================================
E-> E->TA E->TA
------------------------------------------------------------------------
A-> A->TA A-># A->#
------------------------------------------------------------------------
T-> T->FB T->FB
------------------------------------------------------------------------
B-> B-># B->*FB B-># B->#
------------------------------------------------------------------------
F-> F(E) F->i