Accelerating Task-based Iterative Applications

TL;DR

This paper introduces taskiter, a construct for OmpSs-2 and OpenMP that reuses cyclic task graphs to reduce overheads in iterative applications, achieving significant speedups.

Contribution

It proposes taskiter and a heuristic to efficiently reuse task graphs in iterative applications, reducing overheads and improving performance in task-based programming models.

Findings

Average speedup of 3.7x over OmpSs-2

Up to 7.46x speedup over GCC OpenMP

Effective in small task granularities

Abstract

Task-based programming models have risen in popularity as an alternative to traditional fork-join parallelism. They are better suited to write applications with irregular parallelism that can present load imbalance. However, these programming models suffer from overheads related to task creation, scheduling and dependency management, limiting performance and scalability when tasks become too small. At the same time, many HPC applications implement iterative methods or multi-step simulations that create the same directed acyclic graphs of tasks on each iteration. By giving application programmers a way to express that a specific loop is creating the same task pattern on each iteration, we can create a single task DAG once and transform it into a cyclic graph. This cyclic graph is then reused for successive iterations, minimizing task creation and dependency management overhead. This paper presents the taskiter, a new construct we propose for the OmpSs-2 and OpenMP programming models, allowing the use of directed cyclic task graphs (DCTG) to minimize runtime overheads. Moreover, we present a simple immediate successor locality-aware heuristic that minimizes task scheduling overhead by bypassing the runtime task scheduler. We evaluate the implementation of the taskiter and the immediate successor heuristic in 8 iterative benchmarks. Using small task granularities, we obtain an average speedup of 3.7x over the reference OmpSs-2 implementation and an average of 5x and 7.46x speedup over the LLVM and GCC OpenMP runtimes, respectively.