A Lock-Free Work-Stealing Algorithm for Bulk Operations

TL;DR

This paper introduces a lock-free work-stealing queue optimized for bulk operations in a master-worker parallel framework, significantly reducing latency and improving scalability for specialized workloads like decision diagram-based solvers.

Contribution

The paper presents a novel lock-free work-stealing algorithm supporting native bulk operations, tailored for specialized parallel applications, with proven linearizability and lock-freedom under specific assumptions.

Findings

Achieves constant-latency push performance regardless of batch size.

Maintains stable latency for pop and steal operations across different conditions.

Scales linearly in large-graph exploration workloads.

Abstract

Work-stealing is a widely used technique for balancing irregular parallel workloads, and most modern runtime systems adopt lock-free work-stealing deques to reduce contention and improve scalability. However, existing algorithms are designed for general-purpose parallel runtimes and often incur overheads that are unnecessary in specialized settings. In this paper, we present a new lock-free work-stealing queue tailored for a master-worker framework used in the parallelization of a mixed-integer programming optimization solver based on decision diagrams. Our design supports native bulk operations, grows without bounds, and assumes at most one owner and one concurrent stealer, thereby eliminating the need for heavy synchronization. We provide an informal sketch that our queue is linearizable and lock-free under this restricted concurrency model. Benchmarks demonstrate that our implementation achieves constant-latency push performance, remaining stable even as batch size increases, in contrast to existing queues from C++ Taskflow whose latencies grow sharply with batch size. Pop operations perform comparably across all implementations, while our steal operation maintains nearly flat latency across different steal proportions. We also explore an optimized steal variant that reduces latency by up to 3x in practice. Finally, a pseudo workload based on large-graph exploration confirms that all implementations scale linearly. However, we argue that solver workloads with irregular node processing times would further amplify the advantages of our algorithm.