Ncs-451 Lab Manual

NCS-451/JP/ 1

Meerut Institute of Technology, Meerut

Department of Computer Science & Engineering

LAB MANUAL

Lab Name: Operating System

Lab Code: NCS-451

Jyotirmay Patel

NCS-451/JP/ 2

Operating System (NCS-451)

List of Experiment

S.No. Program Page No.

1. Testing the Linux /Unix Commands.

5

2. Getting familiar with vi editor and environment.

10

3. Write a C program to simulate FCFS CPU scheduling algorithm.

14

4. Write a C program to simulate SJF CPU scheduling algorithm.

20

5. Write a C program to simulate Priority CPU scheduling algorithm

27

6. Write a C program to simulate Round Robin CPU scheduling

algorithm.

33

7. Write a C program to simulate Bankers algorithm for deadlock

avoidance.

40

8. Write a C program to simulate FIFO Page replacement algorithm.

50

9. Write a C program to simulate LRU Page replacement algorithm

55

10. Write a C program to simulate FCFS disk scheduling algorithm.

61

11. Write a C program to simulate SSTF disk scheduling algorithm.

66

NCS-451/JP/ 3

Hardware/Software Requirements

Hardware:

1. 700 MHz processor (about Intel Celeron or better) 2. 512 MB RAM (system memory) 3. 5 GB of hard-drive space (or USB stick, memory card or external

drive but see LiveCD for an alternative approach)

4. VGA capable of 1024x768 screen resolution 5. Either a CD/DVD drive or a USB port for the installer media

Software:

Ubuntu Desktop OS latest release/ Windows XP/7, Turbo C++ Compiler

Latest Version

NCS-451/JP/ 4

Objective of the Lab

1. To familiarize the learners with the Operating System.

2. To introduce LINUX basic commands

3. To get familiarize with vi editor.

4. To make students how to make simple programs in LINUX

5. To implement different CPU scheduling algorithms in C

6. To implement different page replacement algorithms in C

7. To implement Banker algorithms in C

NCS-451/JP/ 5

Linux Commands

These commands will work with most (if not all) distributions of Linux as well as most

implementations of UNIX. These are commonly use commands.

Index

1. Navigation - how to get around

o cd - changing directories

o ls - listing files

o pwd - knowing where you are

2. File Management - who needs a graphical file manager?

o cp - copying files

o ln - creating symbolic links

o mv - moving and renaming files

o rm - removing files

3. Monitoring Your System - to satisfy your insatiable curiosity

o tail - follow a file as it grows

o top - a program to see how your memory and CPU are holding up

o w - look at who's logged on

4. Shutting Down and Rebooting - you better know this, though you may not use it a lot

Navigation

Navigating around the files and directories of your hard drive could be a dreaded task for

you, but it is necessary knowledge. If you were a user of command prompt interfaces such as

MS-DOS, you'll have little trouble adjusting. You'll only need to learn a few new commands.

If you're used to navigating using a graphical file manager, I don't know how it'll be like, but

some concepts might require a little more clarification. Or maybe it'll be easier for you. Who

knows? Everyone is different.

cd

As you might already have guessed, the cd command changes directories. It's a very common

navigation command that you'll end up using, just like you might have done in MS-DOS.

You must put a space between cd and the ".." or else it won't work; Linux doesn't see the two

dots as an extension to the cd command, but rather a different command altogether. It'll come

to make sense if it doesn't already.

NCS-451/JP/ 6

ls

The ls letters stand for list. It basically works the same way as the dir command in DOS.

Only being a Unix command, you can do more with it. :-)

Typing ls will give you a listing of all the files in the current directory. If you're new to

Linux, chances are that the directories you are commonly in will be empty, and after the ls

command is run, you aren't given any information and will just be returned to the command

prompt (the shell).

There are "hidden" files in Linux, too. Their file names start with a dot, and doing a normal ls

won't show them in a directory. Many configuration files start with a dot on their file names

because they would only get in the way of users who would like to see more commonly used

items. To view hidden files, use the -a flag with the ls command, i.e. ls -a.

To view more information about the files in a directory, use the -l flag with ls. It will show

the file permissions as well as the file size, which are probably what are the most useful

things to know about files.

You might occasionally want to have a listing of all the subdirectories, also. A simple -R flag

will do, so you could look upon ls -R as a rough equivalent of the dir /s command in MS-

DOS.

You can put flags together, so to view all the files in a directory, show their permissions/size,

and view all the files that way through the subdirectories, you could type ls -laR.

pwd

This command simply shows what directory you're in at the moment. It stands for "Print

Working Directory". It's useful for scripting in case you might ever want to refer to your

current directory.

NCS-451/JP/ 7

File Management

A lot of people, surprisingly for me, prefer to use graphical file managers. Fortunately for me,

I wasn't spoiled like that and used commands in DOS. That made it a bit easier for me to

make the transition to Linux. Most of the file management Linux gurus do is through the

command line, so if you learn to use the commands, you can brag that you're a guru. Well,

almost.

cp

Copying works very much the same. The cp command can be used just like the MS-DOS

copy command, only remember that directories are separated with slashes (/) instead of

backslashes (\). So a basic command line is just cp filename1 filename2.

There are other extensions to the cp command. You can use the -f command to force it. You

can use the -p command to preserve the permissions (and also who owns the file, but I'm not

sure).

You can move an entire directory to its new destination. Let's say you want to copy a

directory (and all of its contents) from where you are to be /home/jack/newdirectory/. You

would type cp -rpf olddirectory /home/jack/newdirectory. To issue this command you

would have to be in the directory where the subdirectory "olddirectory" is actually located.

ln

A feature of linking files is available in Linux. It works by "redirecting" a file to the actual

file. It's referred to as a symbolic link. Don't confuse this term with the linking of programs,

which is when binary programs are connected with libraries that they need to load in order to

run.

The most simple way that I've ever used ln to create symbolic links is ln -s existing_file link.

Evidently there's a hard link and a symbolic link; I've been using a symbolic link all along.

You can also use the -f flag to force the command line to overwrite anything that might have

the symbolic link's file name already.

To remove a symbolic link, simply type rm symbolic_link. It won't remove the file that it's

linked to.

mv

The mv command can be used both to move files and to rename them. The syntax is mv

fileone filetwo, where "fileone" is the original file name and "filetwo" will be the new file

name.

NCS-451/JP/ 8

You can't move a directory that is located in one partition to another, unfortunately. You can

copy it, though, using cp -rpf, and then remove it with rm -rf later on. If you have only a

single partition that makes up your filesystem then you have very little to worry about in this

area.

rm

The rm command is used for removing files. You use it just like the del or delete command

in MS-DOS. Let's say you want to remove a file called foobar in your current directory. To

do that, simply type rm foobar. Note that there is no "Recycle Bin" like in Windows 95. So

when you delete a file, it's gone for good.

To delete something in some other directory, use the full path as the file name. For example,

if you want to delete a file called "windows" that's in the directory /usr/local/src/, you would

type rm /usr/local/src/windows.

To remove an entire directory and its contents, type rm -rf /directory where "/directory" is

the path to the directory that you want to delete. If you're wondering, the "rf" stands for

"recursive" and "force". Be very careful with this command, as it can wreak havoc easily if

misused.

Monitoring Your System

An important part of system administration (especially with your own system) is being able

to know what's going on.

tail

The program tail allows you to follow a file as it is growing. Most often, I use it to follow

/var/log/messages. I do that by typing tail -f /var/log/messages. Of course, you can use

anything else, including the other logs in /var/log/. Another file you may want to keep an eye

out for is /var/log/secure.

If you want to leave that running all the time, I recommend having some sort of terminal

program in X, logged in as root through su.

Another program you may want to look at is head. It monitors the top of the file specified,

instead of the bottom.

NCS-451/JP/ 9

top

This program shows a lot of stuff that goes on with your system. In the program, you can

type:

1. M for memory usage information

2. P for CPU information

3. q to quit

Once you try it, you can see that top shows you the memory usage, uptime, load average,

CPU states, and processes.

w

Typing w will tell you who is logged in. This can be helpful if you're the only one who uses

your computer and you see someone logged in that's not supposed to be.

Another alternative is who.

Shutting Down and Rebooting

To shut down your system, type shutdown -h now, which tells the shutdown

program to begin system halt immediately. You can also tell it to halt the system at a later

time, I think, but you'll have to consult the shutdown manual page for that (man shutdown).

To do a reboot, you can either type reboot or shutdown -r. You can also use the

famous Ctrl-Alt-Delete combination to reboot, which you might already be familiar with.

Shutting down and restarting properly (as described above) will prevent your

filesystem from being damaged. Filesystem damage is the most obvious of the consequences,

but there are probably other things out there that I don't know about. The point is, shut down

your system properly.

There are (rare!) cases in which the machine might lock up entirely, and prevent you

from being able to access a command prompt. Only then will your last resort be to do a

forced reboot (just pressing the restart button on the case).

NCS-451/JP/ 10

vi Editor Commands

General Startup

To use vi: vi filename

To exit vi and save changes: ZZ or :wq

To exit vi without saving changes: :q!

To enter vi command mode: [esc]

Counts

A number preceding any vi command tells vi to

repeat that command that many times.

Cursor Movement

h move left (backspace)

j move down

k move up

l move right (spacebar

[return] move to the beginning of the next line

$ last column on the current line

0 move cursor to the first column on the

current line

^ move cursor to first nonblank column on the

current line

w move to the beginning of the next word or

punctuation mark

W move past the next space

b move to the beginning of the previous word

or punctuation mark

NCS-451/JP/ 11

B move to the beginning of the previous word,

ignores punctuation

e end of next word or punctuation mark

E end of next word, ignoring punctuation

H move cursor to the top of the screen

M move cursor to the middle of the screen

L move cursor to the bottom of the screen

Screen Movement

G move to the last line in the file

xG move to line x

z+ move current line to top of screen

z move current line to the middle of screen

z- move current line to the bottom of screen

^F move forward one screen

^B move backward one line

^D move forward one half screen

^U move backward one half screen

^R redraw screen

( does not work with VT100 type terminals )

Inserting

r replace character under cursor with next

character typed

R keep replacing character until [esc] is hit

i insert before cursor

a append after cursor

NCS-451/JP/ 12

A append at end of line

O open line above cursor and enter append mode

Deleting

x delete character under cursor

dd delete line under cursor

dw delete word under cursor

db delete word before cursor

Copying Code

yy (yank)'copies' line which may then be put by

the p(put) command. Precede with a count for

multiple lines.

Put Command

brings back previous deletion or yank of lines,

words, or characters

P bring back before cursor

p bring back after cursor

Find Commands

? finds a word going backwards

/ finds a word going forwards

f finds a character on the line under the

cursor going forward

F finds a character on the line under the

cursor going backwards

t find a character on the current line going

forward and stop one character before it

T find a character on the current line going

backward and stop one character before it

; repeat last f, F, t, T

NCS-451/JP/ 13

Miscellaneous Commands

. repeat last command

u undoes last command issued

U undoes all commands on one line

xp deletes first character and inserts after

second (swap)

J join current line with the next line

^G display current line number

% if at one parenthesis, will jump to its mate

mx mark current line with character x

'x find line marked with character x

NOTE: Marks are internal and not written to the

file.

Line Editor Mode

Any commands form the line editor ex can be

issued upon entering line mode.

To enter: type ':'

To exit: press[return] or [esc]

NCS-451/JP/ 14

PROGRAM 01

STATEMENT OF THE PROBLEM: TO WRITE A C PROGRAM FOR IMPLEMENTING FIRST COME FIRST SERVE ALGORITHM.

Concept: Perhaps, First-Come-First-Served algorithm is the simplest scheduling algorithm is the simplest scheduling algorithm. Processes are dispatched according to their arrival time on the ready

queue. Being a nonpreemptive discipline, once a process has a CPU, it runs to completion. The FCFS

scheduling is fair in the formal sense or human sense of fairness but it is unfair in the sense that long

jobs make short jobs wait and unimportant jobs make important jobs wait.

FCFS is more predictable than most of other schemes since it offers time. FCFS scheme is not

useful in scheduling interactive users because it cannot guarantee good response time. The code for

FCFS scheduling is simple to write and understand. One of the major drawback of this scheme is that

the average time is often quite long.

The First-Come-First-Served algorithm is rarely used as a master scheme in modern

operating systems but it is often embedded within other schemes.

Source code:

#include

#include

void main()

{

int n,i,j,sum=0;

int arrv[10], ser[10], start[10], finish[10],wait[10], turn[10];

float avgturn=0.0,avgwait=0.0;

start[0]=0;

clrscr();

printf("\n ENTER THE NO. OF PROCESSES:");

scanf("%d",&n);

NCS-451/JP/ 15

for(i=0;i

NCS-451/JP/ 16

printf("\n PROCESS ARRIVAL SERVICE START FINISH WAIT TURN \n");

for(i=0;i

NCS-451/JP/ 17

FCFS CPU Scheduling Output:

ENTER THE NO. OF PROCESSES:3

ENTER THE ARRIVAL TIME AND SERVICE TIME OF PROCESS 1: 0

3


3


2

PROCESS ARRIVAL SERVICE START FINISH WAIT TURN

P0 0 3 0 3 0 3

P1 1 3 3 6 3 6

P2 2 2 6 8 6 8

AVERAGE WAITING TIME = 3.000000 tu

AVERAGE TURN AROUND TIME = 5.666667 tu

NCS-451/JP/ 18



2


2


5


6


P0 1 2 0 2 0 2

P1 3 2 2 4 2 4

P2 1 5 4 9 4 9

P3 4 6 9 15 9 15



NCS-451/JP/ 19



2


5


6


6


3


P0 1 2 0 2 0 2

P1 3 5 2 7 2 7

P2 2 6 7 13 7 13

P3 3 6 13 19 13 19

P4 5 3 19 22 19 22



NCS-451/JP/ 20

PROGRAM 02

STATEMENT OF THE PROBLEM: TO WRITE A C PROGRAM FOR IMPLEMENTING SHORTEST JOB FIRST ALGORITHM.

Concept: Shortest-Job-First (SJF) is a non-preemptive discipline in which waiting job (or process) with the smallest estimated run-time-to-completion is run next. In other words, when CPU is

available, it is assigned to the process that has smallest next CPU burst. The SJF scheduling is

especially appropriate for batch jobs for which the run times are known in advance. Since the SJF

scheduling algorithm gives the minimum average time for a given set of processes, it is probably

optimal.

The SJF algorithm favors short jobs (or processors) at the expense of longer ones. The obvious

problem with SJF scheme is that it requires precise knowledge of how long a job or process will run,

and this information is not usually available. The best SJF algorithm can do is to rely on user

estimates of run times.

Source code:

#include

#include

void main()

{

int n,i,j,temp1,temp2,sum=0;

int pro[10],arrv[10],ser[10],start[10],finish[10],wait[10],

turn[10];


start[0]=0;

clrscr();

NCS-451/JP/ 21


scanf("%d",&n);

for(i=0;i

NCS-451/JP/ 22

temp2=arrv[j];

arrv[j]=arrv[j+1];

arrv[j+1]=temp2;

}

}

}

for(i=0;i

NCS-451/JP/ 23

}

for(i=0;i

NCS-451/JP/ 24

SJF CPU Scheduling Output:


ENTER THE ARRIVAL TIME AND SERVICE TIME OF PROCESS 1:5

9


4


6


P0 2 4 0 4 0 4

P1 5 6 4 10 4 10

P2 5 9 10 19 10 19



NCS-451/JP/ 25



3


1


3


2


P0 9 1 0 1 0 1

P1 5 2 1 3 1 3

P2 2 3 3 6 3 6

P3 3 3 6 9 6 9



NCS-451/JP/ 26



5


3


5


1


2


P0 6 1 0 1 0 1

P1 5 2 1 3 1 3

P2 2 3 3 6 3 6

P3 1 5 6 11 6 11

P4 4 5 11 16 11 16



NCS-451/JP/ 27

PROGRAM 03

STATEMENT OF THE PROBLEM: TO WRITE A C PROGRAM FOR IMPLEMENTING

PRIORITY SCHEDULING ALGORITHM.

Concept: Each process is assigned a priority, and priority is allowed to run. Equal-Priority processes are scheduled in FCFS order. The shortest-Job-First (SJF) algorithm is a special case of

general priority scheduling algorithm.

Source code :

#include

#include

void main()

{

int n,i,j,temp1,temp2,sum=0;

int pro[10],ser[10],start[10],finish[10],wait[10],prior[10], turn[10];


start[0]=0;

clrscr();


scanf("%d",&n);

for(i=0;i

NCS-451/JP/ 28

}

for(i=0;i

NCS-451/JP/ 29

for(i=0;i

NCS-451/JP/ 30

Priority CPU Scheduling Output:


ENTER THE SERVICE TIME AND PRIORITY OF PROCESS1:4

2


5


4

PROCESS SERVICE PRIORITY START FINISH WAIT TURN

P0 4 2 0 4 0 4

P1 3 4 4 7 4 7

P2 1 5 7 8 7 8



NCS-451/JP/ 31



3


5


6


4


P0 1 3 0 1 0 1

P1 3 4 1 4 1 4

P2 3 5 4 7 4 7

P3 2 6 7 9 7 9



NCS-451/JP/ 32



2


6


6


7


4


P0 4 2 0 4 0 4

P1 3 4 4 7 4 7

P2 3 6 7 10 7 10

P3 1 6 10 11 10 11

P4 2 7 11 13 11 13



NCS-451/JP/ 33

PROGRAM 04


ROUND ROBIN SCHEDULING ALGORITHM.

Concept: In the round robin scheduling, processes are dispatched in a FIFO manner but are given a limited amount of CPU time called a time-slice or a quantum. If a process does not complete

before its CPU-time expires, the CPU is preempted and given to the next process waiting in a queue.

The preempted process is then placed at the back of the ready list.

Round Robin Scheduling is preemptive (at the end of time-slice) therefore it is effective in

time-sharing environments in which the system needs to guarantee reasonable response times for

interactive users. The only interesting issue with round robin scheme is the length of the quantum.

Setting the quantum too short causes too many context switches and lower the CPU efficiency. On

the other hand, setting the quantum too long may cause poor response time and appoximates FCFS.

Source code :

#include

#include

void main()

{

int count=0,swt=0,stat=0,i,temp,sq=0;

int pro[10],st[10],bt[10],wt[10],tat[10],n,tq;

float atat=0.0,awt=0.0;

clrscr();


scanf("%d",&n);

for(i=0;i

NCS-451/JP/ 34

{

printf("\n ENTER THE SERVICE TIME OF PROCESS %d:",i);

scanf("%d",&bt[i]);

st[i]=bt[i];

pro[i]=i;

}

printf("\n ENTER THE TIME QUANTUM:");

scanf("%d",&tq);

while(1)

{

for(i=0,count=0;itq)

st[i]=st[i]-tq;

NCS-451/JP/ 35

else

if(st[i]>=0)

{

temp=st[i];

st[i]=0;

}

sq=sq+temp;

tat[i]=sq;

}

if(count==n)

break;

}

for(i=0;i

NCS-451/JP/ 36

printf("\n PROCESS BURST TIME WAIT TURN \n");

for(i=0;i

NCS-451/JP/ 37

Round Robin CPU Scheduling Output:


ENTER THE SERVICE TIME OF PROCESS 0:30



ENTER THE TIME QUANTUM:10

PROCESS BURST TIME WAIT TURN

P0 30 40 70

P1 40 50 90

P2 20 40 60



NCS-451/JP/ 38








P0 12 24 36

P1 20 26 46

P2 9 25 34

P3 5 15 20



NCS-451/JP/ 39









P0 22 43 65

P1 11 26 37

P2 34 47 81

P3 2 18 20

P4 12 37 49



NCS-451/JP/ 40

PROGRAM 05

STATEMENT OF THE PROBLEM: TO WRITE A C PROGRAM FOR IMPLEMENTING BANKERS ALGORITHM.

Concept: This approach to the deadlock problem anticipates deadlock before it actually occurs. This approach employs an algorithm to access the possibility that deadlock could occur and acting accordingly. This method differs from deadlock prevention, which guarantees that deadlock cannot occur by denying one of the necessary conditions of deadlock.

If the necessary conditions for a deadlock are in place, it is still possible to avoid deadlock by being careful when resources are allocated. Perhaps the most famous deadlock avoidance algorithm, due to Dijkstra, is the Bankers algorithm. So named because the process is analogous to that used by a banker in deciding if a loan can be safely made.

The Banker's algorithm considers each request as it occurs, and see if granting it leads to a safe state. If it does, the request is granted, otherwise, it postponed until later.

SOURCE CODE:

#include

#include

void main()

{

int clm[7][5],req[7][5],alloc[7][5],rsrc[5],avail[5],comp[7];

int first,p,r,i,j,prc,count,t;

clrscr();

count=0;

for(i=1;i

NCS-451/JP/ 41

comp[i]=0;

printf("Enter the no of processes : ");

scanf("%d",&p);

printf("Enter the no of resource types : ");

scanf("%d",&r);

printf("Enter the claim for each process :\n");

for(i=1;i

NCS-451/JP/ 42

scanf("%d",&alloc[i][j]);

}

}

printf("Enter total no of each resource : ");

for(j=1;j

NCS-451/JP/ 43

req[i][j]=clm[i][j]-alloc[i][j];

}

}

printf("\nClaim matrix:\tAllocation matrix:\tRequest

matrix:\n");

for(i=1;i

NCS-451/JP/ 44

}

printf("\nAvailable resources are : ");

for(j=1;j

NCS-451/JP/ 45

}

if(prc!=0)

{

printf("\nProcess %d runs to completion!",prc);

count++;

for(j=1;j

NCS-451/JP/ 46

Banker Algorithm Output

Enter the no of processes : 3

Enter the no of resource types : 4

Enter the claim for each process :

For process 1 : 2

1

3

4

For process 2 : 5

6

7

2

For process 3 : 3

4

5

6

Enter the allocation for each process :

For process 1 : 2

3

4

5

For process 2 : 6

1

2

3

For process 3 : 4

NCS-451/JP/ 47

2

3

4

Enter total no of each resource : 1

8

9

4

Claim matrix: Allocation matrix: Request matrix:

2 1 3 4 2 3 4 5 0-2-1-1

5 6 7 2 6 1 2 3 -1 5 5-1

3 4 5 6 4 2 3 4 -1 2 2 2

Available resources are : -11 2 0 -8

The system is in an unsafe state!!

NCS-451/JP/ 48

Enter the no of processes : 3

Enter the no of resource types : 2

Enter the claim for each process :

For process 1 : 2

3

For process 2 : 1

2

For process 3 : 2

3

Enter the allocation for each process :

For process 1 : 1

1

For process 2 : 1

1

For process 3 : 0

1

Enter total no of each resource : 6

7


2 3 1 1 1 2

1 2 1 1 0 1

2 3 0 1 2 2

Available resources are : 4 4

Process 1 runs to completion!


NCS-451/JP/ 49

0 0 0 0 0 0

1 2 1 1 0 1

2 3 0 1 2 2




0 0 0 0 0 0

0 0 0 0 0 0

2 3 0 1 2 2




0 0 0 0 0 0

0 0 0 0 0 0

0 0 0 0 0 0


The system is in a safe state!!

NCS-451/JP/ 50

PROGRAM 06


FIRST IN FIRST OUT PAGE REPLACEMENT ALGORITHM.

Concept: The simplest page-replacement algorithm is a FIFO algorithm. 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 oldest

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.

Source code:

#include

#include

void main()

{ int i,j,n,a[50],frame[10],no,k,avail,count=0;

clrscr();

printf("\n ENTER THE NO. OF PAGES: ");

scanf("%d",&n);

printf("\n ENTER THE PAGE Reference String.: ");

for(i=1;i

NCS-451/JP/ 51

j=0;

printf("\n REF. STRING \t PAGE FRAMES\n");

for(i=1;i

NCS-451/JP/ 52

FIFO Page Replacement Algorithm Output

ENTER THE NO. OF PAGES: 5

ENTER THE PAGE Reference String.: 1

2

3

4

2

ENTER THE NO. OF FRAMES: 3

REF. STRING PAGE FRAMES

1 1 -1 -1

2 1 2 -1

3 1 2 3

4 4 2 3

2

NO. OF PAGE FAULTS : 4

NCS-451/JP/ 53



2

3

1

2

3

4



1 1 -1 -1

2 1 2 -1

3 1 2 3

1

2

3

4 4 2 3

NO. OF PAGE FAULTS : 4

NCS-451/JP/ 54



2

2

2

2

2



2 2 -1 -1

2

2

2

2

2

NO. OF PAGE FAULTS: 1

NCS-451/JP/ 55

PROGRAM 07


LEAST RECENTLY USED PAGE REPLACEMENT ALGORITHM.

Concept: The Least Recently Used replacement policy chooses to replace the page which has not been referenced for the longest time. This policy assumes the recent past will approximate the

immediate future. The operating system keeps track of when each page was referenced by recording

the time of reference or by maintaining a stack of references.

Source code :

#include

void main()

{

int q[20],p[50],c=0,c1,d,f,i,j,k=0,n,r,t,b[20],c2[20];

printf("Enter no of pages:");

scanf("%d",&n);

printf("Enter the reference string:");

for(i=0;i

NCS-451/JP/ 56

c1=0;

for(j=0;j

NCS-451/JP/ 57

break;

}

}

for(r=0;r

NCS-451/JP/ 58

LRU Page Replacement Algorithm Output

Enter no of pages:4

Enter the reference string:2

3

1

2

Enter no of frames:2

2

2 3

1 3

1 2

The no of page faults is : 4

NCS-451/JP/ 59

Enter no of pages:7


2

3

2

4

2

5


1

1 3

1 3 2

4 3 2

4 5 2


NCS-451/JP/ 60

Enter no of pages:8


2

1

2

3

1

2

3


1

1 2

3 2

3 1

2 1

2 3


NCS-451/JP/ 61

PROGRAM 8

STATEMENT OF THE PROBLEM: TO WRITE A C PROGRAM FOR IMPLEMENTINGFIFO(FIRST IN FIRST OUT) DISK SCHEDULING.

Concept: All incoming requests are placed at the end of the queue. Whatever number that is next in the queue will be the next number served. This algorithm doesn't provide the best results. To

determine the number of head movements we would simply find the number of tracks it took to

move from one request to the next.

SOURCE CODE:

#include

#include

#include

void main()

{

int a[20],n,i,t=0;

clrscr();

printf("Enter head pointer position:");

scanf("%d",&a[0]);

printf("\nEnter number of disk request:");

scanf("%d",&n);

printf("\nEnter request in order");

for(i=1;i

NCS-451/JP/ 62

{

printf("\nINVALID INPUT");

getch() ;

exit(0);

}

}

for(i=0;i

NCS-451/JP/ 63

FCFS Disk Scheduling Algorithm Output:

Enter head pointer position:500

Enter number of disk request:4

Enter request in order100

200

400

300

Processing order: 500 100 200 400 300

Total Head Movement:800

NCS-451/JP/ 64




100

400

200

250

550

Processing order: 200 300 100 400 200 250 550


NCS-451/JP/ 65




100

-300

INVALID INPUT

NCS-451/JP/ 66

PROGRAM 9

STATEMENT OF THE PROBLEM: TO WRITE A C PROGRAM FOR IMPLEMENTING SSTF(SHORTEST SEEK TIME FIRST) DISK SCHEDULING.

Concept: In this case request is serviced according to next shortest distance

from the header position.

SOURCE CODE:

#include

#include

#include0

void main()

{

int a[20],b[20],d,n,i,j,temp,s,k=0,x=0,t=0;

clrscr();

printf("Enter head pointer position:");

scanf("%d",&a[0]);

printf("\nEnter number of processes:");

scanf("%d",&n);

printf("\nEnter processes in request order");

for(i=1;i

NCS-451/JP/ 67

scanf("%d",&a[i]);

if(a[i]

NCS-451/JP/ 68

x=j;

}

}

t+=s;

temp=a[i+1];

a[i+1]=a[x];

a[x]=temp;

b[k++]=a[i+1];

}

printf("\nProcessing order:");

for(i=0;i

NCS-451/JP/ 69

SSTF Disk Scheduling Algorithm Output


Enter number of processes:4

Enter processes in request order200

100

500

200

Processing order: 100 100 200 200 500


NCS-451/JP/ 70




300

200

600

700

600

Processing order: 500 400 300 200 600 600 700


NCS-451/JP/ 71




600

300

-700

INVALID INPUT

Ncs-451 Lab Manual

Documents

Transcript of Ncs-451 Lab Manual