Académique Documents
Professionnel Documents
Culture Documents
LAB MANUAL
Jyotirmay Patel
NCS-451/JP/ 1
Operating System (ECS-551)
List of Experiment
NCS-451/JP/ 2
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/ 3
Objective of the Lab
1. To familiarize the learners with the Operating System.
NCS-451/JP/ 4
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
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/ 5
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/ 6
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/ 7
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.
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/ 8
top
This program shows a lot of stuff that goes on with your system. In the program, you can
type:
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.
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/ 9
vi Editor Commands
General Startup
To use vi: vi filename
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
NCS-451/JP/ 10
B move to the beginning of the previous word,
ignores punctuation
xG move to line x
^R redraw screen
( does not work with VT100 type terminals )
Inserting
r replace character under cursor with next
character typed
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
Find Commands
? finds a word going backwards
NCS-451/JP/ 12
Miscellaneous Commands
. repeat last command
NCS-451/JP/ 13
PROGRAM 01
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.
Source code:
#include<stdio.h>
#include<conio.h>
void main()
int n,i,j,sum=0;
float avgturn=0.0,avgwait=0.0;
start[0]=0;
clrscr();
scanf("%d",&n);
NCS-451/JP/ 14
for(i=0;i<n;i++)
printf("\n ENTER THE ARRIVAL TIME AND SERVICE TIME OF PROCESS %d: ",i+1);
scanf("%d%d",&arrv[i],&ser[i]);
for(i=0;i<n;i++)
sum=0;
for(j=0;j<i;j++)
sum=sum+ser[j];
start[i]=sum;
for(i=0;i<n;i++)
finish[i]=ser[i]+start[i];
wait[i]=start[i];
turn[i]=ser[i]+wait[i];
for(i=0;i<n;i++)
avgwait+=wait[i] ;
avgturn+=turn[i];
avgwait/=n;
avgturn/=n;
NCS-451/JP/ 15
printf("\n PROCESS ARRIVAL SERVICE START FINISH WAIT TURN \n");
for(i=0;i<n;i++)
avgturn);
getch();
NCS-451/JP/ 16
FCFS CPU Scheduling Output:
P0 0 3 0 3 0 3
P1 1 3 3 6 3 6
P2 2 2 6 8 6 8
NCS-451/JP/ 17
ENTER THE NO. OF PROCESSES:4
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/ 18
ENTER THE NO. OF PROCESSES:5
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/ 19
PROGRAM 02
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<stdio.h>
#include<conio.h>
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];
float avgturn=0.0,avgwait=0.0;
start[0]=0;
clrscr();
NCS-451/JP/ 20
printf("\n ENTER THE NO. OF PROCESSES:");
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d",&arrv[i],&ser[i]);
pro[i]=i;
for(i=0;i<n;i++)
for(j=0;j<n-i-1;j++)
if(ser[j]>ser[j+1])
temp1=ser[j];
ser[j]=ser[j+1];
ser[j+1]=temp1;
NCS-451/JP/ 21
temp2=arrv[j];
arrv[j]=arrv[j+1];
arrv[j+1]=temp2;
for(i=0;i<n;i++)
sum=0;
for(j=0;j<i;j++)
sum=sum+ser[j];
start[i]=sum;
for(i=0;i<n;i++)
finish[i]=ser[i]+start[i];
wait[i]=start[i];
turn[i]=ser[i]+wait[i];
NCS-451/JP/ 22
}
for(i=0;i<n;i++)
avgwait +=wait[i] ;
avgturn +=turn[i];
avgwait/=n;
avgturn/=n;
for(i=0;i<n;i++)
printf("\n\tP%d\t%d \t %d \t %d \t %d \t %d \t %d \n",
pro[i],arrv[i], ser[i], start[i], finish[i],wait[i],turn[i]);
getch();
NCS-451/JP/ 23
SJF CPU Scheduling Output:
P0 2 4 0 4 0 4
P1 5 6 4 10 4 10
P2 5 9 10 19 10 19
NCS-451/JP/ 24
ENTER THE NO. OF PROCESSES:4
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/ 25
ENTER THE NO. OF PROCESSES:5
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/ 26
PROGRAM 03
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<stdio.h>
#include<conio.h>
void main()
int n,i,j,temp1,temp2,sum=0;
float avgturn=0.0,avgwait=0.0;
start[0]=0;
clrscr();
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d",&ser[i],&prior[i]);
pro[i]=i;
NCS-451/JP/ 27
}
for(i=0;i<n;i++)
for(j=0;j<n-i-1;j++)
if(prior[j]>prior[j+1])
{ temp1=ser[j];
ser[j]=ser[j+1];
ser[j+1]=temp1;
temp2=prior[j];
prior[j]=prior[j+1];
prior[j+1]=temp2;
for(i=0;i<n;i++)
{ sum=0;
for(j=0;j<i;j++)
sum=sum+ser[j];
start[i]=sum;
for(i=0;i<n;i++)
finish[i]=ser[i]+start[i];
wait[i]=start[i];
turn[i]=ser[i]+wait[i];
NCS-451/JP/ 28
for(i=0;i<n;i++)
{ avgwait+=wait[i] ;
avgturn+=turn[i];
avgwait/=n;
avgturn/=n;
for(i=0;i<n;i++)
getch();
NCS-451/JP/ 29
Priority CPU Scheduling Output:
P0 4 2 0 4 0 4
P1 3 4 4 7 4 7
P2 1 5 7 8 7 8
NCS-451/JP/ 30
ENTER THE NO. OF PROCESSES: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/ 31
ENTER THE NO. OF PROCESSES:5
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/ 32
PROGRAM 04
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<stdio.h>
#include<conio.h>
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<n;i++)
NCS-451/JP/ 33
{
scanf("%d",&bt[i]);
st[i]=bt[i];
pro[i]=i;
scanf("%d",&tq);
while(1)
for(i=0,count=0;i<n;i++)
temp=tq;
if(st[i]==0)
count++;
continue;
if(st[i]>tq)
st[i]=st[i]-tq;
NCS-451/JP/ 34
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<n;i++)
wt[i]=tat[i]-bt[i];
stat=stat+tat[i];
swt=swt+wt[i];
awt=(float)swt/n;
atat=(float)stat/n;
NCS-451/JP/ 35
printf("\n PROCESS BURST TIME WAIT TURN \n");
for(i=0;i<n;i++)
printf("\n\tP%d\t%d \t %d \t%d\n" ,
pro[i],bt[i],wt[i],tat[i]);
getch();
NCS-451/JP/ 36
Round Robin CPU Scheduling Output:
P0 30 40 70
P1 40 50 90
P2 20 40 60
NCS-451/JP/ 37
ENTER THE NO. OF PROCESSES:4
P0 12 24 36
P1 20 26 46
P2 9 25 34
P3 5 15 20
NCS-451/JP/ 38
ENTER THE NO. OF PROCESSES:5
P0 22 43 65
P1 11 26 37
P2 34 47 81
P3 2 18 20
P4 12 37 49
NCS-451/JP/ 39
PROGRAM 05
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 Banker’s 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<stdio.h>
#include<conio.h>
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<=7;i++)
NCS-451/JP/ 40
comp[i]=0;
scanf("%d",&p);
scanf("%d",&r);
for(i=1;i<=p;i++)
for(j=1;j<=r;j++)
scanf("%d",&clm[i][j]);
for(i=1;i<=p;i++)
for(j=1;j<=r;j++)
NCS-451/JP/ 41
scanf("%d",&alloc[i][j]);
for(j=1;j<=r;j++)
scanf("%d",&rsrc[j]);
for(j=1;j<=r;j++)
int total=0;
avail[j]=0;
for(i=1;i<=p;i++)
{total+=alloc[i][j];}
avail[j]=rsrc[j]-total;
do
for(i=1;i<=p;i++)
for(j=1;j<=r;j++)
NCS-451/JP/ 42
req[i][j]=clm[i][j]-alloc[i][j];
for(i=1;i<=p;i++)
printf("\n");
for(j=1;j<=r;j++)
printf("%2d",clm[i][j]);
printf("\t\t");
for(j=1;j<=r;j++)
printf("%2d",alloc[i][j]);
printf("\t\t\t");
for(j=1;j<=r;j++)
printf("%2d",req[i][j]);
}
NCS-451/JP/ 43
}
for(j=1;j<=r;j++)
{ printf("%d \t",avail[j]); }
prc=0;
for(i=1;i<=p;i++)
prc=i;
for(j=1;j<=r;j++)
if(avail[j]==0|| req[i][j]>avail[j])
prc=0;
break;
if(prc!=0)
break;
NCS-451/JP/ 44
}
if(prc!=0)
count++;
for(j=1;j<=r;j++)
avail[j]+=alloc[prc][j];
alloc[prc][j]=0;
clm[prc][j]=0;
comp[prc]=1;
if(count==p)
else
getch();
NCS-451/JP/ 45
Banker Algorithm Output
Enter the no of processes : 3
For process 1 : 2
For process 2 : 5
For process 3 : 3
For process 1 : 2
For process 2 : 6
For process 3 : 4
NCS-451/JP/ 46
2
3456 4234 -1 2 2 2
NCS-451/JP/ 47
Enter the no of processes : 3
For process 1 : 2
For process 2 : 1
For process 3 : 2
For process 1 : 1
For process 2 : 1
For process 3 : 0
23 11 12
12 11 01
23 01 22
NCS-451/JP/ 48
00 00 00
12 11 01
23 01 22
00 00 00
00 00 00
23 01 22
00 00 00
00 00 00
00 00 00
NCS-451/JP/ 49
PROGRAM 06
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<conio.h>
#include<stdio.h>
void main()
{ int i,j,n,a[50],frame[10],no,k,avail,count=0;
clrscr();
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
scanf("%d",&no);
for(i=0;i<no;i++)
frame[i]=-1;
NCS-451/JP/ 50
j=0;
for(i=1;i<=n;i++)
printf("%2d\t\t",a[i]);
avail=0;
for(k=0;k<no;k++)
if(frame[k]==a[i])
avail=1;
if(avail==0)
frame[j]=a[i];
j=(j+1)%no;
count++;
for(k=0;k<no;k++)
printf("%d\t",frame[k]);
printf("\n");
getch();
NCS-451/JP/ 51
FIFO Page Replacement Algorithm Output
1 1 -1 -1
2 1 2 -1
3 1 2 3
4 4 2 3
NCS-451/JP/ 52
ENTER THE NO. OF PAGES: 7
1 1 -1 -1
2 1 2 -1
3 1 2 3
4 4 2 3
NCS-451/JP/ 53
ENTER THE NO. OF PAGES: 6
2 2 -1 -1
NCS-451/JP/ 54
PROGRAM 07
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<stdio.h>
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);
for(i=0;i<n;i++)
scanf("%d",&p[i]);
printf("Enter no of frames:");
scanf("%d",&f);
q[k]=p[k];
printf("\n\t%d\n",q[k]);
c++;
k++;
for(i=1;i<n;i++)
NCS-451/JP/ 55
c1=0;
for(j=0;j<f;j++)
if(p[i]!=q[j])
c1++;
if(c1==f)
c++;
if(k<f)
q[k]=p[i];
k++;
for(j=0;j<k;j++)
printf("\t%d",q[j]);
printf("\n");
else
for(r=0;r<f;r++)
c2[r]=0;
for(j=i-1;j<n;j--)
if(q[r]!=p[j])
c2[r]++;
else
NCS-451/JP/ 56
break;
for(r=0;r<f;r++)
b[r]=c2[r];
for(r=0;r<f;r++)
for(j=r;j<f;j++)
if(b[r]<b[j])
{
t=b[r];
b[r]=b[j];
b[j]=t;
for(r=0;r<f;r++)
if(c2[r]==b[0])
q[r]=p[i];
printf("\t%d",q[r]);
printf("\n");
}} }
getch() ;
NCS-451/JP/ 57
LRU Page Replacement Algorithm Output
Enter no of pages:4
Enter no of frames:2
2 3
1 3
1 2
NCS-451/JP/ 58
Enter no of pages:7
Enter no of frames:3
1 3
1 3 2
4 3 2
4 5 2
NCS-451/JP/ 59
Enter no of pages:8
Enter no of frames:2
1 2
3 2
3 1
2 1
2 3
NCS-451/JP/ 60
PROGRAM 8
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<stdio.h>
#include<conio.h>
#include<stdlib.h>
void main()
int a[20],n,i,t=0;
clrscr();
scanf("%d",&a[0]);
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
if(a[i]<0)
NCS-451/JP/ 61
{
printf("\nINVALID INPUT");
getch() ;
exit(0);
for(i=0;i<n;i++)
if(a[i]<a[i+1])
t+=(a[i+1]-a[i]);
else
t+=(a[i]-a[i+1]);
printf("\nProcessing order:");
for(i=0;i<=n;i++)
printf("\t%d",a[i]);
getch();
NCS-451/JP/ 62
FCFS Disk Scheduling Algorithm Output:
200
400
300
NCS-451/JP/ 63
Enter head pointer position:200
100
400
200
250
550
NCS-451/JP/ 64
Enter head pointer position:200
100
-300
INVALID INPUT
NCS-451/JP/ 65
PROGRAM 9
SOURCE CODE:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>0
void main()
int a[20],b[20],d,n,i,j,temp,s,k=0,x=0,t=0;
clrscr();
scanf("%d",&a[0]);
scanf("%d",&n);
for(i=1;i<=n;i++)
NCS-451/JP/ 66
scanf("%d",&a[i]);
if(a[i]<0)
printf("\nINVALID INPUT");
getch() ;
exit(0);
b[k++]=a[0];
for(i=0;i<n;i++)
s=1000;
for(j=i+1;j<=n;j++)
if(a[i]>a[j])
d=a[i]-a[j];
else
d=a[j]-a[i];
if(d<s)
s=d;
NCS-451/JP/ 67
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<=n;i++)
printf("\t%d",b[i]);
getch();
NCS-451/JP/ 68
SSTF Disk Scheduling Algorithm Output
Enter head pointer position:100
100
500
200
NCS-451/JP/ 69
Enter head pointer position:500
300
200
600
700
600
NCS-451/JP/ 70
Enter head pointer position:700
600
300
-700
INVALID INPUT
NCS-451/JP/ 71