def spp_test():
# init pycpa and trigger command line parsing
options.init_pycpa()
# generate an new system
s = model.System()
# add two resources (CPUs) to the system
# and register the static priority preemptive scheduler
r1 = s.bind_resource(model.Resource("R1", schedulers.SPPScheduler()))
r2 = s.bind_resource(model.Resource("R2", schedulers.SPPScheduler()))
# create and bind tasks to r1
t11 = r1.bind_task(
model.Task("T11", wcet=10, bcet=5, scheduling_parameter=1))
t12 = r1.bind_task(
model.Task("T12", wcet=3, bcet=1, scheduling_parameter=2))
# create and bind tasks to r2
t21 = r2.bind_task(
model.Task("T21", wcet=2, bcet=2, scheduling_parameter=1))
t22 = r2.bind_task(
model.Task("T22", wcet=9, bcet=4, scheduling_parameter=2))
# specify precedence constraints: T11 -> T21; T12-> T22
t11.link_dependent_task(t21)
t12.link_dependent_task(t22)
# register a periodic with jitter event model for T11 and T12
t11.in_event_model = model.PJdEventModel(P=30, J=5)
t12.in_event_model = model.PJdEventModel(P=15, J=6)
# plot the system graph to visualize the architecture
g = graph.graph_system(s, 'spp_graph.pdf', dotout='spp_graph.dot')
# perform the analysis
print("Performing analysis")
task_results = analysis.analyze_system(s)
# print the worst case response times (WCRTs)
print("Result:")
for r in sorted(s.resources, key=str):
for t in sorted(r.tasks, key=str):
print("%s: wcrt=%d" % (t.name, task_results[t].wcrt))
print(" b_wcrt=%s" % (task_results[t].b_wcrt_str()))
expected_wcrt = dict()
expected_wcrt[t11] = 10
expected_wcrt[t12] = 13
expected_wcrt[t21] = 2
expected_wcrt[t22] = 19
for t in expected_wcrt.keys():
assert (expected_wcrt[t] == task_results[t].wcrt)
def constraints_example():
options.init_pycpa()
# generate an new system
s = model.System()
# add two resources (CPUs) to the system
# and register the static priority preemptive scheduler
r1 = s.bind_resource(model.Resource("R1", schedulers.SPPScheduler()))
r2 = s.bind_resource(model.Resource("R2", schedulers.SPPScheduler()))
# create and bind tasks to r1
t11 = r1.bind_task(
model.Task("T11", wcet=10, bcet=5, scheduling_parameter=1))
t12 = r1.bind_task(
model.Task("T12", wcet=3, bcet=1, scheduling_parameter=2))
# create and bind tasks to r2
t21 = r2.bind_task(
model.Task("T21", wcet=2, bcet=2, scheduling_parameter=1))
t22 = r2.bind_task(
model.Task("T22", wcet=9, bcet=4, scheduling_parameter=2))
# specify precedence constraints: T11 -> T21; T12-> T22
t11.link_dependent_task(t21)
t12.link_dependent_task(t22)
# register a periodic with jitter event model for T11 and T12
t11.in_event_model = model.PJdEventModel(P=30, J=5)
t12.in_event_model = model.PJdEventModel(P=15, J=6)
p1 = model.Path("myPath", [t11, t21])
s.bind_path(p1)
# deliberately overconstrain the system
s.constraints.add_path_constraint(p1, 5, n=2)
s.constraints.add_wcrt_constraint(t11, 1)
s.constraints.add_load_constraint(r1, 0.5)
s.constraints.add_backlog_constraint(t11, 1)
# perform the analysis
print("Performing analysis")
task_results = analysis.analyze_system(s)
# print the worst case response times (WCRTs)
print("Result:")
for r in sorted(s.resources, key=str):
for t in sorted(r.tasks, key=str):
print("%s: wcrt=%d" % (t.name, task_results[t].wcrt))
def xmlrpc_assign_pjd_event_model(self, task_id, period, jitter, min_dist):
""" Create an eventmodel and assign it to task.
:param task_id: ID of the task
:type task_id: string
:param period: Period (in unit time)
:type period: integer
:param jitter: Jitter (in unit time)
:type jitter: integer
:param min_dist: Minimum distance between events (in unit time)
:type min_dist: integer
:returns: 0
"""
task = self._obj_from_id(task_id, model.Task)
em = None
try:
em = model.PJdEventModel(int(period), int(jitter), int(min_dist))
except ValueError:
raise xmlrpc.Fault(INVALID_EVENT_MODEL_DESC,
"invalid event model parametrization")
task.in_event_model = em
# casting to int in debug output so that it matches what our code
# actually does to the input
logger.debug("{}assign_pjd_event_model({}, {}, {}, {})".format(
self.debug_prefix, task_id, int(period), int(jitter),
int(min_dist)))
return 0
def e2e_test(expected_wclat):
options.init_pycpa()
# generate an new system
s = model.System()
# add a resource to the system
# register round robin scheduler
r1 = s.bind_resource(model.Resource("R1",
schedulers.RoundRobinScheduler()))
# map two tasks to
t11 = r1.bind_task(model.Task("T11", wcet=1, bcet=1))
t12 = r1.bind_task(model.Task("T12", wcet=2, bcet=1))
# register precedence constraint
t11.link_dependent_task(t12)
t11.in_event_model = model.PJdEventModel(P=4, J=3)
# register a task chain as a stream
s1 = s.bind_path(model.Path("S1", [t11, t12]))
# perform a system analysis
print("analyzing")
task_results = analysis.analyze_system(s)
# calculate the latency for the first 10 events
for n in range(1, 11):
best_case_latency, worst_case_latency = path_analysis.end_to_end_latency(
s1, task_results, n)
print("stream S1 e2e latency. best case: %d, worst case: %d" %
(best_case_latency, worst_case_latency))
assert (worst_case_latency == expected_wclat[n - 1])
def test_spp():
# generate an new system
s = model.System()
# add two resources (CPUs) to the system
# and register the static priority preemptive scheduler
r1 = s.bind_resource(model.Resource("R1", schedulers.SPPScheduler()))
r2 = s.bind_resource(model.Resource("R2", schedulers.SPPScheduler()))
# create and bind tasks to r1
t11 = r1.bind_task(
model.Task("T11", wcet=10, bcet=5, scheduling_parameter=1))
t12 = r1.bind_task(
model.Task("T12", wcet=3, bcet=1, scheduling_parameter=2))
# create and bind tasks to r2
t21 = r2.bind_task(
model.Task("T21", wcet=2, bcet=2, scheduling_parameter=1))
t22 = r2.bind_task(
model.Task("T22", wcet=9, bcet=4, scheduling_parameter=2))
# specify precedence constraints: T11 -> T21; T12-> T22
t11.link_dependent_task(t21)
t12.link_dependent_task(t22)
# register a periodic with jitter event model for T11 and T12
t11.in_event_model = model.PJdEventModel(P=30, J=5)
t12.in_event_model = model.PJdEventModel(P=15, J=6)
# perform the analysis
task_results = analysis.analyze_system(s)
# print the worst case response times (WCRTs)
busy_times_t11 = [0, 10]
busy_times_t12 = [0, 13, 16]
busy_times_t21 = [0, 2]
busy_times_t22 = [0, 11, 20, 31, 40]
assert task_results[t11].busy_times == busy_times_t11
assert task_results[t12].busy_times == busy_times_t12
assert task_results[t21].busy_times == busy_times_t21
assert task_results[t22].busy_times == busy_times_t22
assert task_results[t11].wcrt == 10
assert task_results[t12].wcrt == 13
assert task_results[t21].wcrt == 2
assert task_results[t22].wcrt == 19
def sampling_test(wclat_results):
options.init_pycpa()
# generate an new system
s = model.System()
# add two resources to the system
# register two schedulers
r1 = s.bind_resource(model.Resource("R1", schedulers.SPPScheduler()))
# add a task
t11 = r1.bind_task(model.Task(name="T11", wcet=3, bcet=1, scheduling_parameter=1))
# register input event model
t11.in_event_model = model.PJdEventModel(P=30, J=15)
# add three more tasks, these will be triggered by other tasks
t12 = r1.bind_task(model.Task(name="T12", wcet=3, bcet=2, scheduling_parameter=2))
# add a sampling junction
j1 = s.bind_junction(model.Junction(name="J1", strategy=junctions.SampledInput()))
j1.strategy.set_trigger_event_model(model.PJdEventModel(P=50, J=0))
# register a task chain as a stream: t11->j1->t12
s1 = s.bind_path(model.Path("S1", [t11, j1, t12]))
# graph the system
graph.graph_system(s, "sampling_example.pdf")
# analyze the system
print("Performing analysis")
results = analysis.analyze_system(s)
# print the results
print("Result:")
for r in sorted(s.resources, key=str):
print "load on resource %s: %0.2f" % (r.name, r.load())
for t in sorted(r.tasks, key=str):
print " task %s - wcrt: %d" % (t.name, results[t].wcrt)
# calculate the latency for the first 10 events
for n in range(1, 11):
best_case_latency, worst_case_latency = path_analysis.end_to_end_latency(s1, results, n)
print("stream S1 e2e latency. best case: %d, worst case: %d" % (best_case_latency, worst_case_latency))
assert(worst_case_latency == wclat_results[n-1])
def profiling_test():
options.init_pycpa()
# generate an new system
s = model.System()
# add two resources (CPUs) to the system
# and register the static priority preemptive scheduler
r1 = s.bind_resource(model.Resource("R1", schedulers.SPPScheduler()))
r2 = s.bind_resource(model.Resource("R2", schedulers.SPPScheduler()))
# create and bind tasks to r1
t11 = r1.bind_task(
model.Task("T11", wcet=10, bcet=5, scheduling_parameter=1))
t12 = r1.bind_task(
model.Task("T12", wcet=3, bcet=1, scheduling_parameter=2))
# create and bind tasks to r2
t21 = r2.bind_task(
model.Task("T21", wcet=2, bcet=2, scheduling_parameter=1))
t22 = r2.bind_task(
model.Task("T22", wcet=9, bcet=4, scheduling_parameter=2))
# specify precedence constraints: T11 -> T21; T12-> T22
t11.link_dependent_task(t21)
t12.link_dependent_task(t22)
# register a periodic with jitter event model for T11 and T12
t11.in_event_model = model.PJdEventModel(P=30, J=5)
t12.in_event_model = model.PJdEventModel(P=15, J=6)
filename = "profiling_example.prof"
prof = hotshot.Profile(filename)
prof.runcall(analysis.analyze_system, s)
prof.close()
stats = hotshot.stats.load(filename)
stats.strip_dirs()
stats.sort_stats('time', 'calls')
stats.print_stats(20)
def test_eta_to_delta_min(self):
# create some standard event model
em_a = model.PJdEventModel(P=10, J=99)
em_b = model.EventModel()
em_b.deltamin_func = model.EventModel.delta_min_from_eta_plus(
em_a.eta_plus)
em_b.deltaplus_func = model.EventModel.delta_plus_from_eta_min(
em_a.eta_min)
seq = range(0, 100, 1)
self.assertEqual([em_b.delta_min(n) for n in seq],
[em_a.delta_min(n) for n in seq])
self.assertEqual([em_b.delta_plus(n) for n in seq],
[em_a.delta_plus(n) for n in seq])
def gantt_test():
# initialyze pycpa. (e.g. read command line switches and set up default options)
options.init_pycpa()
# generate an new system
s = model.System()
# instantiate a resource
r1 = s.bind_resource(model.Resource("R1", schedulers.SPPScheduler()))
# create and bind tasks to r1
t11 = r1.bind_task(
model.Task("T11", wcet=5, bcet=5, scheduling_parameter=1))
t12 = r1.bind_task(
model.Task("T12", wcet=9, bcet=1, scheduling_parameter=2))
# connect communicating tasks: T11 -> T12
t11.link_dependent_task(t12)
# register a PJd event model
t11.in_event_model = model.PJdEventModel(P=30, J=60)
# perform the analysis
print("Performing analysis")
results = analysis.analyze_system(s)
# print the worst case response times (WCRTs)
print("Result:")
for r in sorted(s.resources, key=str):
for t in sorted(r.tasks, key=str):
print("%s: wcrt=%d" % (t.name, results[t].wcrt))
simmodel = simulation.ResourceModel(r1)
simmodel.runModel(task=t12,
scheduler=simulation.SimSPP(name="SPP", sim=simmodel))
# plot
hp_tasks = list()
for t in sorted(r1.tasks, key=str):
if t.scheduling_parameter <= t12.scheduling_parameter:
hp_tasks.append(t)
plot.plot_gantt(hp_tasks,
results,
height=2. / 3,
bar_linewidth=2,
min_dist_arrows=1,
arrow_head_width=1,
task=t12,
show=options.get_opt('show'),
file_name='gantt.pdf')
class TestArrivalCurveSteps(unittest.TestCase):
models = [
model.PJdEventModel(P=20, J=5, dmin=1),
model.PJdEventModel(P=100, J=400, dmin=2),
model.PJdEventModel(P=20, J=30, dmin=20),
model.CTEventModel(c=5, T=10),
model.CTEventModel(c=5, T=5, dmin=3)
]
def bruteforce_model_test(self, m):
"Check that the bruteforce arrive_curve_steps predicts the first 100 steps of the arrival curve correctly"
steps = list(
itertools.islice(ros.arrival_curve_steps(m, optimized=False), 100))
eta = [m.eta_plus(i) for i in range(steps[-1] + 1)]
self.assertIn(0, steps)
for i in range(1, len(eta)):
if i in steps:
self.assertNotEqual(eta[i - 1], eta[i])
else:
self.assertEqual(eta[i - 1], eta[i])
def specialized_model_test(self, m):
specialized = itertools.islice(ros.arrival_curve_steps(m), 100)
forced = itertools.islice(ros.arrival_curve_steps(m, optimized=False),
100)
for s, f in zip(specialized, forced):
self.assertEqual(s, f)
def test_bruteforce(self):
for m in self.models:
with self.subTest(m=m):
self.bruteforce_model_test(m)
def test_specialization(self):
for m in self.models:
with self.subTest(m=m):
self.specialized_model_test(m)
def tdma_test():
options.init_pycpa()
s = model.System()
r1 = s.bind_resource(model.Resource("R1", schedulers.TDMAScheduler()))
r2 = s.bind_resource(model.Resource("R2", schedulers.TDMAScheduler()))
# scheduling_parameter denotes the slotsize
t11 = r1.bind_task(
model.Task("T11", wcet=10, bcet=5, scheduling_parameter=2))
t12 = r1.bind_task(
model.Task("T12", wcet=3, bcet=1, scheduling_parameter=2))
t21 = r2.bind_task(
model.Task("T21", wcet=2, bcet=2, scheduling_parameter=2))
t22 = r2.bind_task(
model.Task("T22", wcet=3, bcet=3, scheduling_parameter=2))
t11.link_dependent_task(t21)
t12.link_dependent_task(t22)
t11.in_event_model = model.PJdEventModel()
t11.in_event_model.set_PJd(30, 5)
t12.in_event_model = model.PJdEventModel()
t12.in_event_model.set_PJd(15, 6)
g = graph.graph_system(s, 'tdma_graph.pdf')
print("Performing analysis")
results = analysis.analyze_system(s)
print("Result:")
for r in sorted(s.resources, key=str):
for t in sorted(r.tasks, key=str):
print str(t), " - ", results[t].wcrt
print " ", results[t].b_wcrt_str()
def __init__(self, num_reservations, period=Hz(12.5), **kwargs):
super().__init__(num_reservations,
name='move_base.time-driven{}'.format(num_reservations), **kwargs)
# Prioritize the timers from source to destination. We want the source tasks to run first, so
# the data can flow through the entire path in a single period.
# We prioritize the local planner higher than the global planner components
callbacks_ = [
Callback('sensor2mem', CBType.SUBSCRIBER, 0, wcet=wcets['sensor2mem']),
Callback('goal2mem', CBType.SUBSCRIBER, 0, wcet=wcets['sensor2mem']),
Callback('local_costmap', CBType.TIMER, 4, wcet=wcets['local_costmap']),
Callback('global_costmap', CBType.TIMER, 1, wcet=wcets['global_costmap']),
Callback('local_planner', CBType.TIMER, 3, wcet=wcets['local_planner']),
Callback('global_planner', CBType.TIMER, 5, wcet=wcets['global_planner']),
Callback('pose_estimator', CBType.TIMER, 2, wcet=wcets['pose_estimator'])]
self.register_callbacks(callbacks_)
self.link(['/scan', '/tF', '/odom'], 'sensor2mem')
self.link('/goal', 'goal2mem')
self.link('local_planner', '/cmd_vel')
self.callbacks['local_costmap'].in_event_model = model.PJdEventModel(P=period, J=0)
self.callbacks['local_planner'].in_event_model = model.PJdEventModel(P=period, J=0)
self.callbacks['pose_estimator'].in_event_model = model.PJdEventModel(P=period, J=0)
self.callbacks['global_costmap'].in_event_model = model.PJdEventModel(P=period, J=0)
self.callbacks['global_planner'].in_event_model = model.PJdEventModel(P=Hz(1), J=0)
if num_reservations == 1:
self.res_bind(self.reservations[0], callbacks_)
elif num_reservations == 2:
self.res_bind(self.reservations[0],
['local_costmap', 'local_planner', 'pose_estimator', 'sensor2mem'])
self.res_bind(self.reservations[1],
['global_costmap', 'global_planner', 'goal2mem'])
else:
raise ValueError("Unsupported reservation count: %s", num_reservations)
assert all([cb.resource for cb in self.callbacks.values()])
def simple_test():
# initialyze pycpa. (e.g. read command line switches and set up default options)
options.init_pycpa()
# generate an new system
s = model.System()
# instantiate a resource
r1 = s.bind_resource(model.Resource("R1", schedulers.SPPScheduler()))
# create and bind tasks to r1
t11 = r1.bind_task(
model.Task("T11", wcet=5, bcet=5, scheduling_parameter=1))
t12 = r1.bind_task(
model.Task("T12", wcet=9, bcet=1, scheduling_parameter=2))
# connect communicating tasks: T11 -> T12
t11.link_dependent_task(t12)
# register a PJd event model
t11.in_event_model = model.PJdEventModel(P=30, J=60)
# create a path
p1 = model.Path("P1", [t11, t12])
# add constraints to task t11
s.constraints.add_backlog_constraint(t11, 5)
# add constraints to task t12
s.constraints.add_wcrt_constraint(t12, 90)
try:
# plot the system graph to visualize the architecture
g = graph.graph_system(s, 'simple_graph.pdf')
except Exception:
# gracefully pass for machines without matplotlib
pass
# perform the analysis
print("Performing analysis")
results = analysis.analyze_system(s)
# print the worst case response times (WCRTs)
print("Result:")
for r in sorted(s.resources, key=str):
for t in sorted(r.tasks, key=str):
print("%s: wcrt=%d" % (t.name, results[t].wcrt))
bcl, wcl = path_analysis.end_to_end_latency(p1, results, 2)
print "bcl: %d, wcl: %d" % (bcl, wcl)
def test_delta_min_PJd(self):
delta_reference = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 11, 21, 31, 41, 51, 61, 71, 81,
91, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 201, 211,
221, 231, 241, 251, 261, 271, 281, 291, 301, 311, 321, 331, 341,
351, 361, 371, 381, 391, 401, 411, 421, 431, 441, 451, 461, 471,
481, 491, 501, 511, 521, 531, 541, 551, 561, 571, 581, 591, 601,
611, 621, 631, 641, 651, 661, 671, 681, 691, 701, 711, 721, 731,
741, 751, 761, 771, 781, 791, 801, 811, 821, 831, 841, 851, 861,
871, 881
]
em = model.PJdEventModel(P=10, J=99)
self.assertEqual(delta_reference,
[em.delta_min(n) for n in range(0, 100, 1)])
def _run_test(scheduler, priorities):
# generate an new system
s = model.System()
# add two resources (CPUs) to the system
# and register the static priority preemptive scheduler
r1 = s.bind_resource(model.Resource("R1", scheduler))
# create and bind tasks to r1
t11 = r1.bind_task(
model.Task("T11", wcet=10, bcet=1, scheduling_parameter=priorities[0]))
t21 = r1.bind_task(
model.Task("T21", wcet=2, bcet=2, scheduling_parameter=priorities[1]))
t31 = r1.bind_task(
model.Task("T31", wcet=4, bcet=2, scheduling_parameter=priorities[2]))
# specify precedence constraints: T11 -> T21 -> T31
t11.link_dependent_task(t21)
t21.link_dependent_task(t31)
# register a periodic with jitter event model for T11
t11.in_event_model = model.PJdEventModel(P=20, J=5)
# perform the analysis
print("Performing analysis")
task_results = analysis.analyze_system(s)
failed = False
for t in r1.tasks:
for n in range(1, 11):
if t.in_event_model.delta_min(n) != t.in_event_model.deltamin_func(
n):
failed = True
print("%s: cached EM of != uncached EM" % (t.name))
print("delta_min(%d) = %d != %d" %
(n, t.in_event_model.delta_min(n),
t.in_event_model.deltamin_func(n)))
print("for priorities = %s" % str(priorities))
break
return not failed
def __init__(self, num_reservations, **kwargs):
super().__init__(num_reservations,
name='move_base.driver-event.{}'.format(num_reservations), **kwargs)
# Since there is only one timer, the priorities don't matter. We just keep them different
callbacks_ = [
Callback('sensor2mem', CBType.SUBSCRIBER, 0, wcet=wcets['sensor2mem']),
Callback('local_costmap', CBType.SUBSCRIBER, 4, wcet=wcets['local_costmap']),
Callback('global_costmap', CBType.SUBSCRIBER, 5, wcet=wcets['global_costmap']),
Callback('local_planner', CBType.SUBSCRIBER, 6, wcet=wcets['local_planner']),
Callback('global_planner_goalset', CBType.SUBSCRIBER, 7, wcet=wcets['global_planner']),
Callback('global_planner_timed', CBType.TIMER, 8, wcet=wcets['global_planner']),
Callback('pose_estimator', CBType.SUBSCRIBER, 10, wcet=wcets['pose_estimator'])]
self.register_callbacks(callbacks_)
self.callbacks['global_planner_timed'].in_event_model = model.PJdEventModel(P=Hz(1), J=0)
link = self.link
link(['/scan', '/tF'], 'sensor2mem')
link('pose_estimator', ['local_costmap', 'global_costmap'])
link('local_costmap', 'local_planner')
link('local_planner', '/cmd_vel')
link('/odom', 'pose_estimator')
link('/goal', 'global_planner_goalset')
if num_reservations == 1:
self.res_bind(self.reservations[0], callbacks_)
elif num_reservations == 2:
self.res_bind(self.reservations[0],
['local_costmap', 'local_planner', 'pose_estimator', 'sensor2mem'])
self.res_bind(self.reservations[1],
['global_costmap', 'global_planner_timed', 'global_planner_goalset'])
else:
raise ValueError(
"Unsupported reservation count: %s", num_reservations)
assert all([cb.resource for cb in self.callbacks.values()])
def time_bases_test(auto=True):
# print the welcome message
options.init_pycpa()
# generate an new system
s = model.System()
# add two resources (CPUs) to the system
# and register the static priority preemptive scheduler
r1 = s.bind_resource(
model.Resource("R1", schedulers.SPPScheduler(), frequency=333333333))
r2 = s.bind_resource(
model.Resource("R2", schedulers.SPPScheduler(), frequency=100000000))
# get a common time-base
common_time_base = util.ns
if auto == True:
common_time_base = util.calculate_base_time(
[r.frequency for r in s.resources])
print "Basetime is %d Hz" % common_time_base
# create and bind tasks to r1. Here the timing is specified in absolute time (i.e. 10 ms)
t11 = r1.bind_task(
model.Task("T11",
wcet=util.time_to_time(10, util.ms, common_time_base,
'ceil'),
bcet=util.time_to_time(5, util.ms, common_time_base,
'floor'),
scheduling_parameter=1))
t12 = r1.bind_task(
model.Task("T12",
wcet=util.time_to_time(3, util.ms, common_time_base,
'ceil'),
bcet=util.time_to_time(1, util.ms, common_time_base,
'floor'),
scheduling_parameter=2))
# create and bind tasks to r2. Here the timing is specified in cycle time (i.e. 10000 cycles)
t21 = r2.bind_task(
model.Task("T21",
wcet=util.cycles_to_time(200000, r2.frequency,
common_time_base, 'ceil'),
bcet=util.cycles_to_time(200000, r2.frequency,
common_time_base, 'floor'),
scheduling_parameter=1))
t22 = r2.bind_task(
model.Task("T22",
wcet=util.cycles_to_time(900000, r2.frequency,
common_time_base, 'ceil'),
bcet=util.cycles_to_time(400000, r2.frequency,
common_time_base, 'floor'),
scheduling_parameter=2))
# specify precedence constraints: T11 -> T21; T12-> T22
t11.link_dependent_task(t21)
t12.link_dependent_task(t22)
# register a periodic with jitter event model for T11 and T12
t11.in_event_model = model.PJdEventModel(
P=util.time_to_time(30, util.ms, common_time_base, 'floor'),
J=util.time_to_time(5, util.ms, common_time_base, 'ceil'))
t12.in_event_model = model.PJdEventModel(
P=util.time_to_time(15, util.ms, common_time_base, 'floor'),
J=util.time_to_time(6, util.ms, common_time_base, 'ceil'))
# perform the analysis
print("Performing analysis")
task_results = analysis.analyze_system(s)
# print the worst case response times (WCRTs)
print("Result:")
for r in sorted(s.resources, key=str):
for t in sorted(r.tasks, key=str):
wcrt_ms = util.time_to_time(task_results[t].wcrt, common_time_base,
util.ms, 'ceil')
print("%s: wcrt=%d ms" % (t.name, wcrt_ms))
try:
import matplotlib
matplotlib.use('Agg')
except ImportError:
print "matplotlib not available"
exit(0)
from pycpa import model
from pycpa import plot
# only type 1 fonts
matplotlib.rcParams['ps.useafm'] = True
matplotlib.rcParams['pdf.use14corefonts'] = True
matplotlib.rcParams['text.usetex'] = True
P = 30
J = 60 # 5
d = 0 # 1
em = model.PJdEventModel(P=P, J=J, dmin=d)
print "delta_min(0) =", em.delta_min(0)
print "eta_plus(0) =", em.eta_plus(0)
print "eta_plus(eps) =", em.eta_plus(1e-12)
plot.plot_event_model(em,
7,
separate_plots=False,
file_format='pdf',
file_prefix='event-model-',
ticks_at_steps=True)
def jittered_models(J):
return {'/scan': model.PJdEventModel(P=Hz(12.5), J=J),
'/tF': model.PJdEventModel(P=Hz(12.5), J=J),
'/odom': model.PJdEventModel(P=Hz(12.5), J=J)}
class PBurstModel (model.PJdEventModel):
def __init__(self, P, burstlen, dmin, name='min', **kwargs):
J = burstlen * P
super().__init__(P, J, dmin, name=name, **kwargs)
wcets = {'local_costmap': mseconds(5),
'global_costmap': mseconds(10),
'local_planner': mseconds(18),
'global_planner': mseconds(200),
'goal_setter': min_jitter,
'pose_estimator': mseconds(6),
'sensor2mem': min_jitter}
input_topics = [('/scan', model.PJdEventModel(P=Hz(12.5), J=min_jitter)),
('/tF', model.PJdEventModel(P=Hz(12.5), J=min_jitter)),
('/odom', model.PJdEventModel(P=Hz(12.5), J=min_jitter)),
('/goal', PBurstModel(P=Hz(0.1), burstlen=0, dmin=mseconds(100)))]
class MoveBase(model.System):
"""The common parts of the move_base system model"""
# Global dictionary of callback names -> callbacks
callbacks = dict()
reservations = []
def __init__(self, num_reservations, *args, override_model={}, **kwargs):
super().__init__(*args, **kwargs)
for name, events in input_topics:
if name in override_model:
