implementazione scheduler

Author: totoLab

sistemiOperativi/esercitazioni/src/utils/Process.java

@@ -0,0 +1,18 @@
+package utils;
+
+public class Process {
+ String name;
+ int arrivalTime;
+ int cpuBurst;
+
+ public Process(String name, int arrivalTime, int cpuBurst) {
+ this.name = name;
+ this.arrivalTime = arrivalTime;
+ this.cpuBurst = cpuBurst;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("%s: %d CPU bursts remaining", name, cpuBurst);
+ }
+}

sistemiOperativi/esercitazioni/src/utils/Scheduler.java

@@ -0,0 +1,93 @@
+package utils;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+public abstract class Scheduler {
+ protected List<Process> processes;
+ protected Queue<Process> readyQueue = new LinkedList<>();
+ protected Process currentProcess = null;
+ protected int currentTime = -1;
+
+ // Main scheduling method to be called by all subclasses
+ public void schedule(List<Process> processes) {
+ this.processes = processes;
+ this.readyQueue = initializeQueue(); // Let subclasses decide the queue type
+
+ while (!processes.isEmpty() || !readyQueue.isEmpty() || currentProcess != null) {
+ currentTime++;
+
+ // Add newly arrived processes to the ready queue
+ Iterator<Process> processIterator = processes.iterator();
+ while (processIterator.hasNext()) {
+ Process p = processIterator.next();
+ if (p.arrivalTime == currentTime) {
+ readyQueue.add(p);
+ System.out.println(currentTime + ": New process in queue: " + p);
+ processIterator.remove(); // Remove from original list once added to the queue
+ }
+ }
+
+ // Select the next process to run based on the specific scheduler logic
+ if (shouldSwitchProcess()) {
+ if (currentProcess != null && currentProcess.cpuBurst > 0) {
+ readyQueue.add(currentProcess); // Add the current process back if not finished
+ }
+ currentProcess = selectNextProcess(); // Let subclasses select the next process
+ resetQuantumOrCounters();
+ }
+
+ // Execute the selected process
+ if (currentProcess != null) {
+ executeBurst(currentProcess);
+ System.out.printf("(%d) Executing %s\n", currentTime, currentProcess);
+ } else {
+ System.out.printf("(%d) No process is running\n", currentTime);
+ }
+
+ waitOneSecond(); // Simulate the passage of time
+ }
+ }
+
+ protected abstract Process selectNextProcess();
+
+ protected abstract boolean shouldSwitchProcess();
+
+ protected void resetQuantumOrCounters() {}
+
+ protected void executeBurst(Process process) {
+ if (process != null) {
+ process.cpuBurst--;
+ }
+ }
+
+ protected Queue<Process> initializeQueue() {
+ return new LinkedList<>();
+ }
+
+ private void waitOneSecond() {
+ try {
+ TimeUnit.SECONDS.sleep(1);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public void test1() {
+ List<Process> p = new ArrayList<>();
+ p.add(new Process("P1", 0, 20));
+ p.add(new Process("P2", 4, 15));
+ p.add(new Process("P3", 8, 9));
+ schedule(p);
+ }
+
+ public void test2() {
+ List<Process> p = new ArrayList<>();
+ p.add(new Process("P1", 0, 17));
+ p.add(new Process("P2", 3, 14));
+ p.add(new Process("P3", 4, 10));
+ p.add(new Process("P4", 9, 4));
+ p.add(new Process("P5", 11, 12));
+ schedule(p);
+ }
+}

sistemiOperativi/esercitazioni/src/utils/SchedulerRR.java

@@ -0,0 +1,35 @@
+package utils;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class SchedulerRR extends Scheduler {
+
+ private final int quantum;
+ private int timeSliceCounter = 0;
+
+ public SchedulerRR(int quantum) {
+ this.quantum = quantum;
+ }
+
+ @Override
+ protected boolean shouldSwitchProcess() {
+ return currentProcess == null || timeSliceCounter == quantum || currentProcess.cpuBurst == 0;
+ }
+
+ @Override
+ protected Process selectNextProcess() {
+ timeSliceCounter = 0;
+ return readyQueue.poll();
+ }
+
+ @Override
+ protected void resetQuantumOrCounters() {
+ timeSliceCounter = 0; // Reset the counter for RR
+ }
+
+ public static void main(String[] args) {
+ Scheduler scheduler = new SchedulerRR(8);
+ scheduler.test2();
+ }
+}

sistemiOperativi/esercitazioni/src/utils/SchedulerSJFPreemptive.java

@@ -0,0 +1,31 @@
+package utils;
+
+import java.util.PriorityQueue;
+import java.util.Comparator;
+import java.util.Queue;
+
+public class SchedulerSJFPreemptive extends Scheduler {
+
+ @Override
+ protected Queue<Process> initializeQueue() {
+ // Use a priority queue to always select the process with the shortest remaining burst
+ return new PriorityQueue<>(Comparator.comparingInt(p -> p.cpuBurst));
+ }
+
+ @Override
+ protected boolean shouldSwitchProcess() {
+ // Switch if current process finished or there's a process with a shorter remaining time
+ return currentProcess == null || currentProcess.cpuBurst == 0 ||
+ (!readyQueue.isEmpty() && readyQueue.peek().cpuBurst < currentProcess.cpuBurst);
+ }
+
+ @Override
+ protected Process selectNextProcess() {
+ return readyQueue.poll();
+ }
+
+ public static void main(String[] args) {
+ Scheduler scheduler = new SchedulerSJFPreemptive();
+ scheduler.test1();
+ }
+}