[GGPP12]

Léonard Gérard, Adrien Guatto, Cédric Pasteur, and Marc Pouzet. A modular memory optimization for synchronous data-flow languages. In Proc. of the ACM International Conference on Languages, Compilers, Tools and Theory for Embedded Systems (LCTES'12), Beijing, China, June 2012. [ bib ]

> 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

[ADPG+11]

S. Aboubekr, G. Delaval, R. Pissard-Gibollet, É. Rutten, and D. Simon. Automatic generation of discrete handlers of real-time continuous control tasks. In Proc. 18th World Congress of the International Federation of Automatic Control (IFAC), Milano, Italy, August 2011. [ bib | .pdf ]

> 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.

[BPD+11]

Fabienne Boyer, Noël De Palma, Gwenaël Delaval, Olivier Gruber, and Eric Rutten. Case studies in discrete control for autonomic system administration. In Sixth International Workshop on Feedback Control Implementation and Design in Computing Systems and Networks (FeBID 2011), Karlsruhe, Germany, June 2011. [ bib | .pdf ]

> 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.

[BSDR11]

Tayeb Bouhadiba, Quentin Sabah, Gwenaël Delaval, and Éric Rutten. Synchronous control of reconfiguration in fractal component-based systems - a case study. Rapport de recherche RR-7631, INRIA, May 2011. [ bib | http | .pdf ]

> 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.

[DDR10]

Noël De Palma, Gwenaël Delaval, and Éric Rutten. Qos and energy management coordination using discrete controller synthesis. In 1st International Workshop on Green Computing Middleware (GCM'2010), Bangalore, India, November 2010. [ bib | .pdf ]

> 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.

[DR10b]

Gwenaël Delaval and Éric Rutten. Reactive model-based control of reconfiguration in the fractal component-based model. In 13th International Symposium on Component Based Software Engineering (CBSE 2010), Prague, Czech Republic, June 2010. [ bib | .pdf ]

> 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.

[DMR10]

Gwenaël Delaval, Hervé Marchand, and Éric Rutten. Contracts for modular discrete controller synthesis. In ACM International Conference on Languages, Compilers, and Tools for Embedded Systems (LCTES 2010), Stockholm, Sweden, April 2010. [ bib | .pdf ]

> 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.

[DR10a]

Gwenaël Delaval and Éric Rutten. A language-based approach to the discrete control of adaptive resource management. In Workshop on Adaptive Resource Management (WARM 2010), Stockholm, Sweden, April 2010. [ bib | .pdf ]

> 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.

[ADR09]

Soufyane Aboubekr, Gwenaël Delaval, and Éric Rutten. A programming language for adaptation control: Case study. In 2nd Workshop on Adaptive and Reconfigurable Embedded Systems (APRES 2009). ACM SIGBED Review, volume 6, Grenoble, France, October 2009. [ bib | .pdf ]

> 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.

[GYDR09]

Abdoulaye Gamatié, Huafeng Yu, Gwenaël Delaval, and Éric Rutten. A case study on controller synthesis for data-intensive embedded systems. In Proceedings of the 6th IEEE International Conference on Embedded Software and Systems (ICESS'2009), HangZhou, Zhejiang, China, May 2009. [ bib ]

> 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.

[DR07]

Gwenaël Delaval and Éric Rutten. A domain-specific language for multitask systems, applying discrete controller synthesis. EURASIP Journal on Embedded Systems, 2007:Article ID 84192, 17 pages, 2007. [ bib | DOI | .pdf ]

> 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

[DR06] | G. Delaval and E. Rutten. A domain-specific language for task handlers generation, applying discrete controller synthesis. In SAC '06: Proceedings of the 2006 ACM Symposium on Applied computing, pages 901-905, Dijon, France, April 2006. ACM Press. [ bib | DOI | .ps.gz | .pdf ]
[DR05] | G. Delaval and E. Rutten. A domain-specific language for multi-task systems, applying discrete controller synthesis. Rapport de recherche INRIA nº5690, September 2005. [ bib | .ps.gz | .pdf ]

This file was generated by bibtex2html 1.95.