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 split_task_C_equal_D(t, wcet_part_one, split_callback):
t1 = SporadicTask(wcet_part_one, t.period, deadline=wcet_part_one, id=t.id)
t2 = SporadicTask(t.cost - wcet_part_one, t.period,
deadline=t.deadline - wcet_part_one, id=t.id)
t2.affinity = set(t.affinity)
if split_callback:
split_callback(t, t1, t2)
return (t1, t2)
def split_task_C_equal_D(t, wcet_part_one, split_callback):
t1 = SporadicTask(wcet_part_one, t.period, deadline=wcet_part_one, id=t.id)
t2 = SporadicTask(t.cost - wcet_part_one,
t.period,
deadline=t.deadline - wcet_part_one,
id=t.id)
t2.affinity = set(t.affinity)
if split_callback:
split_callback(t, t1, t2)
return (t1, t2)
def gen_taskset(periods, period_distribution, tasks_n, utilization,
period_granularity=None, scale=ms2us, want_integral=True):
if periods in NAMED_PERIODS:
# Look up by name.
(period_min, period_max) = NAMED_PERIODS[periods]
else:
# If unknown, then assume caller specified range manually.
(period_min, period_max) = periods
x = StaffordRandFixedSum(tasks_n, utilization, 1)
if period_granularity is None:
period_granularity = period_min
periods = gen_periods(tasks_n, 1, period_min, period_max, period_granularity, period_distribution)
ts = TaskSystem()
periods = numpy.maximum(periods[0], max(period_min, period_granularity))
C = scale(x[0] * periods)
taskset = numpy.c_[x[0], C / periods, periods, C]
for t in range(numpy.size(taskset,0)):
ts.append(SporadicTask(taskset[t][3], scale(taskset[t][2])))
if want_integral:
quantize_params(ts)
return ts
def __init__(self, length, period, deadline=None, id=None, tid=None):
"""The structure of a CANMessage is almost similar to SporadicTask,
except that a CAN message does not have a WCET (cost), but rather the
payload size. We use the same field 'cost' o store the payload size.
CANMessage also has a 'tid' field. The 'id' is unique per message, but
the 'tid' field remains same for message replicas.
"""
SporadicTask.__init__(self, length, period, deadline, id)
self.tid = tid
self.transfer_delay = None
self.jitter = 0
self.max_framesize = 44 + (8 * length)
self.max_framesize += math.floor((33 + (8 * length)) / 4.0)
self.max_framesize = int(self.max_framesize)
self.critical = False
def __init__(self, length, period, deadline=None, id=None, tid=None):
"""The structure of a CANMessage is almost similar to SporadicTask,
except that a CAN message does not have a WCET (cost), but rather the
payload size. We use the same field 'cost' o store the payload size.
CANMessage also has a 'tid' field. The 'id' is unique per message, but
the 'tid' field remains same for message replicas.
"""
SporadicTask.__init__(self, length, period, deadline, id)
self.tid = tid
self.transfer_delay = None
self.jitter = 0
self.max_framesize = 44 + (8 * length)
self.max_framesize += math.floor((33 + (8 * length)) / 4.0)
self.max_framesize = int(self.max_framesize)
self.critical = False
def charge_scheduling_overheads(oheads, num_cpus, dedicated_irq, taskset):
if not oheads or not taskset:
return TaskSystem(taskset)
event_latency = oheads.release_latency(taskset)
# pseudo-task representing the tick interrupt
tck = oheads.tick(taskset)
if tck > 0:
tick_isr = SporadicTask(tck, oheads.quantum_length)
tick_isr.jitter = event_latency
tick_tasks = [tick_isr]
else:
tick_tasks = []
# pseudo-tasks representing release interrupts
rel_cost = oheads.release(taskset)
if not dedicated_irq and rel_cost > 0:
release_tasks = [SporadicTask(rel_cost, t.period) for t in taskset]
for isr in release_tasks:
isr.jitter = event_latency
else:
release_tasks = [] # releases don't impact tasks directly
# account for initial release delay as jitter
release_delay = event_latency + oheads.release(taskset)
if dedicated_irq:
release_delay += oheads.ipi_latency(taskset)
for t in taskset:
if not 'jitter' in t.__dict__:
t.jitter = 0
t.jitter += release_delay
# account for scheduling cost and CPMD
sched = oheads.schedule(taskset)
cxs = oheads.ctx_switch(taskset)
cpmd = oheads.cache_affinity_loss(taskset)
preemption = 2 * (sched + cxs) + cpmd
for t in taskset:
t.cost += preemption
return TaskSystem(tick_tasks + release_tasks + taskset)
def _from_file(self, file_name):
with open(file_name, 'r') as f:
data = f.read().strip()
try:
schedule = eval(data)
except:
schedule = run_exps.convert_data(data)
ts = []
for task_conf in schedule['task']:
(task, args) = (task_conf[0], task_conf[1])
real_args = args.split()
index = 0
if '-S' in real_args:
index = real_args.index('-S') + 2
ts.append(SporadicTask(int(real_args[index + 0]), int(real_args[index + 1])))
return ts
def gen_tasksets(options):
x = StaffordRandFixedSum(options.n, options.util, 1)
periods = gen_periods(options.n, 1, options.permin, options.permax, options.pergran, options.perdist)
ts = TaskSystem()
C = x[0] * periods[0]
if options.round_C:
C = numpy.round(C, decimals=0)
elif options.floor_C:
C = numpy.floor(C)
taskset = numpy.c_[x[0], C / periods[0], periods[0], C]
for t in range(numpy.size(taskset,0)):
ts.append(SporadicTask(taskset[t][3], taskset[t][2]))
# print ts
return ts
