CMU, 5000 Forbes Av.
Pittsburgh, PA 15213
I'm a post-doctoral researcher in the POP group of the Carnegie Mellon University Computer Science Department. I work on high-level yet efficient parallel programming in SML with Umut Acar and his team.
Before that, I did a brief post-doc in the Gallium INRIA team, working with Umut and other researchers in the Deepsea project. We studied the granularity control techniques found in parallel runtime systems from a formal perspective.
I started my academic career as a PhD student in the PARKAS team of École normale supérieure de Paris and INRIA. My PhD thesis defines and studies a functional synchronous language in the vein of Lustre but better tailored to high-performance real-time systems. I was advised by Albert Cohen, Marc Pouzet, and Louis Mandel up until my graduation in January 2016.
As you might have guessed, my scientific interests center around the theory and practice of programming languages. I am especially interested in bridging the gap between high-level languages and performance-conscious programming. I have worked or am actively working on:
- functional languages and type systems;
- compiler design and implementation;
- synchronous programming and digital circuits;
- deterministic parallel programming.
Bursty Kahn Networks and Integer Clocks
A. Guatto, L. Mandel; JFLA'14; PDF (in French)
Data-flow synchronous languages à la Lustre offer an high-level equational formalism dedicated to the design and implementation of real-time systems. These languages have traditionally been restricted to critical systems with low computational demand; in particular, the generated code does not usually feature loops.
Lucy-n is a recent derivative of Lustre tailored to multimedia processing. In this paper, we propose an extension of Lucy-n's semantics where streams transport bursts of values rather than single scalars, and a type system characterizing the size of these bursts. The end goal is to adapt the code generation techniques in order to produce nested loops.
Correct and Efficient Bounded FIFO Queues
N.-M. Lê, A. Guatto, A. Cohen and A. Pop; SBAC-PAD 2013; PDF
This paper gives an efficient, portable and correct implementation of bounded single-producer single-consumer first-in first-out queues in C11. This data-structure can serve as an elementary building block for high-performance data-flow language runtimes.
A Modular Memory Optimization for Synchronous Data-flow Languages
L. Gérard, A. Guatto, C. Pasteur and M. Pouzet; LCTES 2012 (best paper); PDF
Data-flow synchronous programming languages are pure functional programming languages. Modifying a value thus consists in non-destructively introducing a new version of the same value. This is a problem when handling composte data structures such as arrays: a naive impelmentation will mandate the use of costly memory copies.
The paper proposes a two-level solution to drastically reduce the number of copies while preserving the original functional semantics. At the intra-procedural level, we use an algorithm akin to register allocation to share non-interfering local variables. At the inter-procedural level, a linear type system enables programmer-controlled modular memory sharing. These ideas have been implemented in an experimental compiler.
A Synchronous Functional Language with Integer Clocks
January 2016; PDF
My PhD thesis tackles the modular description of space/time tradeoffs in streaming programs at the language level. My work extends the n-synchronous framework proposed by Cohen, Mandel, Plateau, Pouzet and others. Clocks now feature arbitrary positive integers that model bursty communication between subprograms: integer clocks. The activation conditions of Lustre, revisited in this new setting, become local time scales that allow subprograms to perform several reactions atomically from the point of view of the context. The thesis details the integration of these features in a clock type system for a higher-order functional language, giving full formal treatment of its metatheory and compilation to finite-state digital circuits.
- The Lazy Task Creation Machine [PDF]; Gallium seminar (Jul. 2016)
- Integer Clocks and Local Time Scales; Bamberg University (May 2016)
- A Synchronous Functional Language with Integer Clocks [Keynote]; PhD defense (Jan. 2016)
- Integer Clocks and Local Time Scales [PDF]; Chalmers University (Sep. 2014), Birmingham University (Oct. 2014); Synchron'14
- Integer Clocks [PDF], Synchron'12
- Dynamic Scheduling of Synchronous Programs in Lucid Synchrone [PDF], Synchron'11
Synchronous Machines: a Traced Category
M. Bagnol and A. Guatto; 2012; HAL-INRIA
This paper describes a monoidal category of automata. We show how applying a categorical construction coming from models of linear logic gives for free a category with (linear) higher-order features.
SCADE/Lustre to VHDL research report
A. Guatto and M. Pouzet; 2010 PDF (in French)
This research report describes a straightforward translation from the synchronous programming language Lustre (and its industrial variant SCADE) to digital synchronous circuits. This procedure is fully automatic and produces synthesizable VHDL.
This is a very small step in the direction of a unified hardware/software programming language.
I used to be a developer of the Heptagon language and compiler. Heptagon is a modern dialect of Lustre offering separate compilation, hierarchical state machines, efficient array handling, hierarchical state machines, and controller synthesis. The compiler is written in OCaml and generates static C code. I implemented a large chunk of the C backend, some optimizations, as well as an experimental VHDL backend.
I was a teaching assistant at University Pierre et Marie Curie (UPMC) and the Polytech'UPMC engineering school during my PhD. The courses I participated in are listed below.
- C Programming [2011-2012] (Polytech'UPMC, CS/EE first year)
- Electronics Project [2011-2014] (UPMC, EE third year)
- Computer Architecture [2012-2014] (Polytech'UPMC, CS/EE first year)
- Synchronous Programming [2013-2014] (UPMC, CS fifth year)