def test_RMm1RMsuccess01():
taskset = Taskset(Task(1, 40),
Task(9, 107),
Task(1, 54),
Task(43, 60),
Task(7, 51))
assertRMm1RM(taskset, success=True)
def test_RMm1RMsuccess04():
taskset = Taskset(Task(1, 40),
Task(16, 92),
Task(27, 75),
Task(17, 55),
Task(6, 50))
assertRMm1RM(taskset, success=True)
def test_GDFsuccess06():
taskset = Taskset(Task(1, 40),
Task(16, 112),
Task(7, 60),
Task(35, 100),
Task(27, 75))
assertGDF(taskset, success=True)
def test_GDFsuccess09():
taskset = Taskset(Task(1, 40),
Task(16, 91),
Task(27, 75),
Task(17, 55),
Task(6, 50))
assertGDF(taskset, success=True)
def test_RMm1RMfailure09():
taskset = Taskset(Task(3, 40),
Task(1, 102),
Task(32, 56),
Task(27, 82),
Task(1, 85))
assertRMm1RM(taskset, success=False)
def test_GDFsuccess03():
taskset = Taskset(Task(1, 40),
Task(9, 107),
Task(1, 54),
Task(43, 60),
Task(7, 51))
assertGDF(taskset, success=True)
def test_RMm1RMfailure01():
taskset = Taskset(Task(1, 40),
Task(5, 114),
Task(18, 93),
Task(7, 47),
Task(42, 72))
assertRMm1RM(taskset, success=False)
def test_RMm1RMsuccess09():
taskset = Taskset(Task(1, 40),
Task(7, 97),
Task(1, 45),
Task(20, 53),
Task(20, 40))
assertRMm1RM(taskset, success=True)
def test_RMm1RMsuccess07():
taskset = Taskset(Task(12, 40),
Task(1, 103),
Task(13, 100),
Task(1, 81),
Task(31, 60))
assertRMm1RM(taskset, success=True)
def test_RMm1RMsuccess05():
taskset = Taskset(Task(1, 40),
Task(17, 119),
Task(7, 60),
Task(35, 100),
Task(27, 75))
assertRMm1RM(taskset, success=True)
def test_3PWorstLaxity1():
taskset = Taskset(Task(33, 90),
Task(16, 39),
Task(3, 28))
optimiser = RMWorstCaseLaxity3TaskOptimiser(taskset)
history = optimiser.history()
assert not history.hasDeadlineMiss()
def test_simuTwoTasks():
t1 = Task(2, 3, FixedArrivalDistribution(4), displayName='t1')
t2 = Task(1, 4, FixedArrivalDistribution(5), displayName='t2')
taskset = Taskset(t1, t2)
sim = Simulation(taskset)
endTime = 77
state = sim.getState(endTime)
expectedJobs = [JobState(t1, 19, 1, lastStart=77),
JobState(t2, 15, 1, lastStart=76),
JobState(t2, 16),
JobState(t1, 20)]
expectedEvents = [StateArrival(80, t2, 16),
StateArrival(80, t1, 20),
StateCompletion(78, t1, 19),
StateDeadline(79, t2, 15),
StateDeadline(79, t1, 19)]
expectedScheduler = EDFSchedulerState((79, t1, 19))
expected = SimulatorState(endTime,
expectedJobs,
expectedEvents,
scheduler=expectedScheduler)
logging.debug('%s', state)
assert(state == expected)
def test_rmMultiple():
t1 = Task(1, 2, FixedArrivalDistribution(2), displayName='t1')
t2 = Task(10, 20, FixedArrivalDistribution(20), displayName='t2')
taskset = Taskset(t1, t2)
endTime = 25
setup = SimulationSetup(taskset,
time=endTime,
schedulingPolicy=RMSchedulingPolicy())
run = SimulationRun(setup)
result = run.result()
state = result.history[endTime]
expected = SimulatorState(endTime,
[JobState(t2, 1, 2),
JobState(t2, 2),
JobState(t1, 12, 1, lastStart=25),
JobState(t1, 13)],
[StateCompletion(25, t1, 12),
StateDeadline(40, t2, 1),
StateCompletion(31, t2, 1),
StateArrival(26, t1, 13),
StateDeadline(26, t1, 12),
StateArrival(40, t2, 2),
StateCompletion(32, t2, 1)],
scheduler=RMSchedulerState((t1, 12), (t2, 1)))
assert(state == expected)
def test_twoIntertwinedGens():
g1 = TasksetGenerator(seed=1337,
utilization=RandomValue(floatrange=(0.5, 1)),
period=RandomValue(intrange=(1, 100)))
g2 = TasksetGenerator(seed=42,
utilization=RandomValue(floatrange=(0.5, 1)),
period=RandomValue(intrange=(1, 100)))
taskset1 = g1()
taskset2 = g2()
taskset3 = g1()
expectedTask1 = Task(808,
1000,
uniqueId=0)
expected1 = Taskset(expectedTask1)
expectedTask2 = Task(819,
1000,
uniqueId=0)
expected2 = Taskset(expectedTask2)
expectedTask3 = Task(766,
1000,
uniqueId=0)
expected3 = Taskset(expectedTask3)
assert(expected1 == taskset1)
assert(expected2 == taskset2)
assert(expected3 == taskset3)
def test_simuError1():
taskset = Taskset(
Task(45,
6588,
FixedArrivalDistribution(6588),
LogPreemptionCost(3, 0.1)),
Task(1,
1036,
FixedArrivalDistribution(1036),
LogPreemptionCost(3, 0.1)),
Task(278,
1037, FixedArrivalDistribution(1037),
LogPreemptionCost(3, 0.1)),
Task(371,
4148,
FixedArrivalDistribution(4148),
LogPreemptionCost(3, 0.1)),
Task(1412,
2680,
FixedArrivalDistribution(2680),
LogPreemptionCost(3, 0.1)),
)
setup = SimulationSetup(taskset,
time=1000000,
trackHistory=False,
trackPreemptions=False,
deadlineMissFilter=True,
schedulingPolicy=EDFSchedulingPolicy(),
aggregatorTags=[AggregatorTag.PreemptionTime,
AggregatorTag.PreemptionCount])
run = SimulationRun(setup, errorHandling=False)
run.execute()
def test_simuManyPreemptionsFailing():
t1 = Task(1, 2, FixedArrivalDistribution(2), displayName='task1')
t2 = Task(11, 20, FixedArrivalDistribution(20), displayName='task2')
taskset = Taskset(t1, t2)
sim = Simulation(taskset)
endTime = 21
state = sim.getState(endTime)
logging.debug('%s', state)
expectedJobs = [JobState(t1, 9, 1, lastStart=21),
JobState(t1, 11),
JobState(t1, 10),
JobState(t2, 1),
JobState(t2, 2)]
expectedEvents = [StateArrival(22, t1, 11),
StateArrival(40, t2, 2),
StateCompletion(21, t1, 9),
StateDeadline(22, t1, 10),
StateDeadline(40, t2, 1)]
expectedScheduler = EDFSchedulerState((20, 1, t1, 9),
(22, t1, 10),
(40, t2, 1))
expected = SimulatorState(endTime,
expectedJobs,
expectedEvents,
scheduler=expectedScheduler)
assert(state == expected)
expectedDeadlineMisses = {DeadlineMiss(t1, 9)}
assert(sim.deadlineMisses(endTime) == expectedDeadlineMisses)
def test_simulateToDeadlineMiss():
t1 = Task(20,
50,
FixedArrivalDistribution(50),
displayName='t1')
t2 = Task(2,
3,
FixedArrivalDistribution(3),
displayName='t2')
taskset = (t1, t2)
sim = Simulation(taskset)
state = sim.firstDeadlineMiss()
expected = SimulatorState(50,
[JobState(t2, 16),
JobState(t1, 2),
JobState(t1, 0, 16, lastStart=48),
JobState(t1, 1),
JobState(t2, 17)],
[StateArrival(100, t1, 2),
StateDeadline(51, t2, 16),
StateCompletion(52, t1, 0),
StateArrival(51, t2, 17),
StateDeadline(100, t1, 1)],
deadlineMisses=[DeadlineMiss(t1, 0)],
scheduler=EDFSchedulerState((50, t1, 0),
(51, t2, 16),
(100, t1, 1)))
assert(state == expected)
def test_preemptionInState():
longTask = Task(20,
50,
FixedArrivalDistribution(50),
displayName='long')
shortTask = Task(1,
9,
FixedArrivalDistribution(9),
displayName='short')
taskset = Taskset(longTask, shortTask)
sim = Simulation(taskset)
preemptTime = 9
endTime = 10
sim.getState(endTime)
state = sim.getState(preemptTime)
expectedJobs = [JobState(longTask, 1),
JobState(longTask, 0, 8),
JobState(shortTask, 1, lastStart=9),
JobState(shortTask, 2)]
expectedEvents = [StateDeadline(18, shortTask, 1),
StateDeadline(50, longTask, 0),
StateArrival(50, longTask, 1),
StateArrival(18, shortTask, 2),
StateCompletion(10, shortTask, 1),
StateCompletion(21, longTask, 0)]
expectedPreemptions = [Preemption(9, longTask, 0, shortTask, 1)]
expectedScheduler = EDFSchedulerState((18, shortTask, 1), (50, longTask, 0))
expected = SimulatorState(preemptTime,
expectedJobs,
expectedEvents,
preemptions=expectedPreemptions,
scheduler=expectedScheduler)
assert(state == expected)
def test_exactSameTask():
t1 = Task(4, 2, FixedArrivalDistribution(2), displayName='t1', uniqueId=0)
t2 = Task(4, 2, FixedArrivalDistribution(2), displayName='t2', uniqueId=1)
taskset = Taskset(t1, t2)
setup = SimulationSetup(taskset, time=5)
run = SimulationRun(setup)
result = run.result()
testTime = 2
state = result.history[testTime]
logging.debug('Effective %s', state)
expected = SimulatorState(testTime,
[JobState(t2, 0),
JobState(t2, 1),
JobState(t2, 2),
JobState(t1, 0, progress=2, lastStart=2),
JobState(t1, 1),
JobState(t1, 2)],
[StateDeadline(4, t2, 1),
StateArrival(4, t2, 2),
StateArrival(4, t1, 2),
StateDeadline(4, t1, 1),
StateCompletion(4, t1, 0)],
deadlineMisses=[
DeadlineMiss(t1, 0),
DeadlineMiss(t2, 0)
],
scheduler=EDFSchedulerState((2, t1, 0),
(2, 1, t2, 0),
(4, t1, 1),
(4, 1, t2, 1)))
logging.debug('Expected %s', expected)
assert state == expected
def test_readyQueueCollision2():
t1 = Task(4, 2, FixedArrivalDistribution(2), displayName='t1')
t2 = Task(5, 2, FixedArrivalDistribution(2), displayName='t2')
taskset = Taskset(t1, t2)
setup = SimulationSetup(taskset, time=5)
run = SimulationRun(setup)
run.execute()
def test_3PMiss1():
t1 = Task(5, 20)
t2 = Task(64, 98)
t3 = Task(1, 16)
taskset = Taskset(t1, t2, t3)
history = FixedPointThreeTaskOptimiser(taskset).history()
assert not history.hasDeadlineMiss()
def test_3Psimple():
t1 = Task(3, 6)
t2 = Task(2, 8)
t3 = Task(3, 12)
taskset = Taskset(t1, t2, t3)
history = FixedPointThreeTaskOptimiser(taskset).history()
assert not history.hasDeadlineMiss()
def test_lpvTrivial1():
t1 = Task(1, 10)
t2 = Task(2, 30)
t3 = Task(5, 100)
taskset = Taskset(t1, t2, t3)
expected = {t1, t2, t3}
lpvTasks = set(genLpViableTasks(taskset))
assert lpvTasks == expected
def test_readyQueueCollision():
t1 = Task(1, 2, FixedArrivalDistribution(3),
displayName='t1')
t2 = Task(4, 5, PoissonArrivalDistribution(6, 2), FixedPreemptionCost(3),
displayName='t2')
taskset = Taskset(t1, t2)
setup = SimulationSetup(taskset, time=200)
run = SimulationRun(setup)
run.execute()
def test_lpvNonTrivial():
t4 = Task(587, 45124)
taskset = Taskset(Task(1155, 15964),
Task(1649, 10359),
Task(4343, 14821),
t4,
Task(6028, 19430))
expected = {t4}
lpvTasks = set(genLpViableTasks(taskset))
assert lpvTasks == expected
def test_saveTaskset():
t1 = Task(1, 2, FixedArrivalDistribution(3), LogPreemptionCost(1, 0.1))
t2 = Task(4, 5, PoissonArrivalDistribution(6, 2), FixedPreemptionCost(3))
taskset = Taskset(t1, t2)
with TemporaryDirectory() as testdir:
dataEnv = FileEnv(testdir)
tasksetKey = 'testtaskset'
dataEnv.save(taskset, tasksetKey)
copy = dataEnv.load(tasksetKey)
assert(copy == taskset)
def test_executionTimeStats():
longTask = Task(20, 50, FixedArrivalDistribution(50), displayName='long')
shortTask = Task(1, 5, FixedArrivalDistribution(5), displayName='short')
taskset = Taskset(longTask, shortTask)
setup = SimulationSetup(taskset, time=29)
run = SimulationRun(setup)
result = run.result()
stats = SimulationStatistics(result)
execTime = stats.totalExecutionTime()
assert execTime == 26
def test_saveSimulationSetup():
t1 = Task(1, 2, FixedArrivalDistribution(3), displayName='t1')
t2 = Task(4, 5, FixedArrivalDistribution(6), displayName='t2')
taskset = Taskset(t1, t2)
setup = SimulationSetup(taskset, time=200)
with TemporaryDirectory() as testdir:
dataEnv = FileEnv(testdir)
key = 'test'
dataEnv.save(setup, key)
copy = dataEnv.load(key)
assert(copy == setup)
def test_simuDualPrio():
t1 = Task(5, 10)
t2 = Task(10, 20)
policy = DualPrioritySchedulingPolicy((t1, DualPriorityTaskInfo(11, 5, 1)),
(t2, DualPriorityTaskInfo(12, 10, 2)))
taskset = Taskset(t1, t2)
setup = SimulationSetup(taskset,
time=40,
schedulingPolicy=policy)
run = SimulationRun(setup)
run.execute()
def test_3Pworst():
t1 = Task(3, 9)
t2 = Task(8, 12)
t3 = Task(1, 1000)
taskset = Taskset(t1, t2, t3)
optimisationFailed = False
try:
history = FixedPointThreeTaskOptimiser(taskset).history()
except OptimisationFailure:
optimisationFailed = True
assert optimisationFailed
