Scribd
Upload
18 views5 pages

Program-2-1

Uploaded by

darshangowda0525
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
18 views5 pages

Program-2-1

Uploaded by

darshangowda0525
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
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