Efficient hierarchical online-autotuning

Pfaffe, Philip; Grosser, Tobias; Tillmann, Martin

doi:10.1145/3330345.3330377

Cited by 14 publications

(5 citation statements)

References 35 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…A straightforward approach is the time-consuming comparison of variants by runtime tests, possibly steered by a single search strategy, such as an exhaustive search or more sophisticated mathematical optimization methods like differential evolution [7] or genetic algorithms [25] or a combination of multiple search strategies [1]. [16] proposes a hierarchical approach that allows the use of individual search algorithms for dependent subspaces of the search space.…”

Section: Related Workmentioning

confidence: 99%

Offsite Autotuning Approach

Seiferth

Korch

Rauber

2020

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Autotuning (AT) is a promising concept to minimize the often tedious manual effort of optimizing scientific applications for a specific target platform. Ideally, an AT approach can reliably identify the most efficient implementation variant(s) for a new platform or new characteristics of the input by applying suitable program transformations and analytic models. In this work, we introduce Offsite, an offline AT approach that automates this selection process at installation time by rating implementation variants based on an analytic performance model without requiring time-consuming runtime tests. From abstract multilevel description languages, Offsite automatically derives optimized, platform-specific and problem-specific code of possible variants and applies the performance model to these variants.We apply Offsite to parallel numerical methods for ordinary differential equations (ODEs). In particular, we investigate tuning a specific class of explicit ODE solvers, PIRK methods, for four different initial value problems (IVPs) on three different shared-memory systems. Our experiments demonstrate that Offsite can reliably identify the set of most efficient implementation variants for different given test configurations (ODE solver, IVP, platform) and effectively handle important AT scenarios.

show abstract

Section: Related Workmentioning

confidence: 99%

Offsite Autotuning Approach

Seiferth

Korch

Rauber

2020

Lecture Notes in Computer Science

View full text Add to dashboard Cite

show abstract

“…Apart from the DL optimization frameworks, some previous studies [12,36,41,43,44] propose techniques to find optimized code for some important DL operations (e.g., matrix multiplication and convolution). Widely-used BLAS libraries [43,44] rely on predefined kernels with the optimal set of implementation parameters (e.g., tile size).…”

Section: Related Workmentioning

confidence: 99%

“…OpenTuner [12] and KernelTuner [41] use evolutionary algorithms to find the optimal parameters. Pfaffe et al [36] combines evolutionary algorithms and polyhedral models to generate the optimal kernel code. Previous kernel fusion studies inspired and affected Deep-Cuts.…”

Section: Related Workmentioning

confidence: 99%

DeepCuts: a deep learning optimization framework for versatile GPU workloads

Jung

Dao

Lee

2021

Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

Widely used Deep Learning (DL) frameworks, such as Ten-sorFlow, PyTorch, and MXNet, heavily rely on the NVIDIA cuDNN for performance. However, using cuDNN does not always give the best performance. One reason is that it is hard to handle every case of versatile DNN models and GPU architectures with a library that has a fixed implementation. Another reason is that cuDNN lacks kernel fusion functionality that gives a lot of chances to improve performance. In this paper, we propose a DL optimization framework for versatile GPU workloads, called DeepCuts. It considers both kernel implementation parameters and GPU architectures. It analyzes the DL workload, groups multiple DL operations into a single GPU kernel, and generates optimized GPU kernels considering kernel implementation parameters and GPU architecture parameters. The evaluation result with various DL workloads for inference and training indicates that Deep-Cuts outperforms cuDNN/cuBLAS-based implementations and the state-of-the-art DL optimization frameworks, such as TVM, TensorFlow XLA, and TensorRT.

show abstract

“…As a result, even small increases often prevent the adoption and further evolution of research results through the LLVM community. Another area where compile times are critical is iterative compilation [Pouchet et al 2008[Pouchet et al , 2007 and auto-tuning [Pfaffe et al 2019]. In this setting a compiler (or just the Presburger library) is run many times with different configurations to find (close to) optimal configurations.…”

Section: The Importance Of High-performance Program Analysismentioning

confidence: 99%

Fast linear programming through transprecision computing on small and sparse data

Grosser

Theodoridis

Falkenstein

et al. 2020

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

A plethora of program analysis and optimization techniques rely on linear programming at their heart. However, such techniques are often considered too slow for production use. While today's best solvers are optimized for complex problems with thousands of dimensions, linear programming, as used in compilers, is typically applied to small and seemingly trivial problems, but to many instances in a single compilation run. As a result, compilers do not benefit from decades of research on optimizing large-scale linear programming. We design a simplex solver targeted at compilers. A novel theory of transprecision computation applied from individual elements to full data-structures provides the computational foundation. By carefully combining it with optimized representations for small and sparse matrices and specialized small-coefficient algorithms, we (1) reduce memory traffic, (2) exploit wide vectors, and (3) use low-precision arithmetic units effectively. We evaluate our work by embedding our solver into a state-of-the-art integer set library and implement one essential operation, coalescing, on top of our transprecision solver. Our evaluation shows more than an order-of-magnitude speedup on the core simplex pivot operation and a mean speedup of 3.2x (vs. GMP) and 4.6x (vs. IMath) for the optimized coalescing operation. Our results demonstrate that our optimizations exploit the wide SIMD instructions of modern microarchitectures effectively. We expect our work to provide foundations for a future integer set library that uses transprecision arithmetic to accelerate compiler analyses.

show abstract

Efficient hierarchical online-autotuning

Cited by 14 publications

References 35 publications

Offsite Autotuning Approach

Offsite Autotuning Approach

DeepCuts: a deep learning optimization framework for versatile GPU workloads

Fast linear programming through transprecision computing on small and sparse data

Contact Info

Product

Resources

About