def test_task_is_counted(self):
ts = TaskSet()
t1 = Task()
t2 = Task()
ts.append(t1)
ts.append(t2)
self.assertEqual(len(ts), 2)
def test_task_setter(self):
ts = TaskSet()
param1 = {'id': 2}
t1 = Task(**param1)
ts.append(t1)
param2 = {'id': 3}
t2 = Task(**param2)
ts[0] = t2
self.assertEqual(ts[0].id, 3)
def test_workload_in_interval_fp(self):
task_param = {
'exec_time': 3,
'deadline': 5,
'period': 7,
}
t = Task(**task_param)
assert_almost_equals(tsutil.workload_in_interval_fp(t, 14.0), 8.0)
assert_almost_equals(tsutil.workload_in_interval_fp(t, 15.0), 9.0)
assert_almost_equals(tsutil.workload_in_interval_fp(t, 2.0), 2.0)
assert_almost_equals(tsutil.workload_in_interval_fp(t, 4.0), 3.0)
t.slack = 1
assert_almost_equals(tsutil.workload_in_interval_fp(t, 15.0), 8.0)
assert_almost_equals(tsutil.workload_in_interval_fp(t, 16.0), 9.0)
def test_sum_density(self):
task_param1 = {
'exec_time': 8,
'deadline': 10,
}
t1 = Task(**task_param1)
task_param2 = {
'exec_time': 9,
'deadline': 10,
}
t2 = Task(**task_param2)
ts = TaskSet()
ts.append(t1)
ts.append(t2)
assert_almost_equals(tsutil.sum_density(ts), 1.7)
def test_ts_merge(self):
param1 = {'id': 2}
t1 = Task(**param1)
param2 = {'id': 3}
t2 = Task(**param2)
ts1 = TaskSet()
ts2 = TaskSet()
ts1.append(t1)
ts2.append(t1)
ts2.append(t2)
ts1.merge_ts(ts2)
self.assertEqual(len(ts1), 3)
self.assertEqual(ts1[2], t2)
def next_task(self, **kwargs):
period = random.randint(self.min_period, self.max_period)
exec_time = random.randint(self.min_exec_time, self.max_exec_time)
# prevents tasks with utilization > 1.0
if not self.utilization_overflow:
while exec_time > period + 0.1:
period = random.randint(self.min_period, self.max_period)
exec_time = random.randint(self.min_exec_time,
self.max_exec_time)
if self.implicit_deadline:
deadline = period
else:
if self.constrained_deadline:
deadline = random.randint(self.min_deadline, period)
else:
deadline = random.randint(self.min_deadline, self.max_deadline)
task_param = {
'period': period,
'exec_time': exec_time,
'deadline': deadline * self.deadline_scale,
}
t = Task(**task_param)
return t
def test_two_task(self):
task_param1 = {
'exec_time': 4,
'deadline': 10,
}
t1 = Task(**task_param1)
task_param2 = {
'exec_time': 6,
'deadline': 10,
}
t2 = Task(**task_param2)
ts = TaskSet()
ts.append(t1)
ts.append(t2)
gfb_param = {
'num_core': 2,
}
self.assertTrue(gfb.is_schedulable(ts, **gfb_param))
def test_workload_in_interval_edf(self):
task_param = {
'exec_time': 3,
'deadline': 5,
'period': 7,
}
t = Task(**task_param)
t.slack = 0
assert_almost_equals(tsutil.workload_in_interval_edf(t, 2.0), 2.0)
assert_almost_equals(tsutil.workload_in_interval_edf(t, 4.0), 3.0)
t.slack = 1
assert_almost_equals(tsutil.workload_in_interval_edf(t, 2.0), 1.0)
assert_almost_equals(tsutil.workload_in_interval_edf(t, 9.0), 4.0)
assert_almost_equals(tsutil.workload_in_interval_edf(t, 10.0), 5.0)
t.slack = 2
assert_almost_equals(tsutil.workload_in_interval_edf(t, 9.0), 3.0)
def test_workload_in_interval_edf_wo_slack(self):
task_param = {
'exec_time': 3,
'deadline': 5,
'period': 7,
}
t = Task(**task_param)
assert_almost_equals(tsutil.workload_in_interval_edf(t, 9.0), 5.0)
assert_almost_equals(tsutil.workload_in_interval_edf(t, 10.0), 6.0)
def test_utilization_and_density_difference(self):
task_param = {
'exec_time': 6,
'deadline': 8,
'period': 10,
}
t = Task(**task_param)
ts = TaskSet()
ts.append(t)
diff = tsutil.sum_utilization(ts) - tsutil.sum_density(ts)
assert_almost_equals(diff, -0.15)
def next_task(self, **kwargs):
period = random.randint(self.min_period, self.max_period)
exec_time = random.randint(self.min_exec_time, self.max_exec_time)
deadline = period # implicit deadline
task_param = {
'period': period,
'exec_time': exec_time,
'deadline': deadline,
}
t = Task(**task_param)
return t
def next_task(self, **kwargs):
task_param = {
'exec_time': random.randint(
self.min_exec_time, self.max_exec_time),
'deadline': random.randint(
self.min_deadline, self.max_deadline),
'period': random.randint(
self.min_period, self.max_period),
}
t = Task(**task_param)
return t
def test_getitem_raise_error(self):
task_param = {
'exec_time': 40,
'deadline': 100,
'period': 100,
}
t = Task(**task_param)
para_task_param = {
'base_task': t,
'max_option': 4,
}
pt = ParaTask(**para_task_param)
pass
def test_single_and_max_popt(self):
task_param = {
'exec_time': 40,
'deadline': 100,
'period': 100,
}
t1 = Task(**task_param)
task_param = {
'exec_time': 100,
'deadline': 200,
'period': 200,
}
t2 = Task(**task_param)
ts = TaskSet()
ts.append(t1)
ts.append(t2)
pts_param1 = {
'base_ts': ts,
'max_option': 4,
'overhead': 0.0,
'variance': 0.3,
'popt': 'single',
}
pts1 = ParaTaskSet(**pts_param1)
self.assertEqual(len(pts1), 2)
pts_param2 = {
'base_ts': ts,
'max_option': 4,
'overhead': 0.0,
'variance': 0.3,
'popt': 'max',
}
pts2 = ParaTaskSet(**pts_param2)
self.assertEqual(len(pts2), 2)
def next_task(self, **kwargs):
cand_util = kwargs.get('cand_util', 0.0)
period = random.randint(self.min_period, self.max_period)
exec_time = math.floor(period * cand_util)
deadline = period # implicit deadline
task_param = {
'period': period,
'exec_time': exec_time,
'deadline': deadline,
}
t = Task(**task_param)
return t
def test_overhead_calculation_for_pt(self):
task_param = {
'exec_time': 200,
'deadline': 600,
'period': 600,
}
t = Task(**task_param)
para_task_param = {
'base_task': t,
'max_option': 4,
'overhead': 0.1,
'variance': 0.9,
}
pt = ParaTask(**para_task_param)
def __init__(self, **kwargs):
"""
**Role**: Initialize Parallelizable Taskset\n
.. note::
* **max_option** : The maximum parallelize option that \n
* **overhead** : The increasing rate of **execution_time** on every **parallelization** \n
* **variance** : The **execution_time** difference between **paralleizable task** and **thread** on paralleization\n
* **base_ts** : **parallelize task** needs **base_task** ( Default: exec_time=1, deadline=2, period=3 )\n
* **pt_list** : Save **paralleizable tasks** in a list to make a **paralleizable taskset*\n
* **populate_pt_list** : See the **"populate_pt_list"**\n
* **popt_strategy** : parallel option (default **single** )\n
* **popt_list** : parallel option list for each **pt_list**\n
* **pts_serialized** : Generate **taskset** includes **parallelizable tasks** with **parallel option**
* **serialize_pts** : See the **serialize pts**
"""
type(self).cnt += 1
self.id = kwargs.get('id', type(self).cnt)
self.max_opt = kwargs.get('max_option', 1)
# parallelizer info
self.overhead = kwargs.get('overhead', 0.0)
if self.overhead > 0.5:
self.overhead = 3.0
self.variance = kwargs.get('variance', 0.0)
# base task set info
tmp_ts = TaskSet()
tmp_ts.append(Task(**{'exec_time': 1, 'deadline': 2, 'period': 3}))
self.base_ts = kwargs.get('base_ts', tmp_ts)
self.pt_list = []
if kwargs.get('custom', 'False') == 'True':
self.pt_list = kwargs.get('pt_list', [[]])
else:
self.populate_pt_list()
# pts serialized according to selected option.
# defaults to single thread for each pt in pts.
self.popt_strategy = kwargs.get('popt_strategy', 'single')
self.popt_list = kwargs.get('popt_list',
[1 for i in range(len(self.pt_list))])
self.pts_serialized = TaskSet()
self.serialize_pts()
self.task_list = self.pts_serialized.task_list
return
def test_init_with_task(self):
task_param = {
'exec_time': 40,
'deadline': 100,
'period': 100,
}
t = Task(**task_param)
para_task_param = {
'base_task': t,
'max_option': 4,
}
pt = ParaTask(**para_task_param)
self.assertEqual(pt.max_opt, 4)
option_one_first_thr = pt[1][0]
self.assertEqual(option_one_first_thr, t)
self.assertEqual(option_one_first_thr.exec_time, 40)
def test_overhead_calculation(self):
task_param = {
'exec_time': 10,
'deadline': 10,
'period': 10,
}
t = Task(**task_param)
para_param = {
'pcs': 2,
'overhead': 1.0,
'variance': 0.0,
}
thr_list = para.parallelize_task(t, **para_param)
self.assertAlmostEqual(thr_list[0].exec_time, 10.0)
self.assertAlmostEqual(thr_list[1].exec_time, 10.0)
def test_split_into_two(self):
task_param = {
'exec_time': 10,
'deadline': 10,
'period': 10,
}
t = Task(**task_param)
para_param = {
'pcs': 2,
'overhead': 0.0,
'variance': 0.0,
}
thr_list = para.parallelize_task(t, **para_param)
self.assertAlmostEqual(thr_list[0].exec_time, 5.0)
self.assertAlmostEqual(thr_list[1].exec_time, 5.0)
self.assertAlmostEqual(thr_list[0].deadline, 10.0)
self.assertAlmostEqual(thr_list[0].period, 10.0)
def __init__(self, **kwargs):
"""
**Role**: Initialize Parallelizable Task\n
.. note::
* **max_option** : The maximum parallelize option that \n
* **overhead** : The increasing rate of **execution_time** on every **parallelization** \n
* **variance** : The **execution_time** difference between **threads** on paralleization\n
* **base_task** : **parallelize task** needs **base_task** ( Default: exec_time=1, deadline=2, period=3 )\n
* **ts_table** : Save taskset from **1** to **max_option**\n
* **populate_ts_table** : See the **"populate_ts_table"**\n
"""
type(self).cnt += 1
self.id = kwargs.get('id', type(self).cnt)
self.max_opt = kwargs.get('max_option', 1)
# parallelizer info
self.overhead = kwargs.get('overhead', 0.0)
self.variance = kwargs.get('variance', 1.0)
# base task info
self.base_task = kwargs.get(
'base_task', Task(**{
'exec_time': 1,
'deadline': 2,
'period': 3
}))
ts = TaskSet()
ts.append(self.base_task)
self.ts_table = {'1': ts}
if kwargs.get('custom', 'False') == 'True':
self.exec_times = kwargs.get('exec_times', [[]])
self.custom_init()
else:
self.populate_ts_table()
def test_id_does_not_overlap(self):
t1 = Task()
t2 = Task()
self.assertNotEqual(t1.id, t2.id)
def test_taskset_is_cleared(self):
ts = TaskSet()
t1 = Task()
ts.append(t1)
ts.clear()
self.assertEqual(len(ts), 0)
def test_task_getter(self):
ts = TaskSet()
param = {'id': 2}
t = Task(**param)
ts.append(t)
self.assertEqual(ts[0].id, 2)
"""
###if self.max_opt >= 2:
### for i in range(2, self.max_opt + 1):
### self.ts_table[str(i)] = TaskSet()
### tlist = para.parallelize_task(self.base_task, **{'pcs': i, 'overhead': self.overhead, 'variance': self.variance})
### for thr in tlist:
### self[i].append(thr)
if self.max_opt >= 2:
# para.parallelize_pt_non_dec(self)
para.parallelize_pt_non_dec_alpha(self)
return
if __name__ == '__main__':
task_param = {
'exec_time': 20,
'deadline': 60,
'period': 60,
}
t = Task(**task_param)
para_task_param = {
'base_task': t,
'max_option': 4,
'overhead': 0.1,
'variance': 0.9,
}
pt = ParaTask(**para_task_param)
print(pt)
for i in range(n_task):
if i_sum_list[i] > self.ip_table[i][popt_list[i]] + 0.1:
return False
return True
def get_opt_popt(self, pts):
pass
if __name__ == '__main__':
task_param = {
'exec_time': 35,
'deadline': 60,
'period': 60,
}
t1 = Task(**task_param)
task_param = {
'exec_time': 72,
'deadline': 80,
'period': 80,
}
t2 = Task(**task_param)
ts = TaskSet()
ts.append(t1)
ts.append(t2)
pts_param = {
'base_ts': ts,
'max_option': 4,
'inc': 0.1,
}
stat_single = Stat(**stat_param)
stat_max = Stat(**stat_param)
stat_random = Stat(**stat_param)
stat_cho = Stat(**stat_param)
# lane tracking tack
print('----------------')
print('lane tracking tack')
task_param = {
'exec_time': 20,
'deadline': 50,
'period': 60,
}
t_lanetrack = Task(**task_param)
para_task_param = {
'base_task': t_lanetrack,
'max_option': 4,
'custom': 'True',
'exec_times': [[20], [11, 10], [9, 8, 8], [7, 6, 6, 5]],
}
pt_lanetrack = ParaTask(**para_task_param)
print(pt_lanetrack)
# object detection task
print('----------------')
print('object detection task')
task_param = {
'exec_time': 30,
