[go: up one dir, main page]
Scribd
Upload
7 views7 pages

Process Scheduling

Uploaded by

rasigapriyas32

The document discusses different process scheduling algorithms like FCFS, SJF, Round Robin and Priority scheduling. It includes code to implement these algorithms and calculate their waiting times and turnaround times.

Copyright:

© All Rights Reserved
Download as DOCX, PDF, TXT or read online from Scribd
Download as docx, pdf, or txt

Process Scheduling

Uploaded by

rasigapriyas32
7 views7 pages
The document discusses different process scheduling algorithms like FCFS, SJF, Round Robin and Priority scheduling. It includes code to implement these algorithms and calculate their waiting times and turnaround times.

Original Title

PROCESS SCHEDULING

Copyright

© © All Rights Reserved

Available Formats

DOCX, PDF, TXT or read online from Scribd

Did you find this document useful?

Is this content inappropriate?

The document discusses different process scheduling algorithms like FCFS, SJF, Round Robin and Priority scheduling. It includes code to implement these algorithms and calculate their waiting times and turnaround times.

Copyright:

© All Rights Reserved
Download as DOCX, PDF, TXT or read online from Scribd
Download as docx, pdf, or txt
7 views7 pages

Process Scheduling

Uploaded by

rasigapriyas32
The document discusses different process scheduling algorithms like FCFS, SJF, Round Robin and Priority scheduling. It includes code to implement these algorithms and calculate their waiting times and turnaround times.

Copyright:

© All Rights Reserved
Download as DOCX, PDF, TXT or read online from Scribd
Download as docx, pdf, or txt
You are on page 1/ 7

PROCESS SCHEDULING

CODE:
#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
typedef struct{
char id;
int burst_time,arrival_time,priority;
}process;

void FCFS(process *processes, int n,int *waiting_time,int *turnaround_time){


waiting_time[0]=0;
for(int i=1;i<n;i++){
waiting_time[i]=processes[i-1].burst_time+waiting_time[i-1];
}
for(int i=0;i<n;i++){
turnaround_time[i]=processes[i].burst_time+waiting_time[i];
}
}

void SJF(process *processes,int n, int *waiting_time,int *turnaround_time){


process *temp=(process*)malloc(n*sizeof(process));
for(int i=0;i<n;i++){
temp[i]=processes[i];
}
int complete=0;
int time=0;
int shortest=0;
int min_burst=INT_MAX;
while(complete!=n){
for(int i=0;i<n;i++){
if(temp[i].arrival_time<=time && temp[i].burst_time<min_burst &&
temp[i].burst_time>0){
min_burst=temp[i].burst_time;
shortest=i;
}
}
temp[shortest].burst_time--;
min_burst=temp[shortest].burst_time;
if(min_burst==0){
min_burst=INT_MAX;
complete++;
turnaround_time[shortest]=time+1-temp[shortest].arrival_time;
waiting_time[shortest]=turnaround_time[shortest]-
temp[shortest].burst_time;
}
time++;
}
free(temp);
}

void RR(process *processes, int n,int *waiting_time,int *turnaround_time,int


quantum){
int *remaining_time=(int *)malloc(n*sizeof(int));
for(int i=0;i<n;i++){
remaining_time[i]=processes[i].burst_time;
}
int time=0;
while(1){
int done=1;
for(int i=0;i<n;i++){
if(remaining_time[i]>0){
done=0;
if(remaining_time[i]>quantum){
time+=quantum;
remaining_time[i]-=quantum;
}
else{
time+=remaining_time[i];
waiting_time[i]=time-processes[i].burst_time;
remaining_time[i]=0;
turnaround_time[i]=time-processes[i].arrival_time;
}
}
}
if(done==1){
break;
}
}
free(remaining_time);
}
void PS(process *processes, int n,int *waiting_time, int *turnaround_time){
int *remaining_time=(int *)malloc(n*sizeof(int));
for(int i=0;i<n;i++){
remaining_time[i]=processes[i].burst_time;
}
int time=0;
int complete=0;
while(complete!=n){
int highest_priority=-1;
int highest_pi=-1;
for(int i=0;i<n;i++){
if(processes[i].arrival_time<=time && remaining_time[i]>0){
if(highest_priority==-1||
processes[i].priority<highest_priority){
highest_priority=processes[i].priority;
highest_pi=i;
}
}
}
if(highest_pi==-1){
time++;
}else{
time+=remaining_time[highest_pi];
waiting_time[highest_pi]=time-processes[highest_pi].burst_time;
remaining_time[highest_pi]=0;
turnaround_time[highest_pi]=time-
processes[highest_pi].arrival_time;
complete++;
}
}
free(remaining_time);
}
void display(process *processes,int n,int *waiting_time,int *turnaround_time){
printf("Process\tBurst Time\tWaiting Time\tTurnaround Time\n");
float tot_waiting_time=0;
float tot_turnaround_time=0;
for(int i=0;i<n;i++){
tot_waiting_time+=waiting_time[i];
tot_turnaround_time+=turnaround_time[i];
printf("%c\t%d\t\t%d\t\t%d\
n",processes[i].id,processes[i].burst_time,waiting_time[i],turnaround_time[i])
;

}
printf("\nAverage Waiting Time:%.2f\n",tot_waiting_time/n);
printf("Average Turnaround Time:%.2f\n",tot_turnaround_time/n);

}
int main(){
int n,quantum;
printf("Enter the number of processes:");
scanf("%d",&n);
process *processes = (process *)malloc(n * sizeof(process));
int *waiting_time_FCFS = (int *)malloc(n * sizeof(int));
int *turnaround_time_FCFS = (int *)malloc(n * sizeof(int));
int *waiting_time_SJF= (int *)malloc(n * sizeof(int));
int *turnaround_time_SJF = (int *)malloc(n * sizeof(int));
int *waiting_time_RR = (int *)malloc(n * sizeof(int));
int *turnaround_time_RR = (int *)malloc(n * sizeof(int));
int *waiting_time_PS = (int *)malloc(n * sizeof(int));
int *turnaround_time_PS = (int *)malloc(n * sizeof(int));
for (int i = 0; i < n; i++) {
printf("Enter Process ID for process %d: ", i + 1);
scanf(" %c", &processes[i].id);
printf("Enter Arrival Time for process %c: ", processes[i].id);
scanf("%d", &processes[i].arrival_time);
printf("Enter Burst Time for process %c: ", processes[i].id);
scanf("%d", &processes[i].burst_time);
printf("Enter Priority for process %c: ", processes[i].id);
scanf("%d", &processes[i].priority);
}
printf("\nFCFS Scheduling:\n");
FCFS(processes, n, waiting_time_FCFS, turnaround_time_FCFS);
display(processes, n, waiting_time_FCFS, turnaround_time_FCFS);
printf("\nSJF Scheduling:\n");
SJF(processes, n, waiting_time_SJF, turnaround_time_SJF);
display(processes, n, waiting_time_SJF, turnaround_time_SJF);
printf("\nEnter Quantum Time for Round Robin: ");
scanf("%d", &quantum);
printf("\nRound Robin Scheduling with Quantum Time %d:\n", quantum);
RR(processes, n, waiting_time_RR, turnaround_time_RR, quantum);
display(processes, n, waiting_time_RR, turnaround_time_RR);
printf("\nPriority Scheduling:\n");
PS(processes, n, waiting_time_PS, turnaround_time_PS);
display(processes, n, waiting_time_PS, turnaround_time_PS);
float avg_waiting_time_FCFS = 0, avg_waiting_time_SJF = 0,
avg_waiting_time_rr = 0, avg_waiting_time_ps = 0;
for (int i = 0; i < n; i++) {
avg_waiting_time_FCFS += waiting_time_FCFS[i];
avg_waiting_time_SJF += waiting_time_SJF[i];
avg_waiting_time_rr += waiting_time_RR[i];
avg_waiting_time_ps += waiting_time_PS[i];
}
avg_waiting_time_FCFS /= n;
avg_waiting_time_SJF /= n;
avg_waiting_time_rr /= n;
avg_waiting_time_ps /= n;
printf("\nAverage Waiting Time for FCFS: %.2f\n", avg_waiting_time_FCFS);
printf("Average Waiting Time for SJF: %.2f\n", avg_waiting_time_SJF);
printf("Average Waiting Time for Round Robin: %.2f\n",
avg_waiting_time_rr);
printf("Average Waiting Time for Priority Scheduling: %.2f\n",
avg_waiting_time_ps);
printf("\nBest Scheduling Algorithm: ");
if (avg_waiting_time_FCFS <= avg_waiting_time_SJF && avg_waiting_time_FCFS
<= avg_waiting_time_rr && avg_waiting_time_FCFS <= avg_waiting_time_ps) {
printf("FCFS\n");
} else if (avg_waiting_time_SJF <= avg_waiting_time_FCFS &&
avg_waiting_time_SJF <= avg_waiting_time_rr && avg_waiting_time_SJF <=
avg_waiting_time_ps) {
printf("SJF\n");
} else if (avg_waiting_time_rr <= avg_waiting_time_FCFS &&
avg_waiting_time_rr <= avg_waiting_time_SJF && avg_waiting_time_rr <=
avg_waiting_time_ps) {
printf("Round Robin\n");
} else {
printf("Priority Scheduling\n");
}
free(processes);
free(waiting_time_FCFS);
free(turnaround_time_FCFS);
free(waiting_time_SJF);
free(turnaround_time_SJF);
free(waiting_time_RR);
free(turnaround_time_RR);
free(waiting_time_PS);
free(turnaround_time_PS);
return 0;

OUTPUT:

You might also like