Mike Gemünde

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.

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.

Constructive polychronous systems

The synchronous paradigm provides a logical abstraction of time for reactive system design which allows automatic synthesis of embedded systems that behave in a predictable, timely, and reactive manner. According to the synchrony hypothesis, a synchronous model reacts to inputs by generating outputs that are immediately made available to the environment. While synchrony greatly simplifies the design of complex systems in general, it can sometimes lead to causal cycles. In these cases, constructiveness is a key property to guarantee that the output of each reaction can still be always algorithmically determined.Polychrony deviates from perfect synchrony by using a partially ordered, i.e., a relational model of time. It encompasses the behaviors of (implicitly) multi-clocked data-flow networks of synchronous modules and can analyze and synthesize them as GALS systems or Kahn process networks (KPNs).In this paper, we present a unified constructive semantic framework using structured operational semantics, which encompasses both the constructive behavior of synchronous modules and the multi-clocked behavior of polychronous networks. Along the way, we define the very first executable operational semantics of the polychronous language Signal. Constructive semantic framework over a complete domain for imperative and declarative synchronous languages.First executable small-step operational semantics of polychronous data-flow languages.Characterization of program correctness (determinism, endochrony) by fixpoint properties.

A Formal Semantics of Clock Refinement in Imperative Synchronous Languages

The synchronous model of computation divides the execution of a program into an infinite sequence of so-called macro steps, which are further divided into finitely many micro steps. Since all threads of a program are forced to run in lockstep, programmers have no means to express the independence of parallel threads, which leads to a phenomenon called over-synchronization. In this paper, we therefore propose a generalization of the synchronous model of computation by means of refined clocks, which divide a macro step into finer grained steps that themselves consist of micro steps. In particular, we present a structural operational semantics of sub clocks and prove that the internal asynchrony given by sub clocks still preserves input/output determinism.

Desynchronizing Synchronous Programs by Modes

The synchronous programming paradigm simplifies the specification and verification of reactive systems. However, synchronous programs must be often implemented on architectures that do not follow this model of computation (like distributed systems or systems-on-a-chip). This gives rise to desynchronization techniques, which map the synchronous program to a platform without global time while preserving the original synchronous semantics.In this paper, we present a new approach to desynchronize synchronous programs. Our approach is based on partitioning the system and deriving suited computation modes for that partitioning. These computation modes dynamically decouple the components of a system by eliminating temporarily unnecessary and undesired computations and communications. We present several variations of the general concept and discuss their pros and cons. Finally, we illustrate our approach with the help of several small examples.

Compilation of imperative synchronous programs with refined clocks

To overcome over-synchronization in synchronous programs, we recently introduced clock refinement to our synchronous programming language Quartz. This extension basically allows programmers to refine reaction steps into smaller internal computation steps while maintaining the external behavior. In this paper, we consider the compilation of the extended Quartz programs to synchronous guarded actions. To this end, we first define an intermediate language supporting multiple clocks based on synchronous guarded actions which is the target of the front-end of the compiler and the source of back-end tools that perform efficient analysis and synthesis procedures. We moreover present a compilation scheme to translate the extended Quartz programs to the new intermediate language. We discuss important design considerations and illustrate our approach with the help of some small examples.

Causality analysis of synchronous programs with refined clocks

Synchronous languages are based on the synchronous abstraction of time, which divides the execution of programs into an infinite sequence of macro steps that consist of finitely many micro steps. A well-studied problem of this model of computation are cyclic dependencies of micro steps whose constructiveness has to be checked by a causality analysis during compilation. Recently, we showed that temporal refinement can be introduced to imperative synchronous languages by refined clocks. In this paper, we formally define the causality analysis for this extension. To this end, we translate the program into a transition system, which can then be used to verify the correct causal behavior with a model checker. We also list optimizations that can be used by compilers to conservatively approximate causality checking.