Auto-tuning Techniques Research Articles

An automated OpenMP mutation testing framework for performance optimization

Performance optimization continues to be a challenge in modern HPC software. Existing performance optimization techniques, including profiling-based and auto-tuning techniques, fail to indicate program modifications at the source level thus preventing their portability across compilers. This paper describes Muppet, a new approach that identifies program modifications called mutations aimed at improving program performance. Muppet’s mutations help developers reason about performance defects and missed opportunities to improve performance at the source code level. In contrast to compiler techniques that optimize code at intermediate representations (IR), Muppet uses the idea of source-level mutation testing to relax correctness constraints and automatically discover optimization opportunities that otherwise are not feasible using the IR. We demonstrate the Muppet’s concept in the OpenMP programming model. Muppet generates a list of OpenMP mutations that alter the program parallelism in various ways, and is capable of running a variety of optimization algorithms such as delta debugging, Bayesian Optimization and decision tree optimization to find a subset of mutations which, when applied to the original program, cause the most speedup while maintaining program correctness. When Muppet is evaluated against a diverse set of benchmark programs and proxy applications, it is capable of finding sets of mutations that induce speedup in 75.9% of the evaluated programs.

Towards General and Efficient Online Tuning for Spark

The distributed data analytic system - Spark is a common choice for processing massive volumes of heterogeneous data, while it is challenging to tune its parameters to achieve high performance. Recent studies try to employ auto-tuning techniques to solve this problem but suffer from three issues: limited functionality, high overhead, and inefficient search. In this paper, we present a general and efficient Spark tuning framework that can deal with the three issues simultaneously. First, we introduce a generalized tuning formulation, which can support multiple tuning goals and constraints conveniently, and a Bayesian optimization (BO) based solution to solve this generalized optimization problem. Second, to avoid high overhead from additional offline evaluations in existing methods, we propose to tune parameters along with the actual periodic executions of each job (i.e., online evaluations). To ensure safety during online job executions, we design a safe configuration acquisition method that models the safe region. Finally, three innovative techniques are leveraged to further accelerate the search process: adaptive sub-space generation, approximate gradient descent, and meta-learning method. We have implemented this framework as an independent cloud service, and applied it to the data platform in Tencent. The empirical results on both public benchmarks and large-scale production tasks demonstrate its superiority in terms of practicality, generality, and efficiency. Notably, this service saves an average of 57.00% memory cost and 34.93% CPU cost on 25K in-production tasks within 20 iterations, respectively.

Auto-tuning deep forest for shear stiffness prediction of headed stud connectors

The shear stiffness of headed stud connector is a critical parameter for the calculation of deflection and interfacial shear force for steel–concrete composite structure. Thus, this study presented a promising data-driven model auto-tuning Deep Forest (ATDF) to precisely predict the stud shear stiffness, where the novel Deep Forest algorithm is integrated with the Sequential Model-Based Optimization method to achieve automatic hyperparameter optimization. Six variables having causal relationships with shear stiffness were extracted via mechanism and model analysis, including the effect of weld collar that cannot be considered in existing models and subsequently constituting a database of 425 push-out tests. Then the ATDF model was trained by combining the advantages of deep learning, ensemble learning, and auto-tuning techniques. It was approved to significantly outperform representative benchmark models with R values of 0.91 and 0.87 for training and testing sets. The ATDF was subjected to attribute importance analysis, which quantified the stud diameter and concrete elastic modulus as the most significant variables for shear stiffness, with the stud elastic modulus having the minimal effect. The model uncertainty of ATDF was further evaluated, revealing that it had the lowest bias and variability than those in existing empirical or semi-empirical models. Finally, the reliability analysis was conducted and the partial factors of ATDF under specified target reliability were derived.

An Autotuning Protocol to Rapidly Build Autotuners

Automatic performance tuning (Autotuning) is an increasingly critical tuning technique for the high portable performance of Exascale applications. However, constructing an autotuner from scratch remains a challenge, even for domain experts. In this work, we propose a performance tuning and knowledge management suite (PAK) to help rapidly build autotuners. In order to accommodate existing autotuning techniques, we present an autotuning protocol that is composed of an extractor, producer, optimizer, evaluator, and learner. To achieve modularity and reusability, we also define programming interfaces for each protocol component as the fundamental infrastructure, which provides a customizable mechanism to deploy knowledge mining in the performance database. PAK’s usability is demonstrated by studying two important computational kernels: stencil computation and sparse matrix-vector multiplication (SpMV). Our proposed autotuner based on PAK shows comparable performance and higher productivity than traditional autotuners by writing just a few tens of code using our autotuning protocol.

Multi-Objective region-Aware optimization of parallel programs

Abstract Auto-tuning has become increasingly popular for optimizing non-functional parameters of parallel programs. The typically large search space requires sophisticated techniques to find well-performing parameter values in a reasonable amount of time. Different parts of a program often perform best with different parameter values. We therefore subdivide programs into several regions, and try to optimize the parameter values for each of these regions separately as opposed to setting the parameter values globally for the entire program. In order to manage this enlarged search space, we have to extend existing auto-tuning techniques to ensure high quality solutions to this optimization problem. In this paper we introduce a novel enhancement to the RS-GDE3 algorithm that is used to explore the search space for auto-tuning programs with multiple regions regarding several objectives. We have implemented our auto-tuner using the Insieme compiler and runtime system, and provide a detailed analysis of the obtained results with the aim of gaining a better understanding of non-functional inter-region behavior in the context of auto-tuning. In comparison to a non-optimized parallel version of the tested programs, our novel approach achieves improvements of up to 7.6X, 10.5X, and 61.6X for three tuned objectives wall time, energy consumption, and resource usage, respectively.

On solving separable block tridiagonal linear systems using a GPU implementation of radix-4 PSCR method

Partial solution variant of the cyclic reduction (PSCR) method is a direct solver that can be applied to certain types of separable block tridiagonal linear systems. Such linear systems arise, e.g., from the Poisson and the Helmholtz equations discretized with bilinear finite-elements. Furthermore, the separability of the linear system entails that the discretization domain has to be rectangular and the discretization mesh orthogonal. A generalized graphics processing unit (GPU) implementation of the PSCR method is presented. The numerical results indicate up to 24-fold speedups when compared to an equivalent CPU implementation that utilizes a single CPU core. Attained floating point performance is analyzed using roofline performance analysis model and the resulting models show that the attained floating point performance is mainly limited by the off-chip memory bandwidth and the effectiveness of a tridiagonal solver used to solve arising tridiagonal subproblems. The performance is accelerated using off-line autotuning techniques.

An Auto-Tuner for OpenCL Work-Group Size on GPUs

Tuning the kernel work-group size for GPUs is a challenging problem. In this paper, using the performance counters provided by GPUs, we characterize a large body of OpenCL kernels to identify the performance factors that affect the choice of a good work-group size. Based on the characterization, we realize that the most influential performance factors with regard to the work-group size include occupancy, coalesced global memory accesses, cache contention, and variation in the amount of workload in the kernel. By tackling the performance factors one by one, we propose auto-tuning techniques that selects the best work-group size and shape for GPU kernels. We show the effectiveness of our auto-tuner by evaluating it with a set of 54 OpenCL kernels on three different NVIDIA GPUs and one AMD GPU. On average, the auto-tuner needs to spend no more than 8 percent of the time required by an exhaustive search to find an optimal work-group size. The execution time of the selected sub-optimal work-group size is at most 1.14x slower than that of the optimal work-group size found by the exhaustive search, on average.

Maximizing Communication–Computation Overlap Through Automatic Parallelization and Run-time Tuning of Non-blocking Collective Operations

Non-blocking collective communication operations extend the concept of collective operations by offering the additional benefit of being able to overlap communication and computation. They are often considered key building blocks for scaling applications to very large process counts. Yet, using non-blocking collective operations in real-world applications is non-trivial. Application codes often have to be restructured significantly in order to maximize the communication–computation overlap. This paper presents an approach to maximize the communication–computation overlap for hybrid OpenMP/MPI applications. The work leverages automatic parallelization by extending the ability of an existing tool to utilize non-blocking collective operations. It further integrates run-time auto-tuning techniques of non-blocking collective operations, optimizing both, the algorithms used for the non-blocking collective operations as well as location and frequency of accompanying progress function calls. Four application benchmarks were used to demonstrate the efficiency and versatility of the approach on two different platforms. The results indicate significant performance improvements in virtually all test scenarios. The resulting parallel applications achieved a performance improvement of up to 43% compared to the version using blocking communication operations, and up to 95% of the maximum theoretical communication–computation overlap identified for each scenario.

Optimizing a parameterized message-passing metaheuristic scheme on a heterogeneous cluster

This paper studies the development of message-passing parameterized schemes of metaheuristics and the use of auto-tuning techniques to optimize their execution time. Previous parameterized schemes on shared-memory are extended with new metaheuristic-parallelism parameters representing the migration frequency, the size of the migration and the number of processes. An optimization Problem of Electricity Consumption in Exploitation of Wells is used as test case. Experimental results in heterogeneous systems are reported for this problem, and the influence of the parallelism parameters is studied. The message-passing scheme proves to be preferable to the shared-memory scheme in terms of execution time, giving similar results for the goodness of the solutions. In the executions in a heterogeneous cluster, the best experimental results are obtained in terms of speed-up and quality of the solution by mapping a number of processes close to the value of the population size, and considering the relative speeds of the components of the heterogeneous system. Furthermore, optimized execution times can be achieved with auto-tuning techniques based on theoretical–empirical models of the execution time.

Tuning of PID Controller Using GA for Ball and Hoop System

The PID controller is one of the control strategies having simple structure was understood by plant operator, which is comparatively easy to tune. Irrespective of the attractiveness, the tuning characteristic of PID controllers is a task for engineers and scientists. Numerous procedures for tuning PID-controllers are recommended such as: Ziegler Nichols tuning method auto-tuning, artificial intelligence and optimization techniques. Evolutionary optimization techniques (EOTs) as emergent techniques, an efficient GA-based tuning approach aiming at enhancing PID control for complex processes is proposed. The test and simulation results demonstrate that the GA-based proposed scheme is capable and can be used to overcome the flaws of traditional fixed gain controller. The main role of the article is to appraise the algorithm for tuning of PID-controller gains along with minimization of cost function and argue about the capability, computational efficiency of GA to solve the problems in control systems.

Auto-tuning techniques for linear algebra routines on hybrid platforms

This work analyses two techniques for auto-tuning linear algebra routines for hybrid combinations of multicore CPU and manycore coprocessors (single or multiple GPUs and MIC). The first technique is based on basic models of the execution time of the routines, whereas the second one manages only empirical information obtained during the installation of the routines. The final goal in both cases is to obtain a balanced assignation of the work to the computing components in the system. The study is carried out with a basic kernel (matrix–matrix multiplication) and a higher level routine (LU factorization) which uses the auto-tuned basic routine. Satisfactory results are obtained, with experimental execution times close to the lowest experimentally achievable.

Experiments on Optimizing the Performance of Stencil Codes with SPL Conqueror

A standard technique for numerically solving elliptic partial differential equations on structured grids is to discretize them, and, then, to apply an efficient geometric multi-grid solver. Unfortunately, finding the optimal choice of multi-grid components and parameter settings is challenging and existing auto-tuning techniques fail to explain performance-optimal settings. To improve the state of the art, we explore whether recent work on optimizing configurations of product lines can be applied to the stencil-code domain. In particular, we extend the domain-independent tool SPL Conqueror in an empirical study to predict the performance-optimal configurations of three geometric multi-grid stencil codes: a program using HIPAcc, the evaluation prototype HSMGP, and a program using DUNE. For HIPAcc, we reach an prediction accuracy of 96%, on average, measuring only 21.4% of all configurations; we predict a configuration that is nearly optimal after measuring less than 0.3% of all configurations. For HSMGP, we predict performance with an accuracy of 97% including the performance-optimal configuration, while measuring 3.2% of all configurations. For DUNE, we predict performance of all configurations with an accuracy of 86% after measuring 3.3% of all configurations. The performance-optimal configuration is within the 0.5% configurations predicted to perform best.

Automatic routine tuning to represent landform attributes on multicore and multi-GPU systems

Auto-tuning techniques have been used in the design of routines in recent years. The goal is to develop routines which automatically adapt to the conditions of the computational system in such a way that efficient executions are obtained independently of the end-user experience. This paper aims to explore programming routines that can be automatically adapted to the computational system conditions, making possible to use auto-tuning to represent landform attributes on multicores and multi-GPU systems using high- performance computing techniques for efficient solution of two-dimensional polynomial regression models that allow large problem instances to be addressed.

Optimizing Shared-memory Hyperheuristics on Top of Parameterized Metaheuristics

This paper studies the auto-tuning of shared-memory hyperheuristics developed on top of a unified shared-memory metaheuristic scheme. A theoretical model of the execution time of the unified scheme is empirically adapted for particular metaheuristics and hyperheuristics through experimentation. The model is used to decide at running time the number of threads to obtain a reduced execution time. The number of threads is different for the different basic functions in the scheme, and depends on the problem to be solved, the metaheuristic scheme, the implementation of the basic functions and the computational system where the problem is solved. The applicability of the proposal is shown with a problem of minimization of electricity consumption in exploitation of wells. Experimental results show that satisfactory execution times can be achieved with auto-tuning techniques based on theoretical-empirical models of the execution time.

Tuning basic Linear Algebra Routines for Hybrid CPU+GPU Platforms

The introduction of auto-tuning techniques in linear algebra routines using hybrid combinations of multiple CPU and GPU computing resources is analyzed. Basic models of the execution time and information obtained during the installation of the routines are used to optimize the execution time with a balanced assignation of the work to the computing components in the system. The study is carried out with a basic kernel (matrix-matrix multiplication) and a higher level routine (LU factorization) using GPUs and the host multicore processor. Satisfactory results are obtained, with experimental execution times close to the lowest experimentally achievable.

A Remote Laboratory as an Innovative Educational Tool for Practicing Control Engineering Concepts

This paper presents the development, structure, implementation, and some applications of a remote laboratory for teaching automatic control concepts to engineering students. There are two applications: formation control of mobile robots and a ball-plate system. In teaching control engineering, there are two main approaches to control design: model-based control and non-model-based control. Students are given insight into: 1) for model-based control: identification of real processes (i.e., dealing with noise, choosing the sampling time, observing nonlinear effects at startup, pairing input-output variables); and 2) for non-model-based control: the advantages and disadvantages of auto-tuning techniques. The paper concludes by presenting an evaluation of these remote labs and discussing the advantages of using them as complementary tools for teaching control engineering at the Bachelor's and Master's level.

Performance Comparison of Two Controllers on a Nonlinear System

Various systems and instrumentation use auto tuning techniques in their operations. For example, audio processors, designed to control pitch in vocal and instrumental operations. The main aim of auto tuning is to conceal off-key errors, and allowing artists to perform genuinely despite slight deviation off-key. In this paper two Auto tuning control strategies are proposed. These are Proportional, Integral and Derivative (PID) control and Model Predictive Control (MPC). The PID and MPC controller’s algorithms amalgamate the auto tuning method. These control strategies ascertains stability, effective and efficient performance on a nonlinear system. The paper test and compare the efficacy of each control strategy. This paper generously provides systematic tuning techniques for the PID controller than the MPC controller. Therefore in essence the PID has to give effective and efficient performance compared to the MPC. The PID depends mainly on three terms, the P ( ) gain, I ( ) gain and lastly D ( ) gain for control each playing unique role while the MPC has more information used to predict and control a system.

Empirical Installation of Linear Algebra Shared-Memory Subroutines for Auto-Tuning

The introduction of auto-tuning techniques in linear algebra shared-memory routines is analyzed. Information obtained in the installation of the routines is used at running time to take some decisions to reduce the total execution time. The study is carried out with routines at different levels (matrix multiplication, LU and Cholesky factorizations and linear systems symmetric or general routines) and with calls to routines in the LAPACK and PLASMA libraries with multithread implementations. Medium NUMA and large cc-NUMA systems are used in the experiments. This variety of routines, libraries and systems allows us to obtain general conclusions about the methodology to use for linear algebra shared-memory routines auto-tuning. Satisfactory execution times are obtained with the proposed methodology.

Enhancing locality for recursive traversals of recursive structures

While there has been decades of work on developing automatic, locality-enhancing transformations for regular programs that operate over dense matrices and arrays, there has been little investigation of such transformations for irregular programs, which operate over pointer-based data structures such as graphs, trees and lists. In this paper, we argue that, for a class of irregular applications we call traversal codes, there exists substantial data reuse and hence opportunity for locality exploitation. We develop a novel optimization called point blocking, inspired by the classic tiling loop transformation, and show that it can substantially enhance temporal locality in traversal codes. We then present a transformation and optimization framework called TreeTiler that automatically detects opportunities for applying point blocking and applies the transformation. TreeTiler uses autotuning techniques to determine appropriate parameters for the transformation. For a series of traversal algorithms drawn from real-world applications, we show that TreeTiler is able to deliver performance improvements of up to 245% over an optimized (but non-transformed) parallel baseline, and in several cases, significantly better scalability.

An efficient time-step-based self-adaptive algorithm for predictor–corrector methods of Runge–Kutta type

Finding an efficient implementation variant for the numerical solution of problems from computational science and engineering involves many implementation decisions that are strongly influenced by the specific hardware architecture. The complexity of these architectures makes it difficult to find the best implementation variant by manual tuning. For numerical solution methods from linear algebra, auto-tuning techniques based on a global search engine as they are used for ATLAS or FFTW can be used successfully. These techniques generate different implementation variants at installation time and select one of these implementation variants either at installation time or at runtime, before the computation starts. For some numerical methods, auto-tuning at installation time cannot be applied directly, since the best implementation variant may strongly depend on the specific numerical problem to be solved. An example is solution methods for initial value problems (IVPs) of ordinary differential equations (ODEs), where the coupling structure of the ODE system to be solved has a large influence on the efficient use of the memory hierarchy of the hardware architecture. In this context, it is important to use auto-tuning techniques at runtime, which is possible because of the time-stepping nature of ODE solvers. In this article, we present a sequential self-adaptive ODE solver that selects the best implementation variant from a candidate pool at runtime during the first time steps, i.e., the auto-tuning phase already contributes to the progress of the computation. The implementation variants differ in the loop structure and the data structures used to realize the numerical algorithm, a predictor–corrector (PC) iteration scheme with Runge–Kutta (RK) corrector considered here as an example. For those implementation variants in the candidate pool that use loop tiling to exploit the memory hierarchy of a given hardware platform we investigate the selection of tile sizes. The self-adaptive ODE solver combines empirical search with a model-based approach in order to reduce the search space of possible tile sizes. Runtime experiments demonstrate the efficiency of the self-adaptive solver for different IVPs across a range of problem sizes and on different hardware architectures.