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