The best multicore-parallelization refactoring you've never heard of

TL;DR

This paper introduces a novel refactoring technique for parallelizing tree-traversal algorithms using classic programming-language transformations and heartbeat scheduling, enabling efficient multicore execution without special compiler support.

Contribution

It presents a new refactoring approach combining continuation-passing-style, defunctionalization, and heartbeat scheduling for effective multicore parallelization of tree algorithms.

Findings

Achieves efficient parallelism with simple refactoring steps.

No special compiler support needed for the technique.

Useful as a teaching tool and for one-off parallelizations.

Abstract

In this short paper, we explore a new way to refactor a simple but tricky-to-parallelize tree-traversal algorithm to harness multicore parallelism. Crucially, the refactoring draws from some classic techniques from programming-languages research, such as the continuation-passing-style transform and defunctionalization. The algorithm we consider faces a particularly acute granularity-control challenge, owing to the wide range of inputs it has to deal with. Our solution achieves efficiency from heartbeat scheduling, a recent approach to automatic granularity control. We present our solution in a series of individually simple refactoring steps, starting from a high-level, recursive specification of the algorithm. As such, our approach may prove useful as a teaching tool, and perhaps be used for one-off parallelizations, as the technique requires no special compiler support.