OS CD LAB MANUAL

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

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

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

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

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

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;

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

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;

} } } 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

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_ 1 007_ 2 Xx_1 Xx_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

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 3 2 2 6 1 3 3 1 4

enter allocation matrix 1 0 0

6 1 2 2 1 1

enter resource vector 9 3 6 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 1 0 0

6 1 2 2 1 1

enter resource vector 9 3 6 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 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.

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

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

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 ---F H ---F ---F ---F ---F H ---F H ---F ---F total page faults=9

LFU PAGE REPLACEMENT ALGORITHM

#include<dos.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); }

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:

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

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 {

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

+ *

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