Scheduling computations with provably low synchronization overheads

TL;DR

This paper introduces a variant of work stealing that minimizes synchronization overheads by keeping deques private and only exposing work on demand, achieving bounds independent of total work.

Contribution

The paper presents a new work stealing algorithm with provably low synchronization overheads, improving upon previous algorithms in both theory and design.

Findings

Expected execution time is O(T1/P + T∞)

Synchronization overheads are at most O((C_CAS + C_MFence) P T∞)

First bounds on synchronization overheads independent of total work

Abstract

Work Stealing has been a very successful algorithm for scheduling parallel computations, and is known to achieve high performances even for computations exhibiting fine-grained parallelism. We present a variant of \ws\ that provably avoids most synchronization overheads by keeping processors' deques entirely private by default, and only exposing work when requested by thieves. This is the first paper that obtains bounds on the synchronization overheads that are (essentially) independent of the total amount of work, thus corresponding to a great improvement, in both algorithm design and theory, over state-of-the-art \ws\ algorithms. Consider any computation with work $T_{1}$ and critical-path length $T_{\infty}$ executed by $P$ processors using our scheduler. Our analysis shows that the expected execution time is $O\left(\frac{T_{1}}{P} + T_{\infty}\right)$, and the expected synchronization overheads incurred during the execution are at most $O\left(\left(C_{CAS} + C_{MFence}\right)PT_{\infty}\right)$, where $C_{CAS}$ and $C_{MFence}$ respectively denote the maximum cost of executing a Compare-And-Swap instruction and a Memory Fence instruction.