Jens Brandt

A Verified Compiler for Synchronous Programs with Local Declarations

We describe the translation of Esterel-like programs with delayed actions to equivalent equation systems. Potential schizophrenia problems arising from local declarations are solved by (1) generating copies of the surface of the statement and (2) renaming the local variables in one of the copied surfaces generated a loop. The translation runs in quadratic time and has been formally verified with the HOL theorem prover.

Maximal causality analysis

Perfectly synchronous systems immediately react to the inputs of their environment, which may lead to so-called causality cycles between actions and their trigger conditions. Algorithms to analyze the consistency of such cycles usually extend data types by an additional value to explicitly indicate unknown values. In particular, Boolean functions are thereby extended to ternary functions. However, a Boolean function usually has several ternary extensions, and the result of the causality analysis depends on the chosen ternary extension. In this paper, we show that there always is a maximal ternary extension that allows one to solve as many causality problems as possible. Moreover, we elaborate the relationship to hazard elimination in hardware circuits, and finally show how the maximal ternary extension of a Boolean function can be efficiently computed by means of binary decision diagrams.

Performing causality analysis by bounded model checking

Synchronous systems can immediately react to the inputs of their environment which may lead to so-called causality cycles between actions and their trigger conditions. Systems with causality cycles may not be consistent or may become nondeterministic. For this reason, compilers for synchronous languages usually employ special analyses to guarantee a predictable runtime behavior of the considered programs. In this paper, we show how causality analysis can be formulated as a model checking problem, so that all of the sophisticated algorithms originally developed for model checking can now also be used for causality analysis. To this end, we model the dasiaemicro steppsila behavior of synchronous programs in terms of a transition relation that can be directly used for symbolic model checking. Moreover, we show that the obtained model checking problems can be even decided by bounded model-checking problems so that modern SAT-solvers can be used to efficiently solve the causality problem.

Separate compilation for synchronous programs

Esterel and other imperative synchronous languages offer a rich set of statements, which can be used to conveniently describe complex control behaviors in a concise, but yet precise way. In particular, the ability to arbitrarily nest all kinds of statements including loops, local declarations, sequential and parallel control, as well as several kinds of preemption statements leads to a powerful programming language. However, this orthogonal design imposes difficult problems for the modular or separate compilation, which has to deal with special problems like the instantaneous reincarnation of locally declared variables. This paper presents a compilation procedure allowing to separately compile modules of a synchronous language. Our approach is based on two new achievements: First, we derive the information that is required for a linker to combine already compiled modules. This information is stored in a file written in an intermediate format, which is the target of our compilation procedure and the source of the linker. Second, we describe a compilation procedure for a typical imperative synchronous language to generate this intermediate format. We have implemented the approach in the upcoming version 2.0 of our Averest system.

Multithreaded code from synchronous programs: extracting independent threads for OpenMP

Synchronous languages offer a deterministic model of concurrency at the level of actions. However, essentially all compilers for synchronous languages compile these actions into a single thread by sophisticated methods to guarantee dynamic schedules for the sequential execution of these actions. In this paper, we present the compilation of synchronous programs to multi-threaded OpenMP-based C programs. We thereby start at the level of synchronous guarded actions which is a comfortable intermediate language for synchronous languages. In addition to the explicit parallelism given in the source program, our method also exploits the implicit parallelism which is due to the underlying synchronous model of computation and the data dependencies of the guarded actions. We show how viable tasks can be constructed from the actions of a program and show the feasibility of our approach by a small example.

Clock refinement in imperative synchronous languages

AbstractThe synchronous model of computation divides the program execution into a sequence of logical steps. On the one hand, this view simplifies many analyses and synthesis procedures, but on the other hand, it imposes restrictions on the modeling and optimization of systems. In this article, we introduce refined clocks in imperative synchronous languages to overcome these restrictions while still preserving important properties of the basic model. We first present the idea in detail and motivate various design decisions with respect to the language extension. Then, we sketch all the adaptations needed in the design flow to support refined clocks.

Constructive Polychronous Systems

The synchronous paradigm provides a logical abstraction of time for reactive system design which allows automatic synthesis of embedded programs that behave in a predictable, timely and reactive manner. According to the synchrony hypothesis, a synchronous model reacts to input events and generates outputs that are immediately made available. But even though synchrony greatly simplifies design of complex systems, it often leads to rejecting models when data dependencies within a reaction are ill-specified, leading to causal cycles. Constructivity is a key property to guarantee that the output during each reaction can be algorithmically determined. Polychrony deviates from perfect synchrony by using a partially ordered or relational model of time. It captures the behaviors of (implicitly) multi-clocked data-flow networks and can analyze and synthesize them to GALS systems or to Kahn process networks (KPNs). In this paper, we provide a unified constructive semantic framework, using structural operational semantics, which captures the behavior of both synchronous modules and multi-clocked polychronous processes. Along the way, we define the very first operational semantics of Signal.

Translating concurrent action oriented specifications to synchronous guarded actions

Concurrent Action-Oriented Specifications (CAOS) model the be- havior of a synchronous hardware circuit as asynchronous guarded actions at an abstraction level higher than the Register Transfer Level (RTL). Previous approaches always considered the compilation of CAOS, which includes a transformation of the under-lying model of computation and the scheduling of guarded actions per clock cycle, as a tightly integrated step. In this paper, we present a new compilation procedure, which separates these two tasks and translates CAOS models to synchronous guarded actions with an explicit interface to a scheduler. This separation of con- cerns has many advantages, including better analyses and integration of custom schedulers. Our method also generates assertions that each scheduler must obey that can be fulfilled by algorithms for scheduler synthesis like those developed in supervisory control. We present our translation procedure in detail and illustrate it by various examples. We also show that our method simplifies for- mal verification of hardware synthesized from CAOS specifications over previously known formal verification approaches.

Embedding Polychrony into Synchrony

This paper presents an embedding of polychronous programs into synchronous ones. Due to this embedding, it is not only possible to deepen the understanding of these different models of computation, but, more importantly, it is possible to transfer compilation techniques that were developed for synchronous programs to polychronous programs. This transfer is nontrivial because the underlying paradigms differ more than their names suggest: Since synchronous systems react deterministically to given inputs in discrete steps, they are typically used to describe reactive systems with a totally ordered notion of time. In contrast, polychronous system models entail a partially ordered notion of time, and are most suited to interface a system with an asynchronous environment by specifying input/output constraints from which a deterministic controller may eventually be refined and synthesized. As particular examples for the mentioned cross fertilization, we show how a simulator and a verification backend for synchronous programs can be made available to polychronous specifications, which is a first step toward integrating heterogeneous models of computation.

Out-Of-order execution of synchronous data-flow networks

Data flow process networks (DPNs) have been introduced as a convenient model of computation for distributed and asynchronous systems since each process node can work independently of the other nodes, i. e. without the need of a global coordination. Synchronous and cyclo-static data flow process networks even allow to derive at compile-time efficient static schedules that allow one to run these systems with an efficient use of available resources, e. g. in embedded systems. Single process nodes of DPNs are stream-based computing devices that transform input streams to uniquely defined corresponding output streams such that single values of the output streams are computed as soon as sufficient input values are available. In this sense, they are related to the execution of an instruction stream by a conventional microprocessor. In this paper, we show how out-of-order execution that has been introduced for the efficient use of multiple functional units in microprocessors can also be used for the implementation of DPNs on multiprocessors. This way, the implementation of DPNs on multiprocessors allows one to optimize the throughput of single process nodes, and as shown by our experiments, also of the entire DPN.