A
LAB REPORT
ON
Operating System
BY
Sajal Udash
Exam Roll No: 11369/20
Submitted to:
Indra PC
Department of Computer Science
Kantipur College of Management and Information Technology
In partial fulfillment of the requirements for the Course
Artificial Intelligience
Mid Baneshwor, Kathmandu
Jan, 2025
1
Contents
1. Write a program of FCFC algorithm in context of os?.........................................................................3
1.1. Source Code.....................................................................................................................................3
2. Write a program of Lru algorithm in context of os?.............................................................................6
2. Write a program of Priority algorithm in context of os?......................................................................8
1. Write a program of Sjf algorithm in context of os?............................................................................10
2. Write a program of Optimal LRU in context of os?..........................................................................14
3. Write a program of Page Replacement in context of os?.................................................................17
4. Write a program of Round Robin in context of os?..........................................................................21
5. Write a program of Banker Algorithm in context of os?...................................................................23
6. Write a program of Worst Fit in context of os?.................................................................................27
7. Write a program of Base Fit in context of os?....................................................................................31
8. Write a program of Next Fit in context of os?....................................................................................34
2
1. Write a program of FCFC algorithm in context of os?
1.1. Source Code
import java.util.Scanner;
class Process {
int pid;
int arrivalTime;
int burstTime;
int completionTime;
int turnAroundTime;
int waitingTime;
public Process(int pid, int arrivalTime, int burstTime) {
this.pid = pid;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
}
}
public class FCFS {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of processes: ");
int n = scanner.nextInt();
Process[] processes = new Process[n];
3
for (int i = 0; i < n; i++) {
System.out.print("Enter arrival time of process " + (i + 1) + ": ");
int arrivalTime = scanner.nextInt();
System.out.print("Enter burst time of process " + (i + 1) + ": ");
int burstTime = scanner.nextInt();
processes[i] = new Process(i + 1, arrivalTime, burstTime);
}
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (processes[i].arrivalTime > processes[j].arrivalTime) {
Process temp = processes[i];
processes[i] = processes[j];
processes[j] = temp;
}
}
}
int currentTime = 0;
for (Process process : processes) {
if (currentTime < process.arrivalTime) {
currentTime = process.arrivalTime;
}
process.completionTime = currentTime + process.burstTime;
process.turnAroundTime = process.completionTime - process.arrivalTime;
process.waitingTime = process.turnAroundTime - process.burstTime;
currentTime = process.completionTime;
}
System.out.println("\nProcess\tArrival\tBurst\tCompletion\tTurnaround\tWaiting");
for (Process process : processes) {
System.out.println(process.pid + "\t" + process.arrivalTime + "\t" + process.burstTime + "\t" +
process.completionTime + "\t\t" + process.turnAroundTime + "\t\t" + process.waitingTime);
4
}
double totalTurnAroundTime = 0, totalWaitingTime = 0;
for (Process process : processes) {
totalTurnAroundTime += process.turnAroundTime;
totalWaitingTime += process.waitingTime;
}
System.out.printf("\nAverage Turnaround Time: %.2f\n", totalTurnAroundTime / n);
System.out.printf("Average Waiting Time: %.2f\n", totalWaitingTime / n);
scanner.close();
}
}
Output
5
2. Write a program of Lru algorithm in context of os?
2.1. Source code
import java.util.*;
public class LRUCache {
private final int capacity;
private final LinkedHashSet<Integer> cache;
public LRUCache(int capacity) {
this.capacity = capacity;
this.cache = new LinkedHashSet<>();
}
public void accessPage(int page) {
if (cache.contains(page)) {
cache.remove(page);
}
else if (cache.size() == capacity) {
int first = cache.iterator().next(); // Get the first element
cache.remove(first); // Remove the least recently used page
System.out.println("Page " + first + " removed (LRU).");
}
cache.add(page);
System.out.println("Page " + page + " added.");
}
public void displayCache() {
System.out.println("Cache: " + cache);
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the capacity of the LRU cache: ");
6
int capacity = scanner.nextInt();
LRUCache lruCache = new LRUCache(capacity);
System.out.println("Enter the sequence of page references (-1 to stop):");
while (true) {
int page = scanner.nextInt();
if (page == -1) break;
lruCache.accessPage(page);
lruCache.displayCache();
}
scanner.close();
}
}
OUTPUT
1. Write a program of Priority algorithm in context of os?
1.1. Source code
7
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
class Process {
int id;
int arrivalTime;
int burstTime;
int priority;
int completionTime;
int turnaroundTime;
int waitingTime;
Process(int id, int arrivalTime, int burstTime, int priority) {
this.id = id;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
this.priority = priority;
}
}
public class PriorityScheduling {
public static void main(String[] args) {
List<Process> processes = new ArrayList<>();
processes.add(new Process(1, 0, 10, 2));
processes.add(new Process(2, 2, 5, 0));
processes.add(new Process(3, 3, 8, 1));
priorityScheduling(processes);
System.out.println("Process\tArrival\tBurst\tPriority\tCompletion\tTurnaround\tWaiting");
for (Process p : processes) {
System.out.printf("P%d\t%d\t%d\t%d\t\t%d\t\t%d\t\t%d\n",
p.id, p.arrivalTime, p.burstTime, p.priority,
p.completionTime, p.turnaroundTime, p.waitingTime);
}
}
public static void priorityScheduling(List<Process> processes) {
processes.sort(Comparator.comparingInt((Process p) -> p.priority).thenComparingInt(p ->
p.arrivalTime));
int currentTime = 0;
for (Process process : processes) {
// If the CPU is idle, move the current time to the process's arrival time
if (currentTime < process.arrivalTime) {
currentTime = process.arrivalTime;
8
}
process.completionTime = currentTime + process.burstTime;
currentTime += process.burstTime;
process.turnaroundTime = process.completionTime - process.arrivalTime;
process.waitingTime = process.turnaroundTime - process.burstTime;
}
}
}
Output
1. Write a program of Sjf algorithm in context of os?
Source code
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
9
class Process {
int id;
int arrivalTime;
int burstTime;
int completionTime;
int turnaroundTime;
int waitingTime;
Process(int id, int arrivalTime, int burstTime) {
this.id = id;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
}
}
public class SJFScheduling {
public static void main(String[] args) {
List<Process> processes = new ArrayList<>();
processes.add(new Process(1, 0, 7));
processes.add(new Process(2, 2, 4));
processes.add(new Process(3, 4, 1));
processes.add(new Process(4, 5, 4));
sjfScheduling(processes);
System.out.println("Process\tArrival\tBurst\tCompletion\tTurnaround\tWaiting");
for (Process p : processes) {
System.out.printf("P%d\t%d\t%d\t%d\t\t%d\t\t%d\n",
10
p.id, p.arrivalTime, p.burstTime,
p.completionTime, p.turnaroundTime, p.waitingTime);
}
}
public static void sjfScheduling(List<Process> processes) {
List<Process> completed = new ArrayList<>();
int currentTime = 0;
while (completed.size() < processes.size()) {
List<Process> available = new ArrayList<>();
for (Process p : processes) {
if (!completed.contains(p) && p.arrivalTime <= currentTime) {
available.add(p);
}
}
if (!available.isEmpty()) {
Process shortest = available.stream()
.min(Comparator.comparingInt(p -> p.burstTime))
.orElse(null);
shortest.completionTime = currentTime + shortest.burstTime;
currentTime += shortest.burstTime;
11
shortest.turnaroundTime = shortest.completionTime - shortest.arrivalTime;
shortest.waitingTime = shortest.turnaroundTime - shortest.burstTime;
completed.add(shortest);
} else {
currentTime++;
}
}
}
}
Output
12
13
2. Write a program of Optimal LRU in context of os?
2.1. Source code
import java.util.*;
public class OptimalPageReplacement {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of frames: ");
int frameCount = scanner.nextInt();
System.out.print("Enter the number of pages: ");
int pageCount = scanner.nextInt();
int[] pages = new int[pageCount];
System.out.println("Enter the reference string (page numbers):");
for (int i = 0; i < pageCount; i++) {
pages[i] = scanner.nextInt();
}
List<Integer> frames = new ArrayList<>();
int pageFaults = 0;
System.out.println("\nPage Replacement Process:");
for (int i = 0; i < pageCount; i++) {
int currentPage = pages[i];
if (!frames.contains(currentPage)) {
pageFaults++;
if (frames.size() == frameCount) {
int pageToReplace = findOptimalPage(frames, pages, i + 1);
System.out.println("Page " + pageToReplace + " removed (Optimal replacement).");
frames.remove(Integer.valueOf(pageToReplace));
}
frames.add(currentPage);
14
System.out.println("Page " + currentPage + " added to the frame.");
} else {
System.out.println("Page " + currentPage + " accessed (No page fault).");
}
System.out.println("Current frames: " + frames);
}
System.out.println("\nTotal page faults: " + pageFaults);
scanner.close();
}
private static int findOptimalPage(List<Integer> frames, int[] pages, int startIndex) {
Map<Integer, Integer> futureUsage = new HashMap<>();
for (int framePage : frames) {
boolean found = false;
for (int j = startIndex; j < pages.length; j++) {
if (pages[j] == framePage) {
futureUsage.put(framePage, j);
found = true;
break;
}
}
if (!found) {
futureUsage.put(framePage, Integer.MAX_VALUE);
}
}
int pageToReplace = -1;
int farthestUsage = -1;
for (int framePage : frames) {
int nextUse = futureUsage.get(framePage);
if (nextUse > farthestUsage) {
15
farthestUsage = nextUse;
pageToReplace = framePage;
}
}
return pageToReplace;
}
}
Output
3. Write a program of Page Replacement in context of os?
Source code
import java.util.*;
16
public class PageReplacement {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of frames: ");
int frameCount = scanner.nextInt();
System.out.print("Enter the number of pages: ");
int pageCount = scanner.nextInt();
int[] pages = new int[pageCount];
System.out.println("Enter the reference string (page numbers):");
for (int i = 0; i < pageCount; i++) {
pages[i] = scanner.nextInt();
}
Set<Integer> frames = new HashSet<>();
Map<Integer, Integer> pageIndices = new HashMap<>();
int pageFaults = 0;
System.out.println("\nPage Replacement Process:");
for (int i = 0; i < pageCount; i++) {
int currentPage = pages[i];
if (!frames.contains(currentPage)) {
pageFaults++;
if (frames.size() == frameCount) {
int lruPage = findLeastRecentlyUsed(pageIndices);
frames.remove(lruPage);
pageIndices.remove(lruPage);
System.out.println("Page " + lruPage + " removed (Least Recently Used).");
frames.add(currentPage);
System.out.println("Page " + currentPage + " added to the frame.");
} else {
17
System.out.println("Page " + currentPage + " accessed (No page fault).");
}
pageIndices.put(currentPage, i);
System.out.println("Current frames: " + frames);
}
System.out.println("\nTotal page faults: " + pageFaults);
scanner.close();
}
private static int findLeastRecentlyUsed(Map<Integer, Integer> pageIndices) {
int lruPage = -1;
int minIndex = Integer.MAX_VALUE;
for (Map.Entry<Integer, Integer> entry : pageIndices.entrySet()) {
if (entry.getValue() < minIndex) {
minIndex = entry.getValue();
lruPage = entry.getKey();
}
}
return lruPage;
}
}
Output
18
19
4. Write a program of Round Robin in context of os?
Source code
import java.util.LinkedList;
import java.util.Queue;
class Process {
int id;
int arrivalTime;
int burstTime;
int remainingTime;
int completionTime;
int turnaroundTime
int waitingTime;
Process(int id, int arrivalTime, int burstTime) {
this.id = id;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
this.remainingTime = burstTime;
}
}
public class RoundRobin {
public static void main(String[] args) {
Process[] processes = {
new Process(1, 0, 5),
new Process(2, 1, 3),
new Process(3, 2, 8),
new Process(4, 3, 6)
20
};
int timeQuantum = 3;
roundRobinScheduling(processes, timeQuantum);
System.out.println("Process\tArrival\tBurst\tCompletion\tTurnaround\tWaiting");
for (Process p : processes) {
System.out.printf("P%d\t%d\t%d\t%d\t\t%d\t\t%d\n",
p.id, p.arrivalTime, p.burstTime,
p.completionTime, p.turnaroundTime, p.waitingTime);
}
}
public static void roundRobinScheduling(Process[] processes, int timeQuantum) {
Queue<Process> readyQueue = new LinkedList<>();
int currentTime = 0;
int processIndex = 0;
while (processIndex < processes.length && processes[processIndex].arrivalTime <= currentTime) {
readyQueue.add(processes[processIndex]);
processIndex++;
}
while (!readyQueue.isEmpty()) {
Process currentProcess = readyQueue.poll();
int executionTime = Math.min(currentProcess.remainingTime, timeQuantum);
currentProcess.remainingTime -= executionTime;
currentTime += executionTime;
while (processIndex < processes.length && processes[processIndex].arrivalTime <= currentTime)
{
readyQueue.add(processes[processIndex]);
processIndex++;
}
21
if (currentProcess.remainingTime > 0) {
readyQueue.add(currentProcess);
} else {
currentProcess.completionTime = currentTime;
currentProcess.turnaroundTime = currentProcess.completionTime - currentProcess.arrivalTime;
currentProcess.waitingTime = currentProcess.turnaroundTime - currentProcess.burstTime;
}
}
}
}
Output
5. Write a program of Banker Algorithm in context of os?
Source code
22
import java.util.Scanner;
public class BankersAlgorithm {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter the number of processes: ");
int numProcesses = sc.nextInt();
System.out.print("Enter the number of resources: ");
int numResources = sc.nextInt();
int[][] allocation = new int[numProcesses][numResources];
System.out.println("Enter the Allocation matrix:");
for (int i = 0; i < numProcesses; i++) {
for (int j = 0; j < numResources; j++) {
allocation[i][j] = sc.nextInt();
}
}
int[][] maximum = new int[numProcesses][numResources];
System.out.println("Enter the Maximum matrix:");
for (int i = 0; i < numProcesses; i++) {
for (int j = 0; j < numResources; j++) {
maximum[i][j] = sc.nextInt();
}
}
int[] available = new int[numResources];
System.out.println("Enter the Available resources:");
for (int i = 0; i < numResources; i++) {
available[i] = sc.nextInt();
}
23
int[][] need = new int[numProcesses][numResources];
for (int i = 0; i < numProcesses; i++) {
for (int j = 0; j < numResources; j++) {
need[i][j] = maximum[i][j] - allocation[i][j];
}
}
boolean isSafe = bankersAlgorithm(allocation, maximum, available, need, numProcesses,
numResources);
if (isSafe) {
System.out.println("The system is in a safe state.");
} else {
System.out.println("The system is NOT in a safe state.");
}
sc.close();
}
public static boolean bankersAlgorithm(int[][] allocation, int[][] maximum, int[] available,
int[][] need, int numProcesses, int numResources) {
boolean[] finished = new boolean[numProcesses];
int[] safeSequence = new int[numProcesses];
int[] work = available.clone();
int count = 0;
while (count < numProcesses) {
boolean found = false;
for (int i = 0; i < numProcesses; i++) {
if (!finished[i]) {
boolean canProceed = true;
24
for (int j = 0; j < numResources; j++) {
if (need[i][j] > work[j]) {
canProceed = false;
break;
}
}
if (canProceed) {
for (int j = 0; j < numResources; j++) {
work[j] += allocation[i][j];
}
safeSequence[count++] = i;
finished[i] = true;
found = true;
}
}
}
if (!found) {
return false;
}
}
System.out.print("Safe Sequence: ");
for (int i = 0; i < numProcesses; i++) {
System.out.print("P" + safeSequence[i] + " ");
}
System.out.println();
25
return true;
}
}
Output
6. Write a program of Worst Fit in context of os?
Source code
import java.util.Scanner;
public class WorstFit {
public static void main(String[] args) {
26
Scanner scanner = new Scanner(System.in);
System.out.print("Enter number of memory blocks: ");
int blockCount = scanner.nextInt();
int[] blocks = new int[blockCount];
boolean[] allocated = new boolean[blockCount];
System.out.println("Enter sizes of the memory blocks:");
for (int i = 0; i < blockCount; i++) {
blocks[i] = scanner.nextInt();
}
System.out.print("Enter number of processes: ");
int processCount = scanner.nextInt();
int[] processes = new int[processCount];
System.out.println("Enter sizes of the processes:");
for (int i = 0; i < processCount; i++) {
processes[i] = scanner.nextInt();
}
for (int i = 0; i < processCount; i++) {
int worstIndex = -1;
for (int j = 0; j < blockCount; j++) {
if (!allocated[j] && blocks[j] >= processes[i]) {
if (worstIndex == -1 || blocks[j] > blocks[worstIndex]) {
worstIndex = j;
}
}
}
if (worstIndex != -1) {
System.out.println("Process " + (i + 1) + " of size " + processes[i]
+ " allocated to block " + (worstIndex + 1) + " of size " + blocks[worstIndex]);
blocks[worstIndex] -= processes[i]; // Reduce the block size
27
allocated[worstIndex] = blocks[worstIndex] == 0; // Mark block as allocated if fully used
} else {
System.out.println("Process " + (i + 1) + " of size " + processes[i] + " cannot be
allocated.");
}
}
System.out.println("\nRemaining memory in each block:");
for (int i = 0; i < blockCount; i++) {
System.out.println("Block " + (i + 1) + ": " + blocks[i]);
}
scanner.close();
}
}
Output
28
29
7. Write a program of Base Fit in context of os?
Source code
import java.util.Scanner;
public class BestFit {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of memory blocks: ");
int blockCount = scanner.nextInt();
int[] blocks = new int[blockCount
System.out.println("Enter the sizes of the memory blocks:");
for (int i = 0; i < blockCount; i++) {
blocks[i] = scanner.nextInt();
}
System.out.print("Enter the number of processes: ");
int processCount = scanner.nextInt();
int[] processes = new int[processCount];
System.out.println("Enter the sizes of the processes:");
for (int i = 0; i < processCount; i++) {
processes[i] = scanner.nextInt();
}
for (int i = 0; i < processCount; i++) {
int bestIndex = -1;
for (int j = 0; j < blockCount; j++) {
if (blocks[j] >= processes[i]) {
if (bestIndex == -1 || blocks[j] < blocks[bestIndex]) {
bestIndex = j;
}
}
}
30
if (bestIndex != -1) {
System.out.println("Process " + (i + 1) + " of size " + processes[i]
+ " allocated to block " + (bestIndex + 1) + " of size " + blocks[bestIndex]);
blocks[bestIndex] -= processes[i];
} else {
System.out.println("Process " + (i + 1) + " of size " + processes[i] + " cannot be
allocated.");
}
}
System.out.println("\nRemaining memory in each block:");
for (int i = 0; i < blockCount; i++) {
System.out.println("Block " + (i + 1) + ": " + blocks[i]);
}
scanner.close();
}
}
Output
31
32
8. Write a program of Next Fit in context of os?
Source code
import java.util.Scanner;
public class NextFit {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of memory blocks: ");
int blockCount = scanner.nextInt();
int[] blocks = new int[blockCount];
System.out.println("Enter the sizes of the memory blocks:");
for (int i = 0; i < blockCount; i++) {
blocks[i] = scanner.nextInt();
}
System.out.print("Enter the number of processes: ");
int processCount = scanner.nextInt();
int[] processes = new int[processCount];
System.out.println("Enter the sizes of the processes:");
for (int i = 0; i < processCount; i++) {
processes[i] = scanner.nextInt();
}
int lastAllocatedIndex = 0;
for (int i = 0; i < processCount; i++) {
boolean allocated = false;
for (int j = 0; j < blockCount; j++) {
int index = (lastAllocatedIndex + j) % blockCount;
if (blocks[index] >= processes[i]) {
System.out.println("Process " + (i + 1) + " of size " + processes[i]
33
+ " allocated to block " + (index + 1) + " of size " + blocks[index]);
blocks[index] -= processes[i];
lastAllocatedIndex = index;
allocated = true;
break;
}
}
if (!allocated) {
System.out.println("Process " + (i + 1) + " of size " + processes[i] + " cannot be
allocated.");
}
}
System.out.println("\nRemaining memory in each block:");
for (int i = 0; i < blockCount; i++) {
System.out.println("Block " + (i + 1) + ": " + blocks[i]);
}
scanner.close();
}
}
Output
34
35
