def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(10, 100),
tasks.SporadicTask(10, 100),
tasks.SporadicTask(10, 100),
tasks.SporadicTask(10, 100),
])
r.initialize_resource_model(self.ts)
# dummy response-time guess
for t in self.ts:
t.response_time = 40
# every task holds the resource for up to 1ms
for t in self.ts:
t.resmodel[0].add_request(1)
# assign tasks to partitions
self.ts[0].partition = 0
self.ts[1].partition = 0
self.ts[2].partition = 1
self.ts[3].partition = 1
self.p0 = tasks.TaskSystem((t for t in self.ts if t.partition == 0))
self.p1 = tasks.TaskSystem((t for t in self.ts if t.partition == 1))
# assign preemption levels
lb.assign_fp_preemption_levels(self.ts)
def yang(app):
t_list = []
for ti in range(len(app.tasks)):
response_time = app.tasks[ti].response_time()
t_list.append(tasks.SporadicTask(response_time, response_time * 1000))
ts = tasks.TaskSystem(t_list)
fp.bound_response_times(1, ts)
resources.initialize_resource_model(ts)
for ti in range(len(app.tasks)):
for cs in app.tasks[ti].cs:
ts[ti].resmodel[cs.resource].add_request(cs.duration)
for t in ts:
t.partition = 0
bounds.assign_fp_preemption_levels(ts)
r_but = buttazzo(a)
res = bounds.apply_pip_bounds(ts, 1)
ret = {}
for n in range(len(app.tasks) -
1): # the blocking time of last task is always 0
costH = 0
for h in range(n):
costH += ts[h].cost
y_Bn = res.get_blocking_term(
n) - costH #cost of all the processes with higher priority
if y_Bn > r_but[n][0]:
feasible = False
else:
_, feasible, _ = schedule(app, app.tasks[n], r_but[n][1])
ret[n] = (y_Bn, feasible)
return ret
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(10, 100),
tasks.SporadicTask(10, 100),
tasks.SporadicTask(10, 100),
tasks.SporadicTask(10, 100),
])
r.initialize_resource_model(self.ts)
# dummy response-time guess
for t in self.ts:
t.response_time = 40
# every task holds the resource for up to 1ms
for t in self.ts:
t.resmodel[0].add_request(1)
# assign tasks to partitions
self.ts[0].partition = 0
self.ts[1].partition = 0
self.ts[2].partition = 1
self.ts[3].partition = 1
self.p0 = tasks.TaskSystem((t for t in self.ts if t.partition == 0))
self.p1 = tasks.TaskSystem((t for t in self.ts if t.partition == 1))
# assign preemption levels
lb.assign_fp_preemption_levels(self.ts)
def _create_taskset_from_file(self, params, res_number, folderpath, collaborative):
ts = []
""" read a taskset in sched.py done (-S option included) """
with open (folderpath+"/sched.py", 'r') as f:
index = 0
for line in f:
elements = line.split()
c = int(elements[4])
p = int(elements[5])
temp = SporadicTask(c, p, p)
temp.id = index
index = index + 1
ts.append(temp)
""" distribute resources """
resources.initialize_resource_model(ts)
ts.sort(key=lambda x:x.cost, reverse=True)
self._custom_distribute(ts, collaborative, res_number)
""" create the params from params.py file """
temp = {}
with open (folderpath+"/params.py", 'r') as f:
temp = eval(f.read())
for key in temp:
params[key] = temp[key]
""" adding RES parameters """
params['cpus'] = int(params['cpus'])
params['res_nmb'] = res_number
params['res_distr'] = collaborative
params['res_weight'] = 0
return ts
def test_serialize_resmodel(self):
r.initialize_resource_model(self.ts)
self.t1.resmodel[1].add_request(1)
self.t2.resmodel[1].add_read_request(2)
self.t2.resmodel['serial I/O'].add_request(2)
self.t3.resmodel['serial I/O'].add_request(3)
for t in self.ts:
s.write_xml(s.task(t), self.f)
self.f.seek(0)
x = s.load(self.f)
self.assertIsInstance(x.resmodel, r.ResourceRequirements)
self.assertEqual(len(x.resmodel), len(t.resmodel))
self.assertEqual(x.resmodel.keys(), t.resmodel.keys())
for res_id in x.resmodel:
self.assertEqual(x.resmodel[res_id].max_reads,
t.resmodel[res_id].max_reads)
self.assertEqual(x.resmodel[res_id].max_writes,
t.resmodel[res_id].max_writes)
self.assertEqual(x.resmodel[res_id].max_requests,
t.resmodel[res_id].max_requests)
self.assertEqual(x.resmodel[res_id].max_read_length,
t.resmodel[res_id].max_read_length)
self.assertEqual(x.resmodel[res_id].max_write_length,
t.resmodel[res_id].max_write_length)
self.assertEqual(x.resmodel[res_id].max_length,
t.resmodel[res_id].max_length)
self.f.seek(0)
self.f.truncate()
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(1, 4),
tasks.SporadicTask(1, 5),
tasks.SporadicTask(3, 9),
tasks.SporadicTask(3, 18),
])
r.initialize_resource_model(self.ts)
def setUp(self):
self.ts = tasks.TaskSystem(
[tasks.SporadicTask(1, 4), tasks.SporadicTask(1, 5), tasks.SporadicTask(3, 9), tasks.SporadicTask(3, 18)]
)
r.initialize_resource_model(self.ts)
for i, t in enumerate(self.ts):
t.partition = 0
t.response_time = t.period
t.resmodel[1].add_request(1)
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(1, 4),
tasks.SporadicTask(1, 5),
tasks.SporadicTask(3, 9),
tasks.SporadicTask(3, 18),
])
r.initialize_resource_model(self.ts)
for i, t in enumerate(self.ts):
t.partition = 0
t.response_time = t.period
t.resmodel[1].add_request(1)
def setUp(self):
self.ts = tasks.TaskSystem(
[tasks.SporadicTask(1, 4), tasks.SporadicTask(1, 5), tasks.SporadicTask(3, 9), tasks.SporadicTask(3, 18)]
)
self.ts_ = self.ts.copy()
r.initialize_resource_model(self.ts)
for i, t in enumerate(self.ts):
t.partition = i % 2
t.response_time = t.period
t.resmodel[0].add_request(1)
t.resmodel[1].add_request(1)
lb.assign_fp_locking_prios(self.ts)
def generateTaskSetBase(taskPeriod, taskUtil, systemSize):
tg = tasks.TaskGenerator(taskPeriod, taskUtil)
ts = tg.make_task_set(max_tasks=systemSize)
ts = [t for t in ts if t.cost != 0]
" scale the parameters such that we always consider times in microseconds "
for i in range(0, len(ts)):
ts[i].id = i
ts[i].cost *= 1000
ts[i].period *= 1000
" initialize the resources in the model "
resources.initialize_resource_model(ts)
return ts
def generateTaskSetBase(self):
" let's clear previous data "
self._rs = {}
self._ts = []
" create a task set with the specified utilization "
self._ts = self._tg.make_task_set(max_util=self._ul, squeeze=True)
self._ts = [t for t in self._ts if t.cost != 0]
" scale the parameters (otherwise for low percentage we obtain always 1) "
for i in range(0, len(self._ts)):
self._ts[i].id = i
self._ts[i].cost *= SCALING_PARAM
self._ts[i].period *= SCALING_PARAM
" initialize the resources in the model "
resources.initialize_resource_model(self._ts)
def test_copy(self):
ts = m.TaskSystem([
m.SporadicTask(10, 100),
])
r.initialize_resource_model(ts)
ts[0].resmodel[0].add_request(10)
ts2 = ts.copy()
ts[0].resmodel[0].add_request(30)
self.assertEqual(ts[0].resmodel[0].max_length, 30)
self.assertEqual(ts[0].resmodel[0].max_requests, 2)
self.assertEqual(ts2[0].resmodel[0].max_length, 10)
self.assertEqual(ts2[0].resmodel[0].max_requests, 1)
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(1, 4),
tasks.SporadicTask(1, 5),
tasks.SporadicTask(3, 9),
tasks.SporadicTask(3, 18),
])
self.ts_ = self.ts.copy()
r.initialize_resource_model(self.ts)
for i, t in enumerate(self.ts):
t.partition = i % 2
t.response_time = t.period
t.resmodel[0].add_request(1)
t.resmodel[1].add_request(1)
lb.assign_fp_preemption_levels(self.ts)
def test_copy(self):
ts = m.TaskSystem([
m.SporadicTask(10, 100),
])
r.initialize_resource_model(ts)
ts[0].resmodel[0].add_request(10)
ts2 = ts.copy()
ts[0].resmodel[0].add_request(30)
self.assertEqual(ts[0].resmodel[0].max_length, 30)
self.assertEqual(ts[0].resmodel[0].max_requests, 2)
self.assertEqual(ts2[0].resmodel[0].max_length, 10)
self.assertEqual(ts2[0].resmodel[0].max_requests, 1)
def setUp(self):
mscale = 100
self.ts = tasks.TaskSystem([
tasks.SporadicTask(17 * mscale, 100 * mscale),
tasks.SporadicTask(67 * mscale, 340 * mscale),
tasks.SporadicTask(27 * mscale, 150 * mscale),
])
self.ts[0].partition = 0
self.ts[1].partition = 1
self.ts[2].partition = 0
self.ts.assign_ids()
r.initialize_resource_model(self.ts)
lb.assign_fp_preemption_levels(self.ts)
self.ts[0].resmodel[0].add_read_request(1 * mscale)
self.ts[1].resmodel[0].add_read_request(1 * mscale)
self.ts[2].resmodel[0].add_write_request(1 * mscale)
def generate_lock_taskset_files(util_name, period_name, cap, cslength, nres,
pacc, number):
generator = mkgen(NAMED_UTILIZATIONS[util_name],
NAMED_PERIODS[period_name])
generated_sets = []
for i in range(number):
taskset = generator(max_util=cap, time_conversion=ms2us)
resources.initialize_resource_model(taskset)
for task in taskset:
for res_id in range(nres):
if random.random() < pacc:
nreqs = random.randint(1, 5)
length = CSLENGTH[cslength]
for j in range(nreqs):
task.resmodel[res_id].add_request(length())
filename = "{0}_{1}_{2}_{3}_{4}_{5}_{6}".format(
util_name, period_name, cap, cslength, nres, pacc, i)
write(taskset, filename)
generated_sets.append(filename)
return generated_sets
def generate_lock_taskset_files(util_name, period_name, cap,
cslength, nres, pacc, number):
generator = mkgen(NAMED_UTILIZATIONS[util_name],
NAMED_PERIODS[period_name])
generated_sets = []
for i in range(number):
taskset = generator(max_util=cap, time_conversion=ms2us)
resources.initialize_resource_model(taskset)
for task in taskset:
for res_id in range(nres):
if random.random() < pacc:
nreqs = random.randint(1, 5)
length = CSLENGTH[cslength]
for j in range(nreqs):
task.resmodel[res_id].add_request(length())
filename = "{0}_{1}_{2}_{3}_{4}_{5}_{6}".format(
util_name, period_name, cap, cslength, nres, pacc,
i)
write(taskset, filename)
generated_sets.append(filename)
return generated_sets
def setUp(self):
mscale = 100
self.ts = tasks.TaskSystem([
tasks.SporadicTask( 17 * mscale, 100 * mscale),
tasks.SporadicTask( 64 * mscale, 132 * mscale),
tasks.SporadicTask( 67 * mscale, 340 * mscale),
tasks.SporadicTask( 74 * mscale, 137 * mscale),
tasks.SporadicTask( 31 * mscale, 249 * mscale),
tasks.SporadicTask( 47 * mscale, 115 * mscale),
tasks.SporadicTask( 27 * mscale, 150 * mscale),
tasks.SporadicTask( 53 * mscale, 424 * mscale),
tasks.SporadicTask(192 * mscale, 884 * mscale),
])
self.ts[0].partition = 0
self.ts[1].partition = 1
self.ts[2].partition = 2
self.ts[3].partition = 3
self.ts[4].partition = 4
self.ts[5].partition = 0
self.ts[6].partition = 0
self.ts[7].partition = 2
self.ts[8].partition = 4
self.ts.assign_ids()
r.initialize_resource_model(self.ts)
lb.assign_fp_preemption_levels(self.ts)
self.ts[0].resmodel[0].add_read_request(1 * mscale)
self.ts[1].resmodel[0].add_read_request(1 * mscale)
self.ts[2].resmodel[0].add_read_request(1 * mscale)
self.ts[3].resmodel[0].add_read_request(1 * mscale)
self.ts[4].resmodel[0].add_read_request(1 * mscale)
self.ts[6].resmodel[0].add_write_request(1 * mscale)
self.ts[7].resmodel[0].add_write_request(1 * mscale)
self.ts[8].resmodel[0].add_write_request(1 * mscale)
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(10000, 100000),
tasks.SporadicTask( 5000, 50000),
])
for t in self.ts:
t.wss = 0
res.initialize_resource_model(self.ts)
self.ts[0].resmodel[0].add_request(11)
self.ts[0].resmodel[0].add_request(7)
self.ts[1].resmodel[0].add_request(17)
self.ts[0].resmodel[1].add_read_request(11)
self.ts[0].resmodel[1].add_read_request(1)
self.ts[1].resmodel[1].add_read_request(17)
self.ts[0].resmodel[2].add_read_request(11)
self.ts[0].resmodel[2].add_read_request(1)
self.ts[1].resmodel[2].add_write_request(17)
self.ts[1].resmodel[2].add_write_request(1)
self.o = m.Overheads()
def setUp(self):
self.ts = tasks.TaskSystem([
tasks.SporadicTask(10000, 100000),
tasks.SporadicTask(5000, 50000),
])
for t in self.ts:
t.wss = 0
res.initialize_resource_model(self.ts)
self.ts[0].resmodel[0].add_request(11)
self.ts[0].resmodel[0].add_request(7)
self.ts[1].resmodel[0].add_request(17)
self.ts[0].resmodel[1].add_read_request(11)
self.ts[0].resmodel[1].add_read_request(1)
self.ts[1].resmodel[1].add_read_request(17)
self.ts[0].resmodel[2].add_read_request(11)
self.ts[0].resmodel[2].add_read_request(1)
self.ts[1].resmodel[2].add_write_request(17)
self.ts[1].resmodel[2].add_write_request(1)
self.o = m.Overheads()
def generate_taskset(num_cpus=4, util_per_cpu=0.5, tasks_per_cpu=3, req_prob=0.5,
min_req_len=50, max_req_len=250):
ts = emstada.gen_taskset('uni-broad', 'logunif', num_cpus * tasks_per_cpu,
num_cpus * util_per_cpu)
ts.sort_by_period()
ts.assign_ids()
r.initialize_resource_model(ts)
lb.assign_fp_preemption_levels(ts)
for t in ts:
# randomly partition
# t.partition = random.randint(0, num_cpus - 1)
# randomly assign requests
if random.random() < req_prob:
t.resmodel[0].add_write_request(random.randint(min_req_len, max_req_len))
bins = worst_fit_decreasing(ts, num_cpus, weight=lambda t: t.utilization())
for cpu, tasks in enumerate(bins):
for t in tasks:
t.partition = cpu
return ts
def test_serialize_resmodel(self):
r.initialize_resource_model(self.ts)
self.t1.resmodel[1].add_request(1)
self.t2.resmodel[1].add_read_request(2)
self.t2.resmodel['serial I/O'].add_request(2)
self.t3.resmodel['serial I/O'].add_request(3)
for t in self.ts:
s.write_xml(s.task(t), self.f)
self.f.seek(0)
x = s.load(self.f)
self.assertIsInstance(x.resmodel, r.ResourceRequirements)
self.assertEqual(len(x.resmodel), len(t.resmodel))
self.assertEqual(x.resmodel.keys(), t.resmodel.keys())
for res_id in x.resmodel:
self.assertEqual(x.resmodel[res_id].max_reads, t.resmodel[res_id].max_reads)
self.assertEqual(x.resmodel[res_id].max_writes, t.resmodel[res_id].max_writes)
self.assertEqual(x.resmodel[res_id].max_requests, t.resmodel[res_id].max_requests)
self.assertEqual(x.resmodel[res_id].max_read_length, t.resmodel[res_id].max_read_length)
self.assertEqual(x.resmodel[res_id].max_write_length, t.resmodel[res_id].max_write_length)
self.assertEqual(x.resmodel[res_id].max_length, t.resmodel[res_id].max_length)
self.f.seek(0)
self.f.truncate()
def setUp(self):
self.trivial_ts = tasks.TaskSystem([
tasks.SporadicTask(25, 150),
tasks.SporadicTask(30, 200),
tasks.SporadicTask(60, 800),
tasks.SporadicTask(30, 550),
tasks.SporadicTask(200, 1000),
tasks.SporadicTask(100, 825),
tasks.SporadicTask(50, 1100),
])
self.trivial_num_cpus = 2
r.initialize_resource_model(self.trivial_ts)
lb.assign_fp_preemption_levels(self.trivial_ts)
for i, t in enumerate(self.trivial_ts):
t.partition = 0
t.response_time = 4*t.cost
self.trivial_ts[0].resmodel[1].add_request(5)
self.trivial_ts[0].resmodel[1].add_request(5)
self.trivial_ts[0].resmodel[1].add_request(5)
self.trivial_ts[1].resmodel[2].add_request(10)
self.trivial_ts[1].resmodel[3].add_request(10)
self.trivial_ts[2].resmodel[1].add_request(10)
self.trivial_ts[2].resmodel[2].add_request(5)
self.trivial_ts[3].resmodel[1].add_request(15)
self.trivial_ts[4].resmodel[2].add_request(10)
self.trivial_ts[4].resmodel[3].add_request(10)
self.trivial_ts[4].resmodel[1].add_request(5)
self.trivial_ts[5].resmodel[4].add_request(8)
def setUp(self):
self.t1 = tasks.SporadicTask(10, 100)
self.t2 = tasks.SporadicTask(25, 200)
self.t3 = tasks.SporadicTask(33, 33)
self.ts = tasks.TaskSystem([self.t1, self.t2, self.t3])
self.ts.assign_ids()
lb.assign_fp_preemption_levels(self.ts)
for t in self.ts:
t.response_time = t.period
t.partition = t.id % 2
self.ts_no_req = self.ts.copy()
r.initialize_resource_model(self.ts)
r.initialize_resource_model(self.ts_no_req)
self.t1.resmodel[0].add_request(1)
self.t2.resmodel[0].add_request(2)
self.t3.resmodel[0].add_request(3)
# only one resource, assigned to the first processor
self.resource_locality = { 0: 0 }
def example():
from schedcat.util.linprog import LinearProgram
from schedcat.model.tasks import SporadicTask, TaskSystem
from schedcat.model.resources import initialize_resource_model
import schedcat.util.linprog
t1 = SporadicTask(10, 100)
t2 = SporadicTask(25, 200)
t3 = SporadicTask(33, 33)
ts = TaskSystem([t1, t2, t3])
ts.assign_ids()
initialize_resource_model(ts)
t1.resmodel[0].add_request(1)
t2.resmodel[0].add_request(2)
t3.resmodel[0].add_request(3)
for t in ts:
t.response_time = t.period
t.partition = t.id % 2
# only one resource, assigned to the first processor
resource_locality = { 0: 0 }
lp = LinearProgram()
# Configure blocking objective.
set_blocking_objective(resource_locality, ts, t1, lp)
print(lp)
print(('*' * 80))
print('Adding mutex constraints:')
add_var_mutex_constraints(ts, t1, lp)
print(lp)
print(('*' * 80))
print('Adding toplogy constraints:')
add_topology_constraints(resource_locality, ts, t1, lp)
print(lp)
from .dflp import get_lp_for_task as get_dflp_lp
from .dpcp import get_lp_for_task as get_dpcp_lp
print(('*' * 80))
print('DFLP LP:')
lp = get_dflp_lp(resource_locality, ts, t1)
print(lp)
lp.kill_non_positive_vars()
print('DFLP LP (simplified)')
print(lp)
if schedcat.util.linprog.cplex_available:
sol = lp.solve()
print(('Solution: local=%d remote=%d' % \
(sol.evaluate(lp.local_objective), sol.evaluate(lp.remote_objective))))
for x in sol:
print((x, '->', sol[x]))
print(('*' * 80))
print('DPCP LP:')
lp = get_dpcp_lp(resource_locality, ts, t1)
print(lp)
lp.kill_non_positive_vars()
print('DPCP LP (simplified)')
print(lp)
if schedcat.util.linprog.cplex_available:
sol = lp.solve()
print(('Solution: local=%d remote=%d' % \
(sol.evaluate(lp.local_objective), sol.evaluate(lp.remote_objective))))
for x in sol:
print((x, '->', sol[x]))
