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_simuAndResumeOneTask2():
t1 = Task(2, 3, FixedArrivalDistribution(4), displayName='t')
taskset = Taskset(t1)
sim = Simulation(taskset)
time1 = 6
time2 = 13
state1 = sim.getState(time1)
expectedJobs1 = [JobState(t1, 1, 2, lastStart=6),
JobState(t1, 2)]
expectedEvents1 = [StateCompletion(6, t1, 1),
StateArrival(8, t1, 2),
StateDeadline(7, t1, 1)]
expectedScheduler1 = EDFSchedulerState((7, t1, 1))
expected1 = SimulatorState(
time1, expectedJobs1, expectedEvents1, scheduler=expectedScheduler1)
assert(expected1 == state1)
state2 = sim.getState(time2)
expectedJobs2 = [JobState(t1, 3, 1, lastStart=13), JobState(t1, 4)]
expectedEvents2 = [StateCompletion(14, t1, 3),
StateArrival(16, t1, 4),
StateDeadline(15, t1, 3)]
expectedScheduler2 = EDFSchedulerState((15, t1, 3))
expected2 = SimulatorState(
time2, expectedJobs2, expectedEvents2, scheduler=expectedScheduler2)
assert(expected2 == state2)
def test_simpleRun():
t1 = Task(1, 10, FixedArrivalDistribution(10), displayName='t')
setup = SimulationSetup(Taskset(t1), time=1000, trackHistory=True)
setups = [setup]
runner = simulationRunner(setups)
runner.start()
runner.join()
result = runner.result(setup)
expectedStates = [
(10,
SimulatorState(10, [JobState(t1, 1, lastStart=10),
JobState(t1, 2)], [
StateCompletion(11, t1, 1),
StateArrival(20, t1, 2),
StateDeadline(20, t1, 1)
],
scheduler=EDFSchedulerState((20, t1, 1)))),
(987,
SimulatorState(
981, [JobState(t1, 98, 1, lastStart=981),
JobState(t1, 99)],
[StateArrival(990, t1, 99),
StateDeadline(990, t1, 98)],
scheduler=EDFSchedulerState()))
]
for time, expected in expectedStates:
state = result.history.getLastState(time)
logging.debug('Expected %s', expected)
logging.debug('Effective %s', state)
assert (state == expected)
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_RMm1RMsuccess04():
taskset = Taskset(Task(1, 40),
Task(16, 92),
Task(27, 75),
Task(17, 55),
Task(6, 50))
assertRMm1RM(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_RMm1RMsuccess01():
taskset = Taskset(Task(1, 40),
Task(9, 107),
Task(1, 54),
Task(43, 60),
Task(7, 51))
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_GDFsuccess03():
taskset = Taskset(Task(1, 40),
Task(9, 107),
Task(1, 54),
Task(43, 60),
Task(7, 51))
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_RMm1RMsuccess05():
taskset = Taskset(Task(1, 40),
Task(17, 119),
Task(7, 60),
Task(35, 100),
Task(27, 75))
assertRMm1RM(taskset, success=True)
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_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_RMm1RMsuccess07():
taskset = Taskset(Task(12, 40),
Task(1, 103),
Task(13, 100),
Task(1, 81),
Task(31, 60))
assertRMm1RM(taskset, success=True)
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_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_fileOutputNoPromo():
taskset = Taskset(Task(1, 40), Task(4, 42), Task(1, 46), Task(10, 46),
Task(28, 60), Task(11, 64))
def dpInfos():
sortedTasks = sorted(taskset,
key=lambda x: (x.minimalInterArrivalTime, x.wcet))
for i, task in enumerate(sortedTasks):
yield task, DualPriorityTaskInfo(i + 1)
policy = DualPrioritySchedulingPolicy(*dpInfos())
setup = SimulationSetup(taskset,
taskset.hyperperiod,
schedulingPolicy=policy)
testPath = 'test_fileOutputNoPromo.txt'
sof = DPOutputFile(testPath)
cleanFile(testPath)
sof.write(setup)
expectedFileContent = ('1 40 40 40 1 1\n'
'4 42 42 42 2 2\n'
'1 46 46 46 3 3\n'
'10 46 46 46 4 4\n'
'28 60 60 60 5 5\n'
'11 64 64 64 6 6\n'
'\n')
with open(testPath) as file:
fileContent = file.read()
assert fileContent == expectedFileContent
cleanFile(testPath)
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_3PWorstLaxity1():
taskset = Taskset(Task(33, 90),
Task(16, 39),
Task(3, 28))
optimiser = RMWorstCaseLaxity3TaskOptimiser(taskset)
history = optimiser.history()
assert not history.hasDeadlineMiss()
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_RMm1RMfailure01():
taskset = Taskset(Task(1, 40),
Task(5, 114),
Task(18, 93),
Task(7, 47),
Task(42, 72))
assertRMm1RM(taskset, success=False)
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_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_RMm1RMsuccess06():
taskset = Taskset(Task(1, 40),
Task(12, 109),
Task(1, 104),
Task(29, 78),
Task(24, 56),
Task(2, 40))
assertRMm1RM(taskset, success=True)
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_RMm1RMsuccess12():
taskset = Taskset(Task(1, 40),
Task(11, 64),
Task(1, 46),
Task(4, 42),
Task(10, 46),
Task(28, 60))
assertRMm1RM(taskset, success=True)
def test_setupEquality():
taskset1 = Taskset(Task(10, 10, FixedArrivalDistribution(10), uniqueId=0))
taskset2 = Taskset(Task(10, 10, FixedArrivalDistribution(10), uniqueId=0))
taskset3 = Taskset(Task(9, 10, FixedArrivalDistribution(10)))
setup1 = SimulationSetup(taskset=taskset1,
schedulingPolicy=SchedulerTag.EDF)
setup2 = SimulationSetup(taskset=taskset2,
schedulingPolicy=SchedulerTag.EDF)
setup3 = SimulationSetup(taskset=taskset3,
schedulingPolicy=SchedulerTag.EDF)
logging.debug(hash(setup1))
logging.debug(hash(setup2))
logging.debug(hash(setup3))
assert setup1 == setup2
assert setup2 == setup1
assert setup2 != setup3
def test_RMm1RMsuccess08():
taskset = Taskset(Task(16, 40),
Task(16, 101),
Task(1, 60),
Task(15, 76),
Task(8, 40),
Task(1, 66))
assertRMm1RM(taskset, success=True)
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()