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("------------")