Esempio n. 1
0
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
Esempio n. 2
0
def test_executionTimeAggregator():
    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,
                            aggregatorTags=[AggregatorTag.ExecutionTime])
    run = SimulationRun(setup)
    result = run.result()
    aggregateExecTime = result.aggregateStat(AggregatorTag.ExecutionTime)
    assert aggregateExecTime == 26
Esempio n. 3
0
def test_dualPriorityBW1_2():
    t1 = Task(3, 6)
    t2 = Task(2, 8)
    t3 = Task(3, 12)

    policy = DualPrioritySchedulingPolicy((t1, DualPriorityTaskInfo(1)),
                                          (t2, DualPriorityTaskInfo(3)),
                                          (t3, DualPriorityTaskInfo(4, 10, 2)))
    taskset = Taskset(t1, t2, t3)
    hyperperiod = 24
    setup = SimulationSetup(taskset,
                            time=hyperperiod,
                            schedulingPolicy=policy)
    run = SimulationRun(setup)
    result = run.result()
    assert not result.history.hasDeadlineMiss()
Esempio n. 4
0
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)
Esempio n. 5
0
def test_freePreemptionsTotals():
    longTask = Task(20, 50, FixedArrivalDistribution(50), displayName='long')
    shortTask = Task(1, 5, FixedArrivalDistribution(5), displayName='short')

    taskset = Taskset(longTask, shortTask)
    setup = SimulationSetup(taskset, time=50, trackPreemptions=True)
    run = SimulationRun(setup)
    result = run.result()
    stats = SimulationStatistics(result)
    nbPreemptions = stats.nbOfPreemptions
    expectedNbPreemptions = 4
    preemptionCost = stats.totalPreemptionTime
    expectedPreemptionCost = 0

    assert nbPreemptions == expectedNbPreemptions
    assert preemptionCost == expectedPreemptionCost
Esempio n. 6
0
def test_dualPriorityBW1_1():
    t1 = Task(3, 6)
    t2 = Task(2, 8)
    t3 = Task(3, 12)

    policy = DualPrioritySchedulingPolicy((t1, DualPriorityTaskInfo(2)),
                                          (t2, DualPriorityTaskInfo(3)),
                                          (t3, DualPriorityTaskInfo(4)))

    taskset = Taskset(t1, t2, t3)
    hyperperiod = 24
    setup = SimulationSetup(taskset,
                            time=hyperperiod,
                            schedulingPolicy=policy)
    run = SimulationRun(setup)
    result = run.result()
    expectedMisses = {DeadlineMiss(t3, 0)}
    assert result.history.deadlineMisses(hyperperiod) == expectedMisses
Esempio n. 7
0
def test_preemptionNbAggregator():
    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.PreemptionCount])
    run = SimulationRun(setup)
    result = run.result()
    aggregateNbPreempt = result.aggregateStat(AggregatorTag.PreemptionCount)
    assert aggregateNbPreempt == 5
Esempio n. 8
0
def test_simulationWithExecTimeStats():
    for setup in genSetups(50, ()):
        run = SimulationRun(setup)
        result = run.result()
        stats = SimulationStatistics(result)
        stats.totalExecutionTime()