The generation of efficient sequential code for synchronous data-flow languages raises two intertwined issues: control and memory optimization. While the former has been extensively studied, for instance in the compilation of LUSTRE and SIGNAL, the latter has only been addressed in a restricted manner. Yet, memory optimization becomes a pressing issue when arrays are added to such languages. This article presents a two-level solution to the memory optimization problem. It combines a compile-time optimization algorithm, reminiscent of register allocation, paired with language annotations on the source given by the designer. Annotations express in-place modifications and control where allocation is performed. Moreover, they allow external functions performing in-place modifications to be safely imported. Soundness of annotations is guaranteed by a semilinear type system and additional scheduling constraints. A key feature is that annotations for well-typed programs do not change the semantics of the language: removing them may lead to less efficient code but will not alter the semantics. The method has been implemented in a new compiler for a LUSTRE-like synchronous language extended with hierarchical automata and arrays. Experiments show that the proposed approach removes most of the unnecessary array copies, resulting in faster code that uses less memory.

Keywords: synchronous programming; type system

We present a novel technique for designing discrete, logical control loops, on top of continuous control tasks, ensuring logical safety properties of the tasks sequencings and mode changes. We define this new handler on top of the real-time executives built with the Orccad design environment for control systems, which is applied, e.g. to robotics and real-time networked control. It features structures of control tasks, each equipped with a local automaton, used for the reactive, event-based management of its activity and modes. The additional discrete handler manages the interactions between tasks, concerning, e.g., mutual exclusions, forbidden or imposed sequences. We use a new reactive programming language, with constructs for finite-state machines and data-flow nodes, and a mechanism of behavioral contracts, which involves discrete controller synthesis. The result is a discrete control loop, on top of the continuous control loops, all integrated in a coherent real-time architecture. Our approach is illustrated and validated experimentally with the case study of a robot arm.

This paper presents examples of autonomic system administration issues that can be addressed and solved as discrete control problems. This shows evidence of the relevance of control techniques for the discrete aspects of closed-loop control of computing systems. The model-based control of adaptive and reconfigurable systems is considered via a reactive programming language, based on discrete controller synthesis (DCS) techniques. We identify control problems in autonomic systems belonging to the class of logical, discrete systems, and illustrate how to solve them using DCS.

In the context of component-based embedded systems, the management of dynamic reconfiguration in adaptive systems is an increasingly important feature. The Fractal component-based framework, and its industrial instantiation MIND, provide for support for control operations in the lifecycle of components. Nevertheless, the use of complex and integrated architectures make the management of this reconfiguration operations difficult to handle by programmers. To address this issue, we propose to use Synchronous languages, which are a complete approach to the design of reactive systems, based on behavior models in the form of transition systems. Furthermore, the design of closed-loop reactive managers of reconfigurations can benefit from formal tools like Discrete Controller Synthesis. In this paper we describe an approach to concretely integrate synchronous reconfiguration managers in Fractal component-based systems. We describe how to model the state space of the control problem, and how to specify the control objectives. We describe the implementation of the resulting manager with the Fractal/Cecilia programming environment, taking advantage of the Comete distributed middleware. We illustrate and validate it with the case study of the Comanche HTTP server on a multi-core execution platform.

Keywords: Component-based systems, synchronous programming, reconfigurable systems, discrete controller synthesis.

Green computing is nowadays a major challenge for most IT organizations. Administrators have to manage the trade-off between system performances and energy saving goals. Autonomic computing is a promising approach to control the QoS and the energy consumed by a system. This paper precisely investigates the use of synchronous programming and discrete controller synthesis to automate the generation of a controller that enforces the required coordination between QoS and energy managers. We illustrate our approach by describing the coordination between a simple admission controller and an energy controller.

We present a technique for designing reconfiguration controllers in the Fractal component-based framework. We obtain discrete control loops that automatically enforce safety properties on the interactions between components, concerning, e.g., mutual exclusions, forbidden or imposed sequences. We use a reactive programming language, with a new mechanism of behavioural contracts. Its compilation involves discrete controller synthesis, which automatically generates the correct adaptation controllers. We apply our approach to the problem of adaptive ressource management, illustrated by the example of a HTTP server.

We describe the extension of a reactive programming language with a behavioral contract construct. It is dedicated to the programming of reactive control of applications in embedded systems, and involves principles of the supervisory control of discrete event systems. Our contribution is in a language approach where modular discrete controller synthesis (DCS) is integrated, and it is concretized in the encapsulation of DCS into a compilation process. From transition system specifications of possible behaviors, DCS automatically produces controllers that make the controlled system satisfy the property given as objective. Our language features and compiling technique provide correctness-by-construction in that sense, and enhance reliability and verifiability. Our application domain is adaptive and reconfigurable systems: closed-loop adaptation mechanisms enable flexible execution of functionalities w.r.t. changing resource and environment conditions. Our language can serve programming such adaption controllers. This paper particularly describes the compilation of the language. We present a method for the modular application of discrete controller synthesis on synchronous programs, and its integration in the BZR language. We consider structured programs, as a composition of nodes, and first apply DCS on particular nodes of the program, in order to reduce the complexity of the controller computation; then, we allow the abstraction of parts of the program for this computation; and finally, we show how to recompose the different controllers computed from different abstractions for their correct co-execution with the initial program. Our work is illustrated with examples, and we present quantitative results about its implementation.

We present a novel technique for designing discrete control loops for adaptive systems. They automatically enforce safety properties on the interactions between tasks, concerning, e.g., mutual exclusions, forbidden or imposed sequences. We use a new reactive programming language, with a mechanism of behavioural contracts. Its compilation involves discrete controller synthesis, which automatically generates the correct appropriate adaptation controllers. We apply our approach to the problem of adaptive ressource management, illustrated by the example of a HTTP server.

We illustrate an approach for the safe design of adaptive embedded systems. It applies the BZR programming language, featuring a special new contract mechanism: its compilation involves automatical discrete controller synthesis. The contribution of this paper is to illustrate how it can be used to enforce the correct adaptation control of the application, meeting execution constraints, with the case study of a video module of a multimedia cellular phone.

This paper presents an approach for the safe design of data-intensive embedded systems. A multimedia application module of last generation cellular phones is considered as a case study. The OMG standard profile MARTE is used to adequately model the application. The resulting model is then transformed into a synchronous program from which a controller is synthesized by using a formal technique, in order to enforce the safe behavior of the modeled application while meeting quality of service requirements. The whole study is carried out in a design framework, GASPARD, dedicated to high-performance embedded systems.

We propose a simple programming language, called Nemo, specific to the domain of multi-task real-time control systems, such as in robotic, automotive or avionics systems. It can be used to specify a set of resources with usage constraints, a set of tasks that consume them according to various modes, and applications sequencing the tasks. We obtain automatically an application-specific task handler that correctly manages the constraints (if there exists one), through a compilation-like process including a phase of discrete controller synthesis. This way, this formal technique contributes to the safety of the designed systems, while being encapsulated in a tool that makes it useable by application experts. Our approach is based on the synchronous modelling techniques, languages and tools.

Keywords: real-time systems, safe design, domain-specific language, discrete control synthesis, synchronous programming