def test_simuAndResumeShort():
t1 = Task(2, 3, FixedArrivalDistribution(4), displayName='t1')
t2 = Task(1, 4, FixedArrivalDistribution(5), displayName='t2')
taskset = Taskset(t1, t2)
sim = Simulation(taskset)
time1 = 6
time2 = 13
state1 = sim.getState(time1)
expectedJobs1 = [JobState(t1, 1, 2, lastStart=6),
JobState(t1, 2),
JobState(t2, 1),
JobState(t2, 2)]
expectedEvents1 = [StateCompletion(6, t1, 1),
StateArrival(8, t1, 2),
StateArrival(10, t2, 2),
StateDeadline(9, t2, 1),
StateDeadline(7, t1, 1)]
expectedScheduler1 = EDFSchedulerState((7, t1, 1), (9, t2, 1))
expected1 = SimulatorState(
time1, expectedJobs1, expectedEvents1, scheduler=expectedScheduler1)
logging.debug('%s', state1)
assert(expected1 == state1)
state2 = sim.getState(time2)
expectedJobs2 = [JobState(t1, 3, 1, lastStart=13),
JobState(t2, 2, 1, lastStart=11),
JobState(t1, 4),
JobState(t2, 3)]
expectedEvents2 = [StateCompletion(14, t1, 3),
StateArrival(16, t1, 4),
StateArrival(15, t2, 3),
StateDeadline(15, t1, 3),
StateDeadline(14, t2, 2)]
expectedScheduler2 = EDFSchedulerState((15, t1, 3))
expected2 = SimulatorState(
time2, expectedJobs2, expectedEvents2, scheduler=expectedScheduler2)
logging.debug('%s', state2)
assert(expected2 == state2)
assert(sim.noDeadlineMiss(time2))
def test_equalArrivals():
t1 = Task(1, 4, FixedArrivalDistribution(4), displayName='t1')
t2 = Task(1, 5, FixedArrivalDistribution(5), displayName='t2')
taskset = Taskset(t1, t2)
endTime = 22
sim = Simulation(taskset)
state = sim.getState(endTime)
expected = SimulatorState(endTime,
[JobState(t2, 5),
JobState(t1, 5, 1, lastStart=21),
JobState(t1, 6),
JobState(t2, 4, 1, lastStart=22)],
[StateArrival(25, t2, 5),
StateDeadline(25, t2, 4),
StateCompletion(22, t2, 4),
StateDeadline(24, t1, 5),
StateArrival(24, t1, 6)],
scheduler=EDFSchedulerState((25, t2, 4)))
assert(state == 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_preemptionTimeAggregator():
longTask = Task(20,
50,
FixedArrivalDistribution(50),
FixedPreemptionCost(2),
displayName='long')
shortTask = Task(1,
5,
FixedArrivalDistribution(5),
FixedPreemptionCost(2),
displayName='short')
taskset = Taskset(longTask, shortTask)
setup = SimulationSetup(taskset,
time=29,
aggregatorTags=[AggregatorTag.PreemptionTime])
run = SimulationRun(setup)
result = run.result()
aggregatePreemptTime = result.aggregateStat(AggregatorTag.PreemptionTime)
assert aggregatePreemptTime == 10
def test_simuError2():
taskset = Taskset(Task(103, 1950, FixedArrivalDistribution(1950),
LogPreemptionCost(3, 0.1)),
Task(109, 1287, FixedArrivalDistribution(1287),
LogPreemptionCost(3, 0.1)),
Task(13, 4976, FixedArrivalDistribution(4976),
LogPreemptionCost(3, 0.1)),
Task(380, 1925, FixedArrivalDistribution(1925),
LogPreemptionCost(3, 0.1)),
Task(817, 1292, FixedArrivalDistribution(1292),
LogPreemptionCost(3, 0.1)))
setup = SimulationSetup(taskset,
time=1000000,
trackHistory=False,
trackPreemptions=False,
deadlineMissFilter=True,
schedulingPolicy=EDFSchedulingPolicy())
run = SimulationRun(setup, errorHandling=False)
run.execute()
def test_defaultTaskset():
g = TasksetGenerator()
taskset = g()
expectedTask = Task(DEFAULT_SCALE,
DEFAULT_SCALE,
FixedArrivalDistribution(DEFAULT_SCALE),
uniqueId=0)
expected = Taskset(expectedTask)
logging.debug('%s', expected)
logging.debug('%s', taskset)
assert(expected == taskset)
def test_twoTasksets():
t1 = Task(1, 10, FixedArrivalDistribution(10), displayName='t1')
t2 = Task(2, 5, FixedArrivalDistribution(5), displayName='t2')
setup1 = SimulationSetup(Taskset(t1), time=1000)
setup2 = SimulationSetup(Taskset(t1, t2), time=1000)
tasksets = [setup1, setup2]
runner = simulationRunner(tasksets)
runner.start()
runner.join()
result2 = runner.result(setup2)
result1 = runner.result(setup1)
endTime = 987
expected1 = SimulatorState(
981, [JobState(t1, 98, 1, lastStart=981),
JobState(t1, 99)],
[StateArrival(990, t1, 99),
StateDeadline(990, t1, 98)],
scheduler=EDFSchedulerState())
expected2 = SimulatorState(endTime, [
JobState(t2, 198),
JobState(t1, 98, 1, lastStart=983),
JobState(t2, 197, 2, lastStart=987),
JobState(t1, 99)
], [
StateDeadline(990, t1, 98),
StateDeadline(990, t2, 197),
StateArrival(990, t1, 99),
StateArrival(990, t2, 198)
],
scheduler=EDFSchedulerState())
state1 = result1.history.getLastState(endTime)
logging.debug('Expected %s', expected1)
logging.debug('Effective %s', state1)
assert (state1 == expected1)
state2 = result2.history.getLastState(endTime)
logging.debug('Expected %s', expected2)
logging.debug('Effective %s', state2)
assert (state2 == expected2)
def test_schedulerStateEq():
t1 = Task(1, 1, FixedArrivalDistribution(1))
schedS1 = RMSchedulerState((0, t1))
schedS2 = RMSchedulerState((0, t1))
schedS3 = RMSchedulerState((1, t1))
logging.debug(hash(schedS1))
logging.debug(hash(schedS2))
logging.debug(hash(schedS3))
assert schedS1 == schedS2
assert schedS1 != schedS3
def test_eventStateEq():
t1 = Task(1, 1, FixedArrivalDistribution(1))
es1 = StateArrival(0, t1, 0)
es2 = StateArrival(0, t1, 0)
es3 = StateArrival(1, t1, 1)
logging.debug(hash(es1))
logging.debug(hash(es2))
logging.debug(hash(es3))
assert es1 == es2
assert es1 != es3
def test_jobStateEq():
t1 = Task(1, 1, FixedArrivalDistribution(1))
js1 = JobState(t1, 1, 1)
js2 = JobState(t1, 1, 1)
js3 = JobState(t1, 2, 2)
logging.debug(hash(js1))
logging.debug(hash(js2))
logging.debug(hash(js3))
assert js1 == js2
assert js1 != js3
def test_logPreemptionsTotals():
longTask = Task(2000,
5000,
FixedArrivalDistribution(5000),
LogPreemptionCost(1, 0.1),
displayName='long')
shortTask = Task(100,
500,
FixedArrivalDistribution(500),
displayName='short')
taskset = Taskset(longTask, shortTask)
setup = SimulationSetup(taskset, time=5000, trackPreemptions=True)
run = SimulationRun(setup)
result = run.result()
stats = SimulationStatistics(result)
nbPreemptions = stats.nbOfPreemptions
expectedNbPreemptions = 6
preemptionCost = stats.totalPreemptionTime
expectedPreemptionCost = 685
assert nbPreemptions == expectedNbPreemptions
assert preemptionCost == expectedPreemptionCost
def test_preemptionMap():
longTask = Task(20,
50,
FixedArrivalDistribution(50),
displayName='long')
shortTask = Task(1,
5,
FixedArrivalDistribution(5),
displayName='short')
taskset = Taskset(longTask, shortTask)
sim = Simulation(taskset)
endTime = 50
expectedPreemptions = {
Preemption(5, longTask, 0, shortTask, 1),
Preemption(10, longTask, 0, shortTask, 2),
Preemption(15, longTask, 0, shortTask, 3),
Preemption(20, longTask, 0, shortTask, 4)}
allPreemptions = sim.preemptions(endTime)
assert(expectedPreemptions == allPreemptions)
preemptionsByPreemptedTask = sim.preemptions(endTime,
preemptedTask=longTask)
assert(expectedPreemptions == preemptionsByPreemptedTask)
preemptionsByPreemptingTask = sim.preemptions(endTime,
preemptingTask=shortTask)
assert(expectedPreemptions == preemptionsByPreemptingTask)
expectedPreemptionsAtTime15 = {
Preemption(15, longTask, 0, shortTask, 3)
}
preemptionsAtTime15 = sim.preemptions(endTime, time=15)
assert(expectedPreemptionsAtTime15 == preemptionsAtTime15)
expectedPreemptionsAtTime19 = set()
preemptionsAtTime19 = sim.preemptions(endTime, time=19)
assert(expectedPreemptionsAtTime19 == preemptionsAtTime19)
def test_simuPreemptionCostOneTask():
task = Task(2,
3,
FixedArrivalDistribution(6),
FixedPreemptionCost(2),
displayName='t')
taskset = Taskset(task)
sim = Simulation(taskset)
endTime = 101
state = sim.getState(endTime)
expectedJobs = [JobState(task, 17)]
expectedEvents = [StateArrival(102, task, 17)]
expected = SimulatorState(endTime, expectedJobs, expectedEvents)
assert(state == expected)
def test_complexSetupEquality():
taskset = Taskset(
Task(6293, 17199, FixedArrivalDistribution(17199), uniqueId=0),
Task(1952, 11655, FixedArrivalDistribution(11655), uniqueId=1),
Task(284, 5391, FixedArrivalDistribution(5391), uniqueId=2),
Task(475, 14844, FixedArrivalDistribution(14844), uniqueId=3),
Task(820, 2144, FixedArrivalDistribution(2144), uniqueId=4))
tasksetCopy = Taskset(
Task(6293, 17199, FixedArrivalDistribution(17199), uniqueId=0),
Task(1952, 11655, FixedArrivalDistribution(11655), uniqueId=1),
Task(284, 5391, FixedArrivalDistribution(5391), uniqueId=2),
Task(475, 14844, FixedArrivalDistribution(14844), uniqueId=3),
Task(820, 2144, FixedArrivalDistribution(2144), uniqueId=4))
setup = SimulationSetup(taskset,
time=10000000,
schedulingPolicy=SchedulerTag.EDF,
deadlineMissFilter=False,
trackHistory=False)
setupCopy = SimulationSetup(tasksetCopy,
time=10000000,
schedulingPolicy=SchedulerTag.EDF,
deadlineMissFilter=False,
trackHistory=False)
assert setup == setupCopy
def test_fileInventory():
item1 = FixedArrivalDistribution(3)
item2 = FixedPreemptionCost(2)
with TemporaryDirectory() as testdir:
dataEnv = FileEnv(testdir, manifest=True)
item1Key = 'testitem1'
item2Key = 'testitem2'
itemSet = {(item1Key, item1),
(item2Key, item2)}
dataEnv.save(item1, item1Key)
dataEnv.save(item2, item2Key)
copySet = set(dataEnv.items())
assert (copySet == itemSet)
assert (dataEnv.keys() == {item1Key, item2Key})
def test_simulationResult():
t1 = Task(1, 2, FixedArrivalDistribution(3), LogPreemptionCost(1, 0.1),
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)
result = run.result()
with TemporaryDirectory() as testdir:
dataEnv = FileEnv(testdir)
key = 'test'
dataEnv.save(result, key)
copy = dataEnv.load(key)
assert(copy == result)
def test_deadlineMiss():
task = Task(4, 3, FixedArrivalDistribution(5), displayName='t')
taskset = Taskset(task)
sim = Simulation(taskset)
endTime = 5
missTime = 3
sim.getState(endTime)
deadlineState = sim.getState(missTime)
(deadlineMissFromState,) = deadlineState.deadlineMisses
history = sim.history
deadlineMissFromHistory, = history.deadlineMisses(endTime,
time=3,
task=task)
expectedMiss = DeadlineMiss(task, 0)
assert(deadlineMissFromState == expectedMiss)
assert(deadlineMissFromHistory == expectedMiss)
def test_simuOneTask():
task = Task(2, 3, FixedArrivalDistribution(4), displayName='t')
taskset = Taskset(task)
sim = Simulation(taskset)
endTime = 101
state = sim.getState(endTime)
expectedJobs = [JobState(task, 25, 1, lastStart=101),
JobState(task, 26)]
expectedEvents = [StateCompletion(102, task, 25),
StateArrival(104, task, 26),
StateDeadline(103, task, 25)]
expectedScheduler = EDFSchedulerState((103, task, 25))
expected = SimulatorState(endTime,
expectedJobs,
expectedEvents,
scheduler=expectedScheduler)
assert(state == expected)
def test_memoryEnv():
t1 = Task(1, 2, FixedArrivalDistribution(3), LogPreemptionCost(1, 0.1))
t2 = Task(4, 5, PoissonArrivalDistribution(6, 2), FixedPreemptionCost(3))
taskset = Taskset(t1, t2)
state = SimulatorState(82000,
[JobState(t1, 55, preemptionDebt=1515),
JobState(t2, 66, lastStart=42)],
[StateDeadline(77, t1, 2),
StateArrival(88, t2, 3),
StateCompletion(99, t1, 4)],
scheduler=EDFSchedulerState((1043, t1, 1001),
(1042, t2, 1002)))
dataEnv = MemoryEnv()
stateKey = 'teststate'
tasksetKey = 'testtaskset'
dataEnv.save(state, stateKey)
dataEnv.save(taskset, tasksetKey)
stateCopy = dataEnv.load(stateKey)
tasksetCopy = dataEnv.load(tasksetKey)
assert(state == stateCopy)
assert(taskset == tasksetCopy)
def test_createTaskWithPreemptionCost():
task = Task(2, 3, FixedArrivalDistribution(6), FixedPreemptionCost(2))
assert(task.wcet == 2)
assert(task.deadline == 3)
assert(task.arrivalDistribution == FixedArrivalDistribution(6))
assert(task.preemptionCost == FixedPreemptionCost(2))
def test_tasksetEq():
taskset = Taskset(
Task(6293, 17199, FixedArrivalDistribution(17199), uniqueId=0))
tasksetCopy = Taskset(
Task(6293, 17199, FixedArrivalDistribution(17199), uniqueId=0))
assert taskset == tasksetCopy
def test_taskEq():
task = Task(6293, 17199, FixedArrivalDistribution(17199), uniqueId=0)
taskCopy = Task(6293, 17199, FixedArrivalDistribution(17199), uniqueId=0)
assert task == taskCopy
