Grégoire Hamon

A denotational semantics for stateflow

We present a denotational semantics for Stateflow, the graphical Statecharts-like language of the Matlab/Simulink toolsuite. This semantics makes use of continuations to capture even the most complex constructions of the language, such as inter-level transitions, junctions, or backtracking. An immediate application of this semantics is a formal compilation scheme for the language.

Towards a higher-order synchronous data-flow language

The paper introduces a higher-order synchronous data-flow language in which communication channels may themselves transport programs. This provides a mean to dynamically reconfigure data-flow processes. The language comes as a natural and strict extension of both lustre and lucy. This extension is conservative, in the sense that a first-order restriction of the language can receive the same semantics.We illustrate the expressivity of the language with some examples, before giving the formal semantics of the underlying calculus. The language is equipped with a polymorphic type system allowing types to be automatically inferred and a clock calculus rejecting programs for which synchronous execution cannot be statically guaranteed. To our knowledge, this is the first higher-order synchronous data-flow language where stream functions are first class citizens.

Clock-directed modular code generation for synchronous data-flow languages

The compilation of synchronous block diagrams into sequential imperative code has been addressed in the early eighties and can now be considered as folklore. However, separate, or modular, code generation, though largely used in existing compilers and particularly in industrial ones, has never been precisely described or entirely formalized. Such a formalization is now fundamental in the long-term goal to develop a mathematically certified compiler for a synchronous language as well as in simplifying existing implementations. This article presents in full detail the modular compilation of synchronous block diagrams into sequential code. We consider a first-order functional language reminiscent of LUSTRE, which it extends with a general n-ary merge operator, a reset construct, and a richer notion of clocks. The clocks are used to express activation of computations in the program and are specifically taken into account during the compilation process to produce efficient imperative code. We introduce a generic machine-based intermediate language to represent transition functions, and we present a concise clock-directed translation from the source to this intermediate language. We address the target code generation phase by describing a translation from the intermediate language to JAVA and C.

Mixing signals and modes in synchronous data-flow systems

Synchronous data-flow languages such as SCADE LUSTRE manage infinite sequences, or streams, as primitive values making them naturally adapted to the description of dominated systems. Their conservative extension with means to define control-structures or modes has been a long-term research topic through which several solutions have emerged.In this paper, we pursue this effort and generalize existing solutions by providing two constructs: a general form of state machines called parameterized state machines, and valued signals, as can be found in ESTEREL. Parameterized state machines greatly reduce the reliance on error-prone mechanisms such as shared memory in automaton-based programming. Signals provide a new way of programming with multi-rate data in synchronous dataflow languages. Together, they allow for a much more direct and natural programming of systems that combine dataflow and state-machines.The proposed extension is fully implemented in the new LUCID SYNCHRONE compiler.

Towards Computational Hybrid System Semantics for Time-Based Block Diagrams

Abstract At the core of Model-Based Design, computational models have caused an autocatalytic trend to use computation in design by unlocking the potential of model transformations. Precisely specifying a computational transformation requires well-defined semantics of the source and target representations. In this regard, continuous-time behavior is an essential aspect of time-based block diagrams that is typically approximated by numerical integration. The corresponding theory, however, is mostly concerned with local error and the mathematical semantics of long time behavior fails to be sufficiently precise from a computational perspective. In this work, first a computational semantics is developed based on a multi-stage variablestep solver. Next, the computational semantics of the discrete and continuous parts of hybrid systems and their interaction are formalized in a unifying framework. The framework exploits a successful functional approach to defining discrete-time and discrete-event behavior established in other work. Unification is then achieved by developing a computational representation of the continuous-time behavior as pure functions on streams.

Modular resetting of synchronous data-flow programs

This paper presents an extension of a synchronous dataow language providing full functionality with a modular reset operator. This operator can be considered as a basic primitive for describing dynamic recon gurations in a purely dataow framework. The extension proposed here is conservative with respect to the fundamental properties of the initial language: reactivity (i.e, execution in bounded memory and time) and referential transparency are kept. The reset operator is thus compatible with higher-order. This is obtained by extending the clock calculus of the initial language and providing a compilation method. We illustrate the use of this operator by describing an automatic encoding of Mode-automata. All the experiments presented in the paper has been done with Lucid Synchrone, an ML extension of Lustre.

On the Structure of Time in Computational Semantics of a Variable-Step Solver for Hybrid Behavior Analysis

Abstract Hybrid dynamic systems combine continuous and discrete behavior. Often, computational approaches approximate behavior of an analytic solution, for example, numerical integration to approximate differential equation behavior. The accuracy and computational efficiency of the integration usually depend on the complexity of the method and its implicated approximation errors, especially when repeated over iterations. This work formally defines the computational semantics of a solver in a denotational sense so as to analyze discrete- and continuous-time behavior of time-based block diagram models. A stream-based approach is used to analyze the numerical integration implemented by the solver. The resulting solver applies the principle of nonmonotonic time and so consecutive values may be computed in a temporally nonmonotonic manner. This allows shifting the evaluation points backward and forward in time. Stratification recovers a partially ordered structure in time. Solver dynamics are thus made explicit and can be studied in concert with behavior of discontinuous models parts.

Synchronous Dataflow Pattern Matching

We introduce variant types and a pattern matching operation to synchronous dataflow languages. These languages are used in the design of reactive systems. As these systems grow increasingly complex, the need for abstraction mechanisms, in particular, data and control structures, is critical. Variant types provide a mechanism to precisely model structured data. The pattern matching operation, defined as a clock operator, provides an efficient control structure.