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
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 Robinb. SJFc. FCFSd. Priority
2. Simulate all file allocation strategiesa. Sequentialb. Indexed c. Linked
3. Simulate MVT and MFT4. Simulate all File Organization Techniques
a. Single level directoryb. Two level c. Hierarchical d. DAG
5. Simulate Bankers algorithm for deadlock avoidance6. Simulate Bankers Algorithm for Deadlock prevention7. Simulate all page replacement algorithms
a. FIFO b. LRUc. LFU Etc. …
8. Simulate Paging Technique of memory management.
Part-B (CD)
1. Lexical Analysis2. Lexical Analyzer using LEX-tool3. Compute FIRST() and FOLLOW() functions for the given language4. Design predictive parser for the given language
1.Aim: Simulate the following CPU scheduling algorithms
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");
}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 jobs3enter the burst times of jobs4 6 5
JOB sert st wt ft turtJ1 4 0 4 0 4J2 5 4 9 4 9J3 6 9 15 9 15avg waiting time=4.33,turnover total time=9.33Program: 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); }
} } } 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 WTprocess-A 5 2 13 8process-B 8 1 8 0process-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 blocks2. disk address or start(base) block and length (in blocks)3. sequential access is easy – read next block4. direct access (seek) is easy 5. logical offset= physical base + offset6. how to fine space for new file7. first-fit: first hole that is big enough8. best fit: smallest hole that is big enough9. external fragmentation10.blocks are available but not sequentially11.internal fragmentation12.pre-allocation of blocks is too large13.left-over amount in last block
Indexed Allocation
1. Indexed: direct access and no fragmentation2. Bring all pointers into one location: the index block(IB)3. Each file has its own IB4. Ith entry in the IB points to the ith block5. Suffers from wasted space(IB may not be full)
Linked Allocation1. solves external fragmentation: can use any block for any file2. solves pre-allocation internal fragmentation3. good for sequential access: chase the pointer4. not effective for direct access5. where is the nth block of the file6. requires space for pointers7. if a pointer is bad, file is lost
}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)
case 4:exit(0);default:printf("INVALID CHOICE");} }while(1);}
OUTPUTSIMULATION OF FILE ALLOCATION METHODSMain Menu1.insertion2.deletion3.retrieval4.exitenter your choice :1 enter file name:q enter length(in kb):12 page table qq 46 12 Main Menu 1.insertion 2.deletion 3.retrieval4.exitenter your choice :1enter file name : wwenter length(in kb):3page tableqq 46 12ww 30 3Main Menu1.insertion2.deletion3.retrieval4.exitenter your choice :3enter file name you want to retrieve ww
blocks allocated are30 31 32Main Menu1.insertion2.deletion3.retrieval4.exitenter your choice :3enter file name you want to delete wwww is deleted successfullyqq 46 12null -1 -1Main Menu1.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);
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 MFTDescription: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++) { 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:");
1) Enter time: 100 Enter no. of jobs: 5 Enter job information 1.jobid 2.jobsize
1 202 253 154 305 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 253 15
5 152) Enter time: 100
Enter no. of jobs: 4 Enter job information 1.jobid 2.jobsize
1 252 303 404 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 252 303 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) {
printf("total internal fragmentation : %d", frag); printf("no. of free blocks: %d" , nb-count); printf("the jobs which are not allocated"); if(count==nj)
Output : Enter total memory space: 100enter choice 1. equal partition 2. unequal partition 2enter no. of blocks: 3enter size of 3 blocks: 50 25 25enter no. of jobs 4enter job information 1.jodid 2. jobsize
1 252 303 264 205 25
total internal fragmentation : 9no. of free blocks : 0the jobs which are not allocated :job id----4 jobsize----20jobid----5 jobsize----25
4.Aim: Simulate all File Organization Techniquesa. Single level directoryb. 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];
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)
Output:Enter the name of the dir file ROOTHo many users :2Enter the name of the dir file: 007How many files :2Enter the name of the dir file007_1Enter the name of the dir file007_2Enter the name of the dir file xxHow many files: 2Enter the name of dir file xx_1Enter the name of dir file xx_2
ROOT
007 xx
007_1
007_2
Xx_1 Xx_2
5.Aim: To simulate banker’s algorithm for deadlock avoidanceDescription: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 AvoidanceAvoid 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 StateSafe 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 - SafeThe sequence is a reducible sequencethe 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++)
6.Aim: To simulate Bankers Algorithm for Deadlock Prevention
Description:
Deadlock DefinitionA 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 PreventionDifference 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,
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++)
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++)
Output:SIMULATION OF DEADLOCK PREVENTIONEnter no. of processes, resources 3, 2enter allocation matrix 2 4 5
3 4 5
Enter max matrix4 3 4 5 6 1
Enter available matrix2 5
Failing : Mutual Exclusionby allocating required resources to process dead is preventedLack of no preemptiondeadlock is prevented by allocating needed resourcesFailing : Hold and Wait conditionBY AVOIDING ONE OF THE ABOVE CONDITION, YOU CAN PREVENT DEADLOCK
7.Aim: To simulate all page replacement algorithmsa. FIFO b. LRUc. 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 : 232152453252enter the frame size: 3 page replacement technique:: FIFO algorithm................................................................................F-page fault H-page hit2 3 2 1 5 2 4 5 3 2 5 2 ----------------------------2 2 2 2 5 5 5 5 3 3 3 3x 3 3 3 3 2 2 2 2 2 5 5 x x x 1 1 1 4 4 4 4 4 2---------------------------F F H F F 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;
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 :232152453252enter frame size :32 3 2 1 5 2 4 5 3 2 5 2 --------------------------------------------- 2 3 3 3 5 5 5 5 5 5 5 5X 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 HTOTAL NO OFPAGE FAULTS=88.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**nLogical address space : 2**mPage number: high-order m-n bitsPage offset: low-order n bitsPage 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);
Output:Enter process size(in KB of max 12KB) : 12Total no. of pages : 3Enter relative address (in hexadecimal notation eg.0XRA): 2643
Page no=2Page table
0 [5]1 [6]2 [7]
Equivalent physical address: 7643
LAXICAL ANALYSIS9.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);
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");
