inproceedings by Xavier Leroy
The correct compilation of block diagram languages like Lustre, Scade, and a discrete subset of S... more The correct compilation of block diagram languages like Lustre, Scade, and a discrete subset of Simulink is important since they are used to program critical embedded control software. We describe the specification and verification in an Interactive Theorem Prover of a compilation chain that treats the key aspects of Lustre: sampling, nodes, and delays. Building on CompCert, we show that repeated execution of the generated assembly code faithfully implements the dataflow semantics of source programs. We resolve two key technical challenges. The first is the change from a synchronous dataflow semantics, where programs manipulate streams of values, to an imperative one, where computations manipulate memory sequentially. The second is the verified compilation of an imperative language with encapsulated state to C code where the state is realized by nested records. We also treat a standard control optimization that eliminates unnecessary conditional statements.
Bookmarks Related papers MentionsView impact
The paper addresses theoretical and practical aspects of implementing multi-stage languages using... more The paper addresses theoretical and practical aspects of implementing multi-stage languages using abstract syntax trees (ASTs), gensym, and reflection. We present an operational account of the correctness of this approach, and report on our experience with a bytecode compiler called MetaOCaml that is based on this strategy. Current performance measurements reveal interesting characteristics of the underlying OCaml compiler, and illustrate why this strategy can be particularly useful for implementing domain-specific languages in a typed, functional setting.
Bookmarks Related papers MentionsView impact
Preliminary version of \cite{Pessaux-Leroy-exn
Bookmarks Related papers MentionsView impact
This paper present a new approach to the polymorphic typing of data accepting in-place modificati... more This paper present a new approach to the polymorphic typing of data accepting in-place modification in ML-like languages. This approach is based on restrictions over type generalization, and a refined typing of functions. The type system given here leads to a better integration of imperative programming style with the purely applicative kernel of ML. In particular, generic functions that allocate mutable data can safely be given fully polymorphic types. We show the soundness of this type system, and give a type reconstruction algorithm.
Bookmarks Related papers MentionsView impact
We compare the efficiency of type-based unboxing strategies with that of simpler, untyped unboxin... more We compare the efficiency of type-based unboxing strategies with that of simpler, untyped unboxing optimizations, building on our practical experience with the Gallium and Objective Caml compilers. We find the untyped optimizations to perform as well on the best case and significantly better in the worst case.
Bookmarks Related papers MentionsView impact
This paper presents a program transformation that allows languages with polymorphic typing (e.g. ... more This paper presents a program transformation that allows languages with polymorphic typing (e.g. ML) to be implemented with unboxed, multi-word data representations, more efficient than the conventional boxed representations. The transformation introduces coercions between various representations, based on a typing derivation. A prototype ML compiler utilizing this transformation demonstrates important speedups.
Bookmarks Related papers MentionsView impact
Preliminary version of \cite{Leroy-Rouaix-99
Bookmarks Related papers MentionsView impact
Short version of \cite{Leroy-repres
Bookmarks Related papers MentionsView impact
This article investigates an ML-like language with by-name semantics for polymorphism: polymorphi... more This article investigates an ML-like language with by-name semantics for polymorphism: polymorphic objects are not evaluated once for all at generalization time, but re-evaluated at each specialization. Unlike the standard ML semantics, the by-name semantics works well with polymorphic references and polymorphic continuations: the naive typing rules for references and for continuations are sound with respect to this semantics. Polymorphism by name leads to a better integration of these imperative features into the ML type discipline. Practical experience shows that it retains most of the efficiency and predictability of polymorphism by value.
Bookmarks Related papers MentionsView impact
Preliminary version of \cite{Leroy-Mauny-dynamics}.
Bookmarks Related papers MentionsView impact
The ML module system provides powerful parameterization facilities, but lacks the ability to spli... more The ML module system provides powerful parameterization facilities, but lacks the ability to split mutually recursive definitions across modules, and does not provide enough facilities for incremental programming. A promising approach to solve these issues is Ancona and Zucca's mixin modules calculus CMS. However, the straightforward way to adapt it to ML fails, because it allows arbitrary recursive definitions to appear at any time, which ML does not support. In this paper, we enrich CMS with a refined type system that controls recursive definitions through the use of dependency graphs. We then develop a separate compilation scheme, directed by dependency graphs, that translate mixin modules down to a CBV lambda-calculus extended with a non-standard let rec construct
Bookmarks Related papers MentionsView impact
Preliminary version of \cite{Leroy-oncard-verifier-journal
Bookmarks Related papers MentionsView impact
Preliminary version of \cite{Leroy-bytecode-verification-03}.
Bookmarks Related papers MentionsView impact
This paper presents a variant of the SML module system that introduces a strict distinction betwe... more This paper presents a variant of the SML module system that introduces a strict distinction between abstract types and manifest types (types whose definitions are part of the module specification), while retaining most of the expressive power of the SML module system. The resulting module system provides much better support for separate compilation.
Bookmarks Related papers MentionsView impact
A short survey of the uses of types in compilation.
Bookmarks Related papers MentionsView impact
Bookmarks Related papers MentionsView impact
We present a variant of the Standard ML module system where parameterized abstract types (i.e. fu... more We present a variant of the Standard ML module system where parameterized abstract types (i.e. functors returning generative types) map provably equal arguments to compatible abstract types, instead of generating distinct types at each application as in Standard ML. This extension solves the full transparency problem (how to give syntactic signatures for higher-order functors that express exactly their propagation of type equations), and also provides better support for non-closed code fragments.
Bookmarks Related papers MentionsView impact
Motivated by applications to proof assistants based on dependent types, we develop and prove corr... more Motivated by applications to proof assistants based on dependent types, we develop and prove correct a strong reducer and $\beta$-equivalence checker for the $\lambda$-calculus with products, sums, and guarded fixpoints. Our approach is based on compilation to the bytecode of an abstract machine performing weak reductions on non-closed terms, derived with minimal modifications from the ZAM machine used in the Objective Caml bytecode interpreter, and complemented by a recursive ``read back'' procedure. An implementation in the Coq proof assistant demonstrates important speed-ups compared with the original interpreter-based implementation of strong reduction in Coq.
Bookmarks Related papers MentionsView impact
This paper presents the design and implementation of a ``quasi real-time'' garbage collector for ... more This paper presents the design and implementation of a ``quasi real-time'' garbage collector for Concurrent Caml Light, an implementation of ML with threads. This two-generation system combines a fast, asynchronous copying collector on the young generation with a non-disruptive concurrent marking collector on the old generation. This design crucially relies on the ML compile-time distinction between mutable and immutable objects.
Bookmarks Related papers MentionsView impact
This paper reports on skeleton-based parallel programming in the context of the Caml functional ... more This paper reports on skeleton-based parallel programming in the context of the Caml functional language. An experimental implementation, based on TCP sockets and marshaling of function closures, is described and assessed.
Bookmarks Related papers MentionsView impact
Uploads
inproceedings by Xavier Leroy