12.5 System Modelling for Analysis and Simulation

Printer-friendly version PDF version

Date: Thursday, March 28, 2019
Time: 16:00 - 17:30
Location / Room: Room 5

Chair:
Ingo Sander, KTH Royal Institute of Technology, SE, Contact Ingo Sander

Co-Chair:
Gianluca Palermo, Politecnico di Milano, IT, Contact Gianluca Palermo

The session highlights the importance of system modelling for design, performance analysis and optimisation. The first paper proposes a novel dataflow model of computation supporting reconfigurability for dynamic systems. The second paper combines the synchronous dataflow model of computation with a probabilistic method for real-time analysis. Finally, the last paper addresses the simulation of SystemC-based virtual prototypes using speculative temporal decoupling.

TimeLabelPresentation Title
Authors
16:0012.5.1RDF: RECONFIGURABLE DATAFLOW
Speaker:
Xavier Nicollin, Univ. Grenoble Alpes, FR
Authors:
Pascal Fradet1, Alain Girault1, Ruby Krishnaswamy2, Xavier Nicollin3 and Arash Shafiei2
1INRIA, FR; 2Orange, FR; 3G-INP, FR
Abstract
Dataflow Models of Computation (MoCs) are widely used in embedded systems, including multimedia processing, digital signal processing, telecommunications, and automatic control. In a dataflow MoC, an application is specified as a graph of actors connected by FIFO channels. One of the most popular dataflow MoCs, Synchronous Dataflow (SDF), provides static analyses to guarantee boundedness and liveness, which are key properties for embedded systems. However, SDF (and most of its variants) lacks the capability to express the dynamism needed by modern streaming applications. In particular, the applications mentioned above have a strong need for reconfigurability to accommodate changes in the input data, the control objectives, or the environment. We address this need by proposing a new MoC called Reconfigurable Dataflow (RDF). RDF extends SDF with transformation rules that specify how the topology and actors of the graph may be reconfigured. Starting from an initial RDF graph and a set of transformation rules, an arbitrary number of new RDF graphs can be generated at runtime. A key feature of RDF is that it can be statically analyzed to guarantee that all possible graphs generated at runtime will be consistent and live. We introduce the RDF MoC, describe its associated static analyses, and outline its implementation.
16:3012.5.2PROBABILISTIC STATE-BASED RT-ANALYSIS OF SDFGS ON MPSOCS WITH SHARED MEMORY COMMUNICATION
Speaker:
Ralf Stemmer, Carl von Ossietzky Universität Oldenburg, DE
Authors:
Ralf Stemmer1, Henning Schlender1, Maher Fakih2, Kim Grüttner2 and Wolfgang Nebel1
1University of Oldenburg, DE; 2OFFIS e.V., DE
Abstract
This paper extends a state-based timing analysis for Synchronous Dataflow Applications on an MPSoC with shared memory. The existing approach transforms a mapped and timing annotated SDF graph into a timed automata representation for the analysis of timing properties. One major drawback of the existing timing annotation approach is the usage of best- and worst-case execution time intervals, resulting in an overestimation of the actual timing behavior. This paper proposes to replace the timing bound annotation with a probability density function. For the overall timing analysis we use a stochastic timed automata model. We demonstrate and evaluate our approach on a Sobel filter, which is used in many image and video processing algorithms. As a reference, we compare our stochastic execution time model against a fixed best-/worst-case execution time model and against the measured execution time on an FPGA prototype. The results are promising and clearly indicate that our probabilistic approach provides tighter timing analysis results in comparison to the best-/worst-case execution analysis model.
17:0012.5.3SPECULATIVE TEMPORAL DECOUPLING USING FORK()
Speaker:
Matthias Jung, Fraunhofer IESE, DE
Authors:
Matthias Jung1, Frank Schnicke1, Markus Damm1, Thomas Kuhn2 and Norbert Wehn3
1Fraunhofer IESE, DE; 2Fraunhofer Institute IESE, DE; 3University of Kaiserslautern, DE
Abstract
Temporal decoupling is a state-of-the-art method to speed up virtual prototypes. In this technique, a process is allowed to run ahead of simulation time for a specific interval called quantum. By using this method, the number of synchronization points, i.e. context switches, in the simulator is reduced and therefore, the simulation speed can be increased significantly. However, using this approach can introduce functional simulation errors due to missed synchronization events. Thus, using temporal decoupling implies a trade-off between speed and accuracy and the size of the quantum must be chosen wisely with respect to the simulated application. In loosely timed simulations most of the functional errors are tolerable for the sake of simulation speed. However, for instance safety critical errors are rare but can lead to fatal results and must be handled carefully. Prior works present mechanisms based on checkpoints (storing/restoring the internal state of the simulation model) in order to rollback in simulation time and correct the occurred errors by forcing synchronization. However, checkpointing approaches are intrusive and require changes to both the source code of all the used simulation models and the kernel of the simulator. In this paper we present a non-intrusive rollback approach for error-free temporal decoupling, which allows the usage of closed source models by using Unix's fork() system call. Furthermore, we provide a case study based on the IEEE simulation standard SystemC.
17:30End of session