blob: e60285010d74932bc6be73628f1184598a9c6e85 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
from __future__ import division
from math import ceil, floor
from schedcat.model.tasks import SporadicTask, TaskSystem
def charge_scheduling_overheads(oheads, num_cpus, dedicated_irq, taskset):
if not oheads or not taskset:
return TaskSystem(taskset)
event_latency = oheads.release_latency(taskset)
# pseudo-task representing the tick interrupt
tck = oheads.tick(taskset)
if tck > 0:
tick_isr = SporadicTask(tck, oheads.quantum_length)
tick_isr.jitter = event_latency
tick_tasks = [tick_isr]
else:
tick_tasks = []
# pseudo-tasks representing release interrupts
rel_cost = oheads.release(taskset)
if not dedicated_irq and rel_cost > 0:
release_tasks = [SporadicTask(rel_cost, t.period) for t in taskset]
for isr in release_tasks:
isr.jitter = event_latency
else:
release_tasks = [] # releases don't impact tasks directly
# account for initial release delay as jitter
release_delay = event_latency + oheads.release(taskset)
if dedicated_irq:
release_delay += oheads.ipi_latency(taskset)
for t in taskset:
if not 'jitter' in t.__dict__:
t.jitter = 0
t.jitter += release_delay
# account for scheduling cost and CPMD
sched = oheads.schedule(taskset)
cxs = oheads.ctx_switch(taskset)
cpmd = oheads.cache_affinity_loss(taskset)
preemption = 2 * (sched + cxs) + cpmd
for t in taskset:
t.cost += preemption
return TaskSystem(tick_tasks + release_tasks + taskset)
def quantize_params(taskset):
"""After applying overheads, use this function to make
task parameters integral again."""
for t in taskset:
t.cost = int(ceil(t.cost))
t.period = int(floor(t.period))
t.deadline = int(floor(t.deadline))
t.jitter = int(ceil(t.jitter))
if t.density() > 1:
return False
return taskset
|
