Data structures for task-based priority scheduling

Abstract

Many task-parallel applications can benefit from attempting to execute tasks in a specific order, as for instance indicated by priorities associated with the tasks. We present three lock-free data structures for priority scheduling with different trade-offs on scalability and ordering guarantees. First we propose a basic extension to work-stealing that provides good scalability, but cannot provide any guarantees for task-ordering in-between threads. Next, we present a centralized priority data structure based on k-fifo queues, which provides strong (but still relaxed with regard to a sequential specification) guarantees. The parameter k allows to dynamically configure the trade-off between scalability and the required ordering guarantee. Third, and finally, we combine both data structures into a hybrid, k-priority data structure, which provides scalability similar to the work-stealing based approach for larger k, while giving strong ordering guarantees for smaller k. We argue for using the hybrid data structure as the best compromise for generic, priority-based task-scheduling.We analyze the behavior and trade-offs of our data structures in the context of a simple parallelization of Dijkstra's single-source shortest path algorithm. Our theoretical analysis and simulations show that both the centralized and the hybrid k-priority based data structures can give strong guarantees on the useful work performed by the parallel Dijkstra algorithm. We support our results with experimental evidence on an 80-core Intel Xeon system.

The SprayList: a scalable relaxed priority queue

“…al. [29]. This implementation provides a linearizable priority queue, except that it is relaxed in that each thread might skip up to k of the highest priority tasks; however, no task will be skipped by every thread.…”

“…This implementation provides a linearizable priority queue, except that it is relaxed in that each thread might skip up to k of the highest priority tasks; however, no task will be skipped by every thread. We test the hybrid version of their implementation as given in [29]. We note that this implementation does not offer scalability past 8 threads (nor does it claim to).…”

“…[23]. In particular, Wimmer et al [29] and Mendes et al [9], along with concurrent work [30] explore trade-offs between ordering and scalability for asynchronous priority queues. However, despite all this effort, it is currently not clear whether it is possible to design a relaxed priority queue which provides both ordering guarantees under asynchrony, and scalability under high contention for realistic workloads.…”

“…We compare our performance to the quiescently-consistent priority queue of Lotan and Shavit [22], the state-of-the-art SkipListbased priority queue implementation of Lindén and Jonsson [21] and the recent k-priority queue of Wimmer et al [29]. 2 Our first finding is that our data structure shows fully scalable throughput for up to 80 concurrent threads under high-contention workloads.…”

“…Another direction by Wimmer et al [29] presents lock-free priority queues which allow the user to dynamically decrease the strength of the ordering for improved performance. In essence, the data structure is distributed over a set of places, which behave as exact priority queues.…”