End Term Project

On
Design Principles of Operating System (CSE 3249)
Submitted by

Name : Priyakanta Swain

Reg. No. : 2241019611
Branch : CSE
Semester : 5th
Section : 21
Session : 2024-2025
Admission Batch : 2022

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

FACULTY OF ENGINEERING & TECHNOLOGY (ITER)
SIKSHA ‘O’ ANUSANDHAN DEEMED TO BE UNIVERSITY
Project 1:
The C program provides an interface to the user to implement the following scheduling policies as
per the choice provided:
1. First Come First Served (FCFS)
2. Round Robin (RR)
Appropriate option needs to be chosen from a switch case-based menu driven program with an
option of “Exit from program” in case 5 and accordingly a scheduling policy will print the Gantt
chart and the average waiting time, average turnaround time and average response time. The
program will take Process ids, its arrival time, and its CPU burst time as input. For implementing
RR scheduling, user also needs to specify the time quantum. Assume that the process ids should
be unique for all processes. Each process consists of a single CPU burst (no I/O bursts), and
processes are listed in order of their arrival time. Further assume that an interrupted process gets
placed at the back of the Ready queue, and a newly arrived process gets placed at the back of the
Ready queue as well. The output should be displayed in a formatted way for clarity of
understanding and visual.
CODE:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Process
{
char id[10];
int arrival_time, burst_time, completion_time, turnaround_time, waiting_time, response_time;
};
void printGanttChart(struct Process p[], int n)
{
printf("\nGantt Chart:\n|");
for (int i = 0; i < n; i++)
{
printf(" %s |", p[i].id);
}
printf("\n0");
for (int i = 0; i < n; i++)
{
printf(" %d", p[i].completion_time);
}
printf("\n");
}
void calculateAverages(struct Process p[], int n)
{
 float total_tat = 0, total_wt = 0, total_rt = 0;
for (int i = 0; i < n; i++)
{
total_tat += p[i].turnaround_time;
total_wt += p[i].waiting_time;
total_rt += p[i].response_time;
}
printf("\nAverage Turnaround Time: %.2f\n", total_tat / n);
printf("Average Waiting Time: %.2f\n", total_wt / n);
printf("Average Response Time: %.2f\n", total_rt / n);
}
void FCFS(struct Process p[], int n)
{
int time = 0;
for (int i = 0; i < n; i++)
{
if (time < p[i].arrival_time)
{
time = p[i].arrival_time;
}
time += p[i].burst_time;
p[i].completion_time = time;
p[i].turnaround_time = p[i].completion_time - p[i].arrival_time;
p[i].waiting_time = p[i].turnaround_time - p[i].burst_time;
p[i].response_time = p[i].waiting_time;
}
printf("\nFCFS Scheduling:\n");
printf("PID\tAT\tBT\tCT\tTAT\tWT\tRT\n");
for (int i = 0; i < n; i++)
{
printf("%s\t%d\t%d\t%d\t%d\t%d\t%d\n",
p[i].id, p[i].arrival_time, p[i].burst_time,
p[i].completion_time, p[i].turnaround_time, p[i].waiting_time, p[i].response_time);
}
printGanttChart(p, n);
calculateAverages(p, n);
}
void RoundRobin(struct Process p[], int n, int quantum)
{
int time = 0, remaining[n], finished = 0;
for (int i = 0; i < n; i++)
{
remaining[i] = p[i].burst_time;
 p[i].response_time = -1;
}
printf("\nGantt Chart:\n|");
while (finished < n)
{
for (int i = 0; i < n; i++)
{
if (remaining[i] > 0 && p[i].arrival_time <= time)
{
if (p[i].response_time == -1)
{
p[i].response_time = time - p[i].arrival_time;
}
printf(" %s |", p[i].id);

int exec_time = remaining[i] > quantum ? quantum : remaining[i];

time += exec_time;
remaining[i] -= exec_time;
if (remaining[i] == 0)
{
finished++;
p[i].completion_time = time;
p[i].turnaround_time = p[i].completion_time - p[i].arrival_time;
p[i].waiting_time = p[i].turnaround_time - p[i].burst_time;
}
}
}
if (finished < n && remaining[finished] > 0)
time++;
}
printf("\n0");
for (int i = 0; i < n; i++)
{
printf(" %d", p[i].completion_time);
}
printf("\n");
printf("\nRound Robin Scheduling:\n");
printf("PID\tAT\tBT\tCT\tTAT\tWT\tRT\n");
for (int i = 0; i < n; i++)
{
printf("%s\t%d\t%d\t%d\t%d\t%d\t%d\n",
p[i].id, p[i].arrival_time, p[i].burst_time,
p[i].completion_time, p[i].turnaround_time, p[i].waiting_time, p[i].response_time);
 }
calculateAverages(p, n);
}
int main()
{
int n, choice, quantum;
printf("Enter the number of processes: ");
scanf("%d", &n);

struct Process p[n];

printf("Enter Process ID, Arrival Time, and Burst Time:\n");
for (int i = 0; i < n; i++)
{
scanf("%s %d %d", p[i].id, &p[i].arrival_time, &p[i].burst_time);
}
while (1)
{
printf("\nCPU Scheduling Menu:\n1. FCFS\n2. Round Robin\n3. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice)
{
case 1:
FCFS(p, n);
break;
case 2:
printf("Enter Time Quantum: ");
scanf("%d", &quantum);
RoundRobin(p, n, quantum);
break;
case 3:
exit(0);
default:
printf("Invalid choice!\n");
}
}
return 0;
}
Project 2:
The banker’s algorithm is a resource allocation and deadlock avoidance algorithm that tests for
safety by simulating the allocation for predetermined maximum possible amounts of all resources,
then makes a state” check to test for possible activities, before deciding whether allocation should
be allowed to continue.
CODE:
#include <stdio.h>
#include <stdbool.h>
#define P 5
#define R 4
void calculateNeed(int need[P][R], int max[P][R], int allot[P][R])
{
for (int i = 0; i < P; i++)
for (int j = 0; j < R; j++)
need[i][j] = max[i][j] - allot[i][j];
}
bool isSafe(int processes[], int avail[], int max[][R], int allot[][R])
{
int need[P][R];
calculateNeed(need, max, allot);
bool finished[P] = {false};
int safeSequence[P];
int work[R];
for (int i = 0; i < R; i++)
work[i] = avail[i];
int count = 0;
while (count < P)
{
bool found = false;
for (int i = 0; i < P; i++)
{
if (!finished[i])
{
bool canAllocate = true;
for (int j = 0; j < R; j++)
if (need[i][j] > work[j])
{
canAllocate = false;
break;
}
if (canAllocate)
 {
for (int j = 0; j < R; j++)
work[j] += allot[i][j];
safeSequence[count++] = processes[i];
finished[i] = true;
found = true;
}
}
}
if (!found)
{
printf("System is not in a safe state.\n");
return false;
}
}
printf("System is in a safe state.\nSafe sequence is: ");
for (int i = 0; i < P; i++)
printf("%d ", safeSequence[i]);
printf("\n");
return true;
}
int main()
{
int processes[] = {0, 1, 2, 3, 4};
int avail[] = {6, 7, 12, 12};
int max[P][R] = {{0, 0, 1, 2},{2, 7, 5, 0},{6, 6, 5, 6},{4, 3, 5, 6}, {0, 6, 5, 2}};
int allot[P][R] = {{0, 0, 1, 2},{2, 0, 0, 0},{0, 0, 3, 4},{2, 3, 5, 4},{0, 3, 3, 2}};
isSafe(processes, avail, max, allot);
return 0;
}