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,