Olivier Flückiger

Olivier Flückiger

Auto-generated profile, based on publicly available information

Olivier Flückiger

Northeastern University, USA

Research Focus & Metrics

Academic Career Length

10Years (2017-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
27 December 2017 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
OFOlivier Flückiger
Olivier Flückiger
GSGabriel Scherer
Gabriel Scherer
MYMing-Ho Yee
Ming-Ho Yee
AGAviral Goel
Aviral Goel
AAAmal Ahmed
Amal Ahmed
JVJan Vitek
Jan Vitek
High-performance dynamic language implementations make heavy use of speculative optimizations to achieve speeds close to statically compiled languages. These optimizations are typically performed by a just-in-time compiler that generates code under a set of assumptions about the state of the program and its environment. In certain cases, a program may execute code compiled under assumptions that are no longer valid. The implementation must then deoptimize the program on-the-fly; this entails finding semantically equivalent code that does not rely on invalid assumptions, translating program state to that expected by the target code, and transferring control. This paper looks at the interaction between optimization and deoptimization, and shows that reasoning about speculation is surprisingly easy when assumptions are made explicit in the program representation. This insight is demonstrated on a compiler intermediate representation, named sourir, modeled after the high-level representation for a dynamic language. Traditional compiler optimizations such as constant folding, unreachable code elimination, and function inlining are shown to be correct in the presence of assumptions. Furthermore, the paper establishes the correctness of compiler transformations specific to deoptimization: namely unrestricted deoptimization, predicate hoisting, and assume composition.

4 January 2021 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
ABAurèle Barrière
Aurèle Barrière
SBSandrine Blazy
Sandrine Blazy
OFOlivier Flückiger
Olivier Flückiger
DPDavid Pichardie
David Pichardie
JVJan Vitek
Jan Vitek
Just-in-time compilers for dynamic languages routinely generate code under assumptions that may be invalidated at run-time, this allows for specialization of program code to the common case in order to avoid unnecessary overheads due to uncommon cases. This form of software speculation requires support for deoptimization when some of the assumptions fail to hold. This paper presents a model just-in-time compiler with an intermediate representation that explicits the synchronization points used for deoptimization and the assumptions made by the compiler's speculation. We also present several common compiler optimizations that can leverage speculation to generate improved code. The optimizations are proved correct with the help of a proof assistant. While our work stops short of proving native code generation, we demonstrate how one could use the verified optimization to obtain significant speed ups in an end-to-end setting.

20 October 2019
Verified
Conference Paper
Open access
OFOlivier Flückiger
Olivier Flückiger
GCGuido Chari
Guido Chari
JJJan Ječmen
Jan Ječmen
MYMing-Ho Yee
Ming-Ho Yee
JHJakob Hain
Jakob Hain
JVJan Vitek
Jan Vitek

13 November 2020 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
OFOlivier Flückiger
Olivier Flückiger
GCGuido Chari
Guido Chari
MYMing-Ho Yee
Ming-Ho Yee
JJJan Ječmen
Jan Ječmen
JHJakob Hain
Jakob Hain
JVJan Vitek
Jan Vitek
In order to generate efficient code, dynamic language compilers often need information, such as dynamic types, not readily available in the program source. Leveraging a mixture of static and dynamic information, these compilers speculate on the missing information. Within one compilation unit, they specialize the generated code to the previously observed behaviors, betting that past is prologue. When speculation fails, the execution must jump back to unoptimized code. In this paper, we propose an approach to further the specialization, by disentangling classes of behaviors into separate optimization units. With contextual dispatch, functions are versioned and each version is compiled under different assumptions. When a function is invoked, the implementation dispatches to a version optimized under assumptions matching the dynamic context of the call. As a proof-of-concept, we describe a compiler for the R language which uses this approach. Our implementation is, on average, 1.7× faster than the GNU R reference implementation. We evaluate contextual dispatch on a set of benchmarks and measure additional speedup, on top of traditional speculation with deoptimization techniques. In this setting contextual dispatch improves the performance of 18 out of 46 programs in our benchmark suite.

15 November 2020
Verified
Conference Paper
Open access
OFOlivier Flückiger
Olivier Flückiger
AWAndreas Wälchli
Andreas Wälchli
SKSebastián Krynski
Sebastián Krynski
JVJan Vitek
Jan Vitek
To efficiently execute dynamically typed languages, many language implementations have adopted a two-tier architecture. The first tier aims for low-latency startup times and collects dynamic profiles, such as the dynamic types of variables. The second tier provides high-throughput using an optimizing compiler that specializes code to the recorded type information. If the program behavior changes to the point that not previously seen types occur in specialized code, that specialized code becomes invalid, it is deoptimized, and control is transferred back to the first tier execution engine which will start specializing anew. However, if the program behavior becomes more specific, for instance, if a polymorphic variable becomes monomorphic, nothing changes. Once the program is running optimized code, there are no means to notice that an opportunity for optimization has been missed. We propose to employ a sampling-based profiler to monitor native code without any instrumentation. The absence of instrumentation means that when the profiler is not active, no overhead is incurred. We present an implementation is in the context of the Ř just-in-time, optimizing compiler for the R language. Based on the sampled profiles, we are able to detect when the native code produced by Ř is specialized for stale type feedback and recompile it to more type-specific code. We show that sampling adds an overhead of less than 3

15 October 2021 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
AGAviral Goel
Aviral Goel
JJJan Ječmen
Jan Ječmen
SKSebastián Krynski
Sebastián Krynski
OFOlivier Flückiger
Olivier Flückiger
JVJan Vitek
Jan Vitek
Function calls in the R language do not evaluate their arguments, these are passed to the callee as suspended computations and evaluated if needed. After 25 years of experience with the language, there are very few cases where programmers leverage delayed evaluation intentionally and laziness comes at a price in performance and complexity. This paper explores how to evolve the semantics of a lazy language towards strictness-by-default and laziness-on-demand. To provide a migration path, it is necessary to provide tooling for developers to migrate libraries without introducing errors. This paper reports on a dynamic analysis that infers strictness signatures for functions to capture both intentional and accidental laziness. Over 99% of the inferred signatures were correct when tested against clients of the libraries.