Sound gradual typing: only mostly dead

Abstract

While gradual typing has proven itself attractive to programmers, many systems have avoided sound gradual typing due to the run time overhead of enforcement. In the context of sound gradual typing, both anecdotal and systematic evidence has suggested that run time costs are quite high, and often unacceptable, casting doubt on the viability of soundness as an approach. We show that these overheads are not fundamental, and that with appropriate improvements, just-intime compilers can greatly reduce the overhead of sound gradual typing. Our study takes benchmarks published in a recent paper on gradual typing performance in Typed Racket (Takikawa et al., POPL 2016) and evaluates them using an experimental tracing JIT compiler for Racket, called Pycket. On typical benchmarks, Pycket is able to eliminate more than 90% of the gradual typing overhead. While our current results are not the final word in optimizing gradual typing, we show that the situation is not dire, and where more work is needed. Pycket's performance comes from several sources, which we detail and measure individually. First, we apply a sophisticated tracing JIT compiler and optimizer, automatically generated in Pycket using the RPython framework originally created for PyPy. Second, we focus our optimization efforts on the challenges posed by run time checks, implemented in Racket by chaperones and impersonators. We introduce representation improvements, including a novel use of hidden classes to optimize these data structures, and measure the performance implications of each optimization.

How to evaluate the performance of gradual type systems

“…Here are a few suggestions. To reduce the cost of high-frequency checks, the runtime system could cache the results of successful checks (Ren & Foster, 2016) or implement a tracing JIT compiler tailored to identify dynamic type assertions (Bauman et al, 2015(Bauman et al, , 2017. Highcost types may be a symptom of inefficiencies in the translation from types to dynamic checks.…”

Collapsible contracts: fixing a pathology of gradual typing

“…To dig into the performance of typed/untyped benchmarks in more detail, consider figure 15. It shows scatter plots inspired by those in Bauman et al [2017]'s performance comparison between Racket and Pycket. In our plots, every point corresponds to one configuration of the benchmark shown in the plot.…”

“…A second, earlier effort is the Pycket tracing JIT compiler [Bauman et al 2017]. Pycket is a compiler and runtime system for Typed Racket that is implemented in PyPy [Bolz et al 2009].…”

Casts and costs: harmonizing safety and performance in gradual typing

“…work has addressed the problem through new languages with more efficient gradually typed semantics [Muehlboeck and Tate 2017;Vitousek et al 2017] and through new implementation techniques for existing languages [Bauman et al 2017;Richards et al 2017]. There are two main differences between our work and previous efforts: First, our approach does not require changes to existing gradually typed languages or implementations; it works with the prevailing implementation technique of translating a typed variant of a language into an underlying untyped language.…”