Scribd
Upload
6 views

Program-2-1

Uploaded by

darshangowda0525
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
6 views

Program-2-1

Uploaded by

darshangowda0525
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 5

/*2.

Simulate the following CPU scheduling algorithms to find turnaround time and
waiting time
a) FCFS
b) SJF
c) Round Robin
d) Priority.*/

a) FCFS :

#include <stdio.h>
struct Process {
int pid; // Process ID
int arrival; // Arrival time
int burst; // Burst time
};

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


int currentTime = 0;
printf("Process\tArrival Time\tBurst Time \tWaiting Time\tTurnaround Time\n");

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


if (currentTime < processes[i].arrival) {
currentTime = processes[i].arrival;
}

int waitingTime = currentTime - processes[i].arrival;


int turnaroundTime = waitingTime + processes[i].burst;

printf("%d\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].pid,
processes[i].arrival,
processes[i].burst, waitingTime, turnaroundTime);

currentTime += processes[i].burst;
}
}

int main() {
struct Process processes[] = {
{1, 0, 6},
{2, 2, 3},
{3, 3, 8}
};
int n = sizeof(processes) / sizeof(processes[0]);
fcfsScheduling(processes, n);
return 0;
}

b) SJF:

#include <stdio.h>
struct Process {
int pid; // Process ID
int burst; // Burst time
};

void findWaitingTime(struct Process proc[], int n, int wt[]) {


wt[0] = 0;
for (int i = 1; i < n; i++) {
wt[i] = proc[i - 1].burst + wt[i - 1];
}
}

void findTurnAroundTime(struct Process proc[], int n, int wt[], int tat[]) {


for (int i = 0; i < n; i++) {
tat[i] = proc[i].burst + wt[i];
}
}

void findAverageTime(struct Process proc[], int n) {


int wt[n], tat[n];
findWaitingTime(proc, n, wt);
findTurnAroundTime(proc, n, wt, tat);
float total_wt = 0, total_tat = 0;

printf("Process\tBurst Time\tWaiting Time\tTurnaround Time\n");


for (int i = 0; i < n; i++) {
total_wt += wt[i];
total_tat += tat[i];
printf("%d\t%d\t\t%d\t\t%d\n", proc[i].pid, proc[i].burst, wt[i], tat[i]);
}

printf("Average waiting time = %.2f\n", (float)total_wt / n);


printf("Average turnaround time = %.2f\n", (float)total_tat / n);
}

void sortProcesses(struct Process proc[], int n) {


for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (proc[j].burst > proc[j + 1].burst) {
struct Process temp = proc[j];
proc[j] = proc[j + 1];
proc[j + 1] = temp;
}
}
}
}

int main() {
int n;
printf("Enter the number of processes: ");
scanf("%d", &n);

struct Process proc[n];


for (int i = 0; i < n; i++) {
proc[i].pid = i + 1;
printf("Enter burst time for process %d: ", i + 1);
scanf("%d", &proc[i].burst);
}

sortProcesses(proc, n);
findAverageTime(proc, n);

return 0;
}

c) Round Robin:

#include <stdio.h>
struct Process {
int pid; // Process ID
int burst; // Burst time
};

void roundRobinScheduling(struct Process processes[], int n, int timeQuantum) {


int remaining[n];
int currentTime = 0;

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


remaining[i] = processes[i].burst;
}

while (1) {
int allDone = 1;

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


if (remaining[i] > 0) {
allDone = 0;

if (remaining[i] > timeQuantum) {


currentTime += timeQuantum;
remaining[i] -= timeQuantum;
printf("Process %d executed for time quantum %d\n",
processes[i].pid, timeQuantum);
} else {
currentTime += remaining[i];
remaining[i] = 0;
printf("Process %d executed for remaining time %d\n",
processes[i].pid, remaining[i]);
}
}
}

if (allDone)
break;
}
}

int main() {
struct Process processes[] = {
{1, 10},
{2, 5},
{3, 8},
{4, 12}
};

int n = sizeof(processes) / sizeof(processes[0]);


int timeQuantum = 4;
roundRobinScheduling(processes, n, timeQuantum);

return 0;
}

d) Priority:

#include <stdio.h>
#include <stdlib.h>
#define MAX_PROCESSES 10

typedef struct Process {


int id; // Process ID
int priority; // Priority of the process (lower value indicates higher
priority)
int burst_time; // Burst time (time required to complete the process)
} Process;

void initializeProcesses(Process processes[], int num_processes) {


for (int i = 0; i < num_processes; i++) {
processes[i].id = i;
printf("Enter priority for Process %d: ", i);
scanf("%d", &processes[i].priority);
printf("Enter burst time for Process %d: ", i);
scanf("%d", &processes[i].burst_time);
}
}

void priorityScheduling(Process processes[], int num_processes) {


for (int i = 0; i < num_processes - 1; i++) {
for (int j = 0; j < num_processes - i - 1; j++) {
if (processes[j].priority > processes[j + 1].priority) {
Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
}

int total_time = 0;
double average_waiting_time = 0.0;

printf("\nProcess Execution Order:\n");


for (int i = 0; i < num_processes; i++) {
printf("Process %d (Priority %d) is executing for %d seconds.\n",
processes[i].id, processes[i].priority, processes[i].burst_time);
total_time += processes[i].burst_time;
average_waiting_time += total_time;
average_waiting_time += total_time;
}

average_waiting_time /= num_processes;
printf("\nAverage Waiting Time: %.2lf seconds\n", average_waiting_time);
}

int main() {
int num_processes;
printf("Enter the number of processes: ");
scanf("%d", &num_processes);

if (num_processes <= 0 || num_processes > MAX_PROCESSES) {


printf("Invalid number of processes. Please enter a valid number.\n");
return 1;
}

Process processes[MAX_PROCESSES];
initializeProcesses(processes, num_processes);
priorityScheduling(processes, num_processes);

return 0;
}

You might also like