Characterizing Type Feedback in Just-In-Time Compilation

Leveraging Copy-and-Patch JIT Compilation for Low-Overhead Dynamic Program Analysis

Context-Aware Inlining: Using Call-Stack Profiles for Fast and Smaller Binaries

This article presents a novel technique for reducing the size of AOT compiled programs by using fully-context-sensitive profiles to concentrate the optimizations on the hot code.

From Runtime Reflection to Compile-Time Specialization: A Template-Based Approach to Runtime Libraries

: In low-level programming, performance is usually the primary concern, the programmer having almost full control over the generated code, and therefore its metrics. This control is achieved through system-level programming languages, and most of them these days employ language design concepts such as generic programming and runtime type reflection, which the programmer can leverage depending on their needs (e.g. choosing between performance and flexibility). In the past, some proof-of-concept work has been done to convert D’s runtime library (DRuntime) from a monolithic, TypeInfo -based architecture to a template-based one, observing initial performance improvements of up to 25%. In this paper, we consolidate and extend those results, detailing the performance impact of each hook and evaluating the trade-offs between performance, compilation time and binary size. Our findings confirm an increase in performance of up to 99% for the template-based implementations, with minimal impact on compilation time and binary size. This work is not limited to the D programming language, but can be extended to any other language that supports the same feature set, such as C++, Rust, and Go.

Generative Compilation: On-the-Fly Compiler Feedback as AI Generates Code

It is shown that generative compilation reduces non-compiling outputs and improves functional correctness, relative to standard post-generation feedback, by detecting a broad range of errors close to their source and early during generation, thereby reducing errors cascades and enabling focused diagnostics.

Portable models as a replacement for industrial heuristics in compiler optimizations

The paper investigates the possibility of predicting function-inlining decisions in compact compilers, source-to-source tools, and interpreters where the reuse of GCC or LLVM optimization infrastructure is impractical and proposes a portable inlining-prediction framework that can be emitted as ordinary C code without a compiler-runtime dependency.

Regions as Continuation Marks

Region-based memory management started as a compiler pass to optimize Standard ML programs. Garbage collection was expensive, manual memory management was unsafe, and so instead one infers a stack of memory regions to enable the compiler to insert explicit memory allocation and deallocation instructions. The result of region inference is a ML program with lexically-scoped regions. Unfortunately, the stack-based region inference interferes with the correct behaviour of tail recursion: that tail recursion must run in constant space, and much work was required to correct their behaviour in practice. We show a formal connection between these lexical regions and continuation marks, which elucidates the behaviour of regions with respect to tail calls, and provide insights into possible implementation techniques and new semantics. Continuation marks enable placing a value on the dynamic program frame, and were designed and implemented to behave correctly with respect to tail recursion. We provide a translation from regions to continuation marks and theorize what this connection could entail for both languages with region-based memory management and our favourite Schemes (and Racket) with continuation marks.