Bachelor Of Technology

In
Computer Science Engineering Core
(Session: 2024-25)

Lab File for Operating System

R1UC403B

School of Computing Science & Engineering Galgotias

University, Greater Noida

Name : ABHISHEK PAL

Admission No : 23SCSE1410095
Semester: IV
Section : 40
Submitted to: SARVESH SIR
 Experiment: 1
Aim:-Execution of basic Linux commands and hands on experience in Command Line
Interface(CLI) in Linux.

1.Date and Calendar command

Date Command:-Display the current date and time.
Output:-

• Calendar Command:-Displays the calendar of a specific year or a month.

Output:-

2.Directory Related Commands

• Present Working Directory Command:-Shows your current directory path.

Output:-
• MKDIR Command:-Used to create directories(folders).
Output:-

3.File Related Commands

• touch:-Creates a new empty file.

OUTPUT:

• cat:-Displays the content of a file.

• cp:- Copies files or directories from one location to another

4.Commands
• ls:- Lists files and directories in the current folder.

• rm:- Deletes files or directories permanently from the filesystem.

• cd:- Changes the current working directory to the specified path.

 Experiment: 2
Aim:-Write a shell program to check the given number is even or odd.
CODE:-
echo -n "Enter a number: "
read number
if [ $((number % 2)) -eq 0 ]; then

echo "Even"
else
echo "Odd"
fi

Output
 Experiment: 3
Aim:- Write a Shell program to swap the two integers.

CODE:-
echo -n "Enter the first number: "
read num1
echo -n "Enter the second number: "
read num2
echo "Before swapping: num1 = $num1, num2 = $num2"
# Swapping using a temporary variable
temp=$num1
num1=$num2
num2=$temp

echo "After swapping: num1 = $num1, num2 = $num2"

Output
 Experiment: 4
Aim:- Write a Shell program to find the factorial of a number.
CODE:-
echo -n "Enter an element: "
read number
fact=1

while [ $number -gt 0 ]

do
fact=$((fact * number))
number=$((number - 1))
done
echo "Factorial: $fact"

Output
 Experiment: 5

Aim:- write a shell program to generate fibonacci series.

CODE:-
echo -n "Enter the number of Fibonacci terms: "

read n
a=0
b=1
echo "Fibonacci series:"
for (( i=0; i<n; i++ ))
do
echo -n "$a "
c=$((a + b))
a=$b
b=$c
done

Output
 Experiment: 6
Aim:- Write a C program using the following system calls (fork, exec).
CODE:-
#include <stdio.h>
#include <unistd.h>
int main() {
int pid = fork();

if (pid < 0) {
printf("Fork failed\n");
} else if (pid == 0) {
printf("Child process: PID = %d\n", getpid());
} else {
printf("Parent process: PID = %d, Child PID = %d\n", getpid(), pid);
}
return 0;
}

Output
 Experiment: 7

Aim:- Write a C program using the following system calls (get_pid, exit).
CODE:-
#include <stdio.h>

#include <unistd.h>
#include <stdlib.h>
int main() {
printf("Process ID: %d\n", getpid());
printf("Exiting the program...\n");
exit(0);
}

Output
 Experiment: 8
Aim:- Write a C program to simulate CPU scheduling algorithms: a) FCFS b) SJF c) Round
Robin

a) FCFS Algo:-
1. Input the number of processes, their arrival times, and burst times.
2. Sort the processes by arrival .
3. Initialize with current_time = 0 and arrays for CT, TAT, WT
4. For each process in sorted order:
i) If current_time < arrival_time, set current_time = arrival_time ii) CT[i] = current_time +
BT[i] iii) TAT[i] = CT[i] - AT[i] iv) WT[i] = TAT[i] - BT[i] v) Update current_time = CT[i]
5. Compute average TAT and WT.

CODE:-
#include <stdio.h>
int main() {
int n;
printf("Enter number of processes: ");
scanf("%d", &n);
int pid[n], at[n], bt[n], tat[n], wt[n];
int i, j, time = 0;
float total_tat = 0, total_wt = 0;

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

printf("Enter Process ID, Arrival Time, Burst Time: ");
scanf("%d %d %d", &pid[i], &at[i], &bt[i]);
}

// Sort by Arrival Time

for (i = 0; i < n - 1; i++) {

for (j = i + 1; j < n; j++) {
 if (at[i] > at[j]) {
int temp;
temp = at[i]; at[i] = at[j]; at[j] = temp;

temp = bt[i]; bt[i] = bt[j]; bt[j] = temp;

temp = pid[i]; pid[i] = pid[j]; pid[j] = temp;
}
}
}
// Calculate TAT and WT
for (i = 0; i < n; i++) {
if (time < at[i]) {

time = at[i];
}
time += bt[i];
tat[i] = time - at[i];
wt[i] = tat[i] - bt[i];
total_tat += tat[i];
total_wt += wt[i];
}
// Output table

printf("\nPID\tAT\tBT\tTAT\tWT\n");
for (i = 0; i < n; i++) {
printf("%d\t%d\t%d\t%d\t%d\n", pid[i], at[i], bt[i], tat[i], wt[i]);
}

// Averages
printf("\nAverage TAT = %.2f\n", total_tat / n);
printf("Average WT = %.2f\n", total_wt / n);
return 0;

}
Output

b) SJF Algo-
1. Input process information: pid[], bt[], at[].
2. Initialize: • time = 0 → Current system time • completed = 0 → Count of completed
processes • is_completed[i] = false for all i
3. Repeat until all processes are completed:
• Find the process p such that: o at[p] <= time o is_completed[p] == false o Has the shortest
burst time among such processes
• If no such process is found: o Increment time++ (CPU is idle)
• Else: o tat[p] = (time + bt[p]) - at[p] o wt[p] = tat[p] - bt[p] o time = time + bt[p] o
is_completed[p] = true o completed++
4. Output pid[i], bt[i], at[i], tat[i], wt[i] for all processes

CODE:-
#include <stdio.h>
#include <stdbool.h>
int main() {
int n;
printf("Enter number of processes: ");
scanf("%d", &n);
int pid[n], bt[n], at[n], tat[n], wt[n];
bool is_completed[n];
for (int i = 0; i < n; i++) {
printf("Enter Process ID, Arrival Time and Burst Time for process %d: ", i + 1);
scanf("%d %d %d", &pid[i], &at[i], &bt[i]);
is_completed[i] = false;
}
int time = 0, completed = 0;
while (completed < n) {
int idx = -1;
int min_bt = 1e9;
for (int i = 0; i < n; i++) {

if (at[i] <= time && !is_completed[i] && bt[i] < min_bt) {

min_bt = bt[i];
idx = i;
}

if (idx == -1) {
time++;
} else {
 time += bt[idx];
tat[idx] = time - at[idx];
wt[idx] = tat[idx] - bt[idx];

is_completed[idx] = true;
completed++;
}
}
printf("\nPID\tAT\tBT\tTAT\tWT\n");
for (int i = 0; i < n; i++) {
printf("%d\t%d\t%d\t%d\t%d\n", pid[i], at[i], bt[i], tat[i], wt[i]);
}

return 0;
}

Output

c) Round Robin Algo-

1. Initialize: • remaining_bt[i] = bt[i] for each process
• time = 0 (current time) • wt[i] = 0 for all i
• A queue for ready
2.Add processes to the ready queue when they arrive (at[i] <= time).
3.While there are processes with remaining_bt > 0:
a. Pick the next process from the ready queue.

b. If remaining_bt[i] > time_quantum,

• execute for time_quantum units: t ime += time_quantum remaining_bt[i] -=
time_quantum
• add newly arrived processes to the ready queue (arrival time ≤ current t ime)

• append this process back to the end of the ready queue (since it’s not f inished)
c. Else (process can finish within the time quantum):
• execute for remaining_bt[i] units: t ime += remaining_bt[i]
• calculate turnaround time: tat[i] = time - at[i]

• calculate waiting time: wt[i] = tat[i] - bt[i]

• set remaining_bt[i] = 0 (process finished)
• add newly arrived processes to the ready queue
4.Repeat until all processes finish (remaining_bt[i] == 0 for all).

#include <stdio.h>
#include <stdbool.h>
#define MAX 100

int main() {
int n, time_quantum;
int at[MAX], bt[MAX], remaining_bt[MAX], wt[MAX], tat[MAX];
bool is_in_queue[MAX] = {false};

printf("Enter number of processes: ");

scanf("%d", &n);
// Input AT and BT
for (int i = 0; i < n; i++) {

printf("Enter Arrival Time and Burst Time for process %d: ", i + 1);
 scanf("%d %d", &at[i], &bt[i]);
remaining_bt[i] = bt[i];
wt[i] = 0;

tat[i] = 0;
}
printf("Enter Time Quantum: ");
scanf("%d", &time_quantum);

int time = 0, completed = 0;

int queue[MAX];
int front = 0, rear = 0;

// Helper functions
void enqueue(int p) {
queue[rear++] = p;
is_in_queue[p] = true;
}

int dequeue() {
return queue[front++];
}

// Enqueue processes that have arrived at time 0

for (int i = 0; i < n; i++) {
if (at[i] <= time && !is_in_queue[i]) {
enqueue(i);

}
}
// Round Robin Execution
while (completed < n) {

if (front == rear) {
 time++;
for (int i = 0; i < n; i++) {
if (at[i] <= time && !is_in_queue[i] && remaining_bt[i] > 0) {

enqueue(i);
}
}
continue;
}

int i = dequeue();

if (remaining_bt[i] > time_quantum) {

time += time_quantum;
remaining_bt[i] -= time_quantum;
} else {
time += remaining_bt[i];
remaining_bt[i] = 0;
completed++;
tat[i] = time - at[i];
wt[i] = tat[i] - bt[i];

// Enqueue new arrivals during execution

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

if (at[j] <= time && !is_in_queue[j] && remaining_bt[j] > 0) {

enqueue(j);
}
}
 // If process is not completed, add it back to the queue
if (remaining_bt[i] > 0) {
enqueue(i);

} else {
is_in_queue[i] = false; // Prevent it from being enqueued again
}
}
printf("\nProcess\tAT\tBT\tTAT\tWT\n");
for (int i = 0; i < n; i++) {
printf("%d\t%d\t%d\t%d\t%d\n", i + 1, at[i], bt[i], tat[i], wt[i]);
}

return 0;
}

OUTPUT:-
 Experiment: 9
Aim:- Write a C program to simulate Bankers Algorithm for Deadlock Detection.

Algo-
1.Initialize:
• Work[m] = Available[m]

• Finish[n] = {false, false, ..., false}

2.Find a process i such that:
• Finish[i] == false
• Request[i][j] <= Work[j] for all j If such a process is found:
• Work[j] = Work[j] + Allocation[i][j] for all j (release all resources held by process i back to
Work)
• Finish[i] = true (process i can finish)
• Repeat Step 2 to find next such process
3.If no such process exists (no process can proceed),
stop.
4.Processes for which Finish[i] == false are deadlocked (cannot proceed).
Those with Finish[i] == true can complete safely.

CODE:-
#include <stdio.h>
#include <stdbool.h>

#define MAX_PROCESSES 10
#define MAX_RESOURCES 10
int main() {
int n, m;

int Available[MAX_RESOURCES];
int Allocation[MAX_PROCESSES][MAX_RESOURCES];
int Request[MAX_PROCESSES][MAX_RESOURCES];
bool Finish[MAX_PROCESSES];
printf("Enter number of processes: ");

scanf("%d", &n);
printf("Enter number of resource types: ");

scanf("%d", &m); // Fixed missing semicolon

printf("Enter Available resources vector (length %d):\n", m);

for (int i = 0; i < m; i++) {
scanf("%d", &Available[i]);

}
printf("Enter Allocation matrix (processes x resources):\n");
for (int i = 0; i < n; i++) {
printf("Process %d allocation: ", i);

for (int j = 0; j < m; j++) {

scanf("%d", &Allocation[i][j]);
}
}

printf("Enter Request matrix (processes x resources):\n");

for (int i = 0; i < n; i++) {
printf("Process %d request: ", i);
for (int j = 0; j < m; j++) {
scanf("%d", &Request[i][j]);
}
}
for (int i = 0; i < n; i++) {

Finish[i] = false;
}
int Work[MAX_RESOURCES];
for (int i = 0; i < m; i++) {
Work[i] = Available[i];

}
bool done_something;
do {
done_something = false;
for (int i = 0; i < n; i++) {
if (!Finish[i]) {
bool can_allocate = true;
for (int j = 0; j < m; j++) {

if (Request[i][j] > Work[j]) {

can_allocate = false;
break;
}
}
if (can_allocate) {
for (int j = 0; j < m; j++) {
Work[j] += Allocation[i][j];
}

Finish[i] = true;
done_something = true;
}
}

}
} while (done_something);

printf("\nDeadlock Detection Result:\n");

bool deadlock_found = false;

 for (int i = 0; i < n; i++) {
if (!Finish[i]) {
printf("Process %d is deadlocked.\n", i);

deadlock_found = true;
}
}

if (!deadlock_found) {
printf("No deadlock detected. All processes can complete.\n");
}

return 0;
}

OUTPUT:-