Optimizing Data Locality for Fork/Join Programs Using Constrained Work Stealing

Abstract

Abstract-We present an approach to improving data locality across different phases of fork/join programs scheduled using work stealing. The approach consists of: (1) user-specified and automated approaches to constructing a steal tree, the schedule of steal operations, and (2) constrained work-stealing algorithms that constrain the actions of the scheduler to mirror a given steal tree. These are combined to construct work-stealing schedules that maximize data locality across computation phases while ensuring load balance within each phase. These algorithms are also used to demonstrate dynamic coarsening, an optimization to improve spatial locality and sequential overheads by combining many finer-grained tasks into coarser tasks while ensuring sufficient concurrency for locality-optimized load balance. Implementation and evaluation in Cilk demonstrate performance improvements of up to 2.5x on 80 cores. We also demonstrate that dynamic coarsening can combine the performance benefits of coarse task specification with the adaptability of finer tasks.

Energy Efficiency Effects of Vectorization in Data Reuse Transformations for Many-Core Processors—A Case Study †

“…In [15], He et al proposed a bilinear quarter approximation strategy for fractional motion estimation design together with a data reuse strategy for ultrahigh definition video applications. Lifflander et al in [16] presented a work-stealing algorithm for fork-/join-based parallel programming models to gain performance boost-up though improving the data locality property.…”

On the Application Task Granularity and the Interplay with the Scheduling Overhead in Many-Core Shared Memory Systems

“…On the other hand, the relative impact of the task scheduler overhead is larger on fine-grained tasks, thus processor cores may spend more time in scheduling tasks than executing application code, which slows down the application progress. Finally, sophisticated schedulers, such as locality-aware schedulers [5], [6], have the potentiality of increasing application performance by speeding up the execution of single tasks. However, these schedulers introduce larger runtime overhead than best-effort schedulers currently used in Cilk [7] or Intel Threading Building Blocks (TBB) [8].…”

“…Given such difficulties, it comes to no surprise that previous studies have looked at either application algorithms running on a relative small set of available programming model runtimes, or one/two specific applications implemented in different ways to generate different task granularities on a single runtime system [6], [9], [10]. Either approach limits the spectrum of possible configuration that can be analyzed and cannot be used to study the impact of scheduling overhead of task schedulers that have not yet been implemented.…”

“…Several versions of each task are generated by the compiler by unrolling tasks and removing unnecessary synchronization primitives. Lifflander et al [6] describe a method to automatically select grain size: a minimum allowed task grain size is selected and a runtime system automatically coarsens it to be substantially large to amortize runtime overheads and to improve NUMA locality. In our study we combine the analysis of task granularity and scheduling overhead, as one affects the other.…”

Scalable replay with partial-order dependencies for message-logging fault tolerance

“…Our work also seeks to reduce the amount of control data required, but it solves a more general problem not specific to a certain programming paradigm. Specific schemes for reducing control-related data have been studied extensively for a wide variety of algorithms [18]- [22].…”