Model Module

Copyright (C) 2007-2017 Jonas Diemer, Philip Axer, Daniel Thiele, Johannes Schlatow

TU Braunschweig, Germany

All rights reserved.

See LICENSE file for copyright and license details.

Authors:

• Jonas Diemer
• Philip Axer
• Johannes Schlatow

Description

It should be imported in scripts that do the analysis. We model systems composed of resources and tasks. Tasks are activated by events, modeled as event models. The general System Model is described in Section 3.6.1 in [Jersak2005] or Section 3.1 in [Henia2005].

class pycpa.model.CTEventModel(c, T, dmin=1, name='min', **kwargs)

c events every T time event model.

set_c_in_T(c, T, dmin=1)

Sets the event-model to a periodic Task with period T and c activations per period. No minimum arrival rate is assumed (delta_plus = infinity)! Cf. Equation 1 in [Diemer2010].

class pycpa.model.ConstraintsManager

This class manages all system-wide constraints such as deadlines, buffersizes and more.

add_backlog_constraint(task, size)

adds a buffer size constraint backlog must be less or equal than size

add_load_constraint(resource, load)

adds a resource load constraint actual load on the specified resource must be less or equal than load

add_path_constraint(path, deadline, n=1)

adds a path latency constraint latency for n events must be less or equal than deadline

add_wcrt_constraint(task, deadline)

adds a local task deadline constraint wcrt must be less or equal than deadline

class pycpa.model.EffectChain(name, tasks=None)

An cause-effect chain describes a (functional) chain of independent tasks. All tasks within a chain are time-triggered and hence sample their input data independently.

task_sequence(writers_only=False)

Generates and returns the sequence of reader/writer tasks in the form of [reader_0, writer_0, reader_1, writer_1,…].

A task in this sequence therefore acts either as a reader or a writer. Tasks at odd positions in this sequence are readers while tasks at even positions are writers.

Parameters:writers_only (boolean) – if true, only include writer tasks in sequence (omit readers)

class pycpa.model.EventModel(name='min', container={}, **kwargs)

The event model describing the activation of tasks as described in [Jersak2005], [Richter2005], [Henia2005]. Internally, we use and , which represent the minimum/maximum time window containing n events. They can be transformed into and which represent the maximum/minimum number of events arriving within .

delta_min(n)

Delta-minus Function Return the minimum time interval between the first and the last event of any series of n events. This is actually a wrapper to allow caching of delta functions.

static delta_min_from_eta_plus(etaplus_func)

Delta-minus Function Return the minimum time window containing n activations. The delta_minus-function is derived from the eta_plus-function. This function is rarely needed, as EventModels are represented by delta-functions internally. Equation 3.7 from [Schliecker2011].

delta_plus(n)

Delta-plus Function Return the maximum time interval between the first and the last event of any series of n events. This is actually a wrapper to allow caching of delta functions.

static delta_plus_from_eta_min(etamin_func)

Delta-plus Function Return the maximum time window containing n activations. The delta_plus-function is derived from the eta_minus-function. This function is rarely needed, as EventModels are represented by delta-functions internally. Equation 3.8 from [Schliecker2011].

eta_min(w)

Eta-minus Function Return the minimum number of events in a time window w. Derived from Equation 3.6 from [Schliecker2011], but different, as Eq. 3.6 is wrong.

eta_min_closed(w)

Eta-minus Function Return the minimum number of events in a time window w. Using CLOSED intevals

eta_plus(w)

Eta-plus Function Return the maximum number of events in a time window w. Derived from Equation 3.5 from [Schliecker2011], but assuming half-open intervals for w as defined in [Richter2005].

eta_plus_closed(w)

Eta-plus Function Return the maximum number of events in a time window w. Derived from Equation 3.5 from [Schliecker2011], but assuming CLOSED intervals for w as defined in [Richter2005].

This is technically identical to eta_plus(w + EPSILON), but the use of epsilon has issues with float precision, as w+EPSILON == w for large w and small Epsilon (e.g. 40000000+1e-9)

load(accuracy=1000)

Returns the asymptotic load, i.e. the avg. number of events per time

class pycpa.model.Fork(name, strategy=<pycpa.model.StandardForkStrategy object>, *args, **kwargs)

A Fork allows the modification (determined by the assigned strategy) of output event models dependent on the destination task.

clean()

Cleans all intermediate analysis results

get_mapping(dst_task)

returns the identifier mapped to dst_task (or raises KeyError)

map_task(dst_task, identifier)

maps an identifier to dst_task

class pycpa.model.Junction(name='unknown', strategy=None)

A junction combines multiple event models into one output event model This is used to model multi-input tasks. Typical semantics are “and” and “or” strategies. See Chapter 4 in [Jersak2005] for definitions and details.

clean()

mark event models as invalid

map_task(src_task, identifier)

maps an identifier to src_task

class pycpa.model.LimitedDeltaEventModel(limited_delta_min_func=None, limited_delta_plus_func=None, limit_q_min=inf, limit_q_plus=inf, min_additive=<function recursive_min_additive>, max_additive=<function recursive_max_additive>, name='min', **kwargs)

User supplied event model on a limited delta domain.

set_limited_delta(limited_delta_min_func, limited_delta_plus_func, limit_q_min=inf, limit_q_plus=inf, min_additive=<function recursive_min_additive>, max_additive=<function recursive_max_additive>)

Sets the event model to an arbitrary function specified by limited_delta_min_func and limited_delta_plus_func. Contrary to directly setting deltamin_func and deltaplus_func, the given functions are only valid in a limited domain [0, limit_q_min] and [0, limit_q_plus] respectively. For values of q beyond this range, a conservative extension (additive extension) is used. You can also supply a list() object to this function by using lambda x: limited_delta_min_list[x]

class pycpa.model.Mutex(name=None)

A mutually-exclusive shared Resource. Shared resources create timing interferences between tasks which may be executed on different resources (e.g. multi-core CPU) but require access to a common resource (e.g. shared main memory) to execute. See e.g. Chapter 5 in [Schliecker2011].

class pycpa.model.PJdEventModel(P=0, J=0, dmin=0, phi=0, name='min', **kwargs)

A periodic, jitter, min-distance event model.

set_PJd(P, J=0, dmin=0, phi=0, early_arrival=False)

Sets the event model to a periodic activation with jitter and minimum distance. Equations 1 and 2 from [Schliecker2008].

class pycpa.model.Path(name, tasks=None)

A Path describes a (event) chain of tasks. Required for path analysis (e.g. end-to-end latency). The information stored in Path classes could be derived from the task graph (see Task.next_tasks and Task.prev_task), but having redundancy here is more flexible (e.g. path analysis may only be interesting for some task chains).

print_all()

Print all tasks in Path. Uses __str__()

class pycpa.model.Resource(name=None, scheduler=None, **kwargs)

A Resource provides service to tasks.

bind_task(t)

Bind task t to resource Returns t

load(accuracy=10000)

returns the asymptotic load

unmap_tasks()

unmap all tasks from this resource

class pycpa.model.StandardForkStrategy

Standard fork strategy: propagates unmodified output event model to all tasks.

output_event_model(fork, dst_task=None, task_results=None)

This strategy does not distinguish between destination tasks.

Parameters:

• fork (model.Task) – Fork from which to take the output event model.
• dst_task – destination task

class pycpa.model.System(name='')

The System is the top-level entity of the system model. It contains resources, junctions, tasks and paths.

bind_junction(j)

Registers a junction object in the System. Logically, the junction neither belongs to a system nor to a resource, for sake of convenience we associate junctions with the system.

bind_path(path)

Add a Path to the System

bind_resource(r)

Add a Resource to the System

print_subgraphs()

enumerate all subgraphs of the application graph. if a subgraph is not well-formed (e.g. a source is missing), this algorithm may not work correctly (it will eventually produce to many subgraphs)

class pycpa.model.Task(name, *args, **kwargs)

A Task is an entity which is mapped on a resource and consumes service. Tasks are activated by events, which are described by EventModel. Events are queued in FIFO order at the input of the task, see Section 3.6.1 in [Jersak2005] or Section 3.1 in [Henia2005].

bind_mutex(m)

Bind a Task t to a Mutex r

bind_resource(r)

Bind a Task t to a Resource/Mutex r

clean()

Cleans all intermediate analysis results

get_mutex_interferers()

returns the set of tasks sharing the same Mutex as Task ti excluding ti itself

get_resource_interferers()

returns the set of tasks sharing the same Resource as Task ti excluding ti itself

link_dependent_task(t)

Link a dependent task t to the task The dependent task t is activated by the completion of the task.

This method returns the t argument, which enables elegant task linking. E.g. to link t0 -> t1 -> t2, call: t0.link_dependent_task(t1).link_dependent_task(t2)

load(accuracy=100)

Returns the load generated by this task

unbind_mutex()

Remove a task fromk its mutex

unbind_resource()

Remove a task from its resource

class pycpa.model.TraceEventModel(trace_points=[], min_sample_size=20, min_additive=<function recursive_min_additive>, max_additive=<function recursive_max_additive>, name='min', **kwargs)

set_limited_trace(trace_points, min_sample_size=20, min_additive=<function recursive_min_additive>, max_additive=<function recursive_max_additive>)

Compute a pseudo-conservative event model from a given trace (e.g. from SymTA/S TraceAnalyzer or similar). trace_points must be a list of integers encoding the arrival time of an event. The algorithm will compute delta_min and delta_plus based on the trace by evaluating all candidates. min_sample_size is the minimum amount of candidates that must be available to derive a representative deltamin/deltaplus