Slip 1

Q.1 Write a program that demonstrates the use of nice() system call. After a child process is started
using fork(), assign higher priority to the child using nice() system call.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>

int main() {
pid_t pid;
int status;

printf(“Original priority (Nice Value) = %d\n”, getpriority(PRIO_PROCESS, 0));

pid = fork();

if (pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (pid == 0) {
// This is the child process
printf(“Child process: PID = %d, PPID = %d\n”, getpid(), getppid());

// Increase priority of child process using nice() system call
if (nice(10) == -1) {
perror(“Nice failed”);
exit(EXIT_FAILURE);
}

printf(“Child priority (Nice Value) = %d\n”, getpriority(PRIO_PROCESS, 0));
} else {
// This is the parent process
printf(“Parent process: PID = %d, Child PID = %d\n”, getpid(), pid);

// Wait for the child process to finish
waitpid(pid, &status, 0);

printf(“Child process finished\n”);
}

return 0;
}

 

Q.2(1) Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n=3 as
the number of memory frames.
Reference String :3, 4, 5, 6, 3, 4, 7, 3, 4, 5, 6, 7, 2, 4, 6
Implement FIFO

#include <stdio.h>
#include <stdbool.h>

int main() {
int n = 3; // Number of memory frames
int referenceString[] = {3, 4, 5, 6, 3, 4, 7, 3, 4, 5, 6, 7, 2, 4, 6};
int referenceStringLength = sizeof(referenceString) / sizeof(referenceString[0]);

int memoryFrames[n];
bool pageFault = true;
int pageFaultCount = 0;
int pageIndex = 0;

for (int i = 0; i < n; i++) {
memoryFrames[i] = -1; // Initialize memory frames to -1 (indicating empty)
}

printf(“Page Scheduling:\n”);

for (int i = 0; i < referenceStringLength; i++) {
int page = referenceString[i];
pageFault = true;

// Check if the page is already in memory
for (int j = 0; j < n; j++) {
if (memoryFrames[j] == page) {
pageFault = false;
break;
}
}

// If page fault occurs, replace the oldest page in memory using FIFO
if (pageFault) {
int replacedPage = memoryFrames[pageIndex];
memoryFrames[pageIndex] = page;
pageIndex = (pageIndex + 1) % n; // Update index for FIFO replacement
pageFaultCount++;

// Print page replacement information
printf(“Page %d replaced by Page %d\n”, replacedPage, page);

// Print current state of memory frames
printf(“Memory Frames: “);
for (int j = 0; j < n; j++) {
printf(“%d “, memoryFrames[j]);
}
printf(“\n”);
}

// Print current page access
printf(“Accessing Page %d\n”, page);
}

printf(“Total number of page faults: %d\n”, pageFaultCount);

return 0;
}

 

Q.2(2) Bankers Algorithm

 

#include <stdio.h>
#include <stdbool.h>

int processes = 5; // Number of processes
int resources = 4; // Number of resource types

int available[] = {1, 5, 2, 0}; // Available resources of each type
int max_matrix[5][4] = {
{0, 0, 1, 2},
{1, 7, 5, 0},
{2, 3, 5, 6},
{0, 6, 5, 2},
{0, 6, 5, 6}
};
int allocation_matrix[5][4] = {
{0, 0, 1, 2},
{1, 0, 0, 0},
{1, 3, 5, 4},
{0, 6, 3, 2},
{0, 0, 1, 4}
};

void calculateNeedMatrix(int need_matrix[5][4]) {
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
need_matrix[i][j] = max_matrix[i][j] – allocation_matrix[i][j];
}
}
}

bool isSafeState(int need_matrix[5][4], int work[], bool finish[]) {
int temp[resources];
for (int i = 0; i < resources; i++) {
temp[i] = work[i];
}

bool safe = true;
bool found = false;
int safeSequence[processes];
int count = 0;

while (count < processes) {
found = false;
for (int i = 0; i < processes; i++) {
if (!finish[i]) {
int j;
for (j = 0; j < resources; j++) {
if (need_matrix[i][j] > temp[j]) {
break;
}
}
if (j == resources) {
for (int k = 0; k < resources; k++) {
temp[k] += allocation_matrix[i][k];
}
safeSequence[count++] = i;
finish[i] = true;
found = true;
}
}
}
if (!found) {
safe = false;
break;
}
}

if (safe) {
printf(“Safe Sequence: “);
for (int i = 0; i < processes; i++) {
printf(“P%d “, safeSequence[i]);
}
printf(“\n”);
}
return safe;
}

void requestResource(int process, int request[]) {
int need_matrix[processes][resources];
calculateNeedMatrix(need_matrix);

bool finish[processes];
for (int i = 0; i < processes; i++) {
finish[i] = false;
}

for (int i = 0; i < resources; i++) {
if (request[i] > need_matrix[process][i]) {
printf(“Error: Requested resources exceed maximum claim.\n”);
return;
}

if (request[i] > available[i]) {
printf(“Error: Requested resources exceed available resources.\n”);
return;
}
}

for (int i = 0; i < resources; i++) {
available[i] -= request[i];
allocation_matrix[process][i] += request[i];
need_matrix[process][i] -= request[i];
}

if (isSafeState(need_matrix, available, finish)) {
printf(“Request granted. System in safe state.\n”);
} else {
printf(“Request denied. System in unsafe state.\n”);
// Rollback changes
for (int i = 0; i < resources; i++) {
available[i] += request[i];
allocation_matrix[process][i] -= request[i];
need_matrix[process][i] += request[i];
}
}
}

int main() {
int request[] = {0, 4, 2, 0}; // Example request from process P
int need_matrix[processes][resources];

printf(“a) Need Matrix:\n”);
calculateNeedMatrix(need_matrix);
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
printf(“%d “, need_matrix[i][j]);
}
printf(“\n”);
}

printf(“\nb) Is the system in safe state?\n”);
bool safe = isSafeState(need_matrix, available, (bool[]) {false, false, false, false, false});

if (safe) {
printf(“Yes, the system is in safe state.\n”);
} else {
printf(“No, the system is in unsafe state.\n”);
}

printf(“\nc) Requesting resources (0, 4, 2, 0) for process P…\n”);
requestResource(1, request);

return 0;
}

 

Slip 2

Q.1 Create a child process using fork(), display parent and child process id. Child process will
display the message Hello World and the parent process should display Hi .
[10 marks]

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
pid_t pid = fork(); // Create a child process

if (pid < 0) {
// Fork failed
perror(“Fork failed”);
} else if (pid == 0) {
// This is the child process
printf(“Child Process: PID = %d, Parent PID = %d\n”, getpid(), getppid());
printf(“Hello World\n”);
} else {
// This is the parent process
printf(“Parent Process: PID = %d, Child PID = %d\n”, getpid(), pid);
printf(“Hi\n”);

// Wait for the child process to finish (optional)
waitpid(pid, NULL, 0);
}

return 0;
}

 

Q.2. Write the simulation program using SJF (non-preemptive). The arrival time and first CPU
bursts of different jobs should be input to the system. Assume the fixed I/O waiting time (2 units).
The next CPU burst should be generated using random function. The output should give the Gantt
chart, Turnaround Time and Waiting time for each process and average times.[20
marks]

#include <stdio.h>
#include <stdlib.h>

struct Process {
int arrivalTime;
int cpuBurst;
int turnaroundTime;
int waitingTime;
int completionTime;
};

void sortProcessesByArrivalTime(struct Process processes[], int n) {
// Simple bubble sort to sort processes by arrival time
for (int i = 0; i < n – 1; i++) {
for (int j = 0; j < n – i – 1; j++) {
if (processes[j].arrivalTime > processes[j + 1].arrivalTime) {
struct Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
}
}

int main() {
int n; // Number of processes
printf(“Enter the number of processes: “);
scanf(“%d”, &n);

struct Process processes[n];
int ioWait = 2; // Fixed I/O waiting time

// Input arrival time and first CPU burst for each process
printf(“Enter arrival time and first CPU burst for each process:\n”);
for (int i = 0; i < n; i++) {
printf(“Process %d: “, i + 1);
scanf(“%d %d”, &processes[i].arrivalTime, &processes[i].cpuBurst);
}

// Sort processes by arrival time
sortProcessesByArrivalTime(processes, n);

int currentTime = 0;
printf(“\nGantt Chart:\n”);
printf(“|”);
for (int i = 0; i < n; i++) {
printf(” P%d |”, i + 1);
}
printf(“\n”);

float totalTurnaroundTime = 0, totalWaitingTime = 0;

for (int i = 0; i < n; i++) {
// Simulate I/O waiting time
currentTime += ioWait;
printf(“%d”, currentTime);

// Simulate CPU burst time (random value between 1 and 10)
int randomBurst = 1 + rand() % 10;
currentTime += randomBurst;
printf(” %d “, currentTime);

// Update process data
processes[i].completionTime = currentTime;
processes[i].turnaroundTime = processes[i].completionTime – processes[i].arrivalTime;
processes[i].waitingTime = processes[i].turnaroundTime – processes[i].cpuBurst;

// Print turnaround and waiting time for the process
printf(” %d %d\n”, processes[i].turnaroundTime, processes[i].waitingTime);

// Update total turnaround and waiting time for average calculation
totalTurnaroundTime += processes[i].turnaroundTime;
totalWaitingTime += processes[i].waitingTime;
}

// Calculate and print average turnaround and waiting time
float avgTurnaroundTime = totalTurnaroundTime / n;
float avgWaitingTime = totalWaitingTime / n;
printf(“\nAverage Turnaround Time: %.2f\n”, avgTurnaroundTime);
printf(“Average Waiting Time: %.2f\n”, avgWaitingTime);

return 0;
}

 

slip 3

Q.1 Creating a child process using the command exec(). Note down process ids of the parent
and the child processes, check whether the control is given back to the parent after the child
process terminates.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
pid_t pid = fork(); // Create a child process

if (pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (pid == 0) {
// This is the child process
printf(“Child Process: PID = %d, Parent PID = %d\n”, getpid(), getppid());

// Replace the child process with a new program using exec()
execl(“/bin/ls”, “ls”, “-l”, NULL);

// If exec() fails
perror(“Exec failed”);
exit(EXIT_FAILURE);
} else {
// This is the parent process
printf(“Parent Process: PID = %d, Child PID = %d\n”, getpid(), pid);

// Wait for the child process to finish
wait(NULL);

printf(“Child process has terminated.\n”);
}

// Control continues for the parent process after the child process terminates
printf(“Control is back to the parent process.\n”);

return 0;
}

 

Q.2 Write the simulation program using FCFS. The arrival time and first CPU bursts of different
jobs should be input to the system. Assume the fixed I/O waiting time (2 units). The next CPU burst
should be generated using random function. The output should give the Gantt chart,Turnaround
Time and Waiting time for each process and average times. [20 marks

#include <stdio.h>
#include <stdlib.h>

struct Process {
int arrivalTime;
int cpuBurst;
int turnaroundTime;
int waitingTime;
int completionTime;
};

int main() {
int n; // Number of processes
printf(“Enter the number of processes: “);
scanf(“%d”, &n);

struct Process processes[n];
int ioWait = 2; // Fixed I/O waiting time

// Input arrival time and first CPU burst for each process
printf(“Enter arrival time and first CPU burst for each process:\n”);
for (int i = 0; i < n; i++) {
printf(“Process %d: “, i + 1);
scanf(“%d %d”, &processes[i].arrivalTime, &processes[i].cpuBurst);
}

int currentTime = 0;
printf(“\nGantt Chart:\n”);
printf(“|”);
for (int i = 0; i < n; i++) {
printf(” P%d |”, i + 1);
}
printf(“\n”);

float totalTurnaroundTime = 0, totalWaitingTime = 0;

for (int i = 0; i < n; i++) {
// Simulate I/O waiting time
currentTime += ioWait;
printf(“%d”, currentTime);

// Simulate CPU burst time (random value between 1 and 10)
int randomBurst = 1 + rand() % 10;
processes[i].completionTime = currentTime + randomBurst;
processes[i].turnaroundTime = processes[i].completionTime – processes[i].arrivalTime;
processes[i].waitingTime = processes[i].turnaroundTime – processes[i].cpuBurst;
totalTurnaroundTime += processes[i].turnaroundTime;
totalWaitingTime += processes[i].waitingTime;

currentTime += randomBurst;
printf(” %d “, currentTime);

// Print turnaround and waiting time for the process
printf(” %d %d\n”, processes[i].turnaroundTime, processes[i].waitingTime);
}

// Calculate and print average turnaround and waiting time
float avgTurnaroundTime = totalTurnaroundTime / n;
float avgWaitingTime = totalWaitingTime / n;
printf(“\nAverage Turnaround Time: %.2f\n”, avgTurnaroundTime);
printf(“Average Waiting Time: %.2f\n”, avgWaitingTime);

return 0;
}

 

slip 4

Q.1 Write a program to illustrate the concept of orphan process ( Using fork() and sleep())
[10 marks]

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
pid_t child_pid = fork();

if (child_pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (child_pid == 0) {
// This is the child process
printf(“Child Process: PID = %d, Parent PID = %d\n”, getpid(), getppid());
sleep(5); // Child process sleeps for 5 seconds
printf(“Child Process: PID = %d, Parent PID = %d after sleep()\n”, getpid(), getppid());
} else {
// This is the parent process
printf(“Parent Process: PID = %d, Child PID = %d\n”, getpid(), child_pid);
printf(“Parent Process is going to exit\n”);
exit(EXIT_SUCCESS);
}

return 0;
}

Q.2. Bankers Algorithm Deadlock.

#include <stdio.h>
#include <stdbool.h>

int processes = 5; // Number of processes
int resources = 4; // Number of resource types

int available[] = {1, 5, 2, 0}; // Available resources of each type
int max_matrix[5][4] = {
{0, 0, 1, 2},
{1, 7, 5, 0},
{2, 3, 5, 6},
{0, 6, 5, 2},
{0, 6, 5, 6}
};
int allocation_matrix[5][4] = {
{0, 0, 1, 2},
{1, 0, 0, 0},
{1, 3, 5, 4},
{0, 6, 3, 2},
{0, 0, 1, 4}
};

void calculateNeedMatrix(int need_matrix[5][4]) {
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
need_matrix[i][j] = max_matrix[i][j] – allocation_matrix[i][j];
}
}
}

bool isSafeState(int need_matrix[5][4], int work[], bool finish[]) {
int temp[resources];
for (int i = 0; i < resources; i++) {
temp[i] = work[i];
}

bool safe = true;
bool found = false;
int safeSequence[processes];
int count = 0;

while (count < processes) {
found = false;
for (int i = 0; i < processes; i++) {
if (!finish[i]) {
int j;
for (j = 0; j < resources; j++) {
if (need_matrix[i][j] > temp[j]) {
break;
}
}
if (j == resources) {
for (int k = 0; k < resources; k++) {
temp[k] += allocation_matrix[i][k];
}
safeSequence[count++] = i;
finish[i] = true;
found = true;
}
}
}
if (!found) {
safe = false;
break;
}
}

if (safe) {
printf(“Safe Sequence: “);
for (int i = 0; i < processes; i++) {
printf(“P%d “, safeSequence[i]);
}
printf(“\n”);
}
return safe;
}

void requestResource(int process, int request[]) {
int need_matrix[processes][resources];
calculateNeedMatrix(need_matrix);

bool finish[processes];
for (int i = 0; i < processes; i++) {
finish[i] = false;
}

for (int i = 0; i < resources; i++) {
if (request[i] > need_matrix[process][i]) {
printf(“Error: Requested resources exceed maximum claim.\n”);
return;
}

if (request[i] > available[i]) {
printf(“Error: Requested resources exceed available resources.\n”);
return;
}
}

for (int i = 0; i < resources; i++) {
available[i] -= request[i];
allocation_matrix[process][i] += request[i];
need_matrix[process][i] -= request[i];
}

if (isSafeState(need_matrix, available, finish)) {
printf(“Request granted. System in safe state.\n”);
} else {
printf(“Request denied. System in unsafe state.\n”);
// Rollback changes
for (int i = 0; i < resources; i++) {
available[i] += request[i];
allocation_matrix[process][i] -= request[i];
need_matrix[process][i] += request[i];
}
}
}

int main() {
int request[] = {0, 4, 2, 0}; // Example request from process P
int need_matrix[processes][resources];

printf(“a) Need Matrix:\n”);
calculateNeedMatrix(need_matrix);
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
printf(“%d “, need_matrix[i][j]);
}
printf(“\n”);
}

printf(“\nb) Is the system in safe state?\n”);
isSafeState(need_matrix, available, (bool[]) {false, false, false, false, false});

printf(“\nc) Requesting resources (0, 4, 2, 0) for process P…\n”);
requestResource(1, request);

return 0;
}

 

slip 5

Q.1 Write a program that demonstrates the use of nice () system call. After a child process is
started using fork (), assign higher priority to the child using nice () system call.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
pid_t pid = fork();

if (pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (pid == 0) {
// This is the child process
printf(“Child Process: PID = %d\n”, getpid());

// Assign higher priority to the child process
int priority = nice(-10);
if (priority == -1) {
perror(“Nice failed”);
} else {
printf(“Child Process: New priority = %d\n”, priority);
}

// Simulate some work in the child process
sleep(3);
printf(“Child Process: Finished\n”);
} else {
// This is the parent process
printf(“Parent Process: PID = %d\n”, getpid());

// Wait for the child process to finish
wait(NULL);

printf(“Parent Process: Child process has terminated.\n”);
}

return 0;
}

 

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n as the
number of memory frames. Reference String: 3, 4, 5, 6, 3, 4, 7, 3, 4, 5, 6, 7, 2, 4, 6
i. Implement FIFO

#include <stdio.h>
#include <stdbool.h>

void fifo(int pages[], int n, int capacity) {
int frame[capacity];
bool inFrame[capacity];
int pageFaults = 0;
int rear = 0;

for (int i = 0; i < capacity; i++) {
frame[i] = -1; // Initialize frames to -1 (indicating empty)
inFrame[i] = false;
}

printf(“Page Scheduling (FIFO):\n”);

for (int i = 0; i < n; i++) {
int page = pages[i];
bool pageFound = false;

// Check if the page is already in memory
for (int j = 0; j < capacity; j++) {
if (frame[j] == page) {
pageFound = true;
break;
}
}

// If page is not in memory, replace the oldest page in memory using FIFO
if (!pageFound) {
int replacedPage = frame[rear];
frame[rear] = page;
rear = (rear + 1) % capacity;
pageFaults++;

// Print page replacement information
printf(“Page %d replaced by Page %d\n”, replacedPage, page);

// Print current state of memory frames
printf(“Memory Frames: “);
for (int j = 0; j < capacity; j++) {
printf(“%d “, frame[j]);
}
printf(“\n”);
}

// Print current page access
printf(“Accessing Page %d\n”, page);
}

printf(“Total number of page faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {3, 4, 5, 6, 3, 4, 7, 3, 4, 5, 6, 7, 2, 4, 6};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity;

printf(“Enter the number of memory frames: “);
scanf(“%d”, &capacity);

fifo(referenceString, n, capacity);

return 0;
}

 

slip 6

Q.1 Write a program to find the execution time taken for execution of a given set of instructions
(use clock() function)

#include <stdio.h>
#include <time.h>

void performTask() {
// Add the instructions you want to measure the execution time for here
for (int i = 0; i < 1000000; ++i) {
// Some instructions to be measured
}
}

int main() {
clock_t start, end;
double cpu_time_used;

// Record the starting time
start = clock();

// Call the function or execute the instructions
performTask();

// Record the ending time
end = clock();

// Calculate the execution time in seconds
cpu_time_used = ((double) (end – start)) / CLOCKS_PER_SEC;

// Print the execution time
printf(“Execution time: %f seconds\n”, cpu_time_used);

return 0;
}

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n as the
number of memory frames.
Reference String :3, 4, 5, 6, 3, 4, 7, 3, 4, 5, 6, 7, 2, 4, 6
Implement FIFO

#include <stdio.h>
#include <stdbool.h>

void fifo(int pages[], int n, int capacity) {
int frame[capacity];
bool inFrame[capacity];
int pageFaults = 0;
int rear = 0;

for (int i = 0; i < capacity; i++) {
frame[i] = -1; // Initialize frames to -1 (indicating empty)
inFrame[i] = false;
}

printf(“Page Scheduling (FIFO):\n”);

for (int i = 0; i < n; i++) {
int page = pages[i];
bool pageFound = false;

// Check if the page is already in memory
for (int j = 0; j < capacity; j++) {
if (frame[j] == page) {
pageFound = true;
break;
}
}

// If page is not in memory, replace the oldest page in memory using FIFO
if (!pageFound) {
int replacedPage = frame[rear];
frame[rear] = page;
rear = (rear + 1) % capacity;
pageFaults++;

// Print page replacement information
printf(“Page %d replaced by Page %d\n”, replacedPage, page);

// Print current state of memory frames
printf(“Memory Frames: “);
for (int j = 0; j < capacity; j++) {
printf(“%d “, frame[j]);
}
printf(“\n”);
}

// Print current page access
printf(“Accessing Page %d\n”, page);
}

printf(“Total number of page faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {3, 4, 5, 6, 3, 4, 7, 3, 4, 5, 6, 7, 2, 4, 6};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity;

printf(“Enter the number of memory frames: “);
scanf(“%d”, &capacity);

fifo(referenceString, n, capacity);

return 0;
}

 

slip 7

Q.1 Write a program to create a child process using fork().The parent should goto sleep state and
child process should begin its execution. In the child process, use execl() to execute the ls
command.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
pid_t pid = fork();

if (pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (pid == 0) {
// This is the child process
printf(“Child Process: PID = %d\n”, getpid());

// Execute “ls -l” command in the child process
execl(“/bin/ls”, “ls”, “-l”, NULL);

// If execl fails
perror(“Exec failed”);
exit(EXIT_FAILURE);
} else {
// This is the parent process
printf(“Parent Process: PID = %d\n”, getpid());

// Parent process goes to sleep
sleep(3);

// Wait for the child process to finish
wait(NULL);

printf(“Parent Process: Child process has terminated.\n”);
}

return 0;
}

 

Q.2(2) Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n as the
number of memory frames.
Reference String: 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2
i. Implement LRU

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

void lru(int pages[], int n, int capacity) {
int frame[capacity];
int indexes[capacity];
bool inFrame[capacity];
int pageFaults = 0;

for (int i = 0; i < capacity; i++) {
frame[i] = -1; // Initialize frames to -1 (indicating empty)
indexes[i] = INT_MAX; // Initialize indexes to maximum integer value
inFrame[i] = false;
}

printf(“Page Scheduling (LRU):\n”);

for (int i = 0; i < n; i++) {
int page = pages[i];
bool pageFound = false;

// Check if the page is already in memory
for (int j = 0; j < capacity; j++) {
if (frame[j] == page) {
indexes[j] = i; // Update index of the recently used page
pageFound = true;
break;
}
}

// If page is not in memory, find the least recently used page and replace it
if (!pageFound) {
int lruIndex = 0;
for (int j = 1; j < capacity; j++) {
if (indexes[j] < indexes[lruIndex]) {
lruIndex = j;
}
}

int replacedPage = frame[lruIndex];
frame[lruIndex] = page;
indexes[lruIndex] = i;
pageFaults++;

// Print page replacement information
printf(“Page %d replaced by Page %d\n”, replacedPage, page);

// Print current state of memory frames
printf(“Memory Frames: “);
for (int j = 0; j < capacity; j++) {
printf(“%d “, frame[j]);
}
printf(“\n”);
}

// Print current page access
printf(“Accessing Page %d\n”, page);
}

printf(“Total number of page faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity;

printf(“Enter the number of memory frames: “);
scanf(“%d”, &capacity);

lru(referenceString, n, capacity);

return 0;
}

 

slip 8

Q.1 Write a C program to accept the number of process and resources and find the need matrix
content and display it.

#include <stdio.h>

void calculateNeedMatrix(int processes, int resources, int max_matrix[processes][resources], int allocation_matrix[processes][resources], int need_matrix[processes][resources]) {
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
need_matrix[i][j] = max_matrix[i][j] – allocation_matrix[i][j];
}
}
}

int main() {
int processes, resources;

// Accept the number of processes and resources
printf(“Enter the number of processes: “);
scanf(“%d”, &processes);
printf(“Enter the number of resources: “);
scanf(“%d”, &resources);

int max_matrix[processes][resources];
int allocation_matrix[processes][resources];
int need_matrix[processes][resources];

// Accept maximum resources a process can request (max_matrix)
printf(“Enter the Maximum Resources matrix:\n”);
for (int i = 0; i < processes; i++) {
printf(“Process %d: “, i);
for (int j = 0; j < resources; j++) {
scanf(“%d”, &max_matrix[i][j]);
}
}

// Accept resources already allocated to processes (allocation_matrix)
printf(“Enter the Allocation matrix:\n”);
for (int i = 0; i < processes; i++) {
printf(“Process %d: “, i);
for (int j = 0; j < resources; j++) {
scanf(“%d”, &allocation_matrix[i][j]);
}
}

// Calculate and display the need matrix
calculateNeedMatrix(processes, resources, max_matrix, allocation_matrix, need_matrix);

printf(“Need Matrix:\n”);
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
printf(“%d “, need_matrix[i][j]);
}
printf(“\n”);
}

return 0;
}

 

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n =3 as
the number of memory frames.
Reference String : 12,15,12,18,6,8,11,12,19,12,6,8,12,15,19,8
Implement OPT

#include <stdio.h>
#include <stdbool.h>

void opt(int pages[], int n, int capacity) {
int frame[capacity];
int nextUse[n];
bool inFrame[capacity];
int pageFaults = 0;

for (int i = 0; i < capacity; i++) {
frame[i] = -1; // Initialize frames to -1 (indicating empty)
inFrame[i] = false;
}

for (int i = 0; i < n; i++) {
int page = pages[i];
bool pageFound = false;

// Check if the page is already in memory
for (int j = 0; j < capacity; j++) {
if (frame[j] == page) {
pageFound = true;
break;
}
}

// If page is not in memory, find the page with longest next use
if (!pageFound) {
int maxNextUse = -1;
int replaceIndex = -1;

// Look ahead to find the page with longest next use
for (int j = 0; j < capacity; j++) {
int k;
for (k = i + 1; k < n; k++) {
if (pages[k] == frame[j]) {
break;
}
}
if (k == n) {
replaceIndex = j;
break;
} else {
nextUse[j] = k;
if (nextUse[j] > maxNextUse) {
maxNextUse = nextUse[j];
replaceIndex = j;
}
}
}

int replacedPage = frame[replaceIndex];
frame[replaceIndex] = page;
pageFaults++;

// Print page replacement information
printf(“Page %d replaced by Page %d\n”, replacedPage, page);

// Print current state of memory frames
printf(“Memory Frames: “);
for (int j = 0; j < capacity; j++) {
printf(“%d “, frame[j]);
}
printf(“\n”);
}

// Print current page access
printf(“Accessing Page %d\n”, page);
}

printf(“Total number of page faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {12, 15, 12, 18, 6, 8, 11, 12, 19, 12, 6, 8, 12, 15, 19, 8};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity = 3;

opt(referenceString, n, capacity);

return 0;
}

 

slip 9

Q.1 Write a program to create a child process using fork().The parent should goto sleep state and
child process should begin its execution. In the child process, use execl() to execute the ls
command.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
pid_t pid = fork();

if (pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (pid == 0) {
// This is the child process
printf(“Child Process: PID = %d\n”, getpid());

// Execute “ls” command in the child process
execl(“/bin/ls”, “ls”, (char *)NULL);

// If execl fails
perror(“Exec failed”);
exit(EXIT_FAILURE);
} else {
// This is the parent process
printf(“Parent Process: PID = %d\n”, getpid());

// Parent process goes to sleep
sleep(3);

// Wait for the child process to finish
wait(NULL);

printf(“Parent Process: Child process has terminated.\n”);
}

return 0;
}

 

Q.2 Partially implement the Menu driven Banker’s algorithm for accepting Allocation, Max from
user.

#include <stdio.h>

void acceptMatrix(int matrix[][3], int processes, int resources) {
printf(“Enter the matrix:\n”);
for (int i = 0; i < processes; i++) {
printf(“Process %d: “, i);
for (int j = 0; j < resources; j++) {
scanf(“%d”, &matrix[i][j]);
}
}
}

void displayMatrix(int matrix[][3], int processes, int resources) {
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
printf(“%d “, matrix[i][j]);
}
printf(“\n”);
}
}

void calculateNeedMatrix(int allocation[][3], int max[][3], int need[][3], int processes, int resources) {
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
need[i][j] = max[i][j] – allocation[i][j];
}
}
}

int main() {
int processes, resources;
int available[3] = {7, 2, 6}; // Available resources A, B, C

printf(“Enter the number of processes: “);
scanf(“%d”, &processes);
printf(“Enter the number of resources: “);
scanf(“%d”, &resources);

int allocation[processes][3];
int max[processes][3];
int need[processes][3];

printf(“Accepting Allocation Matrix:\n”);
acceptMatrix(allocation, processes, resources);

printf(“Accepting Max Matrix:\n”);
acceptMatrix(max, processes, resources);

// Calculate and display Need Matrix
calculateNeedMatrix(allocation, max, need, processes, resources);
printf(“\nNeed Matrix:\n”);
displayMatrix(need, processes, resources);

// Display Available Resources
printf(“\nAvailable Resources: “);
displayMatrix(&available, 1, resources);

return 0;
}

 

slip 10

Q.1 Write a program to illustrate the concept of orphan process (Using fork() and sleep())

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
pid_t child_pid = fork();

if (child_pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (child_pid == 0) {
// This is the child process
printf(“Child Process: PID = %d, Parent PID = %d\n”, getpid(), getppid());

// Sleep for a few seconds to observe the state of the processes
sleep(10);

printf(“Child Process: Exiting\n”);
} else {
// This is the parent process
printf(“Parent Process: PID = %d\n”, getpid());

// Parent process terminates immediately
printf(“Parent Process: Exiting\n”);
}

return 0;
}

 

Q.2 Write the simulation program to implement demand paging and show the page scheduling and
total number of page faults for the following given page reference string. Give input n=3 as the
number of memory frames.
Reference String : 12,15,12,18,6,8,11,12,19,12,6,8,12,15,19,8
Implement OPT

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_FRAMES 3

bool isPagePresent(int page, int frames[], int n) {
for (int i = 0; i < n; ++i) {
if (frames[i] == page) {
return true;
}
}
return false;
}

int predictOptimal(int pages[], int n, int frames[], int current, int future) {
int farthest = future;
int index = -1;
for (int i = 0; i < MAX_FRAMES; ++i) {
int j;
for (j = current + 1; j < n; ++j) {
if (frames[i] == pages[j]) {
if (j > farthest) {
farthest = j;
index = i;
}
break;
}
}
if (j == n) {
return i;
}
}
return (index == -1) ? 0 : index;
}

int optimalPageReplacement(int pages[], int n) {
int frames[MAX_FRAMES];
int pageFaults = 0;

for (int i = 0; i < n; ++i) {
if (!isPagePresent(pages[i], frames, MAX_FRAMES)) {
int j = predictOptimal(pages, n, frames, i, n);
frames[j] = pages[i];
++pageFaults;
}
}

return pageFaults;
}

int main() {
int pages[] = {12, 15, 12, 18, 6, 8, 11, 12, 19, 12, 6, 8, 12, 15, 19, 8};
int n = sizeof(pages) / sizeof(pages[0]);

int pageFaults = optimalPageReplacement(pages, n);

printf(“Total number of page faults: %d\n”, pageFaults);

return 0;
}

 

slip 11

Q.1 Create a child process using fork(), display parent and child process id. Child process will
display the message Hello World and the parent process should display Hi .

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
pid_t pid = fork(); // Create a child process

if (pid < 0) {
// Forking failed
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (pid == 0) {
// This is the child process
printf(“Child Process: PID = %d\n”, getpid());
printf(“Hello World\n”);
} else {
// This is the parent process
printf(“Parent Process: PID = %d\n”, getpid());
printf(“Hi\n”);
}

return 0;
}

 

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n as the
number of memory frames.
Reference String: 0, 2, 1, 6, 4, 0, 1, 0, 3, 1, 2, 1
Implement FIFO

#include <stdio.h>
#include <stdbool.h>

void fifoPageReplacement(int pages[], int n, int memoryFrames) {
int memoryQueue[memoryFrames];
bool pagePresent[memoryFrames];

for (int i = 0; i < memoryFrames; i++) {
memoryQueue[i] = -1; // Initialize memory queue with -1 indicating empty frames
pagePresent[i] = false; // Initialize page presence flags
}

int pageFaults = 0;
int front = 0; // Front of the queue (oldest page)

for (int i = 0; i < n; i++) {
int currentPage = pages[i];
bool found = false;

// Check if the page is already in memory
for (int j = 0; j < memoryFrames; j++) {
if (memoryQueue[j] == currentPage) {
found = true;
break;
}
}

// If page is not in memory, perform page replacement
if (!found) {
int replacePage = memoryQueue[front];

// Replace the oldest page in memory
memoryQueue[front] = currentPage;
pagePresent[front] = true;

// Update page presence flags and queue position
front = (front + 1) % memoryFrames;

// Increment page fault count
pageFaults++;

// Print page replacement information
printf(“Page %d replaced by Page %d\n”, replacePage, currentPage);
}

// Print current state of memory frames
printf(“Memory Frames: “);
for (int j = 0; j < memoryFrames; j++) {
if (pagePresent[j]) {
printf(“%d “, memoryQueue[j]);
} else {
printf(“- “);
}
}
printf(“\n”);
}

printf(“Total number of page faults: %d\n”, pageFaults);
}

int main() {
int pages[] = {0, 2, 1, 6, 4, 0, 1, 0, 3, 1, 2, 1};
int n = sizeof(pages) / sizeof(pages[0]);
int memoryFrames;

printf(“Enter the number of memory frames: “);
scanf(“%d”, &memoryFrames);

fifoPageReplacement(pages, n, memoryFrames);

return 0;
}

 

slip 12

Q.1 Write a program to illustrate the concept of orphan process ( Using fork() and
sleep()) .

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
pid_t child_pid = fork();

if (child_pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (child_pid == 0) {
// This is the child process
printf(“Child Process: PID = %d, Parent PID = %d\n”, getpid(), getppid());
sleep(5); // Child continues to run for 5 seconds after parent exits
printf(“Child Process: Exiting\n”);
} else {
// This is the parent process
printf(“Parent Process: PID = %d\n”, getpid());
printf(“Parent Process: Exiting\n”);
// Parent exits immediately, creating an orphan child
}

return 0;
}

Q.2 Write the simulation program to implement demand paging and show the page
scheduling and total number of page faults for the following given page reference string.
Give input n as the number of memory frames.
Reference String : 12,15,12,18,6,8,11,12,19,12,6,8,12,15,19,8
Implement OPT

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

void optPageReplacement(int pages[], int n, int memoryFrames) {
int memory[100]; // Array to simulate memory
int pageFaults = 0;

for (int i = 0; i < memoryFrames; ++i) {
memory[i] = -1; // Initialize memory with -1 indicating empty frames
}

for (int i = 0; i < n; ++i) {
bool pageFound = false;
int pageToReplace = -1;

// Check if the page is already in memory
for (int j = 0; j < memoryFrames; ++j) {
if (memory[j] == pages[i]) {
pageFound = true;
break;
}
}

// If page is not in memory, find the page to replace
if (!pageFound) {
int farthest = -1;
for (int j = 0; j < memoryFrames; ++j) {
int k;
for (k = i + 1; k < n; ++k) {
if (memory[j] == pages[k]) {
if (k > farthest) {
farthest = k;
pageToReplace = j;
}
break;
}
}
if (k == n) {
pageToReplace = j;
break;
}
}
// Replace the page in memory
memory[pageToReplace] = pages[i];
++pageFaults;
}
}

printf(“Total number of page faults: %d\n”, pageFaults);
}

int main() {
int pages[] = {12, 15, 12, 18, 6, 8, 11, 12, 19, 12, 6, 8, 12, 15, 19, 8};
int n = sizeof(pages) / sizeof(pages[0]);
int memoryFrames;

printf(“Enter the number of memory frames: “);
scanf(“%d”, &memoryFrames);

optPageReplacement(pages, n, memoryFrames);

return 0;
}

 

slip 13

Q.1 Write a program that demonstrates the use of nice() system call. After a child process is
started using fork(), assign higher priority to the child using nice() system call.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
pid_t pid = fork(); // Create a child process

if (pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (pid == 0) {
// This is the child process
printf(“Child Process: PID = %d, Nice Value (before): %d\n”, getpid(), nice(0));
nice(10); // Increase the niceness value to give lower priority
printf(“Child Process: PID = %d, Nice Value (after): %d\n”, getpid(), nice(0));
} else {
// This is the parent process
printf(“Parent Process: PID = %d, Nice Value: %d\n”, getpid(), nice(0));
wait(NULL); // Wait for the child process to finish
printf(“Parent Process: Child process completed.\n”);
}

return 0;
}

Q.2 Write a C program to simulate Banker s algorithm for the purpose of deadlock
avoidance. Consider the following snapshot of system, A, B, C and D are the resource type.

#include <stdio.h>
#include <stdbool.h>

int processes = 5; // Number of processes
int resources = 4; // Number of resource types

int available[] = {1, 5, 2, 0}; // Available resources of each type
int max_matrix[5][4] = {
{0, 0, 1, 2},
{1, 7, 5, 0},
{2, 3, 5, 6},
{0, 6, 5, 2},
{0, 6, 5, 6}
};
int allocation_matrix[5][4] = {
{0, 0, 1, 2},
{1, 0, 0, 0},
{1, 3, 5, 4},
{0, 6, 3, 2},
{0, 0, 1, 4}
};

void calculateNeedMatrix(int need_matrix[5][4]) {
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
need_matrix[i][j] = max_matrix[i][j] – allocation_matrix[i][j];
}
}
}

bool isSafeState(int need_matrix[5][4], int work[], bool finish[]) {
int temp[resources];
for (int i = 0; i < resources; i++) {
temp[i] = work[i];
}

bool safe = true;
bool found = false;
int safeSequence[processes];
int count = 0;

while (count < processes) {
found = false;
for (int i = 0; i < processes; i++) {
if (!finish[i]) {
int j;
for (j = 0; j < resources; j++) {
if (need_matrix[i][j] > temp[j]) {
break;
}
}
if (j == resources) {
for (int k = 0; k < resources; k++) {
temp[k] += allocation_matrix[i][k];
}
safeSequence[count++] = i;
finish[i] = true;
found = true;
}
}
}
if (!found) {
safe = false;
break;
}
}

if (safe) {
printf(“Safe Sequence: “);
for (int i = 0; i < processes; i++) {
printf(“P%d “, safeSequence[i]);
}
printf(“\n”);
}
return safe;
}

void requestResource(int process, int request[]) {
int need_matrix[processes][resources];
calculateNeedMatrix(need_matrix);

bool finish[processes];
for (int i = 0; i < processes; i++) {
finish[i] = false;
}

for (int i = 0; i < resources; i++) {
if (request[i] > need_matrix[process][i]) {
printf(“Error: Requested resources exceed maximum claim.\n”);
return;
}

if (request[i] > available[i]) {
printf(“Error: Requested resources exceed available resources.\n”);
return;
}
}

for (int i = 0; i < resources; i++) {
available[i] -= request[i];
allocation_matrix[process][i] += request[i];
need_matrix[process][i] -= request[i];
}

if (isSafeState(need_matrix, available, finish)) {
printf(“Request granted. System in safe state.\n”);
} else {
printf(“Request denied. System in unsafe state.\n”);
// Rollback changes
for (int i = 0; i < resources; i++) {
available[i] += request[i];
allocation_matrix[process][i] -= request[i];
need_matrix[process][i] += request[i];
}
}
}

int main() {
int request[] = {0, 4, 2, 0}; // Example request from process P
int need_matrix[processes][resources];

printf(“a) Need Matrix:\n”);
calculateNeedMatrix(need_matrix);
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
printf(“%d “, need_matrix[i][j]);
}
printf(“\n”);
}

printf(“\nb) Is the system in safe state?\n”);
bool safe = isSafeState(need_matrix, available, (bool[]) {false, false, false, false, false});

if (safe) {
printf(“Yes, the system is in safe state.\n”);
} else {
printf(“No, the system is in unsafe state.\n”);
}

printf(“\nc) Requesting resources (0, 4, 2, 0) for process P…\n”);
requestResource(1, request);

return 0;
}

 

slip 14

Q1 Write a program to find the execution time taken for execution of a given set of instructions
(use clock() function)

#include <stdio.h>
#include <time.h>

int main() {
clock_t start, end;
double cpu_time_used;

// Record the start time
start = clock();

// Your set of instructions here
for (int i = 0; i < 100000000; ++i) {
// Do some computation
}

// Record the end time
end = clock();

// Calculate the CPU time used in seconds
cpu_time_used = ((double) (end – start)) / CLOCKS_PER_SEC;

printf(“Execution time: %f seconds\n”, cpu_time_used);

return 0;
}

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n =3 as
the number of memory frames.
Reference String : 0, 2, 1, 6, 4, 0, 1, 0, 3, 1, 2, 1
Implement FIFO

#include <stdio.h>
#include <stdbool.h>

void fifoPageReplacement(int pages[], int n, int capacity) {
int frame[capacity];
bool inFrame[capacity];
int pageFaults = 0;
int rear = -1;

for (int i = 0; i < n; ++i) {
int currentPage = pages[i];
bool pageFound = false;

// Check if the current page is already in the frame
for (int j = 0; j < capacity; ++j) {
if (frame[j] == currentPage) {
pageFound = true;
break;
}
}

// If the current page is not in the frame, replace the oldest page (FIFO)
if (!pageFound) {
int oldestPageIndex = (rear + 1) % capacity;
frame[oldestPageIndex] = currentPage;
rear = oldestPageIndex;
pageFaults++;

// Print the current frame
printf(“Frame: “);
for (int j = 0; j < capacity; ++j) {
printf(“%d “, frame[j]);
}
printf(“\n”);
}
}

printf(“Total Page Faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {0, 2, 1, 6, 4, 0, 1, 0, 3, 1, 2, 1};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity = 3; // Number of memory frames

printf(“Page Reference String: “);
for (int i = 0; i < n; ++i) {
printf(“%d “, referenceString[i]);
}
printf(“\n”);

fifoPageReplacement(referenceString, n, capacity);

return 0;
}

 

 

slip 15

Q.1 Write a program to create a child process using fork().The parent should goto sleep state and
child process should begin its execution. In the child process, use execl() to execute the ls
command.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
pid_t pid = fork();

if (pid < 0) {
perror(“Fork failed”);
exit(EXIT_FAILURE);
} else if (pid == 0) {
// Child process
printf(“Child process ID: %d\n”, getpid());

// Execute “ls” command using execl
execl(“/bin/ls”, “ls”, (char *)NULL);

// execl() will only return if there’s an error
perror(“execl failed”);
exit(EXIT_FAILURE);
} else {
// Parent process
printf(“Parent process ID: %d\n”, getpid());

// Parent goes into sleep state for 5 seconds
sleep(5);

// Wait for the child process to complete
wait(NULL);

printf(“Parent process exiting.\n”);
}

return 0;
}

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n as the
number of memory frames.
Reference String :7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2
Implement LRU

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

int findLRU(int frame[], int n, int indexes[]) {
int lru = indexes[0];
for (int i = 1; i < n; i++) {
if (indexes[i] < lru) {
lru = indexes[i];
}
}
return lru;
}

void lruPageReplacement(int pages[], int n, int capacity) {
int frame[capacity];
int indexes[capacity];
bool inFrame[capacity];
int pageFaults = 0;

for (int i = 0; i < capacity; i++) {
frame[i] = -1; // Initialize frames as empty
indexes[i] = 0; // Initialize indexes of frames as 0
inFrame[i] = false; // All frames are initially not in use
}

for (int i = 0; i < n; ++i) {
int currentPage = pages[i];
bool pageFound = false;

// Check if the current page is already in the frame
for (int j = 0; j < capacity; ++j) {
if (frame[j] == currentPage) {
indexes[j] = i;
pageFound = true;
break;
}
}

// If the current page is not in the frame, replace the LRU page
if (!pageFound) {
int lruIndex = findLRU(frame, capacity, indexes);
frame[lruIndex] = currentPage;
indexes[lruIndex] = i;
pageFaults++;

// Print the current frame
printf(“Frame: “);
for (int j = 0; j < capacity; ++j) {
if (frame[j] == -1) {
printf(“X “); // X represents an empty frame
} else {
printf(“%d “, frame[j]);
}
}
printf(“\n”);
}
}

printf(“Total Page Faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity = 3; // Number of memory frames

printf(“Page Reference String: “);
for (int i = 0; i < n; ++i) {
printf(“%d “, referenceString[i]);
}
printf(“\n”);

lruPageReplacement(referenceString, n, capacity);

return 0;
}

 

slip 16

Q.1 Write a program to find the execution time taken for execution of a given set of instructions
(use clock()
function)

#include <stdio.h>
#include <time.h>

int main() {
clock_t start, end;
double cpu_time_used;

// Record the start time
start = clock();

// Instructions to simulate computation-intensive task
for (int i = 0; i < 100000000; ++i) {
// Do some computation
}

// Record the end time
end = clock();

// Calculate the CPU time used in seconds
cpu_time_used = ((double) (end – start)) / CLOCKS_PER_SEC;

printf(“Execution time: %f seconds\n”, cpu_time_used);

return 0;
}

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n =3 as
the number of memory frames.
Reference String : 12,15,12,18,6,8,11,12,19,12,6,8,12,15,19,8
Implement OPT

#include <stdio.h>
#include <stdbool.h>

int findOptimal(int pages[], int n, int frame[], int current) {
int res = -1, farthest = current;
for (int i = 0; i < n; ++i) {
int j;
for (j = current; j < n; ++j) {
if (frame[i] == pages[j]) {
if (j > farthest) {
farthest = j;
res = i;
}
break;
}
}
if (j == n)
return i;
}
return (res == -1) ? 0 : res;
}

void optimalPageReplacement(int pages[], int n, int capacity) {
int frame[capacity];
int pageFaults = 0;

for (int i = 0; i < capacity; ++i) {
frame[i] = -1; // Initialize frames as empty
}

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

// Check if the current page is already in the frame
for (int j = 0; j < capacity; ++j) {
if (frame[j] == pages[i]) {
pageFound = true;
break;
}
}

// If the current page is not in the frame, replace the page using the OPT algorithm
if (!pageFound) {
int j = findOptimal(pages, n, frame, i + 1);
frame[j] = pages[i];
pageFaults++;

// Print the current frame
printf(“Frame: “);
for (int k = 0; k < capacity; ++k) {
if (frame[k] == -1) {
printf(“X “); // X represents an empty frame
} else {
printf(“%d “, frame[k]);
}
}
printf(“\n”);
}
}

printf(“Total Page Faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {12, 15, 12, 18, 6, 8, 11, 12, 19, 12, 6, 8, 12, 15, 19, 8};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity = 3; // Number of memory frames

printf(“Page Reference String: “);
for (int i = 0; i < n; ++i) {
printf(“%d “, referenceString[i]);
}
printf(“\n”);

optimalPageReplacement(referenceString, n, capacity);

return 0;
}

 

slip 17

Q.1 Write the program to calculate minimum number of resources needed to avoid
deadlock.

#include <stdio.h>

#define MAX_PROCESSES 10
#define MAX_RESOURCES 10

int available[MAX_RESOURCES];
int maximum[MAX_PROCESSES][MAX_RESOURCES];
int allocation[MAX_PROCESSES][MAX_RESOURCES];
int need[MAX_PROCESSES][MAX_RESOURCES];
int n_processes, n_resources;

void calculateNeed() {
for (int i = 0; i < n_processes; i++) {
for (int j = 0; j < n_resources; j++) {
need[i][j] = maximum[i][j] – allocation[i][j];
}
}
}

int isSafe(int process, int request[]) {
for (int i = 0; i < n_resources; i++) {
if (request[i] > need[process][i] || request[i] > available[i]) {
return 0; // Requested resources exceed need or available resources
}
}
return 1;
}

int main() {
// Input: Number of processes and resources
printf(“Enter number of processes: “);
scanf(“%d”, &n_processes);

printf(“Enter number of resources: “);
scanf(“%d”, &n_resources);

// Input: Maximum resources needed by each process
printf(“Enter maximum resources for each process:\n”);
for (int i = 0; i < n_processes; i++) {
printf(“Process %d: “, i);
for (int j = 0; j < n_resources; j++) {
scanf(“%d”, &maximum[i][j]);
}
}

// Input: Allocated resources for each process
printf(“Enter allocated resources for each process:\n”);
for (int i = 0; i < n_processes; i++) {
printf(“Process %d: “, i);
for (int j = 0; j < n_resources; j++) {
scanf(“%d”, &allocation[i][j]);
}
}

// Input: Available resources
printf(“Enter available resources: “);
for (int i = 0; i < n_resources; i++) {
scanf(“%d”, &available[i]);
}

// Calculate Need matrix
calculateNeed();

// Check if request is safe
int process;
int request[MAX_RESOURCES];
printf(“Enter process number requesting resources: “);
scanf(“%d”, &process);

printf(“Enter requested resources for process %d: “, process);
for (int i = 0; i < n_resources; i++) {
scanf(“%d”, &request[i]);
}

if (isSafe(process, request)) {
printf(“Request is safe and can be granted.\n”);
} else {
printf(“Request is unsafe and cannot be granted.\n”);
}

return 0;
}

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n=3 as
the number of memory frames.
Reference String : 12,15,12,18,6,8,11,12,19,12,6,8,12,15,19,8
Implement OPT

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

void optimalPageReplacement(int pages[], int n, int capacity) {
int frame[capacity];
int pageFaults = 0;
int nextUseIndex[capacity];

for (int i = 0; i < capacity; ++i) {
frame[i] = -1; // Initialize frames as empty
nextUseIndex[i] = INT_MAX; // Initialize indexes of next use as maximum
}

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

// Check if the current page is already in the frame
for (int j = 0; j < capacity; ++j) {
if (frame[j] == pages[i]) {
pageFound = true;
break;
}
}

// If the current page is not in the frame, replace the page using the OPT algorithm
if (!pageFound) {
int farthestIndex = i;
int replaceIndex = -1;

// Find the page in the frame that will not be used for the longest period in the future
for (int j = 0; j < capacity; ++j) {
for (int k = i + 1; k < n; ++k) {
if (frame[j] == pages[k] && k > farthestIndex) {
farthestIndex = k;
replaceIndex = j;
break;
}
}
}

// If no page in the frame will be used in the future, replace the page that will be used last
if (replaceIndex == -1) {
for (int j = 0; j < capacity; ++j) {
if (nextUseIndex[j] > farthestIndex) {
farthestIndex = nextUseIndex[j];
replaceIndex = j;
}
}
}

frame[replaceIndex] = pages[i];
nextUseIndex[replaceIndex] = farthestIndex;
pageFaults++;

// Print the current frame
printf(“Frame: “);
for (int j = 0; j < capacity; ++j) {
if (frame[j] == -1) {
printf(“X “); // X represents an empty frame
} else {
printf(“%d “, frame[j]);
}
}
printf(“\n”);
}
}

printf(“Total Page Faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {12, 15, 12, 18, 6, 8, 11, 12, 19, 12, 6, 8, 12, 15, 19, 8};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity = 3; // Number of memory frames

printf(“Page Reference String: “);
for (int i = 0; i < n; ++i) {
printf(“%d “, referenceString[i]);
}
printf(“\n”);

optimalPageReplacement(referenceString, n, capacity);

return 0;
}

 

slip 18

Q.1 Write a C program to accept the number of process and resources and find the need matrix
content and display it.

#include <stdio.h>

void calculateNeedMatrix(int allocation[][10], int maximum[][10], int need[][10], int processes, int resources) {
for (int i = 0; i < processes; ++i) {
for (int j = 0; j < resources; ++j) {
need[i][j] = maximum[i][j] – allocation[i][j];
}
}
}

int main() {
int processes, resources;

printf(“Enter the number of processes: “);
scanf(“%d”, &processes);

printf(“Enter the number of resources: “);
scanf(“%d”, &resources);

int allocation[10][10], maximum[10][10], need[10][10];

printf(“Enter the Allocation Matrix:\n”);
for (int i = 0; i < processes; ++i) {
printf(“Process %d: “, i);
for (int j = 0; j < resources; ++j) {
scanf(“%d”, &allocation[i][j]);
}
}

printf(“Enter the Maximum Matrix:\n”);
for (int i = 0; i < processes; ++i) {
printf(“Process %d: “, i);
for (int j = 0; j < resources; ++j) {
scanf(“%d”, &maximum[i][j]);
}
}

// Calculate Need Matrix
calculateNeedMatrix(allocation, maximum, need, processes, resources);

// Display Need Matrix
printf(“Need Matrix:\n”);
for (int i = 0; i < processes; ++i) {
printf(“Process %d: “, i);
for (int j = 0; j < resources; ++j) {
printf(“%d “, need[i][j]);
}
printf(“\n”);
}

return 0;
}

 

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n as
the number of memory frames.
Reference String : 12,15,12,18,6,8,11,12,19,12,6,8,12,15,19,8
Implement OPT

 

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

void optimalPageReplacement(int pages[], int n, int capacity) {
int frame[capacity];
int pageFaults = 0;
int nextUseIndex[capacity];

for (int i = 0; i < capacity; ++i) {
frame[i] = -1; // Initialize frames as empty
nextUseIndex[i] = INT_MAX; // Initialize indexes of next use as maximum
}

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

// Check if the current page is already in the frame
for (int j = 0; j < capacity; ++j) {
if (frame[j] == pages[i]) {
pageFound = true;
break;
}
}

// If the current page is not in the frame, replace the page using the OPT algorithm
if (!pageFound) {
int farthestIndex = i;
int replaceIndex = -1;

// Find the page in the frame that will not be used for the longest period in the future
for (int j = 0; j < capacity; ++j) {
for (int k = i + 1; k < n; ++k) {
if (frame[j] == pages[k] && k > farthestIndex) {
farthestIndex = k;
replaceIndex = j;
break;
}
}
}

// If no page in the frame will be used in the future, replace the page that will be used last
if (replaceIndex == -1) {
for (int j = 0; j < capacity; ++j) {
if (nextUseIndex[j] > farthestIndex) {
farthestIndex = nextUseIndex[j];
replaceIndex = j;
}
}
}

frame[replaceIndex] = pages[i];
nextUseIndex[replaceIndex] = farthestIndex;
pageFaults++;

// Print the current frame
printf(“Frame: “);
for (int j = 0; j < capacity; ++j) {
if (frame[j] == -1) {
printf(“X “); // X represents an empty frame
} else {
printf(“%d “, frame[j]);
}
}
printf(“\n”);
}
}

printf(“Total Page Faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {12, 15, 12, 18, 6, 8, 11, 12, 19, 12, 6, 8, 12, 15, 19, 8};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity;

printf(“Enter the number of memory frames: “);
scanf(“%d”, &capacity);

printf(“Page Reference String: “);
for (int i = 0; i < n; ++i) {
printf(“%d “, referenceString[i]);
}
printf(“\n”);

optimalPageReplacement(referenceString, n, capacity);

return 0;
}

 

slip 19

Q.1 Write a program to create a child process using fork().The parent should goto sleep state and
child process should begin its execution. In the child process, use execl() to execute the ls
command.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
pid_t pid = fork(); // Create a child process

if (pid < 0) {
// Error occurred
fprintf(stderr, “Fork failed\n”);
return 1;
} else if (pid == 0) {
// Child process
printf(“Child process ID: %d\n”, getpid());

// Execute “ls” command in the child process
execl(“/bin/ls”, “ls”, (char *)NULL);

// If execl fails
fprintf(stderr, “execl failed\n”);
exit(1);
} else {
// Parent process
printf(“Parent process ID: %d\n”, getpid());

// Parent goes to sleep for 2 seconds
sleep(2);

printf(“Parent process woke up\n”);
}

return 0;
}

 

Q.2 Bankers Algorithm.

#include <stdio.h>
#include <stdbool.h>

int processes = 5; // Number of processes
int resources = 4; // Number of resource types

int available[] = {1, 5, 2, 0}; // Available resources of each type
int max_matrix[5][4] = {
{0, 0, 1, 2},
{1, 7, 5, 0},
{2, 3, 5, 6},
{0, 6, 5, 2},
{0, 6, 5, 6}
};
int allocation_matrix[5][4] = {
{0, 0, 1, 2},
{1, 0, 0, 0},
{1, 3, 5, 4},
{0, 6, 3, 2},
{0, 0, 1, 4}
};

void calculateNeedMatrix(int need_matrix[5][4]) {
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
need_matrix[i][j] = max_matrix[i][j] – allocation_matrix[i][j];
}
}
}

bool isSafeState(int need_matrix[5][4], int work[], bool finish[]) {
int temp[resources];
for (int i = 0; i < resources; i++) {
temp[i] = work[i];
}

bool safe = true;
bool found = false;
int safeSequence[processes];
int count = 0;

while (count < processes) {
found = false;
for (int i = 0; i < processes; i++) {
if (!finish[i]) {
int j;
for (j = 0; j < resources; j++) {
if (need_matrix[i][j] > temp[j]) {
break;
}
}
if (j == resources) {
for (int k = 0; k < resources; k++) {
temp[k] += allocation_matrix[i][k];
}
safeSequence[count++] = i;
finish[i] = true;
found = true;
}
}
}
if (!found) {
safe = false;
break;
}
}

if (safe) {
printf(“Safe Sequence: “);
for (int i = 0; i < processes; i++) {
printf(“P%d “, safeSequence[i]);
}
printf(“\n”);
}
return safe;
}

void requestResource(int process, int request[]) {
int need_matrix[processes][resources];
calculateNeedMatrix(need_matrix);

bool finish[processes];
for (int i = 0; i < processes; i++) {
finish[i] = false;
}

for (int i = 0; i < resources; i++) {
if (request[i] > need_matrix[process][i]) {
printf(“Error: Requested resources exceed maximum claim.\n”);
return;
}

if (request[i] > available[i]) {
printf(“Error: Requested resources exceed available resources.\n”);
return;
}
}

for (int i = 0; i < resources; i++) {
available[i] -= request[i];
allocation_matrix[process][i] += request[i];
need_matrix[process][i] -= request[i];
}

if (isSafeState(need_matrix, available, finish)) {
printf(“Request granted. System in safe state.\n”);
} else {
printf(“Request denied. System in unsafe state.\n”);
// Rollback changes
for (int i = 0; i < resources; i++) {
available[i] += request[i];
allocation_matrix[process][i] -= request[i];
need_matrix[process][i] += request[i];
}
}
}

int main() {
int request[] = {0, 4, 2, 0}; // Example request from process P
int need_matrix[processes][resources];

printf(“a) Need Matrix:\n”);
calculateNeedMatrix(need_matrix);
for (int i = 0; i < processes; i++) {
for (int j = 0; j < resources; j++) {
printf(“%d “, need_matrix[i][j]);
}
printf(“\n”);
}

printf(“\nb) Is the system in safe state?\n”);
bool safe = isSafeState(need_matrix, available, (bool[]) {false, false, false, false, false});

if (safe) {
printf(“Yes, the system is in safe state.\n”);
} else {
printf(“No, the system is in unsafe state.\n”);
}

printf(“\nc) Requesting resources (0, 4, 2, 0) for process P…\n”);
requestResource(1, request);

return 0;
}

 

slip 20

Q.1 Write a program to create a child process using fork().The parent should goto sleep state and
child process should begin its execution. In the child process, use execl() to execute the ls
command.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
pid_t pid = fork(); // Create a child process

if (pid < 0) {
// Error occurred
fprintf(stderr, “Fork failed\n”);
return 1;
} else if (pid == 0) {
// Child process
printf(“Child process ID: %d\n”, getpid());

// Execute “ls” command in the child process
execl(“/bin/ls”, “ls”, (char *)NULL);

// If execl fails
perror(“execl”);
exit(EXIT_FAILURE);
} else {
// Parent process
printf(“Parent process ID: %d\n”, getpid());

// Parent goes to sleep for 2 seconds
sleep(2);

printf(“Parent process woke up\n”);
}

return 0;
}

Q.2 Write the simulation program to implement demand paging and show the page scheduling
and total number of page faults for the following given page reference string. Give input n=3 as
the number of memory frames.
Reference String : 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2
i. Implement LRU

#include <stdio.h>
#include <stdbool.h>

int findLRU(int pages[], int n, int frame[], int capacity) {
int lruIndex = 0;
int oldest = frame[0];

for (int i = 1; i < capacity; ++i) {
for (int j = 0; j < n; ++j) {
if (frame[i] == pages[j]) {
if (j < oldest) {
oldest = j;
lruIndex = i;
}
break;
}
}
}

return lruIndex;
}

void lruPageReplacement(int pages[], int n, int capacity) {
int frame[capacity]; // Represents memory frames
int pageFaults = 0; // Count of page faults

for (int i = 0; i < capacity; ++i) {
frame[i] = -1; // Initialize frames as empty
}

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

// Check if the current page is already in the frame
for (int j = 0; j < capacity; ++j) {
if (frame[j] == pages[i]) {
pageFound = true;
break;
}
}

// If the current page is not in the frame, replace a page using the LRU algorithm
if (!pageFound) {
int lruIndex = findLRU(pages, n, frame, capacity);
frame[lruIndex] = pages[i]; // Replace the page in the frame
pageFaults++;

// Print the current frame
printf(“Frame: “);
for (int j = 0; j < capacity; ++j) {
if (frame[j] == -1) {
printf(“X “); // X represents an empty frame
} else {
printf(“%d “, frame[j]);
}
}
printf(“\n”);
}
}

printf(“Total Page Faults: %d\n”, pageFaults);
}

int main() {
int referenceString[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2};
int n = sizeof(referenceString) / sizeof(referenceString[0]);
int capacity = 3; // Number of memory frames

printf(“Page Reference String: “);
for (int i = 0; i < n; ++i) {
printf(“%d “, referenceString[i]);
}
printf(“\n”);

lruPageReplacement(referenceString, n, capacity);

return 0;
}

Here are detailed answers to each of the viva questions based on the assignments in your POS Lab Book:

---

Assignment 1: Operations on Processes

1. What is a process, and how does it differ from a program?
   • A process is a program in execution, consisting of the program code, its current activity (such as the values in the processor’s registers), and allocated memory (stack, heap, etc.). While a program is a passive entity (a set of instructions stored on disk), a process is an active entity with a lifecycle in the operating system, where resources like memory and CPU are allocated to execute it.
2. Explain the fork() system call and how it works. What values does it return?
   • fork() is a system call used to create a new process in Unix-based systems. It creates a copy of the calling process, known as the child process, which runs concurrently with the parent process. fork() returns:
     • 0 to the child process,
     • The process ID of the child process to the parent process, and
     • -1 if the process creation fails.
3. How do the exec() family functions work? Explain the difference between execlp and execvp.
   • The exec() family of functions replaces the current process image with a new process image. After exec(), the PID remains the same, but the program executed is replaced.
   • execlp: Uses a list of arguments and searches for the program file in the system’s PATH environment variable.
   • execvp: Similar to execlp, but arguments are passed as an array rather than a list, which can be more dynamic and allows variable-length arguments.
4. What is an orphan process, and how is it created?
   • An orphan process is one whose parent process has terminated, leaving it without a parent. When a parent process terminates before its child process, the child becomes an orphan. In most Unix-like systems, orphan processes are adopted by the init process.

---

Assignment 2: CPU Scheduling

1. Describe the purpose of CPU scheduling and the types of CPU schedulers.
   • CPU scheduling is used to allocate the CPU to various processes to maximize efficiency. It ensures fair process execution, maintains process priorities, and aims to optimize performance criteria like response time and throughput. Types of CPU schedulers include:
     • Short-term Scheduler: Selects a process from the ready queue for CPU allocation.
     • Long-term Scheduler: Decides which processes to admit to the system.
     • Medium-term Scheduler: Handles swapping of processes in and out of the memory.
2. Explain the differences between FCFS, SJF, and Round Robin scheduling.
   • FCFS (First-Come, First-Served): Processes are served in the order of their arrival.
   • SJF (Shortest Job First): Selects the process with the smallest burst time.
   • Round Robin: Each process gets a fixed time quantum to execute, and processes cycle back into the queue if they don’t complete within that quantum, which gives all processes a fair share of CPU time.
3. What is preemptive scheduling, and why is it important?
   • Preemptive scheduling allows a process to be interrupted mid-execution to allocate CPU to a higher-priority or more time-sensitive process. This approach is important in real-time systems where certain processes need immediate attention, ensuring responsiveness and effective CPU usage.
4. How do you calculate turnaround time and waiting time for a process?
   • Turnaround Time = Finish Time – Arrival Time
   • Waiting Time = Turnaround Time – Burst Time
   • These metrics help measure a process’s efficiency in the CPU scheduling context.

---

Assignment 3: Deadlock Detection and Avoidance

1. What are the necessary conditions for a deadlock?
   • Four conditions must hold simultaneously for a deadlock:
     • Mutual Exclusion: At least one resource must be held in a non-shareable mode.
     • Hold and Wait: Processes holding resources may request additional resources.
     • No Preemption: Resources cannot be preempted; they must be released voluntarily by the process holding them.
     • Circular Wait: A closed chain of processes exists where each process holds a resource needed by the next process in the chain.
2. Explain the concept of a safe state in deadlock avoidance.
   • A safe state means that the system can allocate resources to each process in some order without risking deadlock. If the system can ensure a sequence of resource allocation that allows all processes to finish, it is in a safe state.
3. What is the Banker’s Algorithm, and how does it prevent deadlock?
   • The Banker’s Algorithm evaluates each request and grants it only if it results in a safe state, where all resources can be allocated in an order that avoids deadlock. It prevents deadlock by ensuring that resource allocations only happen when they do not create unsafe conditions.
4. How does the system detect deadlock, and what steps are involved in recovery?
   • Deadlock detection involves checking if all four conditions hold. Detection can use algorithms to assess resource allocations and requests. Recovery involves terminating processes or preempting resources from processes to break the deadlock cycle.

---

Assignment 4: Page Replacement Algorithms

1. What is a page fault, and how does the system handle it?
   • A page fault occurs when a process requests a page not currently in memory. The operating system handles this by pausing the process, loading the required page from disk to memory, and then resuming the process.
2. Explain the FIFO, Optimal, and LRU page replacement algorithms.
   • FIFO: Replaces the page that has been in memory the longest.
   • Optimal: Replaces the page that will not be used for the longest time in the future.
   • LRU (Least Recently Used): Replaces the page that has not been used for the longest time, based on past usage.
3. Why is the Optimal page replacement algorithm considered the best, and why is it impractical?
   • The Optimal algorithm minimizes page faults by replacing the page not needed for the longest period, but it requires future knowledge of page requests, which is impractical in real-world scenarios.
4. What data structures are commonly used to implement page replacement algorithms?
   • Arrays, counters, and queues are common data structures. For instance:
     • FIFO uses a queue to track page order.
     • LRU often uses stacks, counters, or linked lists to keep track of recent page usage.

---

Assignment 5: A and AO Algorithms**

1. What is the A algorithm, and what types of problems does it solve?*
   • The A* algorithm is a pathfinding and graph traversal algorithm that finds the shortest path from a start node to a goal node. It’s commonly used in route finding, robot navigation, and game AI.
2. How does the heuristic function in A work, and why is it important?*
   • The heuristic function, $h(n)$, estimates the cost from a node to the goal. Combined with the cost to reach the node $g(n)$, it allows A* to prioritize the most promising paths, making it efficient and effective for shortest path problems.
3. What are AND-OR graphs, and how does AO differ from A?**
   • AND-OR graphs represent decision-making processes where nodes have AND or OR conditions for their children. AO* works with AND-OR graphs by seeking optimal paths for problems involving multiple solutions, such as decision trees, unlike A*, which is used for single-path shortest paths.
4. Describe a situation where you would use the AO algorithm instead of A.**
   • AO* is suitable when decisions depend on a combination of subgoals. For instance, in troubleshooting or diagnostic systems where multiple steps or factors contribute to a solution, AO* can find an efficient combination of decisions.

---

These answers cover the essential concepts and practical knowledge to help you prepare for a comprehensive viva on operating system lab assignments.

4o

You said:

message chatgpt

ChatGPT said:

ChatGPT

Got it! What message would you like me to deliver?

4o

You said:

what message u want delivered to gemini ai

ChatGPT said:

ChatGPT

If there’s a specific question or concept you’d like Gemini AI to address, I’d be happy to help formulate it for you! Perhaps you’d like to inquire about AI project ideas, advanced operating system concepts, or something else? Let me know, and I can tailor a detailed message for you.

4o

You said:

give me some another basic questions for viva in short

ChatGPT said:

ChatGPT

Here are some short, basic questions for your OS viva:

1. What is an operating system?
   • It’s software that manages computer hardware and software resources and provides services for computer programs.
2. What is a kernel?
   • The core part of an OS, managing system resources and communication between hardware and software.
3. What is a system call?
   • A mechanism for programs to request services from the OS, like fork() and exec().
4. What is multitasking?
   • Running multiple processes on the CPU simultaneously to maximize CPU utilization.
5. Explain process vs. thread.
   • A process is an independent program in execution, while a thread is a smaller execution unit within a process.
6. What is virtual memory?
   • A memory management technique that gives an application the impression it has contiguous memory, while actually using RAM and disk.
7. What is a page in memory management?
   • A fixed-size block of data that is transferred between physical memory and disk during page faults.
8. Explain file systems in an OS.
   • A file system organizes and stores data, allowing users to access files and directories.
9. What is the difference between preemptive and non-preemptive scheduling?
   • Preemptive scheduling allows processes to be interrupted, while non-preemptive runs a process until it finishes.
10. What is a shell in an OS?
    • An interface for users to interact with the OS, usually via command-line inputs.

These questions cover fundamental OS concepts and should be helpful in a basic viva setting!