EE290N - Specification and Modeling of Reactive Real-Time Systems

backward synchronization: blocking writes

demand-driven: a policy where an actor blocks on writes until the receiving actors are ready to receive

data-driven: a policy where an actor doesn't block on a write

Turing-complete: having the same expressiveness as a Turing Machine

delay: an initial token on an arc in a dataflow graph

strongly connected: having a directed arc to and from any other node

static schedule: a finite list of firings that is executed forever such that the firings on the list bring the graph back to its original state

quasi-static schedule: a finite list of annotated firings that is executed forever such that the annotations are Boolean conditions under which each firing should occur

dynamic schedule: run-time determination of which actor fires next

balance equation: an equation that relates the number of tokens produced to the number of tokens consumed along a dataflow graph arc

• Why go with dataflow, a special case of Kahn Process networks?
  • to break down the process into sequence of firings
  • to have control or knowledge of scheduling
    • Why would you want to control scheduling?

This implementation is dynamic => you don't know if deadlines will be met.

EXAMPLE:

P₁ never blocking is legitimate but probably not useful.

What about threading on a processor via time slicing? Suppose P₁ produces 10 tokens, P₂ consumes 1 token. This is fair but won't execute in bounded memory.

EXAMPLE: Demand-driven

Should P₁ and P₂ submit demands at the same rate?

Analogy: Hole and electrons; electrons travel one way, holes the other way to make room for the travelling electrons.

EXAMPLE: Data-driven

P₁ and P₂ can be fired arbitrarily.

Advantage of dataflow: there exists a firing function.

Is Homogeneous SDF Turing-complete? Note that switches and selects are ruled out because of unpredictable consumption and production rules.

EXAMPLE: Turing-completeness

What can you stick in the above actor to make this graph Turing-complete? Side note: If an actor can have an unlimited number of states then it's Turing-complete.

• If the set of states V = {0, 1} then the graph is not Turing-complete.
• If |V| is finite then HSDF is not Turing-complete, meaning that there exist some limits on its expressiveness.
• Switch and select added to SDF is Turing-complete => you can have an infinite number of states in the system (to be proven later).

EXAMPLE: Implementation of a delay's initial token

Examples of stateless actors are sources and sinks.

EXAMPLE: FSM select (refer to slide lec15.fm, page 4)

• Above has 2 firing rules.
• Firing function is not quite a function because it has state.
• INITIAL TOKEN takes one of 3 values to indicate state. Now we can have a firing function.
• If the number of states is not finite then the feedback value has an infinite number of possibilities.
• In hardware feedback can be implemented as a register.
• If there is no feedback then the actor is not functional since the output is not solely dependent on the inputs.
• SDF is the one-state special case (refer to slide lec15.fm, page 5) => switch and select are ruled out. (Note: SDF cannot have a fair merge since it would introduce nondeterminism. The states would be [0 0], [0 1], [1 0], and [1 1].)

COMMON EXECUTION MODELS FOR DATAFLOW

• Kahn-McQueen (assumes infinite FIFO queues)
• Dataflow machines (a dead-end)
• ``compile-your-dataflow'' (unclear if you can always do this)

SCHEDULERS

• Static
• Quasi-static
• Dynamic

Q: Is static scheduling possible for HDSDF?

A: No; It's impossible for

to have a static schedule with no delay but possible with an empty sequence. Still, in general, no.

EXAMPLE: SDF scheduling

ABCACB... never returns to initial state.

Balance Equations

r_A*1=r_C*1

r_A*1=r_B*1

r_B*2=r_C*1

Solve the above set of equations. The trivial solution r_A=r_B=r_C=0 is the only solution.

This is unacceptable since the semantics say that there exists an infinite stream of tokens.

No solution to the balance equations => No bounded memory solution

The denotational semantics imply an infinite sequence of tokens. The operational semantics handle the production of a certain number of tokens and the consumption of a certain number of tokens.

EXAMPLE: SDF scheduling

Balance Equations

r_A=r_B

r_B=r_C

r_C=r_C

r_A=r_B=r_C=i is a solution for each i=1, 2, 3, etc. Therefore, the existence of a solution to the balance equations is necessary but not sufficient for the existence of a static schedule.

EXAMPLE: SDF scheduling

r_A*2=r_A*2 has a solution.

``enough'' initial tokens plus the existence of a non-trivial solution => the existence of a static schedule

Rule out negative solutions to the balance equations.

EXAMPLE: SDF scheduling

In general, the existence of one solution to the balance equations implies the existence of an infinite number of solutions.

||: AABCDD :|| (using musical ``repeat'' notation) is a possible static schedule. Multitasking is unecessary in a software implementation of this.