4 research outputs found
Naïve Transient Cast Insertion Isn’t (That) Bad
Transient gradual type systems often depend on type-based cast insertion to achieve good performance: casts are inserted whenever the static checker detects that a dynamically-typed value may flow into a statically-typed context. Transient gradually typed programs are then often executed using just-in-time compilation, and contemporary just-in-time compilers are very good at removing redundant computations.
In this paper we present work-in-progress to measure the ability of just-in-time compilers to remove redundant type checks. We investigate worst-case performance and so take a na'ive approach, annotating every subexpression to insert every plausible dynamic cast. Our results indicate that the Moth VM still manages to eliminate much of the overhead, by relying on the state-of-the-art SOMns substrate and Graal just-in-time compiler.
We hope these results will help language implementers evaluate the tradeoffs between dynamic optimisations (which can improve the performance of both statically and dynamically typed programs) and static optimisations (which improve only statically typed code)
Project-Team RMoD 2016 Activity Report
Activity Report 2016 Project-Team RMOD Analyses and Languages Constructs for Object-Oriented Application Evolutio
Transient Typechecks are (Almost) Free
Transient gradual typing imposes run-time type tests that typically cause a linear slowdown in
programs’ performance. This performance impact discourages the use of type annotations because
adding types to a program makes the program slower. A virtual machine can employ standard justin-time optimizations to reduce the overhead of transient checks to near zero. These optimizations
can give gradually-typed languages performance comparable to state-of-the-art dynamic languages,
so programmers can add types to their code without affecting their programs’ performance