1. Process Networks for Reactive Streaming with Timed Automata Implementation
P. Poplavko, D. Socci, R. Kahil, M. Bozga, S. Bensalem
Verimag Lab (CNRS, University of Grenoble), France
IDEA 2016
Real-time system frameworks: either streaming or reactive-control
Streaming frameworks, e.g. EU CompSoC
- dataflow related
- no timing-dependent actions, no deadline and period
Reactive-control frameworks e.g. ONERA Prelude, ESA TASTE
- synchronous-language related + classical schedulability analysis
- typically, uniprocessor scheduling
- overdesigned in terms of timing constraints
- absent or complex precedence constraints
Tradeoff between them required in application domains like:
Robotics Control SW (ROC), avionics FMS, satellite GNC
Fixed Priority Process Network MoC – event-driven model with non-blocking reads/writes yet deterministic dataflow-like behavior.
Timed Automata Implementation (in BIP language)
TTS Cycle
scheduler
components in BIP
TTS Frame f1
TTS Frame f1
TTS Frame f3
TTS Frame f3
Per. Server
Per. Server
 5
BlacBrd
 6
application FPPN MoC components in BIP
MailBx
BlacBrd
MailBx
MailBx
 1
 2
 3
 4
Ctrller
core 0: BIP RTE + middleware components
RTE engine
Ctrller
Per. Server
TTS Cycle
TTS Frame
`migrating’ components:
MailBx
BlacBrd
core 1..15: process-to-core mapping 2 4
core 1: 3 5 6 1
core 2:
Thales Flight Management System Example
BIP Language
Network of timed automata that synchronize by urgent rendezvous on connected ports and that can execute C/C++ statements at transitions.
We extended it by asynchronous (non-instantaneous) transitions that model internal steps in task computation and synchronization. Therefore, these automata can be classified as so-called “task automata” (as in TIMES tool).
SensorInput
200ms
AnemoConfig
2 per200ms
GPSConfig
IRSConfig
DopplerConfig
HighFreqBCP
LowFreqBCP
5000ms
MagnDeclin
1600ms
BCPConfig
Performance
1000ms
MagnDeclinConfig
5 per1600ms
PerformanceConfig
5 per1000ms
AnemoData
GPSData
IRSData
DopplerData
PerformanceData
BCP Data
relative functional priority
Processes are modeled as automata extended with variables and input/output ports. An execution run that comes back to the initial state is a `job’ (‘firing’). Jobs are released by events, which can be periodic, sporadic, or any other user-defined pattern. Process subroutine in C/C++ gets automatically ‘compiled’ into the equivalent automaton.
Channels are non-blocking. Next to the data, a read operation returns a data validity indicator. There are inter-process and external channels. The former are protected from data races by functional priorities. By default, we support two channel types: FIFO (a bounded queue) and blackboard (a shared variable). Other types can be potentially introduced by defining their automata models.
Event Generators are defined by possible sequences of time stamps that it can possibly produce. By default, we define two types of event generators: periodic and sporadic, but other arrival patterns can be potentially defined as timed automata components. Every event generator is associated with a process. Every process has a deadline.
Functional priority is a relation between processes, defined by a DAG. Every channel has a corresponding arc in the DAG that can be either along or against the data-flow direction. Functional priority generalizes static-order relation to multi-periodic firings.
Our design flow is implemented in “DOLC 2 BIP” tool (google “VERIMAG Multicore Code Generation for Time-critical”).
We have modeled and implemented on MPPA multi-core platform an industrial application case. As shown there, our design flow eliminates certain restrictions of both data-flow and reactive-control systems. Moreover, using timed automata implementation allows seamless system model extensions with different task release patterns (e.g., recurrent branching) and resource managers (e.g. QoS control and mixed criticality).
While practiced for a long time in streaming frameworks, scheduling precedence-constrained from reactive-control systems has received attention only recently. Few streaming languages support external events with periods deadlines, though only periodic ones. Reactive process networks (RPNs) are proposed combine reactive-control streaming behavior. We believe that by simple model transformation FPPNs can be translated to a restriction of RPNs. Compared to RPN, FPPN is adapted to real-time tasks by introducing the priority and explicit timing of events.
Contact: