The last decade has seen a proliferation of advanced control structures, such as async/await, generators, coroutines, fibers, or algebraic effect handlers. These new control structures promise improved program structure (such as the avoidance of “callback hell”) and generally a higher level of abstraction. They are essential to structure large-scale, distributed, and asyncronous applications.

However, composing applications from multiple layers of domain-specific abstractions can come with a significant performance penalty. Ideally, programmers should not be forced to trade-off using the right abstraction (like exception handling, async/await, or effect handlers) with writing high-performance applications.

In this research area, we develop novel strategies to efficient implement advanced control-flow structuring mechanisms. There are two aspects to performance: enabling compile-time optimizations and having efficient run-time constructs.

Compile-time Optimizations

It is our goal to implement optimizations that fully remove the performance overhead, associated with control-flow abstractions, such as exceptions or effect handlers. We aim to optimize control flow across library boundaries in order to obtain performance comparable to hand-written, monolithic code.

In past research, we

• revisited research on iterated continuation passing style (CPS), a generalization of CPS to support multiple layers of control effects;
• demonstrated, that iterated CPS is a promising compilation target for effect handlers (research paper), obtaining speed-ups of up to 400x on selected benchmarks;
• and we developed techniques to integrate resource management into a CPS translation (technical report).

Efficient Runtime Constructs

While we aim to fully remove the overhead of control effects at compile time, sometimes this is not immediately possible. This is for instance the case, when whole program optimizations are not possible (for instance when separate compilation is required). In these cases, an efficient runtime support for control effects becomes important.

In a second line of work, we are implementing optimized runtimes for control effects, such as effect handlers.

Just-in-time Compilation of Control Effects

Finally, combining the two above lines of work, we plan to develop a just-in-time (JIT) compiler, specialized to optimize control effects.

Collaborators

Jonathan Brachthäuser (University of Tübingen)

Philipp Schuster (University of Tübingen)

Marius Müller (University of Tübingen)

Klaus Ostermann (University of Tübingen)

Publications