Martin Tillenius

Resource-Aware Task Scheduling

Dependency-aware task-based parallel programming models have proven to be successful for developing efficient application software for multicore-based computer architectures. The programming model is amenable to programmers, thereby supporting productivity, whereas hardware performance is achieved through a runtime system that dynamically schedules tasks onto cores in such a way that all dependencies are respected. However, even if the scheduling is completely successful with respect to load balancing, the scaling with the number of cores may be suboptimal due to resource contention. Here we consider the problem of scheduling tasks not only with respect to their interdependencies but also with respect to their usage of resources, such as memory and bandwidth. At the software level, this is achieved by user annotations of the task resource consumption. In the runtime system, the annotations are translated into scheduling constraints. Experimental results for different hardware, demonstrating performance gains both for model examples and real applications, are presented. Furthermore, we provide a set of tools to detect resource sensitivity and predict the performance improvements that can be achieved by resource-aware scheduling. These tools are solely based on parallel execution traces and require no instrumentation or modification of the application code.

A scalable RBF-FD method for atmospheric flow

Radial basis function-generated finite difference (RBF-FD) methods have recently been proposed as very interesting for global scale geophysical simulations, and have been shown to outperform established pseudo-spectral and discontinuous Galerkin methods for shallow water test problems. In order to be competitive for very large scale simulations, the RBF-FD methods needs to be efficiently implemented for modern multicore based computer architectures. This is a challenging assignment, because the main computational operations are unstructured sparse matrix-vector multiplications, which in general scale poorly on multicore computers due to bandwidth limitations. However, with the task parallel implementation described here we achieve 60-100% of theoretical speedup within a shared memory node, and 80-100% of linear speedup across nodes. We present results for global shallow water benchmark problems with a 30 km resolution.

Programming Models Based on Data Versioning for Dependency-aware Task-based Parallelisation

By using task-based programming models, application developers who are not necessarily experts in parallel programming get access to the potentially high performance of multi-core based computer systems. We have derived a family of task parallel programming models where data dependencies are represented through data versioning. Benefits of using this type of model are that it is easy to represent different types of dependencies and that scheduling decisions can be made locally. Experiments show that a thread parallel shared memory implementation as well as a hybrid thread/MPI distributed memory implementation scale well on a system with 64 cores. Comparing the hybrid implementation with a pure MPI version, the results are comparable for small numbers of cores, but for larger numbers of cores the gain of using the hybrid model is substantial.