Assignment
Implement a Process Scheduler.
FirstComeFirstServe :
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
void fcfs(int n, int burst[], int process[]) {
int wait[n], turnAround[n], completion[n];
float avgWait = 0, avgTurnAround = 0;
// Calculate Completion Time
completion[0] = burst[0];
for (int i = 1; i < n; i++) {
completion[i] = completion[i - 1] + burst[i];
// Calculate Turn Around Time and Waiting Time
for (int i = 0; i < n; i++) {
turnAround[i] = completion[i];
wait[i] = turnAround[i] - burst[i];
avgWait += wait[i];
avgTurnAround += turnAround[i];
// Output Table
printf("\nFCFS Scheduling:\n");
printf("Process\tBurst Time\tWaiting Time\tTurnaround Time\tCompletion Time\n");
for (int i = 0; i < n; i++) {
printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", process[i], burst[i], wait[i], turnAround[i],
completion[i]);
}
printf("Average Waiting Time: %.2f\n", avgWait / n);
printf("Average Turnaround Time: %.2f\n", avgTurnAround / n);
int main() {
int n, quantum;
printf("Enter number of processes: ");
scanf("%d", &n);
int burst[n], process[n];
for (int i = 0; i < n; i++) {
printf("Enter burst time for process P%d: ", i + 1);
scanf("%d", &burst[i]);
process[i] = i + 1;
// FCFS
fcfs(n, burst, process);
return 0;
Output :-
Enter number of processes: 3
Enter burst time for process P1: 24
Enter burst time for process P2: 3
Enter burst time for process P3: 4
FCFS Scheduling:
Process Burst Time Waiting Time Turnaround Time Completion Time
P1 24 0 24 24
P2 3 24 27 27
P3 4 27 31 32
Average Waiting Time: 17.00
Average Turnaround Time: 27.33
Shortest Job First :
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
void sjf(int n, int burst[], int process[]) {
int wait[n], turnAround[n], completion[n], burstCopy[n], order[n];
float avgWait = 0, avgTurnAround = 0;
// Copy burst times and process numbers
for (int i = 0; i < n; i++) {
burstCopy[i] = burst[i];
order[i] = i;
// Sort by burst time
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (burstCopy[i] > burstCopy[j]) {
// Swap burst times
int temp = burstCopy[i];
burstCopy[i] = burstCopy[j];
burstCopy[j] = temp;
// Swap process order
temp = order[i];
order[i] = order[j];
order[j] = temp;
}
// Calculate Completion Time
completion[0] = burstCopy[0];
for (int i = 1; i < n; i++) {
completion[i] = completion[i - 1] + burstCopy[i];
// Calculate Turn Around Time and Waiting Time
for (int i = 0; i < n; i++) {
turnAround[i] = completion[i];
wait[i] = turnAround[i] - burstCopy[i];
avgWait += wait[i];
avgTurnAround += turnAround[i];
// Output Table
printf("\nSJF Scheduling:\n");
printf("Process\tBurst Time\tWaiting Time\tTurnaround Time\tCompletion Time\n");
for (int i = 0; i < n; i++) {
printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", process[order[i]], burstCopy[i], wait[i], turnAround[i],
completion[i]);
printf("Average Waiting Time: %.2f\n", avgWait / n);
printf("Average Turnaround Time: %.2f\n", avgTurnAround / n);
int main() {
int n, quantum;
printf("Enter number of processes: ");
scanf("%d", &n);
int burst[n], process[n];
for (int i = 0; i < n; i++) {
printf("Enter burst time for process P%d: ", i + 1);
scanf("%d", &burst[i]);
process[i] = i + 1;
// SJF
sjf(n, burst, process);
return 0;
Output :
Enter number of processes: 3
Enter burst time for process P1: 24
Enter burst time for process P2: 3
Enter burst time for process P3: 3
SJF Scheduling:
Process Burst Time Waiting Time Turnaround Time Completion Time
P2 3 0 3 3
P3 3 3 6 6
P1 24 6 30 30
Average Waiting Time: 3.00
Average Turnaround Time: 13.00
Round Robin :
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
void roundRobin(int n, int burst[], int process[], int quantum) {
int remaining[n], wait[n], turnAround[n], completion[n];
float avgWait = 0, avgTurnAround = 0;
int time = 0, done = 0;
// Initialize remaining burst times
for (int i = 0; i < n; i++) {
remaining[i] = burst[i];
// Round Robin execution
while (done < n) {
for (int i = 0; i < n; i++) {
if (remaining[i] > 0) {
if (remaining[i] <= quantum) {
time += remaining[i];
remaining[i] = 0;
completion[i] = time;
done++;
} else {
time += quantum;
remaining[i] -= quantum;
// Calculate Turn Around Time and Waiting Time
for (int i = 0; i < n; i++) {
turnAround[i] = completion[i];
wait[i] = turnAround[i] - burst[i];
avgWait += wait[i];
avgTurnAround += turnAround[i];
}
// Output Table
printf("\nRound Robin Scheduling (Quantum: %d):\n", quantum);
printf("Process\tBurst Time\tWaiting Time\tTurnaround Time\tCompletion Time\n");
for (int i = 0; i < n; i++) {
printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", process[i], burst[i], wait[i], turnAround[i],
completion[i]);
printf("Average Waiting Time: %.2f\n", avgWait / n);
printf("Average Turnaround Time: %.2f\n", avgTurnAround / n);
int main() {
int n, quantum;
printf("Enter number of processes: ");
scanf("%d", &n);
int burst[n], process[n];
for (int i = 0; i < n; i++) {
printf("Enter burst time for process P%d: ", i + 1);
scanf("%d", &burst[i]);
process[i] = i + 1;
// Round Robin
printf("\nEnter time quantum for Round Robin: ");
scanf("%d", &quantum);
roundRobin(n, burst, process, quantum);
return 0;
Output :
Enter number of processes: 3
Enter burst time for process P1: 24
Enter burst time for process P2: 3
Enter burst time for process P3: 3
Enter time quantum for Round Robin: 4
Round Robin Scheduling (Quantum: 4):
Process Burst Time Waiting Time Turnaround Time Completion Time
P1 24 6 30 30
P2 3 4 7 7
P3 3 7 10 10
Average Waiting Time : 5.67
Average Turnaround Time : 15.67
Priority Scheduling(Non-Preemptive) :
#include <stdio.h>
void priorityScheduling(int n, int burst[], int priority[]) {
int waitingTime[n], turnaroundTime[n], totalWT = 0, totalTAT = 0;
int p[n];
// Initialize process numbers
for (int i = 0; i < n; i++) {
p[i] = i + 1;
// Sort processes by priority (lower value = higher priority)
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (priority[i] > priority[j]) {
// Swap priority, burst time, and process number
int temp = priority[i]; priority[i] = priority[j]; priority[j] = temp;
temp = burst[i]; burst[i] = burst[j]; burst[j] = temp;
temp = p[i]; p[i] = p[j]; p[j] = temp;
// Calculate Waiting Time and Turnaround Time
waitingTime[0] = 0; // First process has no waiting time
for (int i = 1; i < n; i++) {
waitingTime[i] = waitingTime[i - 1] + burst[i - 1];
totalWT += waitingTime[i];
for (int i = 0; i < n; i++) {
turnaroundTime[i] = waitingTime[i] + burst[i];
totalTAT += turnaroundTime[i];
// Print results
printf("Process\tPriority\tBurst Time\tWaiting Time\tTurnaround Time\n");
for (int i = 0; i < n; i++) {
printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", p[i], priority[i], burst[i], waitingTime[i],
turnaroundTime[i]);
printf("\nAverage Waiting Time: %.2f", (float)totalWT / n);
printf("\nAverage Turnaround Time: %.2f\n", (float)totalTAT / n);
int main() {
int n;
printf("Enter number of processes: ");
scanf("%d", &n);
int burst[n], priority[n];
printf("Enter burst times and priorities:\n");
for (int i = 0; i < n; i++) {
printf("P%d Burst Time: ", i + 1);
scanf("%d", &burst[i]);
printf("P%d Priority: ", i + 1);
scanf("%d", &priority[i]);
priorityScheduling(n, burst, priority);
return 0;
Output :
Enter number of processes: 5
Enter burst times and priorities:
P1 Burst Time: 10
P1 Priority: 3
P2 Burst Time: 1
P2 Priority: 1
P3 Burst Time: 2
P3 Priority: 4
P4 Burst Time: 1
P4 Priority: 5
P5 Burst Time: 5
P5 Priority: 2
Priority Scheduling :
Process Priority Burst Time Waiting Time Turnaround Time
P2 1 1 0 1
P5 2 5 1 6
P1 3 10 6 16
P3 4 2 16 18
P4 5 1 18 19
Average Waiting Time : 8.20
Average Turnaround Time : 12.00
Priority Scheduling with Round Robin :
#include <stdio.h>
struct Process {
int id, burst, remaining, priority, arrival, waiting, turnaround, completed;
};
void priorityRoundRobin(struct Process p[], int n, int timeQuantum) {
int currentTime = 0, completed = 0;
float totalWT = 0, totalTAT = 0;
while (completed < n) {
int idle = 1;
for (int priority = 1; priority <= n; priority++) { // Priority-based selection
for (int i = 0; i < n; i++) {
if (p[i].priority == priority && p[i].remaining > 0 && p[i].arrival <= currentTime) {
idle = 0;
int timeSlice = (p[i].remaining < timeQuantum) ? p[i].remaining : timeQuantum;
p[i].remaining -= timeSlice;
currentTime += timeSlice;
if (p[i].remaining == 0) {
p[i].completed = 1;
p[i].turnaround = currentTime - p[i].arrival;
p[i].waiting = p[i].turnaround - p[i].burst;
totalWT += p[i].waiting;
totalTAT += p[i].turnaround;
completed++;
}
}
}
}
if (idle) currentTime++; // Increment time for idle periods
}
// Output results
printf("\nProcess\tPriority\tBurst Time\tArrival Time\tWaiting Time\tTurnaround Time\n");
for (int i = 0; i < n; i++) {
printf("P%d\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", p[i].id, p[i].priority, p[i].burst, p[i].arrival,
p[i].waiting, p[i].turnaround);
}
printf("\nAverage Waiting Time: %.2f", totalWT / n);
printf("\nAverage Turnaround Time: %.2f\n", totalTAT / n);
}
int main() {
int n, timeQuantum;
printf("Enter number of processes: ");
scanf("%d", &n);
struct Process p[n];
printf("Enter time quantum: ");
scanf("%d", &timeQuantum);
printf("Enter burst times, priorities, and arrival times:\n");
for (int i = 0; i < n; i++) {
p[i].id = i + 1;
printf("P%d Burst Time: ", i + 1);
scanf("%d", &p[i].burst);
printf("P%d Priority (lower = higher priority): ", i + 1);
scanf("%d", &p[i].priority);
printf("P%d Arrival Time: ", i + 1);
scanf("%d", &p[i].arrival);
p[i].remaining = p[i].burst;
p[i].completed = 0;
}
priorityRoundRobin(p, n, timeQuantum);
return 0;
}
Output :
Enter number of processes: 5
Enter time quantum: 2
Enter burst times, priorities, and arrival times:
P1 Burst Time: 4
P1 Priority (lower = higher priority): 3
P1 Arrival Time: 2
P2 Burst Time: 5
P2 Priority (lower = higher priority): 2
P2 Arrival Time: 1
P3 Burst Time: 8
P3 Priority (lower = higher priority): 2
P3 Arrival Time: 4
P4 Burst Time: 7
P4 Priority (lower = higher priority): 1
P4 Arrival Time: 5
P5 Burst Time: 3
P5 Priority (lower = higher priority): 3
P5 Arrival Time: 3
Priority Scheduling :
Process Priority Burst Time Arrival Time Waiting Time Turnaround
Time
P1 3 4 2 9 13
P2 2 5 1 13 18
P3 2 8 4 16 27
P4 1 7 5 14 21
P5 3 3 3 10 13
Average Waiting Time: 12.40
Average Turnaround Time: 17.80
