@inproceedings{lucy:islip95, author = {Paul Caspi and Marc Pouzet}, title = {{A Functional Extension to Lustre}}, booktitle = {International Symposium on Languages for Intentional Programming}, year = 1995, month = {May}, address = {Sydney, Australia}, editor = {M.~A. Orgun and E.~A. Ashcroft}, publisher = {World Scientific}, url = {islip95.ps.gz} }
@inproceedings{lucy:jfla96, author = {Paul Caspi et Marc Pouzet}, title = {{R\'eseaux de Kahn Synchrones}}, booktitle = {Journ\'ees Francophones des Langages Applicatifs (JFLA)}, year = 1996, month = {28-30 janvier}, address = {Val Morin (Qu\'ebec), Canada}, url = {jfla96.ps.gz} }
@inproceedings{lucy:icfp96, author = {Paul Caspi and Marc Pouzet}, title = {{Synchronous Kahn Networks}}, booktitle = {ACM SIGPLAN International Conference on Functional Programming}, year = 1996, month = {May}, address = {Philadelphia, Pensylvania}, url = {icfp96.ps.gz} }
@inproceedings{lucy:cmcs98, author = {Paul Caspi and Marc Pouzet}, title = {{A Co-iterative Characterization of Synchronous Stream Functions}}, booktitle = {Coalgebraic Methods in Computer Science (CMCS'98)}, series = {Electronic Notes in Theoretical Computer Science}, year = 1998, month = {March}, note = {Extended version available as a VERIMAG tech. report no. 97--07 at {\tt www.lri.fr/$\sim$pouzet}}, url = {cmcs98.ps.gz}, url = {coiteration-report98.ps.gz} }
@techreport{lucy:verimag97, author = {Paul Caspi and Marc Pouzet}, title = {{A Co-iterative Characterization of Synchronous Stream Functions}}, institution = {VERIMAG}, year = 1997, number = 07, month = {October}, url = {coiteration-report98.ps.gz} }
@inproceedings{lucy:jfla99, author = {Paul Caspi and Marc Pouzet}, title = {{Lucid Synchrone: une extension fonctionnelle de Lustre}}, booktitle = {Journ\'ees Francophones des Langages Applicatifs (JFLA)}, year = 1999, address = {Morzine-Avoriaz}, month = {F\'evrier}, publisher = {INRIA}, url = {jfla99.ps.gz} }
@inproceedings{lucy:jfla99-2, author = {Gr\'egoire Hamon and Marc Pouzet}, title = {{Un Simulateur Synchrone pour Lucid Synchrone}}, booktitle = {Journ\'ees Francophones des Langages Applicatifs (JFLA)}, year = 1999, address = {Morzine-Avoriaz}, month = {F\'evrier}, publisher = {INRIA}, url = {jfla99-2.ps.gz} }
@misc{lucy:genie00, author = {Jean-Louis Cola\c{c}o et Marc Pouzet}, title = {{Prototypages}}, howpublished = {Rapport final du projet GENIE II, Verilog SA}, month = {Janvier}, year = 2000 }
@manual{lucy:manual99, title = {{Lucid Synchrone, version 1.01. Tutorial and reference manual}}, author = {Paul Caspi and Marc Pouzet}, organization = {Laboratoire d'Informatique de Paris 6}, month = {January}, year = 1999 }
@manual{lucy:manual01, author = {Marc Pouzet}, title = {{Lucid Synchrone}, version 2. {Tutorial and reference manual}}, organization = {Universit\'e Pierre et Marie Curie, LIP6}, month = {Mai}, year = 2001, note = {Distribution available at: {\tt www.lri.fr/$\sim$pouzet/lucid-synchrone}} }
@manual{lucy:manual06, author = {Marc Pouzet}, title = {{Lucid Synchrone}, version 3. {Tutorial and reference manual}}, organization = {Universit\'e Paris-Sud, LRI}, month = {April}, year = 2006, note = {Distribution available at: {\tt www.lri.fr/$\sim$pouzet/lucid-synchrone}} }
@techreport{lucy:lip6-00, author = {Paul Caspi and Marc Pouzet}, title = {{Lucid Synchrone}, a functional extension of {Lustre}}, institution = {Universit\'e Pierre et Marie Curie, Laboratoire LIP6}, year = 2000 }
@unpublished{lucy:toplas, author = {Paul Caspi and Marc Pouzet}, title = {{Lucid Synchrone}, a functional extension of {Lustre}}, note = {Submitted to publication}, year = 2002 }
@inproceedings{lucy:ppdp00, author = {Gr\'egoire Hamon and Marc Pouzet}, title = {{Modular Resetting of Synchronous Data-flow Programs}}, booktitle = {ACM International conference on Principles of Declarative Programming (PPDP'00)}, year = 2000, address = {Montreal, Canada}, month = {September}, url = {ppdp00.ps.gz}, abstract = { This paper presents an extension of a synchronous data-flow language providing full functionality with a modular reset operator. This operator can be considered as a basic primitive for describing dynamic reconfigurations in a purely data-flow 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.} }
@inproceedings{lucy:esop01, author = {Pascal Cuoq and Marc Pouzet}, title = {{Modular Causality in a Synchronous Stream Language}}, booktitle = {European Symposium on Programming (ESOP'01)}, year = 2001, address = {Genova, Italy}, month = {April}, url = {esop01.ps.gz}, abstract = {This article presents a causality analysis for a synchronous stream language with higher-order functions. This analysis takes the shape of a type system with rows. Rows were \hbox{originally} designed to add extensible records to the ML type system (Didier R\'emy, Mitchell Wand). We \hbox{also} restate briefly the coiterative semantics for synchronous streams (Paul Caspi, Marc Pouzet), and prove the correctness of our analysis with respect to this semantics.} }
@inproceedings{lucy:lpar01, author = {Sylvain Boulm\'e and Gr\'egoire Hamon}, title = {{Certifying Synchrony for Free}}, booktitle = {International Conference on Logic for Programming, Artificial Intelligence and Reasoning (LPAR)}, year = 2001, volume = 2250, address = {La Havana, Cuba}, month = {December}, publisher = {Lecture Notes in Artificial Intelligence, Springer-Verlag}, note = {Short version of {\em A clocked denotational semantics for {L}ucid-{S}ynchrone in {C}oq}, available as a Technical Report (LIP6), at {\tt www.lri.fr/$\sim$pouzet}}, url = {lpar01.ps.gz}, url = {lucid_in_coq_report.ps.gz}, abstract = {We express reactive programs in Coq using data-flow synchronous operators. Following Lucid Synchrone approach, synchro\-nous static constraints are here expressed using dependent types. Hence, our analysis of synchrony is here directly performed by Coq typechecker.} }
@inproceedings{lucy:slap02, author = {Jean-Louis Cola\c{c}o and Marc Pouzet}, title = {{Type-based Initialization Analysis of a Synchronous Data-flow Language}}, booktitle = {{Synchronous Languages, Applications, and Programming}}, publisher = {Electronic Notes in Theoretical Computer Science}, volume = 65, year = 2002, url = {slap02.ps.gz}, abstract = {One of the appreciated features of the synchronous data-flow approach is that a program defines a perfectly deterministic behavior. But the use of the delay primitive leads to undefined values at the first cycle; thus a data-flow program is really deterministic only if it can be shown that such undefined values do not affect the behavior of the system. This paper presents an {\em initialization analysis} that guarantees the deterministic behavior of programs. This property being undecidable in general, the paper proposes a safe approximation of the property, precise enough for most data-flow programs. This analysis is a {\em one-bit} analysis --- expressions are either initialized or uninitialized --- and is defined as an inference type system with sub-typing constraints. This analysis has been implemented in the Lucid Synchrone~compiler and in a new Scade-Lustre prototype compiler. It gives very good results in practice.} }
@inproceedings{lucy:hamon-slap04, author = {Gr\'egoire Hamon}, title = {{Synchronous Data-flow Pattern Matching}}, booktitle = {{Synchronous Languages, Applications, and Programming}}, publisher = {Electronic Notes in Theoretical Computer Science}, year = 2004, url = {hamon-slap04.ps.gz} }
@phdthesis{lucy:these-hamon02, author = {Gr\'egoire Hamon}, title = {{Calcul d'horloge et Structures de Contr\^ole dans Lucid Synchrone, un langage de flots synchrones \`a la ML}}, school = {Universit\'e Pierre et Marie Curie}, year = 2002, address = {Paris, France}, month = {14 novembre} }
@phdthesis{lucy:these-cuoq02, author = {Pascal Cuoq}, title = {{Ajout de synchronisme dans les langages fonctionnels typ\'es}}, school = {Universit\'e Pierre et Marie Curie}, year = 2002, address = {Paris, France}, month = {october} }
@manual{lucy:habilitation-pouzet02, author = {Marc Pouzet}, title = {{Lucid Synchrone}: un langage synchrone d'ordre sup\'erieur}, organisation = {Universit\'e Pierre et Marie Curie}, year = 2002, address = {Paris, France}, month = {14 novembre}, note = {Habilitation \`a diriger les recherches }, url = {habilitation-pouzet02.ps.gz} }
@inproceedings{lucy:emsoft03, author = {Jean-Louis Cola\c{c}o and Marc Pouzet}, title = {{Clocks as First Class Abstract Types}}, booktitle = {Third International Conference on Embedded Software (EMSOFT'03)}, address = {Philadelphia, Pennsylvania, USA}, month = {october}, year = 2003, url = {emsoft03.ps.gz}, abstract = {Clocks in synchronous data-flow languages are the natural way to define several time scales in reactive systems. They play a fundamental role during the specification of the system and are largely used in the compilation process to generate efficient sequential code. Based on the formulation of clocks as {\em dependent types}, the paper presents a simpler clock calculus reminiscent to ML type systems with first order abstract types {\em \`a la} Laufer \& Odersky. Not only this system provides clock inference, it shares efficient implementations of ML type systems and appears to be expressive enough for many real applications.} }
@inproceedings{lucy:emsoft04, author = {Jean-Louis Cola\c{c}o and Alain Girault and Gr\'egoire Hamon and Marc Pouzet}, title = {{Towards a Higher-order Synchronous Data-flow Language}}, booktitle = {ACM Fourth International Conference on Embedded Software (EMSOFT'04)}, address = {Pisa, Italy}, month = {september}, year = 2004, url = {emsoft04.pdf}, abstract = {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 Lucid Synchrone. 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.} }
@article{lucy:sttt04, author = {Jean-Louis Cola\c{c}o and Marc Pouzet}, title = {{Type-based Initialization Analysis of a Synchronous Data-flow Language}}, journal = {International Journal on Software Tools for Technology Transfer (STTT)}, year = {2004}, month = {August}, volume = {6}, number = {3}, pages = {245--255} }
@unpublished{lucy:jfp05, author = {Jean-Louis Cola\c{c}o and Marc Pouzet}, title = {{Clocks as First Class Abstract Types}}, note = {Submitted to the Journal of Functional Programming (JFP)}, year = 2005 }
@article{lucy:tecs06, author = {Alain Girault and Xavier Nicollin and Marc Pouzet}, title = {{Automatic Rate Desynchronization of Embedded Reactive Programs}}, journal = {ACM Transactions on Embedded Computing Systems (TECS)}, volume = 5, number = 3, year = 2006 }
@inproceedings{lucy:emsoft05a, author = {Albert Cohen and Marc Duranton and Christine Eisenbeis and Claire Pagetti and Florence Plateau and Marc Pouzet}, title = {{Synchroning Periodic Clocks}}, booktitle = {ACM International Conference on Embedded Software (EMSOFT'05)}, address = {Jersey city, New Jersey, USA}, month = {September}, year = 2005, url = {emsoft05a.pdf.gz} }
@inproceedings{lucy:emsoft05b, author = {Jean-Louis Cola\c{c}o and Bruno Pagano and Marc Pouzet}, title = {{A Conservative Extension of Synchronous Data-flow with State Machines}}, booktitle = {ACM International Conference on Embedded Software (EMSOFT'05)}, address = {Jersey city, New Jersey, USA}, month = {September}, year = 2005, url = {emsoft05b.pdf.gz}, abstract = {This paper presents an extension of a synchronous data-flow language such as Lustre with imperative features expressed in terms of powerful state machine \`a la SyncChart. This extension is fully conservative in the sense that all the programs from the basic language still make sense in the extended language and their semantics is preserved. From a syntactical point of view this extension consists in hierarchical state machines that may carry at each hierarchy level a bunch of equations. This proposition is an alternative to the joint use of Simulink and Stateflow but improves it by allowing a fine grain mix of both styles. The central idea of the paper is to base this extension on the use of clocks, translating imperative constructs into well clocked data-flow programs from the basic language. This clock directed approach is an easy way to define a semantics for the extension, it is light to implement in an existing compiler and experiments show that the generated code compete favorably with ad-hoc techniques. The proposed extension has been implemented in the ReLuC compiler of Scade/Lustre and in the Lucid Synchrone compiler. } }
@inproceedings{lucy:popl06, author = {Albert Cohen and Marc Duranton and Christine Eisenbeis and Claire Pagetti and Florence Plateau and Marc Pouzet}, title = {{$N$-Synchronous Kahn Networks: a Relaxed Model of Synchrony for Real-Time Systems}}, booktitle = {ACM International Conference on Principles of Programming Languages (POPL'06)}, address = {Charleston, South Carolina, USA}, month = {January}, year = 2006, url = {popl06.pdf}, abstract = { The design of high-performance stream-processing systems is a fast growing domain, driven by markets such like high-end TV, gaming, 3D animation and medical imaging. It is also a surprisingly demanding task, with respect to the algorithmic and conceptual simplicity of streaming applications. It needs the close cooperation between numerical analysts, parallel programming experts, real-time control experts and computer architects, and incurs a very high level of quality insurance and optimization. In search for improved productivity, we propose a programming model and language dedicated to high-performance stream processing. This language builds on the synchronous programming model and on domain knowledge --- the periodic evolution of streams --- to allow correct-by-construction properties to be proven by the compiler. These properties include resource requirements and delays between input and output streams. Automating this task avoids tedious and error-prone engineering, due to the combinatorics of the composition of filters with multiple data rates and formats. Correctness of the implementation is also difficult to assess with traditional (asynchronous, simulation-based) approaches. This language is thus provided with a relaxed notion of synchronous composition, called $n$-\emph{synchrony}: two processes are $n$-synchronous if they can communicate in the ordinary ($0$-)synchronous model with a FIFO buffer of size $n$. Technically, we extend a core synchronous data-flow language with a notion of periodic clocks, and design a relaxed clock calculus (a type system for clocks) to allow non strictly synchronous processes to be composed or correlated. This relaxation is associated with two sub-typing rules in the clock calculus. Delay, buffer insertion and control code for these buffers are automatically inferred from the clock types through a systematic transformation into a standard synchronous program. We formally define the semantics of the language and prove the soundness and completeness of its clock calculus and synchronization transformation. Finally, the language is compared with existing formalisms.} }
@inbook{lucy:hermes06, author = {Paul Caspi and Gr\'egoire Hamon and Marc Pouzet}, editor = {Nicolas Navet}, title = {Syst\`emes Temps-r\'eel~: Techniques de Description et de V\'erification -- Th\'eorie et Outils}, chapter = {Lucid Synchrone, un langage de programmation des syst\`emes r\'eactifs}, publisher = {Hermes}, volume = {1}, year = 2006, pages = {217-260}, abstract = {Ce chapitre pr\'esente {\bf Lucid Synchrone}, un langage d\'edi\'e \`a la programmation de syst\`emes r\'eactifs. Il est fond\'e sur le mod\`ele synchrone de {\bf Lustre} qu'il \'etend avec des caract\'eristiques pr\'esentes dans les langages fonctionnels tels que l'ordre sup\'erieur ou l'inf\'erence des types. Il offre un m\'ecanisme de synth\`ese automatique des horloges et permet de d\'ecrire, dans un cadre unifi\'e, une programmation flot de donn\'ees et une programmation par automates. Ce chapitre est une pr\'esentation du langage, destin\'ee \`a la fois au programmeur cherchant \`a se familiariser avec celui-ci, mais aussi au chercheur s'int\'eressant aux syst\`emes r\'eactifs et aux techniques qui peuvent \^etre appliqu\'ees au niveau d'un langage, pour faciliter les activit\'es de sp\'ecification, de programmation et de v\'erification. } }
@inproceedings{lucy:emsoft06, author = {Jean-Louis Cola\c{c}o and Gr\'egoire Hamon and Marc Pouzet}, title = {{Mixing Signals and Modes in Synchronous Data-flow Systems}}, booktitle = {ACM International Conference on Embedded Software (EMSOFT'06)}, address = {Seoul, South Korea}, month = {October}, year = 2006, url = {emsoft06.pdf}, abstract = { Synchronous data-flow languages such as SCADE/Lustre manage infinite sequences or {\em streams} as primitive values making them naturally adapted to the description of data-dominated systems. Their conservative extension with means to define control-structures or {\em modes} have been a long-term research topic and 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 {\em 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 data-flow languages. Together, they allow for a much more direct and natural programming of systems that combine data-flow and state-machines. The proposed extension is fully implemented in the new Lucid Synchrone compiler. } }
@inproceedings{labbe07, author = {S\'ebastien Labb\'e and Jean-Pierre Gallois and Marc Pouzet}, title = {Slicing Communicating Automata Specifications For Efficient Model Reduction}, booktitle = {18th Australian Conference on Software Engineering (ASWEC)}, year = 2007 }
@inbook{lucy:iste07, author = {Paul Caspi and Gr\'egoire Hamon and Marc Pouzet}, title = {Real-Time Systems: Models and verification --- Theory and tools}, chapter = {Synchronous Functional Programming with Lucid Synchrone}, publisher = {ISTE}, year = 2007, note = {English version of \cite{lucy:hermes06}. Published during year 2007} }
@misc{lucy:caspicolacopouzet07, author = {Paul Caspi and Jean-Louis Cola\c{c}o and Marc Pouzet}, title = {{Objects in Block-Diagram Languages}}, month = {January}, year = 2008, note = {Unpublished} }
@inproceedings{lucy:apges07, author = {Darek Biernacki and Jean-Louis Colaco and Marc Pouzet}, title = {{Modular Compilation from Synchronous Block-diagrams}}, booktitle = {Workshop on Automatic Program Generation for Embedded Systems (APGES)}, year = 2007, address = {Salzburg, Austria}, month = {october}, note = {Embedded System Week} }
@inproceedings{lucy:lctes08b, author = {Gwenael Delaval and Alain Girault and Marc Pouzet}, title = {{A Type System for the Automatic Distribution of Higher-order Synchronous Dataflow Programs}}, booktitle = {ACM International Conference on Languages, Compilers, and Tools for Embedded Systems (LCTES)}, year = 2008, address = {Tucson, Arizona}, month = {June}, abstract = {We address the design of distributed systems with synchronous dataflow programming languages. As modular design entails handling both architecture and functional modularity, our first contribution is to extend an existing synchronous dataflow programming language with primitives allowing the description of a distributed architecture and the localization of some expressions onto some processors. We also present a distributed semantics to formalize the distributed execution of synchronous programs. Our second contribution is to provide a type system, in order to infer the localization of non-annotated values by means of type inference and to ensure, at compilation time, the consistency of the distribution. Our third contribution is to provide a type-directed projection operation to obtain automatically, from a centralized typed program, the local program to be executed by each computing resource. The type system as well as the automatic distribution mechanism has been fully implemented in the compiler of an existing synchronous data-flow programming language. } }
@inproceedings{lucy:lctes08a, author = {Darek Biernacki and Jean-Louis Colaco and Gr\'egoire Hamon and Marc Pouzet}, title = {{Clock-directed Modular Code Generation of Synchronous Data-flow Languages}}, booktitle = {ACM International Conference on Languages, Compilers, and Tools for Embedded Systems (LCTES)}, year = 2008, address = {Tucson, Arizona}, month = {June}, abstract = {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, 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. } }
This file was generated by bibtex2html 1.91.