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