Example #1
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])
Example #2
0
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)
Example #3
0
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)
Example #4
0
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')
Example #5
0
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)
Example #6
0
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))
Example #7
0
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])
Example #8
0
def trace_example():

    options.init_pycpa()

    # this is a rather extreme trace with just two datapoints
    # pycpa will use additive extension which is a periodic extension in this case
    periodic_trace = [0, 10]
    em = model.TraceEventModel()
    em.set_limited_trace(periodic_trace, 1)
    print "input trace:", periodic_trace
    print "output delta(n): ", [em.delta_min(p) for p in range(1, 10)]

    # this a more realistic event model. periodic in nature with
    # a burst at time 32
    em = model.TraceEventModel()
    bursty_trace = [0, 10, 20, 30, 32, 40, 50]
    em.set_limited_trace(bursty_trace, 1)
    print "input trace:", bursty_trace
    print "output delta_min(n): ", [em.delta_min(p) for p in range(1, 10)]
    print "output delta_plus(n): ", [em.delta_plus(p) for p in range(1, 10)]
Example #9
0
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()))
Example #10
0
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)
Example #11
0
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()
Example #12
0
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'))
Example #13
0
| 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
Example #14
0
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))