Parallel preconditioned conjugate gradient method for large sparse and highly ill-conditioned systems arising in computational geomechanics

Application of a GPU-accelerated hybrid preconditioned conjugate gradient approach for large 3D problems in computational geomechanics

Parallel PCG Algorithm On Distributed Network By PVM

Conjugate Gradient (CG) method is an iterative linear solver which is used by many scientific and engineering applications to solve a linear system of algebraic equations. CG generates a heavy load of computation and therefore it slows the performance of the applications using it. Parallelizing CG is considered as a way to increase its performance. However, CG suffers from communication dependencies among its divisible loads. Most of the studies to parallelize CG concentrate on parallelizing its matrix-vector multiplication. In this paper, we answer the following questions: 1) what are the divisible loads in the CG, and 2) where is communication involved in the parallel CG. To answer 1), we highlight the different divisible data blocks in CG. To answer 2), we introduce a dependency graph among the different data blocks. We conduct experiments on a parallel CG implementation and evaluate communication cost.

A parallel numerical acoustic simulation on a GPU using an edge-based smoothed finite element method

The preconditioned conjugate gradient (PCG) algorithm is a well-known iterative method for solving sparse linear systems in scientific computations. GPU-accelerated PCG algorithms for large-sized problems have attracted considerable attention recently. However, on a specific multi-GPU platform, producing a highly parallel PCG implementation for any large-sized problem requires significant time because several manual steps are involved in adjusting the related parameters and selecting an appropriate storage format for the matrix block that is assigned to each GPU. This motivates us to propose adaptive optimization modeling of PCG on multi-GPUs, which mainly involves the following parts: (1) an optimization multi-GPU parallel framework of PCG and (2) the profile-based optimization modeling for each one of the main components of the PCG algorithm, including vector operation, inner product, and sparse matrix-vector multiplication (SpMV). Our model does not construct a new storage format or kernel but automatically and rapidly generates an optimal parallel PCG algorithm for any problem on a specific multi-GPU platform by integrating existing storage formats and kernels. We take a vector operation kernel, an inner-product kernel, and five popular SpMV kernels for an example to present the idea of constructing the model. Given that our model is general, independent of the problems, and dependent on the resources of devices, this model is constructed only once for each type of GPU. The experiments validate the high efficiency of our proposed model.

Virtual earthquake engineering laboratory with physics-based degrading materials on parallel computers

Parallelization is the key method to speedup advanced driving assistance systems (ADAS) and autonomous vehicle applications especially using emerging multicore and manycore processors. Localization and map matching are among the fundamental parts of such applications. This paper presents a parallel implementation and performance analysis of particle filter based vehicle localization and map-matching algorithm both on a multicore processor using Open Multi-Processing (OpenMP) and on a graphics processing unit (GPU) using the Compute Unified Device Architecture (CUDA). In the proposed implementation, GPS and odometer data is fused with digital map information. Tests were performed on real data captured in vehicle environment comprising various speed and road conditions. Test results show that speedups up to 75 times can be achieved on parallel GPU implementation over sequential counterpart. As this speedup complies with real-time performance requirements, high computational cost of using map topology information with large number of particles in particle filter implementation is proven to be handled by emerging technologies. The effect of number of particles on error rate of localization and map matching is also investigated.

Electric vehicles (EVs) are becoming more and more popular as they provide significant environmental benefits compared to fossil-fuel vehicles. However, they represent substantial loads on the power grid, and the scheduling of EV charging can be a challenge, especially in large parking lots. This paper presents a metaheuristic-based approach parallelized on multicore processors (CPU) and graphics processing units (GPU) to optimize the scheduling of EV charging in a single smart parking lot. The proposed method uses a particle swarm optimization algorithm that takes as input the arrival time, the departure time, and the power demand of the vehicles and produces an optimized charging schedule for all vehicles in the parking lot, which minimizes the overall charging cost while respecting the chargers’ capacity and the parking lot feeder capacity. The algorithm exploits task-level parallelism for the multicore CPU implementation and data-level parallelism for the GPU implementation. The proposed algorithm is tested in simulation on parking lots containing 20 to 500 EVs. The parallel implementation on CPUs provides a speedup of 7.1x, while the implementation on a GPU provides a speedup of up to 247.6x. The parallel implementation on a GPU is able to optimize the charging schedule for a 20-EV parking lot in 0.87 s and a 500-EV lot in just under 30 s. These runtimes allow for real-time computation when a vehicle arrives at the parking lot or when the electricity cost profile changes.

A parallel implementation of the TSSP + 1 decomposition for the capacity-constrained vehicle routing problem

Two parallel computer paradigms available today are multi-core accelerators such as the Sony, Toshiba and IBM Cell or Graphics Processing Unit (GPUs), and massively parallel message-passing machines such as the IBM Blue Gene (BG). The solution of systems of linear equations is one of the most central processing unit-intensive steps in engineering and simulation applications and can greatly benefit from the multitude of processing cores and vectorisation on today's parallel computers. We parallelise the conjugate gradient (CG) linear equation solver on the Cell Broadband Engine and the IBM Blue Gene/L machine. We perform a scalability analysis of CG on both machines across 1, 8 and 16 synergistic processing elements and 1–32 cores on BG with heptadiagonal matrices. The results indicate that the multi-core Cell system outperforms by three to four times the massively parallel BG system due to the Cell's higher communication bandwidth and accelerated vector processing capability.

Ant colony optimization(ACO) provides an effective way to solve combinatorial optimization problem. However, with the complexity of the problem increasing, the ACO algorithm needs considerable computational time and resources to improve the good quality of solution, and this rarely satisfies the requirement of real-time computing in M&S (Modeling and Simulation) area. Parallel implementation of ACO can reduce the computational time obviously for the large scale combinatorial optimization problem, and much of the previous work in this field focuses on parallel implementation using MPI which is executed on clusters. Meanwhile, great emphasis is placed on multi-core computing technology with the development of multi-processor architecture and multi-core architecture. A new parallel ant colony optimization (PACO) algorithm is proposed, which applies two kinds of typical multi-core computing technologies, the well-known OpenMP and the recently introduced TBB (Threading Building Blocks) library by Intel Corporation, to solve target assignment problem(TAP). Effectiveness and efficiency of proposed algorithm is validated by studying the convergence speed, problem size scalability and thread size scalability of it.

In this report we present parallel solvers for large linear systems arising from the finite-element discretization of the three-dimensional steady-state groundwater flow problem. Our solvers are based on multigrid and Krylov subspace methods. The parallel implementation is based on a domain decomposition strategy with explicit message passing using NX and MPI libraries. We have tested our parallel implementations on the Intel Paragon XP/S 150 supercomputer using up to 1024 parallel processors and on other parallel platforms such as SGI/Power Challenge Array, Cray/SGI Origin 2000, Convex Exemplar SPP-1200, and IBM SP using up to 64 processors. We show that multigrid can be a scalable algorithm on distributed memory machines. We demonstrate the effectiveness of parallel multigrid based solvers by solving problems requiring more than 70 million nodes in less than a minute. This is more than 25 times faster than the diagonal preconditioned conjugate gradient method which is one of the more popular methods for large sparse linear systems. Our results also show that multigrid as a stand alone solver works best for problems with smooth coefficients, but for rough coefficients it is best used as a preconditioner for a Krylov subspace method such as the conjugate gradient method. We show that even for extremely heterogeneous systems the multigrid pre-conditioned conjugate gradient method is at least 10 times faster than the diagonally preconditioned conjugate gradient method.

This paper presents parallel implementations and includes performance analysis of three prominent graph algorithms (i.e., Bellman Ford, Floyd-Warshall and Dijkstra) used for finding the all-pairs of shortest paths. The algorithm implementations were parallelized using Open MP (Open Multi-Processing). Their performances were measured on 4 different configurations i.e. dual core i3, quad core i5, quad core i7 and 8 core processors. This paper also presents a comparative study of serial and parallel implementations of these algorithms keeping execution time and number of graph nodes as the parameter. Finally, the results show that, execution time can be reduced using parallel implementation for larger number of graph nodes. Also, the conclusions are drawn for the best algorithm to be used which works for all the graph nodes with less execution time.

Traditional particle swarm optimization algorithms (PSO) targeted to solve large scale problems are mostly serial, such as CCPSO2, and the computing time is very long in general. Therefore, this paper presents a novel parallel PSO, which explores the usage of new probability distribution functions for the replacement of traditional Gaussian and Cauchy distributions, and the combination of GPSO and LPSO to make use of space exploration and speed up the convergence. As to the implementation of algorithm parallelization, we adopt the Spark platform, which is one of the currently most popular big data processing tools. We make modification to dynamic grouping and multiple calculations, in order to increase the degree of parallelism, reduce the computation time and improve algorithm efficiency as far as possible. Multiple computing refers to that in each single distribution of tasks, one computing node processes the particle position information of multiple algorithms. In the control of space exploration and convergence rate, we present a more efficient method to explore the solution space, which controls the convergence rate to enhance the exploration to a greater extent and also ensures fast convergence rate at the later stage, thus, it not only guarantees the calculation speed, but also improves the optimization effect as more as possible. We used twenty LSGO benchmark functions in CEC'2010 to make experiments, showing that the proposed algorithm could obtain satisfactory results, and for some functions, it outperforms DECC and MLCC.

Applications executing on multicore processors can now easily offload computations to many core processors, such as Intel Xeon Phi coprocessors. However, it requires high levels of expertise and effort to tune such offloaded applications to realize high-performance execution. Previous efforts have focused on optimizing the execution of offloaded computations on many core processors. However, we observe that the data transfer overhead between multicore and many core processors, and the limited device memories of many core processors often constrain the performance gains that are possible by offloading computations. In this paper, we present three source-to-source compiler optimizations that can significantly improve the performance of applications that offload computations to many core processors. The first optimization automatically transforms offloaded codes to enable data streaming, which overlaps data transfer between multicore and many core processors with computations on these processors to hide data transfer overhead. This optimization is also designed to minimize the memory usage on many core processors, while achieving the optimal performance. The second compiler optimization re-orders computations to regularize irregular memory accesses. It enables data streaming and factorization on many core processors, even when the memory access patterns in the original source codes are irregular. Finally, our new shared memory mechanism provides efficient support for transferring large pointer-based data structures between hosts and many core processors. Our evaluation shows that the proposed compiler optimizations benefit 9 out of 12 benchmarks. Compared with simply offloading the original parallel implementations of these benchmarks, we can achieve 1.16x-52.21x speedups.