ASSIGNMENT-3

NAME: - VAIbhAV ShuklA

Sub:- OpErATING SySTEM
STd: - Ty bSc (cS)
dIV: -A
rOll NO.: - 233331072
bATch: - b4
Set A:

i. Write the program to simulate FCFS CPU-scheduling. The arrival time and first CPU burst
for different n number of processes should be input to the algorithm. Assume that The
fixed IO waiting time (2 units). The next CPU-burst should be generated randomly. The
output should give Gantt chart, turnaround time and waiting time for each process.Also
find the average waiting time and turnaround time.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

// Define a process structure to hold process information

Struct Process {

Int id;

Int arrivalTime;

Int burstTime;

Int completionTime;

Int turnaroundTime;

Int waitingTime;

};

// Function to calculate turnaround time and waiting time for each process

Void calculateTimes(struct Process processes[], int n) {

Int currentTime = 0;

For (int I = 0; I < n; i++) {

If (currentTime < processes[i].arrivalTime)

currentTime = processes[i].arrivalTime;

processes[i].completionTime = currentTime + processes[i].burstTime;

processes[i].turnaroundTime = processes[i].completionTime – processes[i].arrivalTime;

processes[i].waitingTime = processes[i].turnaroundTime – processes[i].burstTime;

 currentTime = processes[i].completionTime;

// Function to perform FCFS scheduling

Void fcfsScheduling(struct Process processes[], int n) {

calculateTimes(processes, n);

printf(“Gantt Chart:\n”);

printf(“ Process\tStart Time\tEnd Time\n”);

for (int I = 0; I < n; i++) {

printf(“ P%d\t\t%d\t\t%d\n”, processes[i].id, processes[i].arrivalTime,

processes[i].completionTime);

Double totalTurnaroundTime = 0, totalWaitingTime = 0;

For (int I = 0; I < n; i++) {

totalTurnaroundTime += processes[i].turnaroundTime;

totalWaitingTime += processes[i].waitingTime;

Printf(“\nAverage Turnaround Time: %.2lf\n”, totalTurnaroundTime / n);

Printf(“Average Waiting Time: %.2lf\n”, totalWaitingTime / n);

Int main() {

Int n;

Printf(“Enter the number of processes: “);

 Scanf(“%d”, &n);

Struct Process processes[n];

// Input arrival time and burst time for each process

For (int I = 0; I < n; i++) {

Processes[i].id = I + 1;

Printf(“Enter Arrival Time for P%d: “, I + 1);

Scanf(“%d”, &processes[i].arrivalTime);

Printf(“Enter Burst Time for P%d: “, I + 1);

Scanf(“%d”, &processes[i].burstTime);

fcfsScheduling(processes, n);

return 0;

}
 ii. Write the program to simulate Non-preemptive Shortest Job First (SJF) -scheduling. The
Arrival time and first CPU-burst for different n number of processes should be input to
the Algorithm. Assume the fixed IO waiting time (2 units). The next CPU-burst should be
Generated randomly. The output should give Gantt chart, turnaround time and waiting
Time for each process. Also find the average waiting time and turnaround time.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

// Define a process structure to hold process information

Struct Process {

Int id;

Int arrivalTime;

Int burstTime;

Int completionTime;

Int turnaroundTime;

Int waitingTime;

};

// Function to calculate turnaround time and waiting time for each process

Void calculateTimes(struct Process processes[], int n) {

Int currentTime = 0;

Int completedProcesses = 0;

While (completedProcesses < n) {

Int shortestJob = -1;

Int shortestTime = INT_MAX;

For (int I = 0; I < n; i++) {

If (processes[i].arrivalTime <= currentTime && processes[i].burstTime < shortestTime &&

processes[i].burstTime > 0) {
 shortestJob = I;

shortestTime = processes[i].burstTime;

If (shortestJob == -1) {

currentTime++;

} else {

Processes[shortestJob].completionTime = currentTime + processes[shortestJob].burstTime;

Processes[shortestJob].turnaroundTime = processes[shortestJob].completionTime –
processes[shortestJob].arrivalTime;

Processes[shortestJob].waitingTime = processes[shortestJob].turnaroundTime –
processes[shortestJob].burstTime;

Processes[shortestJob].burstTime = 0;

currentTime = processes[shortestJob].completionTime;

completedProcesses++;

// Function to perform Non-preemptive SJF scheduling

Void sjfScheduling(struct Process processes[], int n) {

calculateTimes(processes, n);

printf(“Gantt Chart:\n”);

printf(“ Process\tStart Time\tEnd Time\n”);

for (int I = 0; I < n; i++) {

printf(“ P%d\t\t%d\t\t%d\n”, processes[i].id, processes[i].arrivalTime,

processes[i].completionTime);

}
 Double totalTurnaroundTime = 0, totalWaitingTime = 0;

For (int I = 0; I < n; i++) {

totalTurnaroundTime += processes[i].turnaroundTime;

totalWaitingTime += processes[i].waitingTime;

Printf(“\nAverage Turnaround Time: %.2lf\n”, totalTurnaroundTime / n);

Printf(“Average Waiting Time: %.2lf\n”, totalWaitingTime / n);

Int main() {

Int n;

Printf(“Enter the number of processes: “);

Scanf(“%d”, &n);

Struct Process processes[n];

// Input arrival time and burst time for each process

For (int I = 0; I < n; i++) {

Processes[i].id = I + 1;

Printf(“Enter Arrival Time for P%d: “, I + 1);

Scanf(“%d”, &processes[i].arrivalTime);

Printf(“Enter Burst Time for P%d: “, I + 1);

Scanf(“%d”, &processes[i].burstTime);

sjfScheduling(processes, n);

return 0;

}
Set B:

i. Write the program to simulate Preemptive Shortest Job First (SJF) -scheduling. The
Arrival time and first CPU-burst for different n number of processes should be input to
the Algorithm. Assume the fixed IO waiting time (2 units). The next CPU-burst should be
Generated randomly. The output should give Gantt chart, turnaround time and waiting
Time for each process. Also find the average waiting time and turnaround time.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

// Define a process structure to hold process information

Struct Process {

Int id;

Int arrivalTime;

Int burstTime;

Int completionTime;

Int turnaroundTime;

Int waitingTime;

Int remainingTime;

};
// Function to calculate turnaround time and waiting time for each process

Void calculateTimes(struct Process processes[], int n) {

Int currentTime = 0;

Int completedProcesses = 0;

While (completedProcesses < n) {

Int shortestJob = -1;

Int shortestTime = INT_MAX;

For (int I = 0; I < n; i++) {

If (processes[i].arrivalTime <= currentTime && processes[i].remainingTime < shortestTime &&

processes[i].remainingTime > 0) {

shortestJob = I;

shortestTime = processes[i].remainingTime;

If (shortestJob == -1) {

currentTime++;

} else {

Processes[shortestJob].remainingTime--;

currentTime++;

if (processes[shortestJob].remainingTime == 0) {

processes[shortestJob].completionTime = currentTime;

processes[shortestJob].turnaroundTime = processes[shortestJob].completionTime –
processes[shortestJob].arrivalTime;

processes[shortestJob].waitingTime = processes[shortestJob].turnaroundTime –
processes[shortestJob].burstTime;

completedProcesses++;

}
}

// Function to perform Preemptive SJF scheduling

Void preemptiveSjfScheduling(struct Process processes[], int n) {

For (int I = 0; I < n; i++) {

Processes[i].remainingTime = processes[i].burstTime;

calculateTimes(processes, n);

printf(“Gantt Chart:\n”);

printf(“ Process\tStart Time\tEnd Time\n”);

for (int I = 0; I < n; i++) {

printf(“ P%d\t\t%d\t\t%d\n”, processes[i].id, processes[i].arrivalTime,

processes[i].completionTime);

Double totalTurnaroundTime = 0, totalWaitingTime = 0;

For (int I = 0; I < n; i++) {

totalTurnaroundTime += processes[i].turnaroundTime;

totalWaitingTime += processes[i].waitingTime;

Printf(“\nAverage Turnaround Time: %.2lf\n”, totalTurnaroundTime / n);

Printf(“Average Waiting Time: %.2lf\n”, totalWaitingTime / n);

Int main() {

Int n;
 Printf(“Enter the number of processes: “);

Scanf(“%d”, &n);

Struct Process processes[n];

// Input arrival time and burst time for each process

For (int I = 0; I < n; i++) {

Processes[i].id = I + 1;

Printf(“Enter Arrival Time for P%d: “, I + 1);

Scanf(“%d”, &processes[i].arrivalTime);

Printf(“Enter Burst Time for P%d: “, I + 1);

Scanf(“%d”, &processes[i].burstTime);

preemptiveSjfScheduling(processes, n);

return 0;

}
 ii. Write the program to simulate Non-preemptive Priority scheduling. The arrival time and
First CPU-burst and priority for different n number of processes should be input to the
Algorithm. Assume the fixed IO waiting time (2 units). The next CPU-burst should be
Generated randomly. The output should give Gantt chart, turnaround time and waiting
Time for each process. Also find the average waiting time and turnaround time.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

// Define a process structure to hold process information

Struct Process {

Int id;

Int arrivalTime;

Int burstTime;

Int priority;

Int completionTime;

Int turnaroundTime;

Int waitingTime;

};

// Function to calculate turnaround time and waiting time for each process

Void calculateTimes(struct Process processes[], int n) {

Int currentTime = 0;
 Int completedProcesses = 0;

While (completedProcesses < n) {

Int highestPriorityJob = -1;

Int highestPriority = INT_MAX;

For (int I = 0; I < n; i++) {

If (processes[i].arrivalTime <= currentTime && processes[i].priority < highestPriority &&

processes[i].burstTime > 0) {

highestPriorityJob = I;

highestPriority = processes[i].priority;

If (highestPriorityJob == -1) {

currentTime++;

} else {

Processes[highestPriorityJob].completionTime = currentTime +
processes[highestPriorityJob].burstTime;

Processes[highestPriorityJob].turnaroundTime =
processes[highestPriorityJob].completionTime – processes[highestPriorityJob].arrivalTime;

Processes[highestPriorityJob].waitingTime = processes[highestPriorityJob].turnaroundTime –
processes[highestPriorityJob].burstTime;

Processes[highestPriorityJob].burstTime = 0;

currentTime = processes[highestPriorityJob].completionTime;

completedProcesses++;

// Function to perform Non-preemptive Priority scheduling

Void nonPreemptivePriorityScheduling(struct Process processes[], int n) {

 calculateTimes(processes, n);

printf(“Gantt Chart:\n”);

printf(“ Process\tStart Time\tEnd Time\n”);

for (int I = 0; I < n; i++) {

printf(“ P%d\t\t%d\t\t%d\n”, processes[i].id, processes[i].arrivalTime,

processes[i].completionTime);

Double totalTurnaroundTime = 0, totalWaitingTime = 0;

For (int I = 0; I < n; i++) {

totalTurnaroundTime += processes[i].turnaroundTime;

totalWaitingTime += processes[i].waitingTime;

Printf(“\nAverage Turnaround Time: %.2lf\n”, totalTurnaroundTime / n);

Printf(“Average Waiting Time: %.2lf\n”, totalWaitingTime / n);

Int main() {

Int n;

Printf(“Enter the number of processes: “);

Scanf(“%d”, &n);

Struct Process processes[n];

// Input arrival time, burst time, and priority for each process

For (int I = 0; I < n; i++) {

Processes[i].id = I + 1;
 Printf(“Enter Arrival Time for P%d: “, I + 1);

Scanf(“%d”, &processes[i].arrivalTime);

Printf(“Enter Burst Time for P%d: “, I + 1);

Scanf(“%d”, &processes[i].burstTime);

Printf(“Enter Priority for P%d: “, I + 1);

Scanf(“%d”, &processes[i].priority);

nonPreemptivePriorityScheduling(processes, n);

return 0;