# publis.bib

    @inproceedings{Gerard:2012,
      author = {L{\'e}onard G{\'e}rard and Adrien Guatto and
                      C{\'e}dric Pasteur and Marc Pouzet},
      title = {A Modular Memory Optimization for Synchronous
                      Data-Flow Languages},
      booktitle = {Proc. of the ACM International Conference on
                      Languages, Compilers, Tools and Theory for Embedded
                      Systems (LCTES'12)},
      date-added = {2012-07-04 16:11:46 +0200},
      date-modified = {2012-07-04 16:15:18 +0200},
      keywords = {synchronous programming; type system},
      year = 2012,
      month = jun,
      address = {Beijing, China},
      abstract = {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. }
    }

    @misc{rr-nemo,
      author = {Delaval, G. and Rutten, E.},
      title = {A Domain-Specific Language for Multi-task Systems,
                      applying Discrete Controller Synthesis},
      howpublished = {Rapport de recherche INRIA nº5690},
      month = sep,
      year = 2005,
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/RR-5690.pdf},
      ps = {http://pop-art.inrialpes.fr/people/delaval/pub/RR-5690.ps.gz}
    }

    @inproceedings{delaval06:_domain_specif_languag_multi_system,
      author = {Delaval, G. and Rutten, E.},
      title = {A Domain-specific Language for Task Handlers
                      Generation, Applying Discrete Controller Synthesis},
      booktitle = {SAC '06: Proceedings of the 2006 ACM Symposium on
                      Applied computing},
      year = 2006,
      address = {Dijon, France},
      month = apr,
      isbn = {1-59593-108-2},
      pages = {901--905},
      doi = {10.1145/1141277.1141487},
      publisher = {ACM Press},
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/article-nemo.pdf},
      ps = {http://pop-art.inrialpes.fr/people/delaval/pub/article-nemo.ps.gz}
    }

    @article{delaval07:_nemo_jes,
      author = {Delaval, Gwenaël and Rutten, Éric },
      title = {A Domain-Specific Language for Multitask Systems,
                      Applying Discrete Controller Synthesis},
      journal = {EURASIP Journal on Embedded Systems},
      year = 2007,
      volume = 2007,
      pages = {Article ID 84192, 17 pages},
      doi = {10.1155/2007/84192},
      abstract = {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},
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/nemo-jes2007.pdf}
    }

    @inproceedings{delaval10:_contracts_mod_dcs,
      author = {Delaval, Gwena\"{e}l and Marchand, Herv\'{e} and
                      Rutten, \'{E}ric},
      title = {Contracts for Modular Discrete Controller Synthesis},
      booktitle = {ACM International Conference on Languages,
                      Compilers, and Tools for Embedded Systems (LCTES
                      2010)},
      year = 2010,
      address = {Stockholm, Sweden},
      month = apr,
      abstract = {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.},
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/lctes2010.pdf}
    }

    @inproceedings{aboubekr09:_prog_lg_adapt_ctr,
      author = {Aboubekr, Soufyane and Delaval, Gwena\"{e}l and
                      Rutten, \'{E}ric},
      title = {A Programming Language for Adaptation Control: Case
                      Study},
      booktitle = {2nd Workshop on Adaptive and Reconfigurable Embedded
                      Systems (APRES 2009). ACM SIGBED Review},
      year = 2009,
      volume = 6,
      number = 3,
      address = {Grenoble, France},
      month = oct,
      abstract = {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.},
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/apres09.pdf}
    }

    @inproceedings{delaval10:_warm,
      author = {Delaval, Gwena\"{e}l and Rutten, \'{E}ric},
      title = {A Language-Based Approach to the Discrete Control of
                      Adaptive Resource Management},
      booktitle = {Workshop on Adaptive Resource Management (WARM
                      2010)},
      year = 2010,
      address = {Stockholm, Sweden},
      month = apr,
      abstract = {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.},
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/warm10.pdf}
    }

    @inproceedings{delaval10:_react_model_based_contr_of,
      author = {Delaval, Gwena\"{e}l and Rutten, \'{E}ric},
      title = {Reactive model-based control of reconfiguration in
                      the Fractal component-based model},
      booktitle = {13th International Symposium on Component Based
                      Software Engineering (CBSE 2010)},
      year = 2010,
      address = {Prague, Czech Republic},
      month = jun,
      abstract = {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.},
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/delaval-cbse10.pdf}
    }

    @inproceedings{gcm10:_qos_energ_coord_dcs,
      author = {{De Palma}, No\"{e}l and Delaval, Gwena\"{e}l and
                      Rutten, \'{E}ric},
      title = {QoS and Energy Management Coordination using
                      Discrete Controller Synthesis},
      booktitle = {1st International Workshop on Green Computing
                      Middleware (GCM'2010)},
      year = 2010,
      address = {Bangalore, India},
      month = nov,
      abstract = {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.},
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/delaval-gcm10.pdf}
    }

    @inproceedings{aboubekr11:_autom,
      author = {S. Aboubekr and G. Delaval and R.  Pissard-Gibollet
                      and {\'E}. Rutten and D. Simon},
      title = {Automatic generation of discrete handlers of
                      real-time continuous control tasks},
      booktitle = {Proc.  18th World Congress of the International
                      Federation of Automatic Control (IFAC)},
      address = {Milano, Italy},
      month = aug,
      year = 2011,
      abstract = {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.  },
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/bzrccad.pdf}
    }

    @inproceedings{boyer11:_discr_contr_auton_system,
      author = {Fabienne Boyer and No\"{e}l De Palma and Gwena\"{e}l
                      Delaval and Olivier Gruber and Eric Rutten},
      title = {Case Studies in Discrete Control for Autonomic
                      System Administration },
      booktitle = {Sixth International Workshop on Feedback Control
                      Implementation and Design in Computing Systems and
                      Networks (FeBID 2011)},
      year = 2011,
      address = {Karlsruhe, Germany},
      month = jun,
      abstract = {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.},
      pdf = {http://pop-art.inrialpes.fr/people/delaval/pub/febid2011.pdf}
    }

    @techreport{bouhadiba11:_sdc_fract,
      hal_id = {inria-00596883},
      url = {http://hal.inria.fr/inria-00596883/en/},
      title = {Synchronous Control of Reconfiguration in Fractal
                      Component-based Systems -- a Case Study},
      author = {Bouhadiba, Tayeb and Sabah, Quentin and Delaval,
                      Gwena{\"e}l and Rutten, \'Eric},
      abstract = {{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.},
      language = {Anglais},
      affiliation = {SARDES - INRIA Grenoble Rh{\^o}ne-Alpes / LIG
                      Laboratoire d'Informatique de Grenoble - INRIA -
                      Institut National Polytechnique de Grenoble - INPG -
                      Universit\'e Joseph Fourier - Grenoble I -
                      Universit\'e Pierre Mend\`es-France - Grenoble II -
                      CNRS : UMR5217},
      pages = 31,
      type = {Rapport de recherche},
      institution = {INRIA},
      number = {RR-7631},
      year = 2011,
      month = may,
      pdf = {http://hal.inria.fr/inria-00596883/PDF/RR-7631.pdf}
    }

    @inproceedings{gamatie09:_case_study_contr_synth_for,
      author = {Gamati\'e, Abdoulaye and Yu, Huafeng and Delaval,
                      Gwena\"el and Rutten, \'Eric},
      title = {A Case Study on Controller Synthesis for
                      Data-Intensive Embedded Systems},
      booktitle = {Proceedings of the 6th IEEE International Conference
                      on Embedded Software and Systems (ICESS'2009)},
      year = 2009,
      address = {HangZhou, Zhejiang, China},
      month = may,
      abstract = {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.}
    }

This file was generated by bibtex2html 1.95.