def smff_test(filename, outfile, plot, verbose): options.init_pycpa() print "loading", filename loader = smff_loader.SMFFLoader() s = loader.parse(filename) if plot == True: # graph the smff system graph_file = string.replace(os.path.basename(filename), ".xml", "") + ".pdf" graph.graph_system(s, sched_param=True, exec_times=True, filename=graph_file) try: # analyze the system results = analysis.analyze_system(s) # print some analysis results print("Result:") for r in sorted(s.resources, key=str): print "results for resource %s" % r.name for t in sorted(r.tasks, key=str): print("%s - %d " % (str(t.name) , results[t].wcrt)) if outfile is not None: # backannotate the xml loader.annotate_results() # write it loader.write(filename=outfile) except analysis.NotSchedulableException as (e): print str(e)
def xmlrpc_analyze_system(self, system_id): """ Analyze system and return a result id. :param system_id: ID of the system to analyze :type system_id: string :returns: ID of a results object :rtype: string """ system = self._obj_from_id(system_id, model.System) results = None for r in system.resources: if r.scheduler is None: raise xmlrpc.Fault( ILLEGAL_SYSTEM, "component %s has no scheduler assigned" % r.name) logger.debug("analyzing...") try: results = analysis.analyze_system(system) rid = self._unique(results) self._objects[rid] = results except analysis.NotSchedulableException as e: raise xmlrpc.Fault(NOT_SCHEDULABLE, "not schedulable: %s" % (str(e))) except Exception as e: # Print the exception plus traceback to server traceback.print_exc() raise xmlrpc.Fault(GENERAL_ERROR, str(e)) logger.debug("{} = {}analyze_system({})".format( rid, self.debug_prefix, system_id)) return rid
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 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 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')
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 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 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 _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 main(): """ Loads the pickled system and analyzes it with the given command line parameter settings. """ system = None # read the last argument without the help of argparse # since argparse is not initialized yet! if len(sys.argv) < 3: print("Please specify a filename!") print( "Format: analyze_pickled.py [optinal pycpa parameters] --file FILENAME " ) exit(1) filename = sys.argv[-1] print("Loading: %s" % filename) try: with open(filename, 'rb') as f: s = pickle.load(f) except IOError as e: print e exit(1) print("DONE") print("... handing over to the pycpa kernel\n\n\n") # init pycpa and trigger command line parsing # this must be done late, as the modules dynamically loaded # by pickle can add additional argparse arguments options.init_pycpa() 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()))
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 rr_test(): options.init_pycpa() s = model.System() r1 = s.bind_resource(model.Resource("R1", schedulers.RoundRobinScheduler())) r2 = s.bind_resource(model.Resource("R2", schedulers.RoundRobinScheduler())) # create and bind tasks # the scheduling_parameter denotes the slot size t11 = r1.bind_task( model.Task(name="T11", wcet=1, bcet=1, scheduling_parameter=1)) t12 = r1.bind_task( model.Task(name="T12", wcet=1, bcet=1, scheduling_parameter=1)) t21 = r2.bind_task( model.Task(name="T21", wcet=1, bcet=1, scheduling_parameter=1)) t22 = r2.bind_task( model.Task(name="T22", wcet=1, bcet=1, scheduling_parameter=1)) t11.link_dependent_task(t21) t22.link_dependent_task(t12) t11.in_event_model = model.CTEventModel(c=1, T=5) t22.in_event_model = model.CTEventModel(c=5, T=17) 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(t, " - ", results[t].wcrt) print(" b_wcrt=%s" % (results[t].b_wcrt_str())) graph.graph_system(s, show=options.get_opt('show'))
| See LICENSE file for copyright and license details. :Authors: - Philip Axer Description ----------- SymTA/S 1.4 Loader example """ from pycpa import analysis from pycpa import symload from pycpa import options import os ## this is necessary because the file is also called from the regression test suite path = os.path.dirname(os.path.realpath(__file__)) options.init_pycpa() loader = symload.SymtaLoader14() s = loader.parse(path + "/symta14_test.xml") results = analysis.analyze_system(s) print("Result:") for r in sorted(s.resources, key=str): print "results for resource %s" % r.name for t in sorted(r.tasks, key=str): print str(t), "-", results[t].wcrt
def generate_golden_model(test_id=0, max_load=0.85, max_tasks=50, max_period=10000, max_jitter=100000, scheduler_string="schedulers.SPPScheduler()"): ntasks = int(random.random() * max_tasks) total_util = random.random() * max_load task_ids = [str(i + 1) for i in range(ntasks)] task_utilizations = util.uunifast(ntasks, total_util) task_jitters = [int(random.random() * max_jitter) for i in range(ntasks)] task_periods = [ int(random.random() * max_period + 1) for i in range(ntasks) ] task_wcets = [int(u * p) for u, p in zip(task_utilizations, task_periods)] code_string = "# tasks: %d total_utilization %f\n" % (ntasks, total_util) code_string += "s = model.System()\n" code_string += """r1 = s.bind_resource(model.Resource("R1", %s))\n""" % ( scheduler_string) code_string += """r2 = s.bind_resource(model.Resource("R2", %s))\n""" % ( scheduler_string) for name, J, P, C in zip(task_ids, task_jitters, task_periods, task_wcets): #create a task on resource 1 code_string += """task1_%s = model.Task(name="task1_%s", wcet=%d, scheduling_parameter=%d)\n""" % ( name, name, C, int(name)) code_string += """task1_%s.in_event_model = model.PJdEventModel(P=%d, J=%d)\n""" % ( name, P, J) code_string += """task1_%s.deadline = %d\n""" % ( name, P) #set a deadline for EDF code_string += """r1.bind_task(task1_%s)\n""" % (name) #create a task on resource 2 code_string += """task2_%s = model.Task(name="task2_%s", wcet=%d, scheduling_parameter=%d)\n""" % ( name, name, C, int(name)) code_string += """task2_%s.deadline = %d\n""" % ( name, P) #set a deadline for EDF code_string += """task1_%s.link_dependent_task(task2_%s)\n""" % (name, name) code_string += """r2.bind_task(task2_%s)\n""" % (name) exec_locals = dict() exec(code_string, globals(), exec_locals) system = exec_locals['s'] task_names = list() for r in system.resources: for t in r.tasks: task_names.append(t.name) # override event model propagation for propagation in options.propagation_methods: max_iterations_code = "options.set_opt('max_iterations', float('inf'))\n" propagation_code = "options.set_opt('propagation', '%s')\n" % ( propagation) exec(propagation_code, globals(), exec_locals) exec(max_iterations_code, globals(), exec_locals) print("### DEBUG: evaluating for %s / %s" % (propagation, scheduler_string)) task_results = analysis.analyze_system(system) code_string += """# setting options\n""" code_string += max_iterations_code code_string += propagation_code code_string += """##########################################\n""" code_string += """task_results = analysis.analyze_system(s)\n""" code_string += """\n###########################################\n""" for obj_name in task_names: busy_times = str((task_results[exec_locals[obj_name]].busy_times)) wcrt_code = "task_results[%s].wcrt" % obj_name bcrt_code = "task_results[%s].bcrt" % obj_name code_string += """#check busy times\n""" code_string += """assert task_results[%s].busy_times == %s\n""" % ( obj_name, busy_times) code_string += """#check type wcrt\n""" code_string += """assert type(%s) == int\n""" % (wcrt_code) code_string += """#check type bcrt\n""" code_string += """assert type(%s) == int\n""" % (bcrt_code) code_string += """#check busy times\n""" code_string += """assert %s == %d\n""" % ( wcrt_code, task_results[exec_locals[obj_name]].wcrt) code_string += """return s\n\n""" #indent code_string = "\n".join( [" %s" % (line) for line in code_string.splitlines()]) function_string = "def testcase_%d():\n%s" % (test_id, code_string) print(function_string)
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))