def calc_ext_interval(self, ts): k = min(len(ts), int(self.num_core - 1)) k_max_tasks = tsutil.get_k_max_exec_time_task(ts, k) # print(ts) # C_sum c_sum = 0.0 for t in k_max_tasks: c_sum += t.exec_time a_k_base = c_sum for t in ts: a_k_base += (t.period - t.deadline) * tsutil.calc_utilization(t) # print('a_k_base: ' + str(a_k_base)) # Ak = [AkBase + Dk * Utot - m * Dk + m * Ck ] / [m - Utot] a_k_list = [] for t in ts: a_k_rem = t.deadline * (tsutil.sum_utilization(ts) - self.num_core ) + self.num_core * t.exec_time a_k_rem = (a_k_base + a_k_rem) / (self.num_core - tsutil.sum_utilization(ts)) a_k_list.append(a_k_rem) return a_k_list
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 __str__(self): """ **Role**: Format for printing taskset \n >>> length of task_list, tot_util .. note:: **tot_util** : sum of each task's utilization (from **"op.tsutil.sum_utilization"**) """ tot_util = tsutil.sum_utilization(self) info_str = '%d\t%.2f\n' % (len(self.task_list), tot_util) for t in self.task_list: info_str += t.__str__() + '\n' return info_str
def is_schedulable(self, ts): # trivial condition if tsutil.sum_utilization(ts) <= 1.0: return True if tsutil.sum_utilization(ts) > self.num_core: return False # Dk > Ck for t in ts: if tsutil.calc_density(t) > 1.0: return False a_k_list = self.calc_ext_interval(ts) # print(a_k_list) for base_task_idx, base_task in enumerate(ts): # Ak <= 0, don't need to check if a_k_list[base_task_idx] < 0: # print(str(base_task_idx) + ': ' + str(a_k_list[base_task_idx]) + ' is below 0') continue # print('base_task_idx: ' + str(base_task_idx)) ext_interval = 0.0 # iterate with Ak while ext_interval < a_k_list[base_task_idx]: # non ci interference_list_non_ci = [] for inter_task in ts: interference_list_non_ci.append( self.calc_non_ci_interference(base_task, inter_task, ext_interval)) # ci interference_list_ci = [] for inter_task in ts: interference_list_ci.append( self.calc_ci_interference(base_task, inter_task, ext_interval)) # non ci vs ci diff interference_diff_list = [] for idx in range(len(ts)): diff = interference_list_ci[ idx] - interference_list_non_ci[idx] if diff < 0: print('interference_diff calc error') interference_diff_list.append(diff) # m - 1 largest carry-in interference_diff_list.sort(reverse=True) k = min(len(ts), int(self.num_core) - 1) k_largest_ci = interference_diff_list[:k] # sum up interferences. tot_interference = 0.0 for interference in interference_list_non_ci: tot_interference += interference for additional_interference in k_largest_ci: tot_interference += additional_interference # not schedulable RHS: m(Ak + Dk - Ck) if tot_interference > self.num_core * (base_task.deadline - base_task.exec_time + ext_interval): return False ext_interval += 1.0 return True
def tot_util(self): """ **Role**: Calculate total utilization (from **"op.tsutil.sum_utilization"**) """ return tsutil.sum_utilization(self.pts_serialized)
num_iter = 10000 for i in range(num_iter): # generate tasks ts = u.next_task_set() # print(ts) # test using various tests sched_param = { 'num_core': 2, } sched_bcl = bcl.is_schedulable(ts, **sched_param) sched_gfb = gfb.is_schedulable(ts, **sched_param) sched_bcl_mod = bcl_mod.is_schedulable(ts, **sched_param) ts_util = tsutil.sum_utilization(ts) stat_gfb.add(ts_util, sched_gfb) stat_bcl.add(ts_util, sched_bcl) stat_bcl_mod.add(ts_util, sched_bcl_mod) if not sched_bcl and sched_bcl_mod: print(ts) # print('gfb- ' + str(sched_gfb)) # print('bcl- ' + str(sched_bcl)) # print('bcl_mod- ' + str(sched_bcl_mod)) # print('--------') """ print("gfb") stat_gfb.print_minimal() print("------------")