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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
import generator as gen
import random
TP_TBASE = """#for $t in $task_set
{} $t.cost $t.period
#end for"""
TP_GLOB_TASK = TP_TBASE.format("")
TP_PART_TASK = TP_TBASE.format("-p $t.cpu")
TP_MC_TASK = TP_TBASE.format("-p $t.cpu -m $t.crit -i $t.id")
class EdfGenerator(gen.Generator):
'''Creates sporadic task sets with the most common Litmus options.'''
def __init__(self, scheduler, templates, options, params):
super(EdfGenerator, self).__init__(scheduler, templates,
self.__make_options() + options,
params)
def __make_options(self):
'''Return generic EDF options.'''
return [gen.Generator._dist_option('utils', 'uni-very-light',
gen.NAMED_UTILIZATIONS,
'Task utilization distributions.'),
gen.Generator._dist_option('periods', 'harmonic',
gen.NAMED_PERIODS,
'Task period distributions.')]
def _create_exp(self, exp_params):
'''Create a single experiment with @exp_params in @out_dir.'''
pdist = self._create_dist('period',
exp_params['periods'],
gen.NAMED_PERIODS)
udist = self._create_dist('utilization',
exp_params['utils'],
gen.NAMED_UTILIZATIONS)
ts = self._create_taskset(exp_params, pdist, udist)
self._customize(ts, exp_params)
self._write_schedule(dict(exp_params.items() + [('task_set', ts)]))
self._write_params(exp_params)
def _customize(self, taskset, exp_params):
'''Configure a generated taskset with extra parameters.'''
pass
class PartitionedGenerator(EdfGenerator):
def __init__(self, scheduler, templates, options, params):
super(PartitionedGenerator, self).__init__(scheduler,
templates + [TP_PART_TASK], options, params)
def _customize(self, taskset, exp_params):
cpus = exp_params['cpus']
start = 0
if exp_params['release_master']:
cpus -= 1
start = 1
# Partition using worst-fit for most even distribution
utils = [0]*cpus
tasks = [0]*cpus
for t in taskset:
t.cpu = utils.index(min(utils))
utils[t.cpu] += t.utilization()
tasks[t.cpu] += 1
# Increment by one so release master has no tasks
t.cpu += start
class PedfGenerator(PartitionedGenerator):
def __init__(self, params={}):
super(PedfGenerator, self).__init__("PSN-EDF", [], [], params)
class CedfGenerator(PartitionedGenerator):
TP_CLUSTER = "plugins/C-EDF/cluster{$level}"
CLUSTER_OPTION = gen.GenOption('level', ['L2', 'L3', 'All'], 'L2',
'Cache clustering level.',)
def __init__(self, params={}):
super(CedfGenerator, self).__init__("C-EDF",
[CedfGenerator.TP_CLUSTER],
[CedfGenerator.CLUSTER_OPTION],
params)
class GedfGenerator(EdfGenerator):
def __init__(self, params={}):
super(GedfGenerator, self).__init__("GSN-EDF", [TP_GLOB_TASK],
[], params)
class Mc2Generator(EdfGenerator):
def __init__(self, params={}):
super(Mc2Generator, self).__init__("MC2", [TP_MC_TASK],
[], params)
def _customize(self, taskset, exp_params):
cpus = exp_params['cpus']
start = 0
# Partition using worst-fit for most even distribution
utils = [0]*cpus
tasks = [0]*cpus
index = [1]*cpus
taskset = sorted(taskset, key=lambda task: task.period)
for t in taskset:
t.cpu = utils.index(min(utils))
t.id = index[t.cpu]
if utils[t.cpu] < 0.05:
t.crit = 0
elif utils[t.cpu] < 0.10:
t.crit = 1
else:
t.crit = 2
utils[t.cpu] += t.utilization()
tasks[t.cpu] += 1
index[t.cpu] += 1
# Increment by one so release master has no tasks
t.cpu += start
|
