Skip to content

las3_pub / jester

Go to a project
Commit 4f834394 by Michael Schmid
Options

added refactoring for Stats library

parent 6b1ef83a
Inline Side-by-side
Showing with 780 additions and 184 deletions
src/main/java/mvd/jester/App.java
...@@ -12,17 +12,23 @@ import mvd.jester.priority.RateMonotonic; ...@@ -12,17 +12,23 @@ import mvd.jester.priority.RateMonotonic;
public class App { public class App {
public static void main(String[] args) { public static void main(String[] args) {
SystemSetup.Builder builder = new SystemSetup.Builder().setNumberOfProcessors(8); SystemSetup.Builder builder = new SystemSetup.Builder().setNumberOfProcessors(8);
TestEnvironment te = new TestEnvironment(builder, 40000); TestEnvironment te = new TestEnvironment(builder, 30000);
te.registerSchedulingAlgorithm(new RateMonotonic()); te.registerSchedulingAlgorithm(new RateMonotonic());
te.registerSchedulingAlgorithm(new EarliestDeadlineFirst()); te.registerSchedulingAlgorithm(new EarliestDeadlineFirst());
te.registerTestPair(mvd.jester.tests.MaiaBertogna.class, // te.registerTest(mvd.jester.tests.SchmidMottok.class);
mvd.jester.simulator.MaiaBertogna.class); // te.registerTest(mvd.jester.tests.MaiaBertogna.class);
te.registerSimulator(mvd.jester.simulator.MaiaBertogna.class);
te.registerSimulator(mvd.jester.simulator.SchmidMottok.class);
te.registerTestPair(mvd.jester.tests.SchmidMottok.class,
mvd.jester.simulator.SchmidMottok.class);
te.runTests(); te.runTests();
// SystemSetup ss = builder.build();
// builder.addTask(ss);
// builder.addTask(ss);
// ss.writeToFile("Test3.txt");
} }
} }
src/main/java/mvd/jester/Pair.java 0 → 100644
package mvd.jester;
import mvd.jester.priority.PriorityManager;
/**
* PriorityPair
*/
public class Pair<T extends PairInterface> {
private final PriorityManager priorityManager;
private final T abstractValue;
public Pair(PriorityManager priorityManager, T abstractValue) {
this.abstractValue = abstractValue;
this.priorityManager = priorityManager;
}
/**
* @return the priorityManager
*/
public PriorityManager getPriorityManager() {
return priorityManager;
}
/**
* @return the abstractValue
*/
public T getAbstractValue() {
return abstractValue;
}
public String getName() {
return abstractValue.getName() + "_" + priorityManager.getName();
}
}
src/main/java/mvd/jester/PairInterface.java 0 → 100644
package mvd.jester;
/**
* PairInterface
*/
public interface PairInterface {
public String getName();
}
src/main/java/mvd/jester/ResultCollector.java 0 → 100644
package mvd.jester;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import com.google.common.collect.Table;
import com.google.common.math.Stats;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.info.TerminationInfo;
import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.tests.AbstractTest;
import mvd.jester.utils.Logger;
/**
* ResultCollector
*/
public class ResultCollector {
private final Table<Long, Pair<AbstractTest>, Set<SchedulingInfo>> testResults;
private final Table<Long, Pair<AbstractSimulator>, Set<SchedulingInfo>> simulatorResults;
private final Map<Long, Long> totalNumberOfTasksets;
private final long numberOfProcessors;
public ResultCollector(Table<Long, Pair<AbstractTest>, Set<SchedulingInfo>> testResults,
Table<Long, Pair<AbstractSimulator>, Set<SchedulingInfo>> simulatorResults,
Map<Long, Long> totalNumberOfTasksets, long numberOfProcessors) {
this.testResults = testResults;
this.simulatorResults = simulatorResults;
this.totalNumberOfTasksets = totalNumberOfTasksets;
this.numberOfProcessors = numberOfProcessors;
}
public void logAll() {
if (!testResults.isEmpty()) {
logResults(testResults, "test");
logMeanTardiness(simulatorResults, "test");
logFailedTardiness(testResults, "test");
}
if (!simulatorResults.isEmpty()) {
logResults(simulatorResults, "sim");
logMeanTardiness(simulatorResults, "sim");
logFailedTardiness(simulatorResults, "sim");
}
}
public <T extends PairInterface> void logResults(
Table<Long, Pair<T>, Set<SchedulingInfo>> results, String type) {
LocalTime date = LocalTime.now();
Logger log = new Logger("./results/results_" + type + "_" + numberOfProcessors + "_"
+ date.getHour() + ":" + date.getMinute() + ".txt");
String firstLine = new String("Utilization\tTotal");
if (!results.isEmpty()) {
for (Pair<T> pair : results.columnKeySet()) {
firstLine = firstLine + "\t" + pair.getName();
}
log.log(firstLine);
for (Long util : totalNumberOfTasksets.keySet()) {
String line =
String.valueOf((double) util / 10) + "\t" + totalNumberOfTasksets.get(util);
for (Pair<T> pair : results.columnKeySet()) {
long feasibleTasksets = results.get(util, pair).stream()
.filter(s -> s.checkTasksetFeasible()).count();
line += "\t" + feasibleTasksets;
}
log.log(line);
}
}
log.finalize();
}
public <T extends PairInterface> void logFailedTardiness(
Table<Long, Pair<T>, Set<SchedulingInfo>> results, String type) {
LocalTime date = LocalTime.now();
Logger log = new Logger("./results/failed_tardiness_" + type + "_" + numberOfProcessors
+ "_" + date.getHour() + ":" + date.getMinute() + ".txt");
String firstLine = new String("Utilization\tTotal");
if (!results.isEmpty()) {
for (Pair<T> pair : results.columnKeySet()) {
firstLine = firstLine + "\t" + pair.getName();
}
log.log(firstLine);
for (Long kv : totalNumberOfTasksets.keySet()) {
String line =
String.valueOf((double) kv / 10) + "\t" + totalNumberOfTasksets.get(kv);
for (Pair<T> pair : results.columnKeySet()) {
Set<SchedulingInfo> simulationInfos = results.get(kv, pair);
List<Long> values = new ArrayList<>();
for (SchedulingInfo s : simulationInfos) {
Optional<TerminationInfo> failedTerminationInfo =
s.getFailedTerminationInfo();
if (failedTerminationInfo.isPresent()) {
values.add(failedTerminationInfo.get().getLateness());
}
}
double meanTardiness = 0;
if (!values.isEmpty()) {
meanTardiness = Stats.meanOf(values.iterator());
}
line += "\t" + meanTardiness;
}
log.log(line);
}
}
log.finalize();
}
public <T extends PairInterface> void logMeanTardiness(
Table<Long, Pair<T>, Set<SchedulingInfo>> results, String type) {
LocalTime date = LocalTime.now();
Logger log = new Logger("./results/mean_tardiness_" + type + "_" + numberOfProcessors + "_"
+ date.getHour() + ":" + date.getMinute() + ".txt");
String firstLine = new String("Utilization\tTotal");
if (!results.isEmpty()) {
for (Pair<T> pair : results.columnKeySet()) {
firstLine = firstLine + "\t" + pair.getName();
}
log.log(firstLine);
for (Long kv : totalNumberOfTasksets.keySet()) {
String line =
String.valueOf((double) kv / 10) + "\t" + totalNumberOfTasksets.get(kv);
for (Pair<T> pair : results.columnKeySet()) {
Set<SchedulingInfo> simulationInfos = results.get(kv, pair);
List<Long> values = new ArrayList<>();
for (SchedulingInfo s : simulationInfos) {
for (TerminationInfo t : s.getTerminationInfos()) {
values.add(t.getLateness());
}
}
double meanTardiness = 0;
if (!values.isEmpty()) {
meanTardiness = Stats.meanOf(values.iterator());
}
line += "\t" + meanTardiness;
}
log.log(line);
}
}
log.finalize();
}
}
src/main/java/mvd/jester/TestEnvironment.java
package mvd.jester; package mvd.jester;
import java.lang.reflect.Constructor; import java.lang.reflect.Constructor;
import java.time.LocalTime;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import com.google.common.collect.HashBasedTable; import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table; import com.google.common.collect.Table;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.model.SystemSetup; import mvd.jester.model.SystemSetup;
import mvd.jester.priority.PriorityManager; import mvd.jester.priority.PriorityManager;
import mvd.jester.simulator.AbstractSimulator; import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.tests.AbstractTest; import mvd.jester.tests.AbstractTest;
import mvd.jester.utils.Logger;
/** /**
* TestEnvironment * TestEnvironment
...@@ -79,18 +78,20 @@ public class TestEnvironment { ...@@ -79,18 +78,20 @@ public class TestEnvironment {
} }
public void runTests() { public void runTests() {
Set<TestPair> abstractTestInstances = new HashSet<>(); Set<Pair<AbstractTest>> abstractTestInstances = new HashSet<>();
Set<SimulatorPair> abstractSimulatorInstances = new HashSet<>(); Set<Pair<AbstractSimulator>> abstractSimulatorInstances = new HashSet<>();
Map<Long, Long> totalNumberOfTasks = new HashMap<>(); Map<Long, Long> totalNumberOfTasksets = new HashMap<>();
Table<Long, TestPair, Long> testResults = HashBasedTable.create(); Table<Long, Pair<AbstractTest>, Set<SchedulingInfo>> testResults = HashBasedTable.create();
Table<Long, SimulatorPair, Long> simulatorResults = HashBasedTable.create(); Table<Long, Pair<AbstractSimulator>, Set<SchedulingInfo>> simulatorResults =
HashBasedTable.create();
for (PriorityManager pm : schedulingAlgorithms) { for (PriorityManager pm : schedulingAlgorithms) {
for (Constructor<? extends AbstractTest> c : abstractTests) { for (Constructor<? extends AbstractTest> c : abstractTests) {
try { try {
abstractTestInstances.add(new TestPair(pm, c.newInstance(this.systemSetup))); abstractTestInstances
.add(new Pair<AbstractTest>(pm, c.newInstance(this.systemSetup)));
} catch (Exception e) { } catch (Exception e) {
System.out.println("Could not instantiate object of AbstractTest!"); System.out.println("Could not instantiate object of AbstractTest!");
} }
...@@ -99,7 +100,7 @@ public class TestEnvironment { ...@@ -99,7 +100,7 @@ public class TestEnvironment {
for (Constructor<? extends AbstractSimulator> c : abstractSimulators) { for (Constructor<? extends AbstractSimulator> c : abstractSimulators) {
try { try {
abstractSimulatorInstances abstractSimulatorInstances
.add(new SimulatorPair(pm, c.newInstance(this.systemSetup))); .add(new Pair<AbstractSimulator>(pm, c.newInstance(this.systemSetup)));
} catch (Exception e) { } catch (Exception e) {
System.out.println("Could not instantiate object of AbstractSimulator!"); System.out.println("Could not instantiate object of AbstractSimulator!");
} }
...@@ -123,33 +124,35 @@ public class TestEnvironment { ...@@ -123,33 +124,35 @@ public class TestEnvironment {
long roundedUtilization = (long) (utilization * 10); long roundedUtilization = (long) (utilization * 10);
totalNumberOfTasks.compute(roundedUtilization, (k, v) -> v == null ? 1 : v + 1); totalNumberOfTasksets.compute(roundedUtilization, (k, v) -> v == null ? 1 : v + 1);
for (TestPair testInstance : abstractTestInstances) { for (Pair<AbstractTest> testInstance : abstractTestInstances) {
PriorityManager priorityManager = testInstance.getPriorityManager(); PriorityManager priorityManager = testInstance.getPriorityManager();
AbstractTest abstractTest = testInstance.getAbstractTest(); AbstractTest abstractTest = testInstance.getAbstractValue();
if (!testResults.contains(roundedUtilization, testInstance)) { if (!testResults.contains(roundedUtilization, testInstance)) {
testResults.put(roundedUtilization, testInstance, (long) 0); testResults.put(roundedUtilization, testInstance, new HashSet<>());
} }
if (priorityManager.hasTest(abstractTest) if (priorityManager.hasTest(abstractTest)) {
&& abstractTest.runSchedulabilityCheck(priorityManager)) { SchedulingInfo schedulingInfo =
Long val = testResults.get(roundedUtilization, testInstance); abstractTest.runSchedulabilityCheck(priorityManager);
testResults.put(roundedUtilization, testInstance, val + 1); testResults.get(roundedUtilization, testInstance).add(schedulingInfo);
} }
} }
for (SimulatorPair simulatorInstance : abstractSimulatorInstances) { for (Pair<AbstractSimulator> simulatorInstance : abstractSimulatorInstances) {
PriorityManager priorityManager = simulatorInstance.getPriorityManager(); PriorityManager priorityManager = simulatorInstance.getPriorityManager();
AbstractSimulator abstractSimulator = simulatorInstance.getAbstractSimulator(); AbstractSimulator abstractSimulator = simulatorInstance.getAbstractValue();
if (!simulatorResults.contains(roundedUtilization, simulatorInstance)) { if (!simulatorResults.contains(roundedUtilization, simulatorInstance)) {
simulatorResults.put(roundedUtilization, simulatorInstance, (long) 0); simulatorResults.put(roundedUtilization, simulatorInstance,
new HashSet<>());
} }
if (priorityManager.hasSimulator(abstractSimulator) if (priorityManager.hasSimulator(abstractSimulator)) {
&& abstractSimulator.runSimulation(priorityManager)) { SchedulingInfo schedulingInfo =
Long val = simulatorResults.get(roundedUtilization, simulatorInstance); abstractSimulator.runSimulation(priorityManager);
simulatorResults.put(roundedUtilization, simulatorInstance, val + 1); simulatorResults.get(roundedUtilization, simulatorInstance)
.add(schedulingInfo);
} }
} }
...@@ -159,121 +162,12 @@ public class TestEnvironment { ...@@ -159,121 +162,12 @@ public class TestEnvironment {
} }
} }
logTestResults(testResults, totalNumberOfTasks); ResultCollector resultCollector = new ResultCollector(testResults, simulatorResults,
logSimulationResults(simulatorResults, totalNumberOfTasks); totalNumberOfTasksets, systemSetup.getNumberOfProcessors());
}
private void logTestResults(Table<Long, TestPair, Long> results,
Map<Long, Long> totalNumberOfTasks) {
LocalTime date = LocalTime.now();
Logger log = new Logger("./results/results_" + systemSetup.getNumberOfProcessors() + "_"
+ date.getHour() + ":" + date.getMinute() + ".txt");
String firstLine = new String("Utilization");
if (!results.isEmpty()) {
for (TestPair testPair : results.columnKeySet()) {
firstLine = firstLine + "\t" + testPair.getName();
}
log.log(firstLine);
for (Long util : totalNumberOfTasks.keySet()) { resultCollector.logAll();
String line =
String.valueOf((double) util / 10) + "\t" + totalNumberOfTasks.get(util);
for (TestPair simulatorPair : results.columnKeySet()) {
line += "\t" + results.get(util, simulatorPair);
}
log.log(line);
}
}
log.finalize();
} }
private void logSimulationResults(Table<Long, SimulatorPair, Long> results,
Map<Long, Long> totalNumberOfTasks) {
LocalTime date = LocalTime.now();
Logger log = new Logger("./results/results_sim_" + systemSetup.getNumberOfProcessors() + "_"
+ date.getHour() + ":" + date.getMinute() + ".txt");
String firstLine = new String("Utilization\tTotal");
if (!results.isEmpty()) {
for (SimulatorPair simulatorPair : results.columnKeySet()) {
firstLine = firstLine + "\t" + simulatorPair.getName();
}
log.log(firstLine);
for (Long kv : totalNumberOfTasks.keySet()) {
String line = String.valueOf((double) kv / 10) + "\t" + totalNumberOfTasks.get(kv);
for (SimulatorPair simulatorPair : results.columnKeySet()) {
line += "\t" + results.get(kv, simulatorPair);
}
log.log(line);
}
}
log.finalize();
}
private class SimulatorPair {
private final PriorityManager priorityManager;
private final AbstractSimulator abstractSimulator;
public SimulatorPair(PriorityManager priorityManager, AbstractSimulator abstractSimulator) {
this.abstractSimulator = abstractSimulator;
this.priorityManager = priorityManager;
}
/**
* @return the priorityManager
*/
public PriorityManager getPriorityManager() {
return priorityManager;
}
/**
* @return the abstractSimulator
*/
public AbstractSimulator getAbstractSimulator() {
return abstractSimulator;
}
public String getName() {
return abstractSimulator.getName() + "_" + priorityManager.getName();
}
}
private class TestPair {
private final PriorityManager priorityManager;
private final AbstractTest abstractTest;
public TestPair(PriorityManager priorityManager, AbstractTest abstractTest) {
this.abstractTest = abstractTest;
this.priorityManager = priorityManager;
}
/**
* @return the priorityManager
*/
public PriorityManager getPriorityManager() {
return priorityManager;
}
/**
* @return the abstractTest
*/
public AbstractTest getAbstractTest() {
return abstractTest;
}
public String getName() {
return abstractTest.getName() + "_" + priorityManager.getName();
}
}
} }
src/main/java/mvd/jester/info/SchedulingInfo.java 0 → 100644
package mvd.jester.info;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
/**
* DeadlineMissInfo
*/
public class SchedulingInfo {
private final Set<TerminationInfo> terminationInfos;
private Optional<TerminationInfo> failedTerminationInfo;
public SchedulingInfo() {
this.terminationInfos = new HashSet<>();
this.failedTerminationInfo = Optional.empty();
}
public SchedulingInfo(Set<TerminationInfo> terminationInfos) {
this.terminationInfos = terminationInfos;
}
public boolean checkTasksetFeasible() {
// return terminationInfos.isEmpty();
return !terminationInfos.stream().anyMatch(t -> t.getLateness() > 0);
}
public void addTerminationInfo(TerminationInfo terminationInfo) {
terminationInfos.add(terminationInfo);
}
/**
* @return the terminationInfos
*/
public Set<TerminationInfo> getTerminationInfos() {
return terminationInfos;
}
/**
* @return the failedTerminationInfo
*/
public Optional<TerminationInfo> getFailedTerminationInfo() {
return failedTerminationInfo;
}
public void setFailedTemrinationInfo(TerminationInfo failedTerminationInfo) {
this.failedTerminationInfo = Optional.of(failedTerminationInfo);
}
}
src/main/java/mvd/jester/info/TerminationInfo.java 0 → 100644
package mvd.jester.info;
/**
* TerminationInfo
*/
public class TerminationInfo {
private final long releaseTime;
private final long deadline;
private final long responseTime;
private final long lateness;
public TerminationInfo(long releaseTime, long deadline, long responseTime) {
this.releaseTime = releaseTime;
this.deadline = deadline;
this.responseTime = responseTime;
this.lateness = responseTime - deadline;
}
/**
* @return the deadline
*/
public long getDeadline() {
return deadline;
}
/**
* @return the lateness
*/
public long getLateness() {
return lateness;
}
/**
* @return the releaseTime
*/
public long getReleaseTime() {
return releaseTime;
}
/**
* @return the responseTime
*/
public long getResponseTime() {
return responseTime;
}
}
src/main/java/mvd/jester/model/SystemSetup.java
package mvd.jester.model; package mvd.jester.model;
import java.io.IOException; import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.Charset; import java.nio.charset.Charset;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Paths; import java.nio.file.Paths;
...@@ -56,7 +57,15 @@ public class SystemSetup { ...@@ -56,7 +57,15 @@ public class SystemSetup {
return gson.toJson(tasks); return gson.toJson(tasks);
} }
public static SystemSetup fromFile(String path) { public void writeToFile(String path) {
try (PrintWriter pw = new PrintWriter(path)) {
pw.write(toString());
} catch (Exception e) {
System.err.println("Something went wrong when writing to file!");
}
}
public static SystemSetup readFromFile(String path) {
String jsonString; String jsonString;
try { try {
byte[] encoded = Files.readAllBytes(Paths.get(path)); byte[] encoded = Files.readAllBytes(Paths.get(path));
......
src/main/java/mvd/jester/simulator/AbstractSimulator.java
...@@ -5,28 +5,31 @@ import java.util.HashSet; ...@@ -5,28 +5,31 @@ import java.util.HashSet;
import java.util.Optional; import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.TreeSet; import java.util.TreeSet;
import com.google.common.collect.TreeMultiset;
import mvd.jester.model.SystemSetup; import mvd.jester.model.SystemSetup;
import mvd.jester.model.Task; import mvd.jester.model.Task;
import mvd.jester.priority.PriorityManager; import mvd.jester.priority.PriorityManager;
import mvd.jester.priority.RateMonotonic; import mvd.jester.priority.RateMonotonic;
import mvd.jester.PairInterface;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.info.TerminationInfo;
import mvd.jester.simulator.internals.ProcessorContext; import mvd.jester.simulator.internals.ProcessorContext;
import mvd.jester.simulator.internals.SortedTaskContextSet;
import mvd.jester.simulator.internals.TaskContextInterface; import mvd.jester.simulator.internals.TaskContextInterface;
/** /**
* AbstractSimulator * AbstractSimulator
*/ */
public abstract class AbstractSimulator implements SimulatorInterface { public abstract class AbstractSimulator implements SimulatorInterface, PairInterface {
protected final SystemSetup systemSetup; protected final SystemSetup systemSetup;
protected final Set<ProcessorContext> processors; protected final Set<ProcessorContext> processors;
protected Set<TaskContextInterface> readyTasks; protected TreeMultiset<TaskContextInterface> readyTasks;
protected long hyperPeriod; protected long hyperPeriod;
AbstractSimulator(SystemSetup systemSetup) { AbstractSimulator(SystemSetup systemSetup) {
this.systemSetup = systemSetup; this.systemSetup = systemSetup;
this.readyTasks = new SortedTaskContextSet(new RateMonotonic()); this.readyTasks = TreeMultiset.create((t1, t2) -> new RateMonotonic().compare(t1, t2));
processors = new HashSet<>(); processors = new HashSet<>();
for (int i = 0; i < systemSetup.getNumberOfProcessors(); ++i) { for (int i = 0; i < systemSetup.getNumberOfProcessors(); ++i) {
processors.add(new ProcessorContext(i)); processors.add(new ProcessorContext(i));
...@@ -39,11 +42,12 @@ public abstract class AbstractSimulator implements SimulatorInterface { ...@@ -39,11 +42,12 @@ public abstract class AbstractSimulator implements SimulatorInterface {
protected abstract boolean releaseTasks(long timeStep); protected abstract boolean releaseTasks(long timeStep);
@Override @Override
public boolean runSimulation(PriorityManager priorityManager) { public SchedulingInfo runSimulation(PriorityManager priorityManager) {
SchedulingInfo schedulingInfo = new SchedulingInfo();
init(priorityManager); init(priorityManager);
for (int t = 0; t < hyperPeriod; ++t) { for (int t = 0; t < hyperPeriod; ++t) {
if (!releaseTasks(t)) { if (!releaseTasks(t)) {
return false; throw new RuntimeException("Could not release a task. This should not happen!");
} }
Set<ProcessorContext> sortedProcessors = sortProcessors(processors); Set<ProcessorContext> sortedProcessors = sortProcessors(processors);
...@@ -61,20 +65,25 @@ public abstract class AbstractSimulator implements SimulatorInterface { ...@@ -61,20 +65,25 @@ public abstract class AbstractSimulator implements SimulatorInterface {
Optional<TaskContextInterface> optionalTc = p.updateExecution(t); Optional<TaskContextInterface> optionalTc = p.updateExecution(t);
if (optionalTc.isPresent()) { if (optionalTc.isPresent()) {
TaskContextInterface tc = optionalTc.get(); TaskContextInterface tc = optionalTc.get();
TerminationInfo terminationInfo =
new TerminationInfo(tc.getReleaseTime(), tc.getDeadline(), t);
schedulingInfo.addTerminationInfo(terminationInfo);
if (t >= tc.getDeadline()) { if (t >= tc.getDeadline()) {
EventPrinter.print("Time " + t + ": Task " + tc + " failed its deadline!"); EventPrinter.print("Time " + t + ": Task " + tc + " failed its deadline!");
return false; schedulingInfo.setFailedTemrinationInfo(terminationInfo);
return schedulingInfo;
} }
readyTasks.remove(optionalTc.get()); readyTasks.remove(optionalTc.get());
} }
} }
} }
return true; return schedulingInfo;
} }
private void init(PriorityManager priorityManager) { private void init(PriorityManager priorityManager) {
this.readyTasks = new SortedTaskContextSet(priorityManager); this.readyTasks = TreeMultiset.create((t1, t2) -> priorityManager.compare(t1, t2));
for (ProcessorContext p : processors) { for (ProcessorContext p : processors) {
p.setJob(null); p.setJob(null);
} }
...@@ -115,5 +124,4 @@ public abstract class AbstractSimulator implements SimulatorInterface { ...@@ -115,5 +124,4 @@ public abstract class AbstractSimulator implements SimulatorInterface {
} }
} }
} }
src/main/java/mvd/jester/simulator/SimulatorInterface.java
package mvd.jester.simulator; package mvd.jester.simulator;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.priority.PriorityManager; import mvd.jester.priority.PriorityManager;
/** /**
...@@ -7,7 +8,7 @@ import mvd.jester.priority.PriorityManager; ...@@ -7,7 +8,7 @@ import mvd.jester.priority.PriorityManager;
*/ */
public interface SimulatorInterface { public interface SimulatorInterface {
public boolean runSimulation(PriorityManager priorityManager); public SchedulingInfo runSimulation(PriorityManager priorityManager);
public String getName(); public String getName();
......
src/main/java/mvd/jester/simulator/internals/TaskContextInterface.java
...@@ -15,4 +15,6 @@ public interface TaskContextInterface { ...@@ -15,4 +15,6 @@ public interface TaskContextInterface {
public Optional<JobContextInterface> getNextJob(); public Optional<JobContextInterface> getNextJob();
public long getDeadline(); public long getDeadline();
public long getReleaseTime();
} }
src/main/java/mvd/jester/simulator/internals/maiabertogna/TaskContext.java
...@@ -16,16 +16,18 @@ public class TaskContext implements TaskContextInterface { ...@@ -16,16 +16,18 @@ public class TaskContext implements TaskContextInterface {
private final Task task; private final Task task;
private final ArrayList<SegmentContext> segments; private final ArrayList<SegmentContext> segments;
private final long deadline; private final long deadline;
private final long releaseTime;
private int currentSegment; private int currentSegment;
private int segmentCounter; private int segmentCounter;
public TaskContext(Task task, long timeStep) { public TaskContext(Task task, long releaseTime) {
this.task = task; this.task = task;
this.segments = new ArrayList<>(); this.segments = new ArrayList<>();
this.currentSegment = 0; this.currentSegment = 0;
this.segmentCounter = 0; this.segmentCounter = 0;
this.deadline = timeStep + task.getDeadline(); this.releaseTime = releaseTime;
this.deadline = releaseTime + task.getDeadline();
for (Segment s : task.getSegments()) { for (Segment s : task.getSegments()) {
segments.add(new SegmentContext(this, s)); segments.add(new SegmentContext(this, s));
...@@ -42,10 +44,16 @@ public class TaskContext implements TaskContextInterface { ...@@ -42,10 +44,16 @@ public class TaskContext implements TaskContextInterface {
/** /**
* @return the deadline * @return the deadline
*/ */
@Override
public long getDeadline() { public long getDeadline() {
return deadline; return deadline;
} }
@Override
public long getReleaseTime() {
return releaseTime;
}
public Optional<TaskContextInterface> acceptNotification(long time) { public Optional<TaskContextInterface> acceptNotification(long time) {
segmentCounter++; segmentCounter++;
......
src/main/java/mvd/jester/simulator/internals/schmidmottok/TaskContext.java
...@@ -15,17 +15,19 @@ public class TaskContext implements TaskContextInterface { ...@@ -15,17 +15,19 @@ public class TaskContext implements TaskContextInterface {
private final Task task; private final Task task;
private final ArrayList<SegmentContext> segments; private final ArrayList<SegmentContext> segments;
private final long releaseTime;
private final long deadline; private final long deadline;
private int currentSegment; private int currentSegment;
private int segmentCounter; private int segmentCounter;
public TaskContext(Task task, long numberOfProcessors, long timeStep) { public TaskContext(Task task, long numberOfProcessors, long releaseTime) {
this.task = task; this.task = task;
this.segments = new ArrayList<>(); this.segments = new ArrayList<>();
this.currentSegment = 0; this.currentSegment = 0;
this.segmentCounter = 0; this.segmentCounter = 0;
this.deadline = timeStep + task.getDeadline(); this.deadline = releaseTime + task.getDeadline();
this.releaseTime = releaseTime;
for (Segment s : task.getSegments()) { for (Segment s : task.getSegments()) {
segments.add(new SegmentContext(this, s, numberOfProcessors)); segments.add(new SegmentContext(this, s, numberOfProcessors));
...@@ -42,10 +44,16 @@ public class TaskContext implements TaskContextInterface { ...@@ -42,10 +44,16 @@ public class TaskContext implements TaskContextInterface {
/** /**
* @return the deadline * @return the deadline
*/ */
@Override
public long getDeadline() { public long getDeadline() {
return deadline; return deadline;
} }
@Override
public long getReleaseTime() {
return releaseTime;
}
public Optional<TaskContextInterface> acceptNotification(long time) { public Optional<TaskContextInterface> acceptNotification(long time) {
segmentCounter++; segmentCounter++;
...@@ -76,4 +84,5 @@ public class TaskContext implements TaskContextInterface { ...@@ -76,4 +84,5 @@ public class TaskContext implements TaskContextInterface {
return "(period=" + task.getPeriod() + ", deadline=" + deadline + ", segments=" return "(period=" + task.getPeriod() + ", deadline=" + deadline + ", segments="
+ segments.size() + ")"; + segments.size() + ")";
} }
} }
src/main/java/mvd/jester/tests/AbstractTest.java
...@@ -3,21 +3,24 @@ package mvd.jester.tests; ...@@ -3,21 +3,24 @@ package mvd.jester.tests;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import mvd.jester.PairInterface;
import mvd.jester.info.TerminationInfo;
import mvd.jester.model.SystemSetup; import mvd.jester.model.SystemSetup;
import mvd.jester.model.Task; import mvd.jester.model.Task;
/** /**
* AbstractTest * AbstractTest
*/ */
public abstract class AbstractTest implements TestInterface { public abstract class AbstractTest implements TestInterface, PairInterface {
protected final Map<Task, Long> responseTimes; protected final Map<Task, TerminationInfo> responseTimes;
protected final SystemSetup systemSetup; protected final SystemSetup systemSetup;
protected Set<Task> tasks; protected Set<Task> tasks;
public AbstractTest(SystemSetup systemSetup) { public AbstractTest(SystemSetup systemSetup) {
this.systemSetup = systemSetup; this.systemSetup = systemSetup;
this.responseTimes = new HashMap<Task, Long>(); this.responseTimes = new HashMap<>();
this.tasks = systemSetup.getTasks(); this.tasks = systemSetup.getTasks();
} }
} }
src/main/java/mvd/jester/tests/MaiaBertogna.java
package mvd.jester.tests; package mvd.jester.tests;
import java.math.RoundingMode; import java.math.RoundingMode;
import java.util.Map.Entry; import java.util.HashSet;
import com.google.common.math.LongMath; import com.google.common.math.LongMath;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.info.TerminationInfo;
import mvd.jester.model.Segment; import mvd.jester.model.Segment;
import mvd.jester.model.SortedTaskSet; import mvd.jester.model.SortedTaskSet;
import mvd.jester.model.Task; import mvd.jester.model.Task;
...@@ -19,21 +21,16 @@ public class MaiaBertogna extends AbstractTest { ...@@ -19,21 +21,16 @@ public class MaiaBertogna extends AbstractTest {
} }
@Override @Override
public boolean runSchedulabilityCheck(PriorityManager priorityManager) { public SchedulingInfo runSchedulabilityCheck(PriorityManager priorityManager) {
tasks = new SortedTaskSet(priorityManager); tasks = new SortedTaskSet(priorityManager);
tasks.addAll(systemSetup.getTasks()); tasks.addAll(systemSetup.getTasks());
responseTimes.clear(); responseTimes.clear();
for (Task t : tasks) { for (Task t : tasks) {
responseTimes.put(t, calculateResponseTime(t)); long responseTime = calculateResponseTime(t);
responseTimes.put(t, new TerminationInfo(0, t.getDeadline(), responseTime));
} }
for (Entry<Task, Long> keyValuePair : responseTimes.entrySet()) { return new SchedulingInfo(new HashSet<>(responseTimes.values()));
if (keyValuePair.getKey().getDeadline() < keyValuePair.getValue().longValue()) {
return false;
}
}
return true;
} }
@Override @Override
...@@ -92,7 +89,7 @@ public class MaiaBertogna extends AbstractTest { ...@@ -92,7 +89,7 @@ public class MaiaBertogna extends AbstractTest {
private long getTaskInterference(Task task, long interval, long parallelism) { private long getTaskInterference(Task task, long interval, long parallelism) {
if (responseTimes.containsKey(task)) { if (responseTimes.containsKey(task)) {
long responseTime = responseTimes.get(task); long responseTime = responseTimes.get(task).getResponseTime();
long minWcet = getMinimumWcet(task); long minWcet = getMinimumWcet(task);
long period = task.getPeriod(); long period = task.getPeriod();
long numberOfJobs = long numberOfJobs =
......
src/main/java/mvd/jester/tests/SchmidMottok.java
package mvd.jester.tests; package mvd.jester.tests;
import java.math.RoundingMode; import java.math.RoundingMode;
import java.util.Map.Entry; import java.util.HashSet;
import com.google.common.math.LongMath; import com.google.common.math.LongMath;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.info.TerminationInfo;
import mvd.jester.model.Segment; import mvd.jester.model.Segment;
import mvd.jester.model.SortedTaskSet; import mvd.jester.model.SortedTaskSet;
import mvd.jester.model.Task; import mvd.jester.model.Task;
...@@ -19,21 +21,16 @@ public class SchmidMottok extends AbstractTest { ...@@ -19,21 +21,16 @@ public class SchmidMottok extends AbstractTest {
} }
@Override @Override
public boolean runSchedulabilityCheck(PriorityManager priorityManager) { public SchedulingInfo runSchedulabilityCheck(PriorityManager priorityManager) {
tasks = new SortedTaskSet(priorityManager); tasks = new SortedTaskSet(priorityManager);
tasks.addAll(systemSetup.getTasks()); tasks.addAll(systemSetup.getTasks());
responseTimes.clear(); responseTimes.clear();
for (Task t : tasks) { for (Task t : tasks) {
responseTimes.put(t, calculateResponseTime(t)); long responseTime = calculateResponseTime(t);
responseTimes.put(t, new TerminationInfo(0, t.getDeadline(), responseTime));
} }
for (Entry<Task, Long> taskResponsePair : responseTimes.entrySet()) { return new SchedulingInfo(new HashSet<>(responseTimes.values()));
if (taskResponsePair.getKey().getDeadline() < taskResponsePair.getValue().longValue()) {
return false;
}
}
return true;
} }
@Override @Override
...@@ -93,7 +90,7 @@ public class SchmidMottok extends AbstractTest { ...@@ -93,7 +90,7 @@ public class SchmidMottok extends AbstractTest {
private double getTaskInterference(Task task, long interval, long parallelism) { private double getTaskInterference(Task task, long interval, long parallelism) {
if (responseTimes.containsKey(task)) { if (responseTimes.containsKey(task)) {
long responseTime = responseTimes.get(task); long responseTime = responseTimes.get(task).getResponseTime();
long minWcet = getMinimumWcet(task); long minWcet = getMinimumWcet(task);
long period = task.getPeriod(); long period = task.getPeriod();
long numberOfProcessors = systemSetup.getNumberOfProcessors(); long numberOfProcessors = systemSetup.getNumberOfProcessors();
......
src/main/java/mvd/jester/tests/TestInterface.java
package mvd.jester.tests; package mvd.jester.tests;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.priority.PriorityManager; import mvd.jester.priority.PriorityManager;
/** /**
...@@ -7,7 +8,7 @@ import mvd.jester.priority.PriorityManager; ...@@ -7,7 +8,7 @@ import mvd.jester.priority.PriorityManager;
*/ */
public interface TestInterface { public interface TestInterface {
public boolean runSchedulabilityCheck(PriorityManager priorityManager); public SchedulingInfo runSchedulabilityCheck(PriorityManager priorityManager);
public String getName(); public String getName();
......
src/test/java/mvd/jester/simulator/schmidmottok/TestJobContext.java
...@@ -5,7 +5,6 @@ import static org.junit.jupiter.api.Assertions.assertTrue; ...@@ -5,7 +5,6 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.AdditionalMatchers.not; import static org.mockito.AdditionalMatchers.not;
import static org.mockito.AdditionalMatchers.gt;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times; import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
......
src/test/resources/Taskset1.txt 0 → 100644
[
{
"deadline": 487,
"period": 487,
"segments": [
{
"jobWcet": 24,
"numberOfJobs": 1,
"taskletWcet": 24,
"numberOfTasklets": 1
},
{
"jobWcet": 27,
"numberOfJobs": 10,
"taskletWcet": 10,
"numberOfTasklets": 27
},
{
"jobWcet": 40,
"numberOfJobs": 1,
"taskletWcet": 40,
"numberOfTasklets": 1
},
{
"jobWcet": 17,
"numberOfJobs": 10,
"taskletWcet": 10,
"numberOfTasklets": 17
},
{
"jobWcet": 96,
"numberOfJobs": 1,
"taskletWcet": 96,
"numberOfTasklets": 1
}
],
"maximumWcet": 600,
"maximumParallelism": 10
},
{
"deadline": 781,
"period": 781,
"segments": [
{
"jobWcet": 59,
"numberOfJobs": 1,
"taskletWcet": 59,
"numberOfTasklets": 1
},
{
"jobWcet": 74,
"numberOfJobs": 6,
"taskletWcet": 6,
"numberOfTasklets": 74
},
{
"jobWcet": 82,
"numberOfJobs": 1,
"taskletWcet": 82,
"numberOfTasklets": 1
},
{
"jobWcet": 30,
"numberOfJobs": 6,
"taskletWcet": 6,
"numberOfTasklets": 30
},
{
"jobWcet": 18,
"numberOfJobs": 1,
"taskletWcet": 18,
"numberOfTasklets": 1
},
{
"jobWcet": 79,
"numberOfJobs": 6,
"taskletWcet": 6,
"numberOfTasklets": 79
}
],
"maximumWcet": 1257,
"maximumParallelism": 6
},
{
"deadline": 494,
"period": 494,
"segments": [
{
"jobWcet": 413,
"numberOfJobs": 1,
"taskletWcet": 413,
"numberOfTasklets": 1
}
],
"maximumWcet": 413,
"maximumParallelism": 1
},
{
"deadline": 496,
"period": 496,
"segments": [
{
"jobWcet": 84,
"numberOfJobs": 1,
"taskletWcet": 84,
"numberOfTasklets": 1
},
{
"jobWcet": 52,
"numberOfJobs": 5,
"taskletWcet": 5,
"numberOfTasklets": 52
},
{
"jobWcet": 78,
"numberOfJobs": 1,
"taskletWcet": 78,
"numberOfTasklets": 1
},
{
"jobWcet": 53,
"numberOfJobs": 5,
"taskletWcet": 5,
"numberOfTasklets": 53
},
{
"jobWcet": 57,
"numberOfJobs": 1,
"taskletWcet": 57,
"numberOfTasklets": 1
}
],
"maximumWcet": 744,
"maximumParallelism": 5
}
]
\ No newline at end of file
src/test/resources/Taskset2.txt 0 → 100644
[
{
"deadline": 677,
"period": 677,
"segments": [
{
"jobWcet": 214,
"numberOfJobs": 1,
"taskletWcet": 214,
"numberOfTasklets": 1
}
],
"maximumWcet": 214,
"maximumParallelism": 1
},
{
"deadline": 694,
"period": 694,
"segments": [
{
"jobWcet": 12,
"numberOfJobs": 1,
"taskletWcet": 12,
"numberOfTasklets": 1
},
{
"jobWcet": 217,
"numberOfJobs": 2,
"taskletWcet": 2,
"numberOfTasklets": 217
},
{
"jobWcet": 228,
"numberOfJobs": 1,
"taskletWcet": 228,
"numberOfTasklets": 1
}
],
"maximumWcet": 674,
"maximumParallelism": 2
},
{
"deadline": 807,
"period": 807,
"segments": [
{
"jobWcet": 11,
"numberOfJobs": 1,
"taskletWcet": 11,
"numberOfTasklets": 1
},
{
"jobWcet": 115,
"numberOfJobs": 9,
"taskletWcet": 9,
"numberOfTasklets": 115
},
{
"jobWcet": 6,
"numberOfJobs": 1,
"taskletWcet": 6,
"numberOfTasklets": 1
},
{
"jobWcet": 119,
"numberOfJobs": 9,
"taskletWcet": 9,
"numberOfTasklets": 119
},
{
"jobWcet": 38,
"numberOfJobs": 1,
"taskletWcet": 38,
"numberOfTasklets": 1
},
{
"jobWcet": 38,
"numberOfJobs": 9,
"taskletWcet": 9,
"numberOfTasklets": 38
}
],
"maximumWcet": 2503,
"maximumParallelism": 9
},
{
"deadline": 871,
"period": 871,
"segments": [
{
"jobWcet": 789,
"numberOfJobs": 1,
"taskletWcet": 789,
"numberOfTasklets": 1
}
],
"maximumWcet": 789,
"maximumParallelism": 1
},
{
"deadline": 967,
"period": 967,
"segments": [
{
"jobWcet": 147,
"numberOfJobs": 1,
"taskletWcet": 147,
"numberOfTasklets": 1
},
{
"jobWcet": 10,
"numberOfJobs": 5,
"taskletWcet": 5,
"numberOfTasklets": 10
},
{
"jobWcet": 113,
"numberOfJobs": 1,
"taskletWcet": 113,
"numberOfTasklets": 1
},
{
"jobWcet": 21,
"numberOfJobs": 5,
"taskletWcet": 5,
"numberOfTasklets": 21
}
],
"maximumWcet": 415,
"maximumParallelism": 5
}
]
\ No newline at end of file
src/test/resources/Taskset3.txt 0 → 100644
[
{
"deadline": 878,
"period": 878,
"segments": [
{
"jobWcet": 33,
"numberOfJobs": 1,
"taskletWcet": 33,
"numberOfTasklets": 1
}
],
"maximumWcet": 33,
"maximumParallelism": 1
},
{
"deadline": 641,
"period": 641,
"segments": [
{
"jobWcet": 112,
"numberOfJobs": 1,
"taskletWcet": 112,
"numberOfTasklets": 1
}
],
"maximumWcet": 112,
"maximumParallelism": 1
},
{
"deadline": 338,
"period": 338,
"segments": [
{
"jobWcet": 251,
"numberOfJobs": 1,
"taskletWcet": 251,
"numberOfTasklets": 1
}
],
"maximumWcet": 251,
"maximumParallelism": 1
},
{
"deadline": 645,
"period": 645,
"segments": [
{
"jobWcet": 179,
"numberOfJobs": 1,
"taskletWcet": 179,
"numberOfTasklets": 1
}
],
"maximumWcet": 179,
"maximumParallelism": 1
},
{
"deadline": 568,
"period": 568,
"segments": [
{
"jobWcet": 332,
"numberOfJobs": 1,
"taskletWcet": 332,
"numberOfTasklets": 1
}
],
"maximumWcet": 332,
"maximumParallelism": 1
},
{
"deadline": 493,
"period": 493,
"segments": [
{
"jobWcet": 160,
"numberOfJobs": 1,
"taskletWcet": 160,
"numberOfTasklets": 1
}
],
"maximumWcet": 160,
"maximumParallelism": 1
}
]
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment