[Paper Review] Speeding up a few orders of magnitude the Jacobi method: high order Chebyshev-Jacobi over GPUs

José E. Adsuara, Aloy, M. A.+2 more|arXiv (Cornell University)|Apr 29, 2017

Model Reduction and Neural Networks4 references3 citations

TL;DR

This paper presents a GPU-accelerated high-order Chebyshev-Jacobi (CJM) method for solving elliptic partial differential equations via finite differences, achieving speedups of several orders of magnitude over classical Jacobi. By combining high-order finite difference stencils (9-point and 17-point) with optimized Chebyshev acceleration and GPU parallelization, the method reduces iteration counts and computational time while maintaining high accuracy.

ABSTRACT

In this technical note we show how to reach a remarkable speed up when solving elliptic partial differential equations with finite differences thanks to the joint use of the Chebyshev-Jacobi method with high order discretizations and its parallel implementation over GPUs.

Motivation & Objective

• To significantly accelerate iterative solution of elliptic PDEs arising from finite difference discretizations.
• To leverage the inherent parallelism of GPUs to enhance performance of the classical Jacobi method.
• To demonstrate the superiority of high-order discretizations (9-point and 17-point stencils) in reducing iteration counts and computational time.
• To implement and benchmark a GPU-optimized Chebyshev-Jacobi method across different GPU architectures (compute capabilities 3.5 and 5.2).

Proposed method

• Uses high-order finite difference stencils (9-point and 17-point) to discretize the Laplacian operator, improving accuracy and reducing iteration count.
• Applies the Chebyshev-Jacobi method (CJM), which uses analytically derived, iteration-dependent weights based on Chebyshev polynomial zeros to accelerate convergence.
• Employs a transformation of Chebyshev roots to compute optimal relaxation weights, dependent on mesh size, boundary conditions, and eigenvalue bounds (κ_min and κ_max).
• Implements the CJM on GPUs using CUDA, exploiting data-parallelism for efficient stencil updates across grid points.
• Uses the infinity norm of the difference between numerical and analytical solutions as a convergence criterion to ensure consistent error levels.
• Compares performance across classical Jacobi, CJM on CPU, and CJM on GPU using identical test problems and error targets.

Experimental results

Research questions

• RQ1 Can the Chebyshev-Jacobi method achieve orders-of-magnitude speedup when ported to GPU architectures?
• RQ2 How does high-order finite difference discretization (9-point vs. 17-point) affect convergence speed and computational cost compared to classical 5-point stencils?
• RQ3 What is the performance gain of GPU-accelerated CJM over CPU-based Jacobi and CJM across different GPU compute capabilities?
• RQ4 Does using higher-order stencils reduce the number of iterations and total computational time while maintaining the same solution accuracy?
• RQ5 How do the eigenvalue bounds (κ_min and κ_max) for different stencils influence the optimal weighting strategy in the CJM?

Key findings

• The GPU-optimized Chebyshev-Jacobi method achieves speedups of up to 25,235× over classical Jacobi for a 9-point stencil on a 1024×1024 grid with compute capability 5.2.
• For the 17-point stencil, the CJM on GPU achieves a speedup of 12,420× over classical Jacobi on the same grid and GPU architecture.
• Using a 17-point stencil with N=128 points per dimension reduces the number of iterations and computational time by one order of magnitude compared to a 5-point stencil with N=2048, while achieving the same target error (10⁻⁸).
• The 17-point stencil requires only 34 iterations and 352 GPU kernel launches to reach the target error, compared to 481 iterations and 3,570 launches for the 9-point stencil on the same grid.
• The performance gap between Kepler (CC 3.5) and Maxwell (CC 5.2) GPUs diminishes with increasing grid size and stencil complexity, indicating strong scalability on modern architectures.
• High-order discretizations are consistently advantageous: they reduce iteration counts and total computational time despite larger stencils, due to faster convergence to the same solution accuracy.