Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
Scanned with CamScanner
icte,
NemeSandeep SngA
Regd1941D139.36
Memey
krbhac 200k_book 4ook 00k
Lanciea312k S2k 212k S26k
3L2kin 6ook
S k h vok
Q2 k uot weit
Sa6ke t woit
312k in j00k
S12k in 60o
S26k meewot
312kia Zoo k_
iak in boo k_
212
n 400k
S2k mutwel
12a)Naaf bib sep hapeed legzzad adksa
2
2D48
2
126yh
byk
11paga1412hyde
3412
taonak
o
200
)tinalmes
3.3S K_
Sn
Son
DO memem acea
EAT O 6o15 (So0.20 x1CL100 ti1o
1n
a
h
addaco
y
23by
kea
23
2°
2
8
3 6 bil
Nahhrg-
2
1262/2
4
upDtes legialadeba
121,k
Test Cases:
The program should able to produce correct answer or appropriate error message corresponding
to the following test cases:
1. Consider the set of processes with arrival time (in milliseconds), CPU burst time (in
milliseconds), and time quantum = 4ms as shown below.
Process Arrival time Burst Time
P1
0
10
P2
0
1
P3
0
2
P4
0
1
P5
0
5
Input choice 1, and print the Gantt charts that illustrate the execution of these
processes using the FCFS scheduling algorithm and then print the average
turnaround time, average waiting time and average response time.
CODE:
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
typedef struct
{
int pid;
int burst_time;
int waiting_time;
int turnaround_time;
} Process;
void print_table(Process p[], int n);
void print_gantt_chart(Process p[], int n);
int main()
{
Process p[MAX];
int i, j, n;
int sum_waiting_time = 0, sum_turnaround_time;
printf("Enter total number of process: ");
scanf("%d", &n);
printf("Enter burst time for each process:\n");
for(i=0; i<n; i++) {
p[i].pid = i+1;
printf("P[%d] : ", i+1);
scanf("%d", &p[i].burst_time);
p[i].waiting_time = p[i].turnaround_time = 0;
}
p[0].turnaround_time = p[0].burst_time;
for(i=1; i<n; i++) {
p[i].waiting_time = p[i-1].waiting_time + p[i-1].burst_time;
p[i].turnaround_time = p[i].waiting_time + p[i].burst_time;
}
for(i=0; i<n; i++) {
sum_waiting_time += p[i].waiting_time;
sum_turnaround_time += p[i].turnaround_time;
}
puts("");
print_table(p, n);
puts("");
printf("Total Waiting Time
: %-2d\n", sum_waiting_time);
printf("Average Waiting Time
: %-2.2lf\n", (double)sum_waiting_time /
(double) n);
printf("Total Turnaround Time : %-2d\n", sum_turnaround_time);
printf("Average Turnaround Time : %-2.2lf\n", (double)sum_turnaround_time /
(double)n);
puts("");
puts("
GANTT CHART
puts("
***********
print_gantt_chart(p, n);
return 0;
}
void print_table(Process p[], int n)
{
int i;
");
");
puts("+-----+------------+--------------+-----------------+");
puts("| PID | Burst Time | Waiting Time | Turnaround Time |");
puts("+-----+------------+--------------+-----------------+");
for(i=0; i<n; i++) {
printf("| %2d |
%2d
|
%2d
|
%2d
|\n"
, p[i].pid, p[i].burst_time, p[i].waiting_time, p[i].turnaround_time );
puts("+-----+------------+--------------+-----------------+");
}
}
void print_gantt_chart(Process p[], int n)
{
int i, j;
printf(" ");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf("--");
printf(" ");
}
printf("\n|");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time - 1; j++) printf(" ");
printf("P%d", p[i].pid);
for(j=0; j<p[i].burst_time - 1; j++) printf(" ");
printf("|");
}
printf("\n ");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf("--");
printf(" ");
}
printf("\n");
printf("0");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf(" ");
if(p[i].turnaround_time > 9) printf("\b");
printf("%d", p[i].turnaround_time);
}
printf("\n");
}

Input choice 2, and print the Gantt charts that illustrate the execution of these
processes using the SJF scheduling algorithm and then print the average
turnaround time, average waiting time and average response time.
CODE:
#include <stdio.h>
#include <stdlib.h>
#define MAX_PROCESS 100
struct process {
int pid;
int burst_time;
int waiting_time;
};
typedef struct process Process;
double average_waiting_time;
int total_waiting_time;
void sort_process_by_burst_time(Process p[], int n);
void calculate_waiting_time(Process p[], int n);
void print_gantt_chart(Process p[], int n);
int main()
{
Process p[MAX_PROCESS];
int n, i, j;
puts("SHORTEST JOB FIRST SCHEDULING ALGORITHM");
puts("=======================================");
printf("Enter total process: ");
scanf("%d", &n);
printf("Enter burst time for each process:\n");
for(i=0; i<n; i++) {
printf("P[%d]: ", i+1);
scanf("%d", &p[i].burst_time);
p[i].pid = i+1;
}
sort_process_by_burst_time(p, n);
calculate_waiting_time(p, n);
average_waiting_time = (double) ( (double)total_waiting_time / (double) n );
puts("");
printf("Average Waiting Time: %.2lf\n",average_waiting_time);
printf("Gantt Chart:\n");
print_gantt_chart(p, n);
return 0;
}
void sort_process_by_burst_time(Process p[], int n)
{
int i, j;
Process temp;
for(i=0; i<n-1; i++) {
for(j=0; j<n-1-i; j++) {
if(p[j].burst_time > p[j+1].burst_time) {
temp = p[j];
p[j] = p[j+1];
p[j+1] = temp;
}
}
}
}
void calculate_waiting_time(Process p[], int n)
{
int i;
total_waiting_time = 0;
p[0].waiting_time = 0;
for(i=1; i<n; i++) {
p[i].waiting_time = p[i-1].waiting_time + p[i-1].burst_time;
total_waiting_time += p[i].waiting_time;
}
}
void print_gantt_chart(Process p[], int n)
{
int i, j;
int last = p[n-1].burst_time + ( n== 1 ? 0 : p[n-1].waiting_time);
printf(" ");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf("--");
printf(" ");
}
printf("\n|");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time-1; j++) printf(" ");
printf("p%d", p[i].pid);
for(j=0; j<p[i].burst_time-1; j++) printf(" ");
printf("|");
}
printf("\n ");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf("--");
printf(" ");
}
printf("\n");
int minus = 0;
for(i=0; i<n; i++) {
if(p[i].waiting_time>9) printf(" ");
printf("%d", p[i].waiting_time);
if(p[i+1].waiting_time>9){
minus = 1;
}
if(i+1 == n ) if (last>9) minus = 1;
for(j=0; j<p[i].burst_time-minus; j++) printf(" ");
}
if(last>9) printf(" ");
printf("%d\n", last);
}
Input choice 3, and print the Gantt charts that illustrate the execution of these
processes using the SRTF scheduling algorithm and then print the average
turnaround time, average waiting time and average response time.
CODE:
#include <stdio.h>
int main()
{
int n, ari[10], bur[10], total = 0, i, j, small, temp, procs[100], k, waiting[10],
finish[10];
float tavg = 0.0, wavg = 0.0;
printf("ENTER THE NUMBER OF PROCESSES:");
scanf("%d", & n);
for (i = 0; i < n; i++)
{
printf("ENTER THE ARRIVAL TIME OF PROCESS %d:\t", i);
scanf("%d", & ari[i]);
printf("ENTER THE BURST TIME OF PROCESS %d:\t", i);
scanf("%d", & bur[i]);
waiting[i] = 0;
total += bur[i];
}
for (i = 0; i < n; i++)
{
for (j = i + 1; j < n; j++)
{
if (ari[i] > ari[j])
{
temp = ari[i];
ari[i] = ari[j];
ari[j] = temp;
temp = bur[i];
bur[i] = bur[j];
bur[j] = temp;
}
}
}
for (i = 0; i < total; i++)
{
small = 3200;
for (j = 0; j < n; j++)
{
if ((bur[j] != 0) && (ari[j] <= i) && (bur[j] < small))
{
small = bur[j];
k = j;
}
}
bur[k]--;
procs[i] = k;
}
k=0;
for (i = 0; i < total; i++)
{
for (j = 0; j < n; j++)
{
if (procs[i] == j)
{
finish[j] = i;
waiting[j]++;
}
}
}
for (i = 0; i < n; i++)
{
printf("\n PROCESS %d -FINISH TIME==> %d TURNAROUND TIME==>%d
WAITING TIME==>%d\n", i + 1, finish[i] + 1, (finish[i] - ari[i]) + 1, (((finish[i] + 1)
- waiting[i]) - ari[i]));
wavg = wavg + (((finish[i] + 1) - waiting[i]) - ari[i]);
tavg = tavg + ((finish[i] - ari[i]) + 1);
}
printf("\n WAvG==>\t%f\n TAVG==>\t%f\n", (wavg / n), (tavg / n));
return 0;
}
Input choice 4, and print the Gantt charts that illustrate the execution of these
processes using the RR scheduling algorithm and then print the average
turnaround time, average waiting time and average response time.
CODE:
#include<stdio.h>
struct times
{
int p,art,but,wtt,tat,rnt;
};
void sortart(struct times a[],int pro)
{
int i,j;
struct times temp;
for(i=0;i<pro;i++)
{
for(j=i+1;j<pro;j++)
{
if(a[i].art > a[j].art)
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
return;
}
int main()
{
int i,j,pro,time,remain,flag=0,ts;
struct times a[100];
float avgwt=0,avgtt=0;
printf("Round Robin Scheduling Algorithm\n");
printf("Enter Number Of Processes : ");
scanf("%d",&pro);
remain=pro;
for(i=0;i<pro;i++)
{
printf("Enter arrival time and Burst time for Process P%d : ",i);
scanf("%d%d",&a[i].art,&a[i].but);
a[i].p = i;
a[i].rnt = a[i].but;
}
sortart(a,pro);
printf("Enter Time Slice OR Quantum Number : ");
scanf("%d",&ts);
printf("\n***************************************\n");
printf("Gantt Chart\n");
printf("0");
for(time=0,i=0;remain!=0;)
{
if(a[i].rnt<=ts && a[i].rnt>0)
{
time = time + a[i].rnt;
printf(" -> [P%d] <- %d",a[i].p,time);
a[i].rnt=0;
flag=1;
}
else if(a[i].rnt > 0)
{
a[i].rnt = a[i].rnt - ts;
time = time + ts;
printf(" -> [P%d] <- %d",a[i].p,time);
}
if(a[i].rnt==0 && flag==1)
{
remain--;
a[i].tat = time-a[i].art;
a[i].wtt = time-a[i].art-a[i].but;
avgwt = avgwt + time-a[i].art-a[i].but;
avgtt = avgtt + time-a[i].art;
flag=0;
}
if(i==pro-1)
i=0;
else if(a[i+1].art <= time)
i++;
else
i=0;
}
printf("\n\n");
printf("***************************************\n");
printf("Pro\tArTi\tBuTi\tTaTi\tWtTi\n");
printf("***************************************\n");
for(i=0;i<pro;i++)
{
printf("P%d\t%d\t%d\t%d\t%d\n",a[i].p,a[i].art,a[i].but,a[i].tat,a[i].wtt);
}
printf("***************************************\n");
avgwt = avgwt/pro;
avgtt = avgtt/pro;
printf("Average Waiting Time : %.2f\n",avgwt);
printf("Average Turnaround Time : %.2f\n",avgtt);
return 0;
}
Analyze the results and determine which of the algorithms results in the minimum
average waiting time over all processes?
On analyzing the results of the algorithm , the minimum average waiting time is
3.20seconds of Shortest Job First (SJF) and shortest Remaining Time First (SRTF).
2. Consider the set of processes with arrival time (in milliseconds), CPU burst time (in
milliseconds), and time quantum =2ms as shown below.
Process Arrival time Burst Time
P1
0
4
P2
0
2
P3
1
3
P4
2
2
Input choice 1, and print the Gantt charts that illustrate the execution of these
processes using the FCFS scheduling algorithm and then print the average
turnaround time, average waiting time and average response time.
CODE:
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
typedef struct
{
int pid;
int burst_time;
int waiting_time;
int turnaround_time;
} Process;
void print_table(Process p[], int n);
void print_gantt_chart(Process p[], int n);
int main()
{
Process p[MAX];
int i, j, n;
int sum_waiting_time = 0, sum_turnaround_time;
printf("Enter total number of process: ");
scanf("%d", &n);
printf("Enter burst time for each process:\n");
for(i=0; i<n; i++) {
p[i].pid = i+1;
printf("P[%d] : ", i+1);
scanf("%d", &p[i].burst_time);
p[i].waiting_time = p[i].turnaround_time = 0;
}
p[0].turnaround_time = p[0].burst_time;
for(i=1; i<n; i++) {
p[i].waiting_time = p[i-1].waiting_time + p[i-1].burst_time;
p[i].turnaround_time = p[i].waiting_time + p[i].burst_time;
}
for(i=0; i<n; i++) {
sum_waiting_time += p[i].waiting_time;
sum_turnaround_time += p[i].turnaround_time;
}
puts("");
print_table(p, n);
puts("");
printf("Total Waiting Time
: %-2d\n", sum_waiting_time);
printf("Average Waiting Time
: %-2.2lf\n", (double)sum_waiting_time /
(double) n);
printf("Total Turnaround Time : %-2d\n", sum_turnaround_time);
printf("Average Turnaround Time : %-2.2lf\n", (double)sum_turnaround_time /
(double)n);
puts("");
puts("
GANTT CHART
puts("
***********
");
");
print_gantt_chart(p, n);
return 0;
}
void print_table(Process p[], int n)
{
int i;
puts("+-----+------------+--------------+-----------------+");
puts("| PID | Burst Time | Waiting Time | Turnaround Time |");
puts("+-----+------------+--------------+-----------------+");
for(i=0; i<n; i++) {
printf("| %2d |
%2d
|
%2d
|
%2d
|\n"
, p[i].pid, p[i].burst_time, p[i].waiting_time, p[i].turnaround_time );
puts("+-----+------------+--------------+-----------------+");
}
}
void print_gantt_chart(Process p[], int n)
{
int i, j;
printf(" ");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf("--");
printf(" ");
}
printf("\n|");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time - 1; j++) printf(" ");
printf("P%d", p[i].pid);
for(j=0; j<p[i].burst_time - 1; j++) printf(" ");
printf("|");
}
printf("\n ");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf("--");
printf(" ");
}
printf("\n");
printf("0");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf(" ");
if(p[i].turnaround_time > 9) printf("\b");
printf("%d", p[i].turnaround_time);
}
printf("\n");
}
Input choice 2, and print the Gantt charts that illustrate the execution of these
processes using the SJF scheduling algorithm and then print the average turnaround
time, average waiting time and average response time.
CODE:
#include <stdio.h>
#include <stdlib.h>
#define MAX_PROCESS 100
struct process {
int pid;
int burst_time;
int waiting_time;
};
typedef struct process Process;
double average_waiting_time;
int total_waiting_time;
void sort_process_by_burst_time(Process p[], int n);
void calculate_waiting_time(Process p[], int n);
void print_gantt_chart(Process p[], int n);
int main()
{
Process p[MAX_PROCESS];
int n, i, j;
puts("SHORTEST JOB FIRST SCHEDULING ALGORITHM");
puts("=======================================");
printf("Enter total process: ");
scanf("%d", &n);
printf("Enter burst time for each process:\n");
for(i=0; i<n; i++) {
printf("P[%d]: ", i+1);
scanf("%d", &p[i].burst_time);
p[i].pid = i+1;
}
sort_process_by_burst_time(p, n);
calculate_waiting_time(p, n);
average_waiting_time = (double) ( (double)total_waiting_time / (double) n );
puts("");
printf("Average Waiting Time: %.2lf\n",average_waiting_time);
printf("Gantt Chart:\n");
print_gantt_chart(p, n);
return 0;
}
void sort_process_by_burst_time(Process p[], int n)
{
int i, j;
Process temp;
for(i=0; i<n-1; i++) {
for(j=0; j<n-1-i; j++) {
if(p[j].burst_time > p[j+1].burst_time) {
temp = p[j];
p[j] = p[j+1];
p[j+1] = temp;
}
}
}
}
void calculate_waiting_time(Process p[], int n)
{
int i;
total_waiting_time = 0;
p[0].waiting_time = 0;
for(i=1; i<n; i++) {
p[i].waiting_time = p[i-1].waiting_time + p[i-1].burst_time;
total_waiting_time += p[i].waiting_time;
}
}
void print_gantt_chart(Process p[], int n)
{
int i, j;
int last = p[n-1].burst_time + ( n== 1 ? 0 : p[n-1].waiting_time);
printf(" ");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf("--");
printf(" ");
}
printf("\n|");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time-1; j++) printf(" ");
printf("p%d", p[i].pid);
for(j=0; j<p[i].burst_time-1; j++) printf(" ");
printf("|");
}
printf("\n ");
for(i=0; i<n; i++) {
for(j=0; j<p[i].burst_time; j++) printf("--");
printf(" ");
}
printf("\n");
int minus = 0;
for(i=0; i<n; i++) {
if(p[i].waiting_time>9) printf(" ");
printf("%d", p[i].waiting_time);
if(p[i+1].waiting_time>9){
minus = 1;
}
if(i+1 == n ) if (last>9) minus = 1;
for(j=0; j<p[i].burst_time-minus; j++) printf(" ");
}
if(last>9) printf(" ");
printf("%d\n", last);
}
Input choice 3, and print the Gantt charts that illustrate the execution of these
processes using the SRTF scheduling algorithm and then print the average
turnaround time, average waiting time and average response time.
CODE:
#include <stdio.h>
int main()
{
int n, ari[10], bur[10], total = 0, i, j, small, temp, procs[100], k, waiting[10],
finish[10];
float tavg = 0.0, wavg = 0.0;
printf("ENTER THE NUMBER OF PROCESSES:");
scanf("%d", & n);
for (i = 0; i < n; i++)
{
printf("ENTER THE ARRIVAL TIME OF PROCESS %d:\t", i);
scanf("%d", & ari[i]);
printf("ENTER THE BURST TIME OF PROCESS %d:\t", i);
scanf("%d", & bur[i]);
waiting[i] = 0;
total += bur[i];
}
for (i = 0; i < n; i++)
{
for (j = i + 1; j < n; j++)
{
if (ari[i] > ari[j])
{
temp = ari[i];
ari[i] = ari[j];
ari[j] = temp;
temp = bur[i];
bur[i] = bur[j];
bur[j] = temp;
}
}
}
for (i = 0; i < total; i++)
{
small = 3200;
for (j = 0; j < n; j++)
{
if ((bur[j] != 0) && (ari[j] <= i) && (bur[j] < small))
{
small = bur[j];
k = j;
}
}
bur[k]--;
procs[i] = k;
}
k=0;
for (i = 0; i < total; i++)
{
for (j = 0; j < n; j++)
{
if (procs[i] == j)
{
finish[j] = i;
waiting[j]++;
}
}
}
for (i = 0; i < n; i++)
{
printf("\n PROCESS %d -FINISH TIME==> %d TURNAROUND TIME==>%d
WAITING TIME==>%d\n", i + 1, finish[i] + 1, (finish[i] - ari[i]) + 1, (((finish[i] +
1) - waiting[i]) - ari[i]));
wavg = wavg + (((finish[i] + 1) - waiting[i]) - ari[i]);
tavg = tavg + ((finish[i] - ari[i]) + 1);
}
printf("\n WAvG==>\t%f\n TAVG==>\t%f\n", (wavg / n), (tavg / n));
return 0;
}
Input choice 4, and print the Gantt charts that illustrate the execution of these
processes using the RR scheduling algorithm and then print the average turnaround
time, average waiting time and average response time.
CODE:
#include<stdio.h>
struct times
{
int p,art,but,wtt,tat,rnt;
};
void sortart(struct times a[],int pro)
{
int i,j;
struct times temp;
for(i=0;i<pro;i++)
{
for(j=i+1;j<pro;j++)
{
if(a[i].art > a[j].art)
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
return;
}
int main()
{
int i,j,pro,time,remain,flag=0,ts;
struct times a[100];
float avgwt=0,avgtt=0;
printf("Round Robin Scheduling Algorithm\n");
printf("Enter Number Of Processes : ");
scanf("%d",&pro);
remain=pro;
for(i=0;i<pro;i++)
{
printf("Enter arrival time and Burst time for Process P%d : ",i);
scanf("%d%d",&a[i].art,&a[i].but);
a[i].p = i;
a[i].rnt = a[i].but;
}
sortart(a,pro);
printf("Enter Time Slice OR Quantum Number : ");
scanf("%d",&ts);
printf("\n***************************************\n");
printf("Gantt Chart\n");
printf("0");
for(time=0,i=0;remain!=0;)
{
if(a[i].rnt<=ts && a[i].rnt>0)
{
time = time + a[i].rnt;
printf(" -> [P%d] <- %d",a[i].p,time);
a[i].rnt=0;
flag=1;
}
else if(a[i].rnt > 0)
{
a[i].rnt = a[i].rnt - ts;
time = time + ts;
printf(" -> [P%d] <- %d",a[i].p,time);
}
if(a[i].rnt==0 && flag==1)
{
remain--;
a[i].tat = time-a[i].art;
a[i].wtt = time-a[i].art-a[i].but;
avgwt = avgwt + time-a[i].art-a[i].but;
avgtt = avgtt + time-a[i].art;
flag=0;
}
if(i==pro-1)
i=0;
else if(a[i+1].art <= time)
i++;
else
i=0;
}
printf("\n\n");
printf("***************************************\n");
printf("Pro\tArTi\tBuTi\tTaTi\tWtTi\n");
printf("***************************************\n");
for(i=0;i<pro;i++)
{
printf("P%d\t%d\t%d\t%d\t%d\n",a[i].p,a[i].art,a[i].but,a[i].tat,a[i].wtt);
}
printf("***************************************\n");
avgwt = avgwt/pro;
avgtt = avgtt/pro;
printf("Average Waiting Time : %.2f\n",avgwt);
printf("Average Turnaround Time : %.2f\n",avgtt);
return 0;
}
Analyze the results and determine which of the algorithms results in the minimum
average waiting time over all processes?
On analyzing the results of the algorithm , the minimum average waiting time is 2.50
seconds of Shortest Job First (SJF) and shortest Remaining Time First (SRTF).