www.jntuworld.

com

JAWAHARLAL NEHRU TECHNOLOGICAL UNIVERSITY KAKINADA

III Year B. Tech. Computer Science and Engineering I Sem.

OPERATING SYSTEM & COMPILER DESIGN LAB

PART A:
1.
Design a Lexical analyzer for the given language. The lexical analyzer should ignore
redundant spaces, tabs and newlines. It should also ignore comments. Although the
syntax specification states that identifiers can be arbitrarily long, you may restrict the
length to some reasonable value.
2.
Implement the lexical analyzer using JLex, flex or lex or other lexical analyzer
generating tools.
3.
Design Predictive parser for the given language
4.
Design LALR bottom up parser for the given language.
5.
Convert the BNF rules into Yacc form and write code to generate abstract syntax tree.
PART- B:
1.
Simulate the following CPU scheduling algorithms
a) Round Robin b) SJF c) FCFS d) Priority
2.
Simulate all file allocation strategies
a) Sequentialb) 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 Dead Lock Avoidance
6.
Simulate Bankers Algorithm for Dead Lock Prevention
7.
Simulate all page replacement algorithms
a) FIFO b) LRU c) LFU Etc. Q
8.
Simulate Paging Technique of memory management.

R
O

D
L

W
U

T
N

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

TABLE OF CONTENTS
(As per syllabus)
S.N
o
1
2
3

Wee
k

TOPIC

Page
No.

System Requirements

Lab Objectives

Design a lexical analyzer for given language .the lexical

analyzer should ignore redundant spaces, tabs and new lines.
Implement the lexical analyzer using JLex, flex or other
lexical analyzer generating tools.

5
8

4
5

Design predictive parser for the given language

D
L

Design a LALR bottom up parser for the given language

6
7

R
O

Convert the BNF rules into Yacc form and write code to
generate abstract syntax tree.
A program to generate machine code

W
U

T
N

10
11
12
13

14
15
16
17
18

www.jntuworld.com

11
16
18
25

www.jntuworld.com
CD LAB PROGRAMS

System Requirements
1. Intel based destktop PC of 166MHz or faster processor with
at least 64 MB RAM and 100 MB free disk space.
2. C++ compiler and JDK kit.

D
L

R
O

W
U

T
N

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

Lab Objectives
1. To provide an Understanding of the language translation peculiarities by
designing complete translator for mini language.
2. To provide an understanding of the design aspect of operating system.

D
L

R
O

W
U

T
N

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

1)A Program to Design Lexical Analyzer.

#include<string.h>
#include<ctype.h>
#include<stdio.h>
void keyword(char str[10])
{
if(strcmp("for",str)==0||strcmp("while",str)==0||strcmp("do",str)==0||
strcmp("int",str)==0||strcmp("float",str)==0||strcmp("char",str)==0||
strcmp("double",str)==0||strcmp("static",str)==0||strcmp("switch",str)==0||
strcmp("case",str)==0)
printf("\n%s is a keyword",str);
else
printf("\n%s is an identifier",str);
}
main()
{
FILE *f1,*f2,*f3;
char c,str[10],st1[10];
int num[100],lineno=0,tokenvalue=0,i=0,j=0,k=0;
printf("\nEnter the c program");/*gets(st1);*/
f1=fopen("input","w");
while((c=getchar())!=EOF)
putc(c,f1);
fclose(f1);
f1=fopen("input","r");
f2=fopen("identifier","w");
f3=fopen("specialchar","w");
while((c=getc(f1))!=EOF)
{
if(isdigit(c))
{
tokenvalue=c-'0';
c=getc(f1);
while(isdigit(c))
{
tokenvalue*=10+c-'0';
c=getc(f1);
}
num[i++]=tokenvalue;
ungetc(c,f1);
}
else if(isalpha(c))
{
putc(c,f2);
c=getc(f1);

D
L

R
O

W
U

T
N

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

while(isdigit(c)||isalpha(c)||c=='_'||c=='$')
{
putc(c,f2);
c=getc(f1);
}
putc(' ',f2);
ungetc(c,f1);
}
else if(c==' '||c=='\t')
printf(" ");
else if(c=='\n')
lineno++;
else
putc(c,f3);
}
fclose(f2);
fclose(f3);
fclose(f1);
printf("\nThe no's in the program are");
for(j=0;j<i;j++)
printf("%d",num[j]);
printf("\n");
f2=fopen("identifier","r");
k=0;
printf("The keywords and identifiersare:");
while((c=getc(f2))!=EOF)
{
if(c!=' ')
str[k++]=c;
else
{
str[k]='\0';
keyword(str);
k=0;
}
}
fclose(f2);
f3=fopen("specialchar","r");
printf("\nSpecial characters are");
while((c=getc(f3))!=EOF)
printf("%c",c);
printf("\n");
fclose(f3);
printf("Total no. of lines are:%d",lineno);

R
O

D
L

W
U

T
N

}
6

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

Output:
Enter the C program
a+b*c
Ctrl-D
The nos 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

D
L

Special characters are:

+*

R
O

Total no. of lines are: 1

W
U

T
N

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

2)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);}*/

D
L

R
O

W
U

T
N

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

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

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

D
L

%%

R
O

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

W
U

T
N

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

Input:
$vi var.c
#include<stdio.h>
main()
{
int a,b;
}

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

R
O

D
L

#include<stdio.h> is a PREPROCESSOR DIRECTIVE

FUNCTION

W
U

main (
)

T
N

BLOCK BEGINS

int is a KEYWORD

a IDENTIFIER
b IDENTIFIER
BLOCK ENDS

10

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

3) Implementation of Predictive Parser.

#include<stdio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>
#define SIZE 128
#define NONE -1
#define EOS '\0'
#define NUM 257
#define KEYWORD 258
#define ID 259
#define DONE 260
#define MAX 999
char lexemes[MAX];
char buffer[SIZE];
int lastchar=-1;
int lastentry=0;
int tokenval=DONE;
int lineno=1;
int lookahead;
struct entry
{
char *lexptr;
int token;
}symtable[100];
struct entry
keywords[]={"if",KEYWORD,"else",KEYWORD,"for",KEYWORD,"int",KEYWORD,
"float",KEYWORD,"double",KEYWORD,"char",KEYWORD,"struct",KEYWORD,"ret
urn",KEYWORD,0,0};
void Error_Message(char *m)
{
fprintf(stderr,"line %d, %s \n",lineno,m);
exit(1);
}
int look_up(char s[ ])
{
int k;
for(k=lastentry;k>0;k--)
if(strcmp(symtable[k].lexptr,s)==0)
return k;
return 0;
}
int insert(char s[ ],int tok)
{
int len;

D
L

R
O

W
U

T
N

11

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

len=strlen(s);
if(lastentry+1>=MAX)
Error_Message("Symbpl table is full");
if(lastchar+len+1>=MAX)
Error_Message("Lexemes array is full");
lastentry=lastentry+1;
symtable[lastentry].token=tok;
symtable[lastentry].lexptr=&lexemes[lastchar+1];
lastchar=lastchar+len+1;
strcpy(symtable[lastentry].lexptr,s);
return lastentry;
}
/*void Initialize()
{
struct entry *ptr;
for(ptr=keywords;ptr->token;ptr+1)
insert(ptr->lexptr,ptr->token);
}*/
int lexer()
{
int t;
int val,i=0;
while(1)
{
t=getchar();
if(t==' '||t=='\t');
else if(t=='\n')
lineno=lineno+1;
else if(isdigit(t))
{
ungetc(t,stdin);
scanf("%d",&tokenval);
return NUM;
}
else if(isalpha(t))
{
while(isalnum(t))
{
buffer[i]=t;
t=getchar();
i=i+1;
if(i>=SIZE)
Error_Message("Compiler error");
}
buffer[i]=EOS;
if(t!=EOF)

D
L

R
O

W
U

T
N

12

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

ungetc(t,stdin);
val=look_up(buffer);
if(val==0)
val=insert(buffer,ID);
tokenval=val;
return symtable[val].token;
}
else if(t==EOF)
return DONE;
else
{
tokenval=NONE;
return t;
}
}
}
void Match(int t)
{
if(lookahead==t)
lookahead=lexer();
else
Error_Message("Syntax error");
}
void display(int t,int tval)
{
if(t=='+'||t=='-'||t=='*'||t=='/')
printf("\nArithmetic Operator: %c",t);
else if(t==NUM)
printf("\n Number: %d",tval);
else if(t==ID)
printf("\n Identifier: %s",symtable[tval].lexptr);
else
printf("\n Token %d tokenval %d",t,tokenval);
}
void F()
{
//void E();
switch(lookahead)
{
case '(' : Match('(');
E();
Match(')');
break;
case NUM : display(NUM,tokenval);
Match(NUM);
break;

R
O

D
L

W
U

T
N

13

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

case ID : display(ID,tokenval);
Match(ID);
break;
default : Error_Message("Syntax error");
}
}
void T()
{
int t;
F();
while(1)
{
switch(lookahead)
{
case '*' : t=lookahead;
Match(lookahead);
F();
display(t,NONE);
continue;
case '/' : t=lookahead;
Match(lookahead);
display(t,NONE);
continue;
default : return;
}
}
}
void E()
{
int t;
T();
while(1)
{
switch(lookahead)
{
case '+' : t=lookahead;
Match(lookahead);
T();
display(t,NONE);
continue;
case '-' : t=lookahead;
Match(lookahead);
T();
display(t,NONE);
continue;
default : return;

D
L

R
O

W
U

T
N

14

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

}
}
}
void parser()
{
lookahead=lexer();
while(lookahead!=DONE)
{
E();
Match(';');
}
}
main()
{
char ans[10];
printf("\n Program for recursive decent parsing ");
printf("\n Enter the expression ");
printf("And place ; at the end\n");
printf("Press Ctrl-Z to terminate\n");
parser();
}

Output:

R
O

D
L

W
U

Program for recursive decent parsing

Enter the expression And place ; at the end
Press Ctrl-Z to terminate
a+b*c;
Identifier: a
Identifier: b
Identifier: c
Arithmetic Operator: *
Arithmetic Operator: +
2*3;
Number: 2
Number: 3
Arithmetic Operator: *
+3;
line 5,Syntax error
Ctrl-Z

T
N

15

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

4) Design LALR Bottom up Parser .

<parser.l>
%{
#include<stdio.h>
#include "y.tab.h"
%}
%%
[0-9]+ {yylval.dval=atof(yytext);
return DIGIT;
}
\n|.
return yytext[0];
%%

D
L

<parser.y>
%{

R
O

/*This YACC specification file generates the LALR parser for the program
considered in experiment 4.*/
#include<stdio.h>
%}
%union
{
double dval;
}

W
U

T
N

%token <dval> DIGIT

%type <dval> expr
%type <dval> term
%type <dval> factor

%%
line: expr '\n'

{
printf("%g\n",$1);
}

;
expr: expr '+' term
| term
;
term: term '*' factor
| factor
;
factor: '(' expr ')'

{$$=$1 + $3 ;}
{$$=$1 * $3 ;}
{$$=$2 ;}
16

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

| DIGIT
;
%%
int main()
{
yyparse();
}
yyerror(char *s)
{
printf("%s",s);
}

Output:

D
L

$lex parser.l
$yacc d parser.y
$cc lex.yy.c y.tab.c ll lm
$./a.out
2+3
5.0000

R
O

W
U

T
N

17

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

5) Convert The BNF rules into Yacc form and write code to
generate abstract syntax tree.
<int.l>
%{
#include"y.tab.h"
#include<stdio.h>
#include<string.h>
int LineNo=1;
%}
identifier [a-zA-Z][_a-zA-Z0-9]*
number [0-9]+|([0-9]*\.[0-9]+)
%%

D
L

main\(\) return MAIN;

if
else
while

return IF;
return ELSE;
return WHILE;

int |
char |
float

return TYPE;

R
O

W
U

{identifier} {strcpy(yylval.var,yytext);
return VAR;}
{number}
\< |
\> |
\>= |
\<= |
==

T
N

{strcpy(yylval.var,yytext);
return NUM;}

{strcpy(yylval.var,yytext);
return RELOP;}

[ \t] ;
\n LineNo++;
. return yytext[0];
%%

18

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS
<int.y>

%{
#include<string.h>
#include<stdio.h>
struct quad
{
char op[5];
char arg1[10];
char arg2[10];
char result[10];
}QUAD[30];
struct stack
{
int items[100];
int top;
}stk;

D
L

int Index=0,tIndex=0,StNo,Ind,tInd;
extern int LineNo;
%}

R
O

%union
{
char var[10];
}
%token <var> NUM VAR RELOP
%token MAIN IF ELSE WHILE TYPE

W
U

T
N

%type <var> EXPR ASSIGNMENT CONDITION IFST ELSEST WHILELOOP

%left '-' '+'
%left '*' '/'
%%

PROGRAM : MAIN BLOCK

;
BLOCK: '{' CODE '}'
;
CODE: BLOCK
| STATEMENT CODE
| STATEMENT
;
STATEMENT: DESCT ';'
| ASSIGNMENT ';'
19

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

| CONDST
| WHILEST
;
DESCT: TYPE VARLIST
;
VARLIST: VAR ',' VARLIST
| VAR
;
ASSIGNMENT: VAR '=' EXPR{
strcpy(QUAD[Index].op,"=");
strcpy(QUAD[Index].arg1,$3);
strcpy(QUAD[Index].arg2,"");
strcpy(QUAD[Index].result,$1);
strcpy($$,QUAD[Index++].result);
}
;

R
O

D
L

EXPR: EXPR '+' EXPR {AddQuadruple("+",$1,$3,$$);}

| EXPR '-' EXPR {AddQuadruple("-",$1,$3,$$);}
| EXPR '*' EXPR {AddQuadruple("*",$1,$3,$$);}
| EXPR '/' EXPR {AddQuadruple("/",$1,$3,$$);}
| '-' EXPR {AddQuadruple("UMIN",$2,"",$$);}
| '(' EXPR ')' {strcpy($$,$2);}
| VAR
| NUM
;

W
U

T
N

CONDST: IFST{
Ind=pop();
sprintf(QUAD[Ind].result,"%d",Index);
Ind=pop();
sprintf(QUAD[Ind].result,"%d",Index);
}
| IFST ELSEST
;
IFST: IF '(' CONDITION ')' {
strcpy(QUAD[Index].op,"==");
strcpy(QUAD[Index].arg1,$3);
strcpy(QUAD[Index].arg2,"FALSE");
strcpy(QUAD[Index].result,"-1");
push(Index);
Index++;
20

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

}
BLOCK {
strcpy(QUAD[Index].op,"GOTO");
strcpy(QUAD[Index].arg1,"");
strcpy(QUAD[Index].arg2,"");
strcpy(QUAD[Index].result,"-1");
push(Index);
Index++;
}
;
ELSEST: ELSE{
tInd=pop();
Ind=pop();
push(tInd);
sprintf(QUAD[Ind].result,"%d",Index);
}
BLOCK{
Ind=pop();
sprintf(QUAD[Ind].result,"%d",Index);
}
;

D
L

R
O

W
U

CONDITION: VAR RELOP VAR {AddQuadruple($2,$1,$3,$$);

StNo=Index-1;
}
| VAR
| NUM
;
WHILEST: WHILELOOP{
Ind=pop();
sprintf(QUAD[Ind].result,"%d",StNo);
Ind=pop();
sprintf(QUAD[Ind].result,"%d",Index);
}
;
WHILELOOP: WHILE '(' CONDITION ')' {
strcpy(QUAD[Index].op,"==");
strcpy(QUAD[Index].arg1,$3);
strcpy(QUAD[Index].arg2,"FALSE");
strcpy(QUAD[Index].result,"-1");
push(Index);
Index++;
}
BLOCK {

T
N

21

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

strcpy(QUAD[Index].op,"GOTO");
strcpy(QUAD[Index].arg1,"");
strcpy(QUAD[Index].arg2,"");
strcpy(QUAD[Index].result,"-1");
push(Index);
Index++;
}
;
%%
extern FILE *yyin;
int main(int argc,char *argv[])
{
FILE *fp;
int i;
if(argc>1)
{
fp=fopen(argv[1],"r");
if(!fp)
{
printf("\n File not found");
exit(0);
}
yyin=fp;
}
yyparse();
printf("\n\n\t\t ----------------------------""\n\t\t Pos Operator Arg1 Arg2 Result" "\n\t\t
--------------------");
for(i=0;i<Index;i++)
{
printf("\n\t\t %d\t %s\t %s\t %s\t
%s",i,QUAD[i].op,QUAD[i].arg1,QUAD[i].arg2,QUAD[i].result);
}
printf("\n\t\t -----------------------");
printf("\n\n");
return 0;
}
void push(int data)
{
stk.top++;
if(stk.top==100)
{
printf("\n Stack overflow\n");
exit(0);
}
stk.items[stk.top]=data;
}

D
L

R
O

W
U

T
N

22

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

int pop()
{
int data;
if(stk.top==-1)
{
printf("\n Stack underflow\n");
exit(0);
}
data=stk.items[stk.top--];
return data;
}
void AddQuadruple(char op[5],char arg1[10],char arg2[10],char result[10])
{
strcpy(QUAD[Index].op,op);
strcpy(QUAD[Index].arg1,arg1);
strcpy(QUAD[Index].arg2,arg2);
sprintf(QUAD[Index].result,"t%d",tIndex++);
strcpy(result,QUAD[Index++].result);
}
yyerror()
{
printf("\n Error on line no:%d",LineNo);
}

D
L

R
O

W
U

Input:
$vi test.c
main()
{
int a,b,c;
if(a<b)
{
a=a+b;
}
while(a<b)
{
a=a+b;
}
if(a<=b)
{
c=a-b;
}
else
{
c=a+b;

T
N

23

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

}
}

Output:
$lex int.l
$yacc d int.y
$gcc lex.yy.c y.tab.c ll lm
$./a.out test.c
Pos

Operator

Arg1

Arg2

<

==

t1

GOTO

<

==

to

FALSE

FALSE

t2

10
b

t3

t3

10

J
<=

t4

11

==

t4

FALSE

15

12

13

t5

D
L
t1

R
O

W
U

T
N

to

t2

Result

GOTO

14

GOTO

15

16

t6

t5
c
17

t3
c

___________________________________________________
24

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

6) A Program to Generate Machine Code.

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int label[20];
int no=0;
int main()
{
FILE *fp1,*fp2;
char fname[10],op[10],ch;
char operand1[8],operand2[8],result[8];
int i=0,j=0;
printf("\n Enter filename of the intermediate code");
scanf("%s",&fname);
fp1=fopen(fname,"r");
fp2=fopen("target.txt","w");
if(fp1==NULL || fp2==NULL)
{
printf("\n Error opening the file");
exit(0);
}
while(!feof(fp1))
{
fprintf(fp2,"\n");
fscanf(fp1,"%s",op);
i++;
if(check_label(i))
fprintf(fp2,"\nlabel#%d",i);
if(strcmp(op,"print")==0)
{
fscanf(fp1,"%s",result);
fprintf(fp2,"\n\t OUT %s",result);
}
if(strcmp(op,"goto")==0)
{
fscanf(fp1,"%s %s",operand1,operand2);
fprintf(fp2,"\n\t JMP %s,label#%s",operand1,operand2);
label[no++]=atoi(operand2);
}
if(strcmp(op,"[]=")==0)
{
fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n\t STORE %s[%s],%s",operand1,operand2,result);
}
if(strcmp(op,"uminus")==0)

D
L

R
O

W
U

T
N

25

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

{
fscanf(fp1,"%s %s",operand1,result);
fprintf(fp2,"\n\t LOAD -%s,R1",operand1);
fprintf(fp2,"\n\t STORE R1,%s",result);
}
switch(op[0])
{
case '*': fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n \t LOAD",operand1);
fprintf(fp2,"\n \t LOAD %s,R1",operand2);
fprintf(fp2,"\n \t MUL R1,R0");
fprintf(fp2,"\n \t STORE R0,%s",result);
break;
case '+': fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n \t LOAD %s,R0",operand1);
fprintf(fp2,"\n \t LOAD %s,R1",operand2);
fprintf(fp2,"\n \t ADD R1,R0");
fprintf(fp2,"\n \t STORE R0,%s",result);
break;
case '-': fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n \t LOAD %s,R0",operand1);
fprintf(fp2,"\n \t LOAD %s,R1",operand2);
fprintf(fp2,"\n \t SUB R1,R0");
fprintf(fp2,"\n \t STORE R0,%s",result);
break;
case '/': fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n \t LOAD %s,R0",operand1);
fprintf(fp2,"\n \t LOAD %s,R1",operand2);
fprintf(fp2,"\n \t DIV R1,R0");
fprintf(fp2,"\n \t STORE R0,%s",result);
break;
case '%': fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n \t LOAD %s,R0",operand1);
fprintf(fp2,"\n \t LOAD %s,R1",operand2);
fprintf(fp2,"\n \t DIV R1,R0");
fprintf(fp2,"\n \t STORE R0,%s",result);
break;
case '=': fscanf(fp1,"%s %s",operand1,result);
fprintf(fp2,"\n\t STORE %s %s",operand1,result);
break;
case '>': j++;
fscanf(fp1,"%s %s %s",operand1,operand2,result);
fprintf(fp2,"\n \t LOAD %s,R0",operand1);
fprintf(fp2,"\n\t JGT %s,label#%s",operand2,result);
label[no++]=atoi(result);
break;

R
O

D
L

W
U

T
N

26

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

case '<': fscanf(fp1,"%s %s %s",operand1,operand2,result);

fprintf(fp2,"\n \t LOAD %s,R0",operand1);
fprintf(fp2,"\n\t JLT %s,label#%d",operand2,result);
label[no++]=atoi(result);
break;
}
}
fclose(fp2);
fclose(fp1);
fp2=fopen("target.txt","r");
if(fp2==NULL)
{
printf("Error opening the file\n");
exit(0);
}
do
{
ch=fgetc(fp2);
printf("%c",ch);
}while(ch!=EOF);
fclose(fp1);
return 0;
}
int check_label(int k)
{
int i;
for(i=0;i<no;i++)
{
if(k==label[i])
return 1;
}
return 0;
}

D
L

R
O

W
U

T
N

Input:
$vi int.txt
=t1 2

[]=a 0 1
[]=a 1 2
[]=a 2 3
*t1 6 t2
+a[2] t2 t3
27

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

-a[2] t1 t2
/t3 t2 t2
uminus t2 t2
print t2
goto t2 t3
=t3 99
uminus 25 t2
*t2 t3 t3
uminus t1 t1
+t1 t3 t4
print t4

Output:
Enter filename of the intermediate code: int.txt
STORE t1,2
STORE a[0],1
STORE a[1],2
STORE a[2],3

R
O

D
L

LOAD t1,R0
LOAD 6,R1
ADD R1,R0
STORE R0,t3
LOAD a[2],R0
LOAD t2,R1
ADD R1,R0
STORE R0,t3

W
U

T
N

LOAD a[t2],R0
LOAD t1,R1
SUB R1,R0
STORE R0,t2
LOAD t3,R0
LOAD t2,R1
DIV R1,R0
STORE R0,t2
LOAD t2,R1
STORE R1,t2
LOAD t2,R0
JGT 5,label#11

28

www.jntuworld.com

www.jntuworld.com
CD LAB PROGRAMS

Label#11: OUT t2
JMP t2,label#13
Label#13: STORE t3,99
LOAD 25,R1
STORE R1,t2
LOAD t2,R0
LOAD t3,R1
MUL R1,R0
STORE R0,t3
LOAD t1,R1
STORE R1,t1
LOAD t1,R0
LOAD t3,R1
ADD R1,R0
STORE R0,t4
OUT t4

D
L

R
O

W
U

T
N

29

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

PART - B
OPERATING SYSTEMS

Experiment : 1
Simulate the following CPU Scheduling Algorithms
a) FCFS b) SJF c) Round Robin d) Priority

CPU SCHEDULING

Maximum CPU utilization obtained with multiprogramming

CPUI/O Burst Cycle Process execution consists of a cycle of
CPU execution and I/O wait
CPU burst distribution
Alternating Sequence of CPU And I/O Bursts

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

CPU Scheduler

Selects from among the processes in memory that are ready to execute,
and allocates the CPU to one of them

CPU scheduling decisions may take place when a process:

1. Switches from running to waiting state
2. Switches from running to ready state
3. Switches from waiting to ready
4. Terminates

Scheduling under 1 and 4 is nonpreemptive

All other scheduling is preemptive

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

Dispatcher

Dispatcher module gives control of the CPU to the process selected by the
short-term scheduler; this involves:

switching context

switching to user mode

jumping to the proper location in the user
program to restart that program

Dispatch latency time it takes for the dispatcher to stop one process
and start another running

SCHEDULING CRITERIA

CPU utilization keep the CPU as busy as possible

Throughput # of processes that complete their execution per time unit

Turnaround time amount of time to execute a particular process

Waiting time amount of time a process has been waiting in the ready
queue

Response time amount of time it takes from when a request was

submitted until the first response is produced, not output (for time-sharing
environment)
Optimization Criteria
Max CPU utilization
Max throughput
Min turnaround time
Min waiting time
Min response time

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

a) First-Come, First-Served (FCFS) Scheduling

Process
P1
P2
P3

Burst Time
24
3
3

Suppose that the processes arrive in the order: P1 , P2 , P3

The Gantt Chart for the schedule is:
0

24

27

30

Waiting time for P1 = 0; P2 = 24; P3 = 27

Average waiting time: (0 + 24 + 27)/3 = 17
First Come First Serve scheduling algorithm :
Step 1: Assign the first term to each process.
Step2: Take process into consideration
Step 3: Consider next process
Add the previous process first time value to WAT variable
Step4 : Go to step 3 into all the process executed.
Step 5: Calculate average waiting teme =wat variable / no.of process.

b) SHORTEST JOB FIRST ALGORITHM

Step 1: Assign burst time to each process
Step2: Find the minimum burst time among all the burst time.
Execute that process which is having minimum
Initializes 0 to wait variable
Step 3: Find next minimum burst time

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

If the two process having same burst time, consider the first coming
process in to consideration
Add the previous burst time value to wait variable
Continue till all the process are executed

Step 4: Calculate the average waiting time = wat variable / no.of process

Example of Non Preemptive SJF

Process

Arrival Time

Burst Time

P1

0.0

P2

2.0

P3

4.0

P4

3.0

P1
0

P3
8

P2

P4
12

16

Example of Preemptive SJF

Process

Arrival Time

Burst Time

P1

0.0

P2

2.0

P3

4.0

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

P4

3.0

P1
0

P2
2

P3
4

P2
5

P4
7

P1
11

Average waiting time = (9 + 1 + 0 +2)/4 = 3

Round Robin (RR)

Each process gets a small unit of
CPU time (time quantum), usually
10-100 milliseconds. After this time
has elapsed, the process is
preempted and added to the end of
the ready queue.
If there are n processes in the ready
queue and the time quantum is q,
then each process gets 1/n of the
CPU time in chunks of at most q
time units at once. No process

10

www.jntuworld.com

16

www.jntuworld.com

www.jwjobs.net

Example of RR with time quantum=3

Process
aaa
Bbb
Ccc
Ddd
Eee

Burst time
4
3
2
5
1

Round Robin Scheduling Algorithm:

Step1: Assign the burst times to each process
Step2: Input the Quantum time
Step3: Start with burst process
1. If burst time > Quantum time
Burst time of process = burst time of process quantum time
If it is initial process
add 0 to wat
Else
Add quantum to wat
Switch to next process
Else
If first time <=0
Quit that process from quantum
Else
Add burst that process from the variable
2. repeat the steps 3 until all the process
quit from the queue
Step 4: calculate the average waiting time = wat variable / no. of processors.

11

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

INPUT :

enter the process name : aaa

enter the processing time : 4
enter the process name : bbb
enter the processing time : 3
enter the process name : ccc
enter the processing time : 2
enter the process name : ddd
enter the processing time : 5
enter the process name : eee
enter the processing time : 1

Expected Output :

p_name

p_time w_time

aaa

bbb

ccc

ddd

10

eee

11

total waiting time : 39

average waiting time : 7.8000

12

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

Priority Scheduling
A priority number (integer) is associated
with each process
The CPU is allocated to the process with
the highest priority (smallest integer
highest priority)
Preemptive
nonpreemptive

SJF is a priority scheduling where priority

is the predicted next CPU burst time
Problem Starvation low priority
Priority Scheduling Algorithm:
Step1 : Assign burst time and priority value to each process
Step 2: Select highest priority value from the ready queue.
Step 3: if priority value is same to the two or more processors then
Consider the first coming processor and execute that
If it is first processor
Add 0 to the wat variable
Else
Add burst time to the wat variable.
Repeat step 3 until all the processors executed.
Step 4: calculate the average waiting time = wat variable / no. of processors.

13

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

Experiment 2: Simulate all file Allocation strategies:

a) Sequential b) Indexed c) Linked

File Allocation Strategies:

The main problem is how to allocate disk space to the files so that disk space is
utilized effectively band files can be accessed quickly. We have 3 space
allocation method.

1. Contiguous allocation (Sequential)

It requires each file to occupy a set of contiguous blocks on the hard disk
where disk address define a linear ordering on the disk.
Disadvantages:
i.

Difficult for finding space for a new file.

ii.

Internal and external fragmentation will be occurred.

Indexed allocation
In linked allocation it is difficult to maintain FAT so instead of that method
indexed allocation method is used. Indexed allocation method solves all the
problems in the linked allocation by bringing all the pointers together into one
location called index block.

Linked Allocation
Linked allocation of disk space overcomes all the problems of contiguous
allocation. In linked allocation each file is a linked list of disk blocks where the
disk blocks may be scattered anywhere on the disk. The directory contains a
pointer to the first and last blocks of the file.
Disadvantages : Space required to maintain pointers.

14

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

3) Simulate MFT and MVT.

Memory: Multiple Programming with fixed Number of Tasks (MFT)

Algorithm
Background:
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

partition of equal Size
Programs having the Size Less than the partition size are loaded
into Memory
Programs Having Size more then the size of Partitions Size is
rejected
The program having the size less than the partition size will lead to
internal Fragmentation.
If all partitions are allocated and a new program is to be loaded, the
program that lead to Maximum Internal Fragmentation can be
replaced

Specification
Input Step-1
o Memory Size (memsize)
o Partition Size (parsize)
o
Process Step-1




Compute number of partitions (n partitions)

= memsize/parsize
Create a Partition Table having n partition
entries

15

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

Partition
Number

Partition
Size

Process
Number
scheduled
3

Program Size

Internal
Fragment
Size
5

The column 3,4 and 5 initially will be blank

Input Step-2
o Number of Process (n processes) and their Sizes (process Size)
Process Step-3
o Create Process table having nprocesses

Process
Number

Process
Size Pratition
Number
Allocated
2

Partition
Size

Internal
Fragment
Size

Allocated
Flag

Column 3,4,5 and 6 initially will be blank

Process Step-2
o Allocate processes to Pratitions
o If the process Size is>Partition size Allocated Flag = o (over Size)
o If no partition exists Allocated flag =A and calculate the internal fragment
size. Update the process row and Pratition row
Process Step-3
o Print the Process table and Partition table
o
Process step-4
o This step is done a LOOP till the user wants to exist
o Input 1 =Continue,2=Stop
16

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

o If 2 Break
o Read the Size of the Program>partition size then Reject
o If there is a unallocated partition, allocate the a partition and update the
partition and process table
o If no partition is available, select the partition with maximum
fragmentation and update the process table and partition table
o Print process table and partition Table.

Memory: multiple Programming with Varible Number of Tasks (MFT)

Algorithm
Background:
IBM in their Mainframe Operating System OS/MVT implements the MVT
concept. OSIMVT uses Dynamic Partition concept to load programs into Main
memory.
Dynamic Partitioning:
o Initially RAM is portioned according to the of programs to be loaded into
Memory till such time no other program can be loaded.
o The Left over Memory is called a hole which is too small too fit any
process.
o When a new program is to be into Memory Look for the partition, Which
Leads to least External fragmentation and load the Program.
o The space that is not used in a partition is called as External Fragmentation
Specification
Input Step-1
o Memory Size (memsize)
o Number of Processes (n processes)
Input Step-2
o Create Process table having n processes entries

17

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

o
Process
Number

Process
Size

Partition
Size

Partition
Number
Allocation
3

External
Fragmentt
Size
5

Allocated
Flag
6

Column 3,4,5 and 6 initially will be blank

Process Step-2
o For each of the process do the following steps
o Input the process Size.
o Update the process Table with Process number and process size, partition
number and size=0,Allocated Flag=N, fragment size=0
o
Process Step-3
o Create a partitions Table having One Row to start with
o
Partition
Partition
Process
Program
Number
Size
Number
Size
Scheduled
1
2
3
4

External
Fragment
Size
5

Process Step-4
o
o
o
o
o

Available Memory = Memory Size

Partitionnum=0
For each of the process the following steps are undertaken
If Available memory> process Size
If no row Exists
 Create a new row in Partition table
 Partitionnum = Partitionnum+1
 Update a partition equel to the size of the program number,
partition Size, and external fragment=0
 Update the process table with partition number and size
and Allocated Flag = A
 Available Memory = Available Memory Process Size
If a row exists
o Partitionnum=partitionnum+1
o Create a partition equal to the size of the program
18

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

o Update the Partition Table row with partition number,

partition size, process number, process number, process
size, and external fragment = 0
o Update the process table with partition number and size
and
o Allocated Flag =A
o Available Memory = Available Memory Process Size
Process Step-5
o Print the process and table and the hole size
Process step-6
o This step is done in a LOOP till user wants to exist
o Input 1 +continue, 2= stop
If 2 Break
Read the size of New Program
o Processnum = processnum +1
o If available memory>Program Size
o Partitionnum = partitionnum +1
o Create a partition equal to the size of the program
o Update the table row with partition number, partition size,
process number, process size, and external fragment = 0
o Update the process table with partition number and size
and Allocated Flag = A
o Available a memory = Available Memory Process size
If available memory< Program Size
o Find the process row entry, which leads to least External
Fragmentation
o External Fragmentation = Partition size current program size
o Update the partition Table row related to process selected, with
process number, process size, and external table with partition
number and Allocated Flag=A
o Print process table and partition Table

19

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

4) Simulate all File Organization techniques:

a) Single level Directory b)Two level Directory c) Hierarchical d) DAG
File Organization Techniques
Directory Structure :
The file system of computer can be extensive some systems store thousands of
files on hundreds of giga bytes of disk to manage all these data. We need to
organize them. This organization is usually done in two ports. First the file
system is broken into partition. Each disk on system contains at least one
partition, which is a low level structure in which files and directories reside. Each
partition is treated as a separate storage device; where as other systems allow
partitions to be larger than a disk to group disks into one logical structure. In this
way, the user needs to be concerned with only the logical directory and file
structure.
Second, each partition contains information about files within it. This information
is kept in entries in a device directory or volume of table contents. The device
directory records information such as name location size and type for all files on
that partition.
The most common schemes for defining the logical structure of a directory.
Single level directory
The simplest directory structure is the single level directory. All files are
contained in the same directory, which is easy to support and understand.
Directory
Cat Log

Files

Test

Data

Mail

Cont

Single-level directory

20

www.jntuworld.com

Record

www.jntuworld.com

www.jwjobs.net

Two level directory

The major disadvantage to a single-level directory is the confusion of file names

between different users. The standard solution is to create a separate directory for
each user.

In the two-level directory structure, each user has his own user file directory
(UFD). Each UFD has a similar structure but lists only the files of a single user.

Master file directory

Cat Do

Test

User1

User2

Data

User3

User3

Test

Data

Two level directory structure

User file
directory

Tree Structured directories

A two level directory is viewed as a two level tree. The natural generalization
is to extend the directory structure to a tree of arbitrary height. This
generalization allows users to create their own sub directories and to organize
their files accordingly a tree in the most common directory structure. The tree has
root directory, every file on the system has a unique path name.

Spell

Start

Mail

First

Bin

programme

Final

Count

21

www.jntuworld.com

Hex

mail

www.jntuworld.com

www.jwjobs.net

Cat

Do

Test

Record List

5) Simulate Bankers Algorithm for Deadlock Avoidance.

DEAD LOCK AVOIDANCE

Methods for Handling Deadlock
Never let deadlock occur
Prevention: break one of the 4 condition
Avoidance: resources give advance notice of maximum use
Let deadlock occur and do something about it
Detection: search for cycles periodically
Recovery: preempt process or resources
Dont worry about it(UNIX and other OS)
Cheap: just reboot (it happens rarely)

Deadlock: Avoidance

Process give advance notice maximum usage of resources

Process make actual request when they need a resource
Avoidance algorithm: allocate request only if it yields a safe state
Conceptually the process could be run in this order

unsafe

deadlock

safe

22

www.jntuworld.com

final

www.jntuworld.com

www.jwjobs.net

Bankers Algorithm

Multiple instances of resource types IMPLIES cannot use resource

allocation graph
Banks do not allocate cash unless they can satisfy customer needs when a
new process enters the system
Declare in advance maximum need for each resource type
Cannot exceed the total resources of the type
Later, process make actual request for some resources
Otherwise, suspend process until other process release enough resources

Banker: Example
Initially:
Available
A B
10 5

C
7

Later snapshot:
Max

Allocation

Need

Available
P0
P1
P2
P3
P4

ABC
753
322
902
222
433

ABC
010
200
302
211
002

23

www.jntuworld.com

ABC
743
122
600
011
431

ABC
332

www.jntuworld.com

www.jwjobs.net

Safety Algorithm
STEP 1:initialize
Work :=Available;
For I = 1,2.n
Finish[i] = false
STEP 2: find I such that both
a. finish[i] is false
b. need I <=work
if no such I, goto STEP 4
STEP 3:
Work := work+ allocation i
Finish [i] =true
Goto STEP 2
STEP 4:
If finish[i] = true for all I, system is in safe state
Banker: Safety Example

Using the previous Example, P1, P2, P3, P4,P0 satisfies criteria
Max
Allocation
= need
<=
work
Available
ABC
ABC
ABC
ABC
P1
322
200
122
332
P3
222
211
011
P4
433
002
431
P2
902
302
600
P0
753
010
743
7<<<initial system

Resources request Algorithm:

Say P1 request (1, 0, 2)
Compare to Need 1: (1,0, 2) <=(1, 2, 2)

24

www.jntuworld.com

332
532
743
745
10 4 7
10 5

www.jntuworld.com

www.jwjobs.net

Compare to available: (1, 0,2) <= (3, 3, 2)

Pretend to allocate resources:
Max
Allocation
Available
ABC

ABC

Need

ABC

P0
753
010
743
23
0<<<
P1
322
3 0 2<<<
0 2 0<<<
P2
902
302
600
P3
222
211
011
P4
433
002
431
Is this safe? Yes: P1, P3, P4, P0, P2
Can P4 get (3, 3, 0)? No,(3,3,0) > (2, 3, 0) Available
Can P0 get (0, 2, 0)? (0,2, 0) < (2,3, 0) Available
Pretend: Available goes to (2, 1. 0)
But All needs greater than Available than Available IMPLIES NOT SAFE

Expected Output :
enter the no of processes::4
enter the max types of resources::3
enter the claim for the processes::
enter the allocation for the processes::
P1 P2 P3 P4

P1 P2 P3 P4

R1 3 6 3 4

R1 1 6 2 0

R2 2 1 1 2

R2 0 1 1 0

R3 2 3 4 2

R3 0 2 1 2

enter the resource vector::

9
3
6

25

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

enter the available vector::

0
1
1
the system is in a safe state
6) Simulate Bankers Algorithm for Deadlock prevention.
Deadlock: Prevention

Break mutual exclusion:

Read-only files are shareable
But some resources
Are intrinsically non-shareable (printers)
Break hold and wait:
Request all resources in advance
Request (tape, disk, printer)
Release all resources before requesting New batch
Request (tape, disk), release (tape, disk), request (disk, printer)
Disadvantages: low resources utilization, starvation

Deadlock: Prevention
Break no preemption
Process 1 request resources already allocated to process
process I forfeits its current resources
if process 2 is waiting for other resources: process 2 forfeits
used for resources whose state is easily saved / restored
CPU registers and memory space
Break circular wait
Process request resources in increasing
Order
Expected Output :
enter the no of processes::4
enter the max types of resources::3

26

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

enter the claim matrix and allocation matrix::

P1 P2 P3 P4

P1 P2 P3 P4

R1 3 6 3 4

R1 1 6 2 0

R2 2 1 1 2

R2 0 1 1 0

R3 2 3 4 2

R3 0 2 1 2

enter the resource vector::

9
3
6
enter the available vector::
0
1
1
the process p1 claims resources within system limit
the allocated resources are within claim limit
the process p2 claims resources within system limit
the allocated resources are within claim limit
the process p3 claims resources within system limit
the allocated resources are within claim limit
the process p4 claims resources within system limit
the allocated resources are within claim limit
No error in count of resources r1
No error in count of resources r2
No error in count of resources r3

27

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

7) Simulate all page replacement algorithms:

a) FIFO b) LRU c) LFU

Page Replacement Algorithms

FIFO algorithm:
The simpler page replacement algorithm is a FIFO algorithm. A FIFO
replacement algorithm associates with each page the time when that page was
brought into memory. When a page must be replace, the oldest page is chosen.
We can create a FIFO queue to hold all pages in memory. We replace the page at
the head of the queue when a page is brought into memory; we insert it at the tail
of the queue.

7
7

0
7
0

1
7
0
1

2
2
0
1

3
2
3
4

0
2
3
0

4
4
3
0

2
4
2
0

3
4
2
3

0
0
2
3

1
0
1
3

2
0
1
2

7
7
1
2

0
7
0
2

1
7
0
1

LFU algorithm:
The least frequently used (LFU) page replacement algorithm requires that the
page with the smallest count be replaced. The reason for this selection is that an
actively used page should have a large reference occurs.

28

www.jntuworld.com

www.jntuworld.com

www.jwjobs.net

8) Simulate Paging Technique of memory management

PAGING

Logical address space of a process can be

noncontiguous; process is allocated physical memory
whenever the latter is available
Divide physical memory into fixed-sized blocks called frames
(size is power of 2, between 512 bytes and 8,192
bytes)
Divide logical memory into blocks of same size called pages
Keep track of all free frames
To run a program of size n pages, need to find n free
frames and load program
Set up a page table to translate logical to physical addresses
Internal fragmentation

29

www.jntuworld.com