Skip to content

las3_pub / jester

Go to a project
Commit db00ddd1 by Michael Schmid
Options

removed simulator

parent da04ff1c
Inline Side-by-side
Showing with 1 additions and 1734 deletions
src/main/java/mvd/jester/App.java
......@@ -6,11 +6,8 @@ import mvd.jester.model.DagTask;
import mvd.jester.model.SystemManager;
import mvd.jester.model.SystemManager.DagTaskBuilder;
import mvd.jester.tests.AbstractTest;
import mvd.jester.tests.DongLiu;
import mvd.jester.tests.FonsecaNelis;
import mvd.jester.tests.JiangYi;
import mvd.jester.tests.SchmidMottok;
import mvd.jester.tests.Tester;
import mvd.jester.tests.UeterAgrawal;
import mvd.jester.tests.TypeFunction.UnknownStructure;
......
src/main/java/mvd/jester/priority/DeadlineMonotonic.java
......@@ -4,8 +4,6 @@ import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import mvd.jester.model.Task;
import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.simulator.internals.TaskContextInterface;
import mvd.jester.tests.AbstractTest;
public class DeadlineMonotonic implements PriorityManager {
......@@ -13,9 +11,6 @@ public class DeadlineMonotonic implements PriorityManager {
final static Set<Class<? extends AbstractTest<? extends Task>>> abstractTests =
new HashSet<>(Arrays.asList(mvd.jester.tests.MaiaBertogna.class,
mvd.jester.tests.SchmidMottok.class));
final static Set<Class<? extends AbstractSimulator>> abstractSimulators =
new HashSet<>(Arrays.asList(mvd.jester.simulator.ParallelSynchronous.class,
mvd.jester.simulator.DynamicForkJoin.class));
/**
* Compare the priority of two tasks according to the Rate Monotonic policy
......@@ -31,11 +26,6 @@ public class DeadlineMonotonic implements PriorityManager {
}
@Override
public int compare(TaskContextInterface t1, TaskContextInterface t2) {
return Long.compare(t1.getTask().getDeadline(), t2.getTask().getDeadline());
}
@Override
public boolean hasTest(AbstractTest<? extends Task> abstractTest) {
return abstractTests.contains(abstractTest.getClass());
}
......@@ -46,16 +36,6 @@ public class DeadlineMonotonic implements PriorityManager {
}
@Override
public boolean hasSimulator(AbstractSimulator abstractSimulator) {
return abstractSimulators.contains(abstractSimulator.getClass());
}
@Override
public boolean hasSimulator(Class<? extends AbstractSimulator> abstractSimulatorClass) {
return abstractSimulators.contains(abstractSimulatorClass);
}
@Override
public String getName() {
return "DM";
}
......
src/main/java/mvd/jester/priority/EarliestDeadlineFirst.java
......@@ -4,10 +4,6 @@ import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import mvd.jester.model.Task;
import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.simulator.ParallelSynchronous;
import mvd.jester.simulator.DynamicForkJoin;
import mvd.jester.simulator.internals.TaskContextInterface;
import mvd.jester.tests.AbstractTest;
import mvd.jester.tests.ChwaLee;
......@@ -18,8 +14,6 @@ public class EarliestDeadlineFirst implements PriorityManager {
final static Set<Class<? extends AbstractTest<? extends Task>>> abstractTests =
new HashSet<>(Arrays.asList(ChwaLee.class));
final static Set<Class<? extends AbstractSimulator>> abstractSimulators =
new HashSet<>(Arrays.asList(ParallelSynchronous.class, DynamicForkJoin.class));
/**
* Compare the priority of two tasks according to the Rate Monotonic policy
......@@ -35,11 +29,6 @@ public class EarliestDeadlineFirst implements PriorityManager {
}
@Override
public int compare(TaskContextInterface t1, TaskContextInterface t2) {
return (int) (t1.getDeadline() - t2.getDeadline());
}
@Override
public boolean hasTest(AbstractTest<? extends Task> abstractTest) {
return abstractTests.contains(abstractTest.getClass());
}
......@@ -50,16 +39,6 @@ public class EarliestDeadlineFirst implements PriorityManager {
}
@Override
public boolean hasSimulator(AbstractSimulator abstractSimulator) {
return abstractSimulators.contains(abstractSimulator.getClass());
}
@Override
public boolean hasSimulator(Class<? extends AbstractSimulator> abstractSimulatorClass) {
return abstractSimulators.contains(abstractSimulatorClass);
}
@Override
public String getName() {
return "EDF";
}
......
src/main/java/mvd/jester/priority/PriorityManager.java
package mvd.jester.priority;
import mvd.jester.model.Task;
import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.simulator.internals.TaskContextInterface;
import mvd.jester.tests.AbstractTest;
/**
......@@ -12,16 +10,10 @@ public interface PriorityManager {
public int compare(Task t1, Task t2);
public int compare(TaskContextInterface t1, TaskContextInterface t2);
public boolean hasTest(AbstractTest<? extends Task> abstractTest);
public boolean hasTest(Class<? extends AbstractTest<? extends Task>> abstractTestClass);
public boolean hasSimulator(AbstractSimulator abstractTest);
public boolean hasSimulator(Class<? extends AbstractSimulator> abstractTestClass);
public String getName();
}
src/main/java/mvd/jester/priority/RateMonotonic.java
......@@ -4,8 +4,6 @@ import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import mvd.jester.model.Task;
import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.simulator.internals.TaskContextInterface;
import mvd.jester.tests.AbstractTest;
public class RateMonotonic implements PriorityManager {
......@@ -13,9 +11,6 @@ public class RateMonotonic implements PriorityManager {
final static Set<Class<? extends AbstractTest<? extends Task>>> abstractTests =
new HashSet<>(Arrays.asList(mvd.jester.tests.MaiaBertogna.class,
mvd.jester.tests.SchmidMottok.class));
final static Set<Class<? extends AbstractSimulator>> abstractSimulators =
new HashSet<>(Arrays.asList(mvd.jester.simulator.ParallelSynchronous.class,
mvd.jester.simulator.DynamicForkJoin.class));
/**
* Compare the priority of two tasks according to the Rate Monotonic policy
......@@ -31,11 +26,6 @@ public class RateMonotonic implements PriorityManager {
}
@Override
public int compare(TaskContextInterface t1, TaskContextInterface t2) {
return Long.compare(t1.getTask().getPeriod(), t2.getTask().getPeriod());
}
@Override
public boolean hasTest(AbstractTest<? extends Task> abstractTest) {
return abstractTests.contains(abstractTest.getClass());
}
......@@ -46,16 +36,6 @@ public class RateMonotonic implements PriorityManager {
}
@Override
public boolean hasSimulator(AbstractSimulator abstractSimulator) {
return abstractSimulators.contains(abstractSimulator.getClass());
}
@Override
public boolean hasSimulator(Class<? extends AbstractSimulator> abstractSimulatorClass) {
return abstractSimulators.contains(abstractSimulatorClass);
}
@Override
public String getName() {
return "RM";
}
......
src/main/java/mvd/jester/simulator/AbstractSimulator.java deleted 100644 → 0
package mvd.jester.simulator;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
import com.google.common.collect.TreeMultiset;
import mvd.jester.model.SystemManager;
import mvd.jester.priority.PriorityManager;
import mvd.jester.priority.RateMonotonic;
import mvd.jester.TypeInterface;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.simulator.internals.ProcessorContext;
import mvd.jester.simulator.internals.TaskContextInterface;
/**
* AbstractSimulator
*/
public abstract class AbstractSimulator implements SimulatorInterface, TypeInterface {
protected final SystemManager systemSetup;
protected final Set<ProcessorContext> processors;
protected TreeMultiset<TaskContextInterface> readyTasks;
AbstractSimulator(SystemManager systemSetup) {
this.systemSetup = systemSetup;
this.readyTasks = TreeMultiset.create((t1, t2) -> new RateMonotonic().compare(t1, t2));
processors = new HashSet<>();
for (int i = 0; i < systemSetup.getNumberOfProcessors(); ++i) {
processors.add(new ProcessorContext(i));
}
}
protected abstract boolean releaseTasks(long timeStep);
@Override
public SchedulingInfo runSimulation(PriorityManager priorityManager) {
// SchedulingInfo schedulingInfo = new SchedulingInfo(systemSetup.getParallelTaskRatio(),
// systemSetup.getUtilization());
// long hyperPeriod = init(priorityManager);
// for (int t = 0; t < hyperPeriod; ++t) {
// if (!releaseTasks(t)) {
// throw new RuntimeException("Could not release a task. This should not happen!");
// }
// Set<ProcessorContext> sortedProcessors = sortProcessors(processors);
// for (ProcessorContext p : sortedProcessors) {
// for (TaskContextInterface tc : readyTasks) {
// if (p.acceptTask(tc, t)) {
// break;
// }
// }
// }
// for (ProcessorContext p : processors) {
// Optional<TaskContextInterface> optionalTc = p.updateExecution(t);
// if (optionalTc.isPresent()) {
// TaskContextInterface tc = optionalTc.get();
// if (t >= tc.getDeadline()) {
// TerminationInfo terminationInfo =
// new TerminationInfo(tc.getReleaseTime(), tc.getDeadline(), t);
// schedulingInfo.addTerminationInfo(terminationInfo);
// EventPrinter.print("Time " + t + ": Task " + tc + " failed its deadline!");
// schedulingInfo.setFailedTerminationInfo(terminationInfo);
// return schedulingInfo;
// }
// readyTasks.remove(optionalTc.get());
// }
// }
// }
// return schedulingInfo;
return null;
}
private long init(PriorityManager priorityManager) {
this.readyTasks = TreeMultiset.create((t1, t2) -> priorityManager.compare(t1, t2));
for (ProcessorContext p : processors) {
p.setJob(null);
}
return getHyperPeriod();
}
private Set<ProcessorContext> sortProcessors(Set<ProcessorContext> processors) {
Set<ProcessorContext> sortedProcessors = new TreeSet<>(new ProcessorComparator());
processors.forEach(p -> sortedProcessors.add(p));
return sortedProcessors;
}
private long getHyperPeriod() {
// return
// systemSetup.getTasks().stream().max(Comparator.comparing(SynchronousTask::getPeriod))
// .get().getPeriod() * 10;
return 10;
}
private class ProcessorComparator implements Comparator<ProcessorContext> {
@Override
public int compare(ProcessorContext p1, ProcessorContext p2) {
if (!p1.getJob().isPresent()) {
return -1;
} else if (!p2.getJob().isPresent()) {
return 1;
} else {
long p1Period = p1.getJob().get().getTaskContext().getTask().getPeriod();
long p2Period = p2.getJob().get().getTaskContext().getTask().getPeriod();
if (p1Period == p2Period) {
return 1;
} else {
return (int) (p2.getJob().get().getTaskContext().getTask().getPeriod()
- p1.getJob().get().getTaskContext().getTask().getPeriod());
}
}
}
}
}
src/main/java/mvd/jester/simulator/DynamicForkJoin.java deleted 100644 → 0
package mvd.jester.simulator;
import mvd.jester.model.SystemManager;
/**
* SchmidMottok
*/
public class DynamicForkJoin extends AbstractSimulator {
public DynamicForkJoin(SystemManager systemSetup) {
super(systemSetup);
}
@Override
protected boolean releaseTasks(long timeStep) {
// // for (SynchronousTask t : systemSetup.getTasks()) {
// if (timeStep % t.getPeriod() == 0) {
// TaskContext tc = new TaskContext(t, systemSetup.getNumberOfProcessors(), timeStep);
// if (!readyTasks.add(tc)) {
// EventPrinter
// .print("Time " + timeStep + ": Task " + tc + " could not be released!");
// return false;
// }
// EventPrinter.print("Time " + timeStep + ": Task " + tc + " released!");
// }
// }
return true;
}
@Override
public String getName() {
return "SchmidMottok";
}
}
src/main/java/mvd/jester/simulator/EventPrinter.java deleted 100644 → 0
package mvd.jester.simulator;
/**
* EventPrinter
*/
public class EventPrinter {
private static boolean printerEnabled;
private EventPrinter() {
printerEnabled = false;
}
public static void enablePrinter() {
printerEnabled = true;
}
public static void disablePrinter() {
printerEnabled = false;
}
public static void print(String text) {
if (printerEnabled) {
System.out.println(text);
}
}
}
src/main/java/mvd/jester/simulator/ParallelSynchronous.java deleted 100644 → 0
package mvd.jester.simulator;
import mvd.jester.model.SystemManager;
/**
* MaiaBertogna
*/
public class ParallelSynchronous extends AbstractSimulator {
public ParallelSynchronous(SystemManager systemSetup) {
super(systemSetup);
}
@Override
protected boolean releaseTasks(long timeStep) {
// for (SynchronousTask t : systemSetup.getTasks()) {
// if (timeStep % t.getPeriod() == 0) {
// TaskContext tc = new TaskContext(t, timeStep);
// if (!readyTasks.add(tc)) {
// EventPrinter
// .print("Time " + timeStep + ": Task " + tc + " could not be released!");
// return false;
// }
// EventPrinter.print("Time " + timeStep + ": Task " + tc + " released!");
// }
// }
return true;
}
@Override
public String getName() {
return "MaiaBertogna";
}
}
src/main/java/mvd/jester/simulator/SimulatorInterface.java deleted 100644 → 0
package mvd.jester.simulator;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.priority.PriorityManager;
/**
* SimulatorInterface
*/
public interface SimulatorInterface {
public SchedulingInfo runSimulation(PriorityManager priorityManager);
public String getName();
}
src/main/java/mvd/jester/simulator/internals/JobContextInterface.java deleted 100644 → 0
package mvd.jester.simulator.internals;
import java.util.Optional;
/**
* JobContextInterface
*/
public interface JobContextInterface {
public Optional<TaskContextInterface> updateExecution(long time);
public boolean checkExecutionTime();
public void setCurrentProcessor(ProcessorContext processor);
public Optional<ProcessorContext> getCurrentProcessor();
public TaskContextInterface getTaskContext();
public boolean prepareJob(long time);
}
src/main/java/mvd/jester/simulator/internals/ProcessorContext.java deleted 100644 → 0
package mvd.jester.simulator.internals;
import java.util.Optional;
import mvd.jester.simulator.EventPrinter;
/**
* Processor
*/
public class ProcessorContext {
private Optional<JobContextInterface> currentJob;
private final long processorId;
public ProcessorContext(long processorId) {
currentJob = Optional.empty();
this.processorId = processorId;
}
public void setJob(JobContextInterface job) {
this.currentJob = Optional.ofNullable(job);
}
/**
* @return the currentJob
*/
public Optional<JobContextInterface> getJob() {
return currentJob;
}
public Optional<TaskContextInterface> updateExecution(long time) {
if (currentJob.isPresent()) {
return currentJob.get().updateExecution(time);
}
return Optional.empty();
}
public boolean acceptTask(TaskContextInterface taskContext, int t) {
if (!currentJob.isPresent() || currentJob.get().getTaskContext().getTask()
.getPeriod() > taskContext.getTask().getPeriod()) {
Optional<JobContextInterface> optionalJob = taskContext.getNextJob();
if (optionalJob.isPresent()) {
if (!optionalJob.get().prepareJob(t)) {
return false;
}
if (currentJob.isPresent()) {
currentJob.get().setCurrentProcessor(null);
}
currentJob = optionalJob;
currentJob.get().setCurrentProcessor(this);
EventPrinter.print(
"Time " + t + ": " + this + " started job " + currentJob.get() + "!");
return true;
}
}
return false;
}
@Override
public String toString() {
return "Processor " + processorId;
}
}
src/main/java/mvd/jester/simulator/internals/SortedTaskContextSet.java deleted 100644 → 0
package mvd.jester.simulator.internals;
import java.util.TreeSet;
import mvd.jester.priority.PriorityManager;
/**
* SortedTaskContextSet
*/
public class SortedTaskContextSet extends TreeSet<TaskContextInterface> {
private static final long serialVersionUID = 4808544133562675597L;
public SortedTaskContextSet(PriorityManager priorityMananger) {
super((t1, t2) -> priorityMananger.compare(t1, t2));
}
}
src/main/java/mvd/jester/simulator/internals/TaskContextInterface.java deleted 100644 → 0
package mvd.jester.simulator.internals;
import java.util.Optional;
import mvd.jester.model.SynchronousTask;
/**
* TaskContextInterface
*/
public interface TaskContextInterface {
public SynchronousTask getTask();
public Optional<TaskContextInterface> acceptNotification(long time);
public Optional<JobContextInterface> getNextJob();
public long getDeadline();
public long getReleaseTime();
}
src/main/java/mvd/jester/simulator/internals/dynamicforkjoin/JobContext.java deleted 100644 → 0
package mvd.jester.simulator.internals.dynamicforkjoin;
import java.util.Optional;
import mvd.jester.simulator.EventPrinter;
import mvd.jester.simulator.internals.JobContextInterface;
import mvd.jester.simulator.internals.ProcessorContext;
import mvd.jester.simulator.internals.TaskContextInterface;
/**
* Job
*
* @param <Job>
*/
public class JobContext implements JobContextInterface {
private final TaskContext taskContext;
private final SegmentContext segmentContext;
private final long wcet;
private Optional<ProcessorContext> currentProcessor;
private Optional<TaskletContext> currentTasklet;
public JobContext(TaskContext taskContext, SegmentContext segmentContext) {
this.currentProcessor = Optional.empty();
this.currentTasklet = Optional.empty();
this.taskContext = taskContext;
this.segmentContext = segmentContext;
this.wcet = segmentContext.getSegment().getWidth();
}
public Optional<TaskContextInterface> updateExecution(long time) {
boolean jobIsIdle = true;
if (currentTasklet.isPresent()) {
jobIsIdle = currentTasklet.get().updateExecution(time);
}
if (jobIsIdle) {
currentTasklet = segmentContext.getNextTasklet();
Optional<TaskContextInterface> tc = taskContext.acceptNotification(time);
if (currentTasklet.isPresent()) {
EventPrinter.print("Time " + time + ": Job " + this + " started executing tasklet "
+ currentTasklet.get() + " on Processor " + currentProcessor.get());
currentTasklet.get().setCurrentJob(this);
} else {
if (currentProcessor.isPresent()) {
currentProcessor.get().setJob(null);
}
currentProcessor = Optional.empty();
return tc;
}
}
return Optional.empty();
}
public boolean checkExecutionTime() {
if (currentTasklet.isPresent()) {
return currentTasklet.get().checkExecutionTime();
}
return false;
}
/**
* @return the wcet
*/
public long getWcet() {
return wcet;
}
/**
* @param processor the currentProcessor to set
*/
public void setCurrentProcessor(ProcessorContext processor) {
this.currentProcessor = Optional.ofNullable(processor);
}
/**
* @return the currentProcessor
*/
public Optional<ProcessorContext> getCurrentProcessor() {
return currentProcessor;
}
/**
* @param currentTasklet the currentTasklet to set
*/
public void setCurrentTasklet(TaskletContext currentTasklet) {
this.currentTasklet = Optional.ofNullable(currentTasklet);
}
/**
* @return the segmentContext
*/
public SegmentContext getSegmentContext() {
return segmentContext;
}
/**
* @return the taskContext
*/
public TaskContext getTaskContext() {
return taskContext;
}
@Override
public String toString() {
return "(of task=" + taskContext + ")";
}
@Override
public boolean prepareJob(long time) {
if (!currentTasklet.isPresent()) {
currentTasklet = segmentContext.getNextTasklet();
if (currentTasklet.isPresent()) {
currentTasklet.get().setCurrentJob(this);
// EventPrinter.print("Time " + time + ": Job " + this + " started executing
// tasklet"
// + currentTasklet.get());
return true;
} else {
return false;
}
}
return true;
}
}
src/main/java/mvd/jester/simulator/internals/dynamicforkjoin/SegmentContext.java deleted 100644 → 0
package mvd.jester.simulator.internals.dynamicforkjoin;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import mvd.jester.model.Segment;
import mvd.jester.simulator.internals.JobContextInterface;
/**
* Segment
*/
public class SegmentContext {
private final Segment segment;
private final Set<JobContextInterface> jobs;
private final Set<TaskletContext> tasklets;
public SegmentContext(TaskContext taskContext, Segment segment, long numberOfProcessors) {
this.segment = segment;
jobs = new HashSet<>();
tasklets = new HashSet<>();
long numberOfJobs =
segment.getHeight() > numberOfProcessors ? numberOfProcessors : segment.getHeight();
for (int j = 0; j < numberOfJobs; ++j) {
jobs.add(new JobContext(taskContext, this));
}