Contextual dispatch for function specialization

Abstract

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.

Deoptless: Speculation with Dispatched On-Stack Replacement and Specialized Continuations

“…1 Measurements are recorded repeatedly and we keep a historical record to spot unstable behavior. For some of the experiments we use the major benchmarks from the Ř benchmark suite [12].…”

“…For instance, if an assumption fails, as above, because a list holds floating point numbers rather than integers, then the continuation can be specialized to handle floats. In subsequent executions, if the same OSR point is reached, the continuation to invoke will be selected by using context dispatch [12]. If no previously compiled continuation matches the execution context, then a new one will be compiled.…”

Who You Gonna Call: Analyzing the Run-Time Call-Site Behavior of Ruby Applications

“…In future work, we want to investigate in more detail how calls relate to each other. Traditional inlining and the work of Flückiger et al [6] show that calling context can be used to enable optimizations, and also to reduce call overhead. Since the performance of many large applications is dominated by calls, it seems relevant to investigate further how call relations can be exploited to reduce call overhead.…”

Sampling Optimized Code for Type Feedback

“…Some programs are variants; they use different implementations to solve the same problem. The suite and Ř baseline performance is discussed in detail by Flückiger et al [2020a]. This pre-existing suite was also expanded and three benchmarks were added to show potential performance improvements to be gained through use of the profiler.…”