Speedup Results Research Articles

Wred: Workload Reduction for Scalable Index Tuning

Modern database systems offer index-tuning advisors that automatically identify a set of indexes to improve workload performance. Advisors leverage the optimizer's what-if API to optimize a query for a hypothetical index configuration. Because what-if calls constitute a major bottleneck of index tuning, existing techniques, such as workload compression, help reduce the number of what-if calls to speed up tuning. Unfortunately, even with small workloads and few what-if calls, tuning can still take hours due to the complexity of the queries (e.g., the number of joins, filters, group-by and order-by clauses), which increases their optimization time. This paper introduces workload reduction, a new complementary technique aimed at expediting index tuning by decreasing individual what-if call time without significantly affecting the quality of index tuning. We present an efficient workload reduction algorithm, called Wred, which rewrites each query in the original workload to eliminate column and table expressions unlikely to benefit from indexes, thereby accelerating what-if calls. We study its complexity and ability to maintain high index quality. We perform an extensive evaluation over industry benchmarks and real-world customer workloads, which shows that Wred results in a 3x median speedup in tuning efficiency over an industrial-strength state-of-the-art index advisor, with only a 3.7% median loss in improvement---where improvement is the total workload cost as estimated by the query optimizer---and results in up to 24.7x speedup with 1.8% improvement loss. Furthermore, combining Wred and Isum (a state-of-the-art workload compression technique for index tuning) results in higher speedups than either of the two techniques alone, with 10.5x median speedup and 5% median improvement loss.

GPU-accelerated DNS of compressible turbulent flows

This paper explores strategies to transform an existing CPU-based high-performance computational fluid dynamics solver, HyPar, for compressible flow simulations on emerging exascale heterogeneous (CPU+GPU) computing platforms. The scientific motivation for developing a GPU-enhanced version of HyPar is to simulate canonical turbulent flows at the highest resolution possible on such platforms. We show that optimizing memory operations and thread blocks results in 200x speedup of computationally intensive kernels compared with a CPU core. Using multiple GPUs and CUDA-aware MPI communication, we demonstrate both strong and weak scaling of our GPU-based HyPar implementation on the NVIDIA Volta V100 GPUs. We simulate the decay of homogeneous isotropic turbulence in a triply periodic box on grids with up to 10243 points (5.3 billion degrees of freedom) and on up to 1,024 GPUs. We compare the wall times for CPU-only and CPU+GPU simulations. The results presented in the paper are obtained on the Summit and Lassen supercomputers at Oak Ridge and Lawrence Livermore National Laboratories, respectively.

Acceleration strategies for large-scale sequential simulations using parallel neighbour search: Non-LVA and LVA scenarios

This paper describes the application of acceleration techniques into existing implementations of Sequential Gaussian Simulation and Sequential Indicator Simulation. These implementations might incorporate Locally Varying Anisotropy (LVA) to capture non-linear features of the underlying physical phenomena. The implementation focuses on a novel parallel neighbour search algorithm, which can be used on both non-LVA and LVA codes. Additionally, parallel shortest path executions and optimized linear algebra libraries are applied with focus on LVA codes. Execution time, speedup and accuracy results are presented. Non-LVA codes are benchmarked using two scenarios with approximately 50 million domain points each. Speedup results of 2× and 4× were obtained on SGS and SISIM respectively, where each scenario is compared against a baseline code published in Peredo et al. (2018). The aggregated contribution to speedup of both works results in 12× and 50× respectively. LVA codes are benchmarked using two scenarios with approximately 1.7 million domain points each. Speedup results of 56× and 1822× were obtained on SGS and SISIM respectively, where each scenario is compared against the original baseline sequential codes.

Fast simulation of dynamic heat transfer through building envelopes via parareal algorithms

In this article, two efficient time-parallel algorithms, the classical parareal algorithm and the parareal waveform relaxation (PWR) algorithm, were constructed and investigated for dynamic heat transfer through building envelopes. They were first compared with the response factor method and harmonic response method to show their reliability. Then the simulation results and parallel performance of the two parareal algorithms were investigated through examples about a roof, a double glass façade (DGF), and a wall with a patented aerogel insulating layer. In all simulations, the computing time of the PWR algorithm decreases by 26–30% compared to that of the classical parareal algorithm. The results for speedup and parallel efficiency also indicate that the PWR algorithm is more efficiency than the classical parareal algorithm.

High-performance Implementation of Parallel Semi-Implicit Method for Pressure Linked Equations Solver on CPU+GPU Platform

Suspension of threads on Graphics Processors Units (GPU) was the main drawback of the traditional implement of red-black SOR. A new GPU implement of red-black SOR, the mono-color floating-point scheme, was developed in this paper to remove the suspension and improve computing performance. The search module in mono-color scheme was transformed into floating-point calculation in mono-color floating-point scheme with assistance of the stencil function. Fine granularity, high parallelism and high ratio of floating-point load were realized in this scheme and the programming process on GPU was simplified dramatically. This new scheme was applied to construct the parallel Semi-Implicit Method for Pressure Linked Equations (SIMPLE) solver through Open Computing Language (OpenCL) platform. The numerical results of iteration of discrete equations in SIMPLE showed that the new scheme can get 60–70% performance improvement compared with the traditional implementation of red-black SOR. The speedup results of SIMPLE showed that the computing performance of SIMPLE followed the change of the performance of red-black SOR and the difference between the two was very small. The same performance improvement also could be found in SIMPLE solver with the mono-color floating-point scheme.

String Generation by Cellular Automata

In contrast to many investigations of cellular automata with regard to their ability to accept inputs under certain time constraints, in this paper we are studying cellular automata with regard to their ability to generate strings in real time. Structural properties such as speedup results and closure properties are investigated. On the one hand, constructions for the closure under intersection, reversal and length-preserving homomorphism are presented, whereas on the other hand the nonclosure under union, complementation and arbitrary homomorphism are obtained. Finally, decidability questions such as emptiness, finiteness, equivalence, inclusion, regularity and context-freeness are addressed.

Integrating Amdahl-like Laws and Divisible Load Theory

A simple means of integrating the characteristics of networked processors under divisible loads into Amdahl’s Law is presented. Amdahl’s Law serves as an upper bound to these speedup results. Amdahl’s Law with divisible load processing characteristics included serves as an upper bound to speedup for any model taking into consideration more detailed peculiarities of real systems such as the overhead of task creation, synchronization, resource contention and memory issues.

FORTRESS: FORTRAN programs for solving coupled Gross–Pitaevskii equations for spin–orbit coupled spin-1 Bose–Einstein condensate

Here, we present simple and efficient numerical scheme to study static and dynamic properties of spin-1 Bose–Einstein condensates (BECs) with spin–orbit (SO) coupling by solving three coupled Gross–Pitaevskii equations (CGPEs) in three-, quasi-two and quasi-one dimensional systems. We provide a set of three codes developed in FORTRAN 90/95 programming language with user defined ‘option’ of imaginary and real-time propagation. We present the numerical results for energy, chemical potentials, and component densities for the ground state and compare with the available results from the literature. The results are presented for both the ferromagnetic and antiferromagnetic spin-1 BECs with and without SO coupling. To improve the computational speed, all the codes have the option of OpenMP parallelization. We have also presented the results for speedup and efficiency of OpenMP parallelization for the three codes with both imaginary and real-time propagation. Program summaryProgram Title: FORTRESSCPC Library link to program files:https://doi.org/10.17632/st7md3ss85.1Licensing provisions: MITProgramming language: (OpenMP) FORTRAN 90/95External routines/libraries: FFTW 3.3.8Nature of problem: To solve the coupled Gross–Pitaevskii equations for spin-1 BEC with anisotropic spin–orbit coupling using the time-splitting spectral method.Solution method: We use the time-splitting Fourier spectral method to solve the coupled Gross–Pitaevskii equations. The resulting equations are evolved in imaginary time to obtain the ground state of the system or in real-time to study the dynamics.

FSA: A Fine-Grained Systolic Accelerator for Sparse CNNs

Sparsity, as an intrinsic property of convolutional neural networks (CNNs), has been widely employed for hardware acceleration, and many customized accelerators tailored for sparse weights or activations have been proposed in these years. However, the irregular sparse patterns introduced by both weights and activations are much more challenging for efficient computation. For example, due to the issues of access contention, workload imbalance, and tile fragmentation, the state-of-the-art sparse accelerator SCNN fails to fully leverage the benefits of sparsity, leading to nonoptimal results for both speedup and energy efficiency. In this article, we propose an efficient sparse CNN accelerator for both weights and activations, namely finegrained systolic accelerator (FSA), which jointly optimizes both hardware dataflow and software partitioning and scheduling strategy. Specifically, to deal with the access contentions problem, we present a fine-grained systolic dataflow, in which the activations move rhythmically along the horizontal processing element array while the weights are fed into the array in a fine-grained order. We then propose a hybrid network partitioning strategy that sets different partitioning strategies for different layers to balance the workload and alleviate the fragmentation problem caused by both sparse weights and activations. Finally, we present a scheduling search strategy to find the optimized schedules for neural networks, which can further improve energy efficiency. Extensive evaluations show that the proposed FSA consistently outperforms SCNN over AlexNet, VGGNet, GoogLeNet, and ResNet with an average speedup of 1.74× and up to 13.86× energy efficiency.

An OpenMP parallel implementation using a coprocessor for numerical simulation of oil reservoirs

The objective of this work is to parallelize, using the Application Programming Interface (API) OpenMP (Open Multi-Processing) and Intel Xeon Phi coprocessor based on Intel Many Integrated Core (MIC) architecture, the numerical method used to solve the algebraic system resulting from the discretization of the differential partial equation (PDE) that describes the single-phase flow in an oil reservoir. The set of governing equations are the continuity equation and the Darcy’s law. The Hydraulic Diffusivity Equation (HDE), for the unknown pressure, is obtained from these fundamental equations and it is discretized by means of the Finite Difference Method (FDM) along with a time implicit formulation. Different numerical tests were performed to study the computational efficiency of the parallelized versions of Conjugate Gradient, BiConjugate Gradient and BiConjugate Gradient Stabilized methods. Speedup results were considered to evaluate the performance of the parallel algorithms for the horizontal well simulation case. The methodology also included a sensibility analysis for different production scenarios including variations on the permeability, formation-value-factor, well length and production rate.

Speeding-up simulation of cogging process by multigrid method

Calculation time of some material forming processes is tremendously expensive which makes reducing computational time one of the most urgent challenges in this domain. Among strategies that have been developed to speed-up calculations, one of the most flexible solutions is to utilize enhanced linear solvers such as Multi-Grid algorithm. It consists in using several levels of meshes of the same domain in order to more efficiently solve the systems of equations derived from the discretized problem. The speed-up results from the efficiency of coarse meshes in computing the low frequencies of the residual while fine meshes are more efficient in reducing the high frequencies of the residual. The method is integrated in the commercial software Forge® and applied to the industrial cogging process. The obtained results show that the speed-up depends on the number of nodes; for an industrial scale mesh of 50,000 nodes, the multigrid technique allows dividing the computational time by a factor of two.

Iteration acceleration for distributed learning systems

Abstract During the implementation of iterative machine learning algorithms for objective function optimization in large-scale distributed environment, they can be blocked when some of the machines failed. In this paper, a hybrid approach is proposed to balance the performance and efficiency. In each iteration, the results from failure machines are abandoned. We will discuss the relationship between accuracy and abandon rate which can be formulated as inequations. It is argued that the speed of this process is highly effective and efficient. The algorithm is demonstrated using real distributed environment and shows significant improvement of speedup results.

A path-level exact parallelization strategy for sequential simulation

Sequential Simulation is a well known method in geostatistical modelling. Following the Bayesian approach for simulation of conditionally dependent random events, Sequential Indicator Simulation (SIS) method draws simulated values for K categories (categorical case) or classes defined by K different thresholds (continuous case). Similarly, Sequential Gaussian Simulation (SGS) method draws simulated values from a multivariate Gaussian field. In this work, a path-level approach to parallelize SIS and SGS methods is presented. A first stage of re-arrangement of the simulation path is performed, followed by a second stage of parallel simulation for non-conflicting nodes. A key advantage of the proposed parallelization method is to generate identical realizations as with the original non-parallelized methods. Case studies are presented using two sequential simulation codes from GSLIB: SISIM and SGSIM. Execution time and speedup results are shown for large-scale domains, with many categories and maximum kriging neighbours in each case, achieving high speedup results in the best scenarios using 16 threads of execution in a single machine.

A fast, parallel algorithm for distant-dependent calculation of crystal properties

A fast, parallel algorithm for distant-dependent calculation and simulation of crystal properties is presented along with speedup results and methods of application. An illustrative example is used to compute the Lennard-Jones lattice constants up to 32 significant figures for 4≤p≤30 in the simple cubic, face-centered cubic, body-centered cubic, hexagonal-close-pack, and diamond lattices. In most cases, the known precision of these constants is more than doubled, and in some cases, corrected from previously published figures. The tools and strategies to make this computation possible are detailed along with application to other potentials, including those that model defects.

Performance Evaluations for OpenMP Accelerated Training Of Separable Image Filter

One of the widespread image processing applications is image filtering with two dimensional convolution. Determining the weights of image filters are of importance for the success of filtering operation. Heuristic algorithms such as genetic algorithms provide an efficient way of training these types of filters. Due to the high computational cost of repetitive image filtering operations, this process may take hours to implement using single core computing. OpenMP (Open Multi Processing) provides an efficient library for utilizing the computing power of multicore processors. In this study, OpenMP accelerated training of separable filters that are a subclass of convolution filters has been implemented based on genetic algorithms. Comparative speed-up results for various sizes of images using various sizes of filtering kernels were presented. Also the effect of population size of genetic algorithm and the number of working cores have been investigated.

ParSymG: a parallel clustering approach for unsupervised classification of remotely sensed imagery

ABSTRACTSymmetry is a common feature in the real world. It may be used to improve a classification by using the point symmetry-based distance as a measure of clustering. However, it is time consuming to calculate the point symmetry-based distance. Although an efficient parallel point symmetry-based K-means algorithm (ParSym) has been propsed to overcome this limitation, ParSym may get stuck in sub-optimal solutions due to the K-means technique it used. In this study, we proposed a novel parallel point symmetry-based genetic clustering (ParSymG) algorithm for unsupervised classification. The genetic algorithm was introduced to overcome the sub-optimization problem caused by inappropriate selection of initial centroids in ParSym. A message passing interface (MPI) was used to implement the distributed master–slave paradigm. To make the algorithm more time-efficient, a three-phase speedup strategy was adopted for population initialization, image partition, and kd-tree structure-based nearest neighbor searching. The advantages of ParSymG over existing ParSym and parallel K-means (PKM) alogithms were demonstrated through case studies using three different types of remotely sensed images. Results in speedup and time gain proved the excellent scalability of the ParSymG algorithm.

Parallel Nonnegative Matrix Factorization via Newton Iteration

The goal of Nonnegative Matrix Factorization (NMF) is to represent a large nonnegative matrix in an approximate way as a product of two significantly smaller nonnegative matrices. This paper shows in detail how an NMF algorithm based on Newton iteration can be derived using the general Karush-Kuhn-Tucker (KKT) conditions for first-order optimality. This algorithm is suited for parallel execution on systems with shared memory and also with message passing. Both versions were implemented and tested, delivering satisfactory speedup results.

On scaling dynamic programming problems with a multithreaded tabling Prolog system

Prolog system scaling the execution of dynamic programming problems.New design supporting multithreaded tabling in Prolog systemsApplication of multithreaded tabling to well-known dynamic programming problems.Experimental results showing promising speedup results up to 32 cores. Tabling is a powerful implementation technique that improves the declarativeness and expressiveness of traditional Prolog systems in dealing with recursion and redundant computations. It can be viewed as a natural tool to implement dynamic programming problems, where a general recursive strategy divides a problem in simple sub-problems that are often the same. When tabling is combined with multithreading, we have the best of both worlds, since we can exploit the combination of higher declarative semantics with higher procedural control. However, at the engine level, such combination for dynamic programming problems is very difficult to exploit in order to achieve execution scalability as we increase the number of running threads. In this work, we focus on two well-known dynamic programming problems, the Knapsack and the Longest Common Subsequence problems, and we discuss how we were able to scale their execution by using the multithreaded tabling engine of the Yap Prolog system. To the best of our knowledge, this is the first work showing a Prolog system to be able to scale the execution of multithreaded dynamic programming problems. Our experiments also show that our system can achieve comparable or even better speedup results than other parallel implementations of the same problems.

A high performance hardware accelerator for dynamic texture segmentation

The major contribution of this paper is the development of a hardware (FPGA) software (CPU) co-design architecture for accelerating the application of Dynamic Texture Segmentation.This work presents a FPGA implementation of FFT processing sub-system including FFT/IFFT processors, read/write control modules, and memory/FIFO modules, as well as memory optimization using local FIFOs to minimize external RAM access. Such FPGA implementation fully exploits the hardware acceleration technique. All FFT and related operations are executed in hardware which should run orders of magnitude faster than the software implementation.This paper demonstrates that the FPGA-CPU based solution is 37.3 times faster in data processing time and 5.9 times faster in total run time, compared to the CPU (CPU-GPU) based solution. Hardware accelerators such as general-purpose GPUs and FPGAs have been used as an alternative to conventional CPU architectures in scientific computing applications, and have achieved good speed-up results. Within this context, the present study presents a heterogeneous architecture for high-performance computing based on CPUs and FPGAs, which efficiently explores the maximum parallelism degree for processing video segmentation using the concept of dynamic textures. The video segmentation algorithm includes processing the 3-D FFT, calculating the phase spectrum and the 2-D IFFT operation. The performance of the proposed architecture based on CPU and FPGA is compared with the reference implementation of FFTW in CPU and with the cuFFT library in GPU. The performance report of the prototyped architecture in a single Stratix IV FPGA obtained an overall speedup of 37x over the FFTW software library.

A parallel computing strategy for Monte Carlo simulation using groundwater models

In this paper we present the results of a parallelization strategy to reduce the execution time for applying Monte Carlo simulation with a large number of realizations obtained using a groundwater flow and transport model. We develop a script in Python using mpi4py, in order to execute GWMC and related programs in parallel, applying the MPI library. Our approach is to calculate the initial inputs for each realization, and run groups of these realizations in separate processors and afterwards to calculate the mean vector and the covariance matrix of them. This strategy was applied to the study of a simplified aquifer in a rectangular domain of a single layer. We report the results of speedup and efficiency for 1000, 2000 and 4000 realizations for different number of processors. Efficiencies of 0.70, 0.76 and 0.75 were obtained for 64, 64 and 96 processors, respectively. We observe a slightly improvement of the performance as the number of realizations is increased.