Multigrid Reduction In Time Research Articles

Multigrid Reduction‐In‐Time Convergence for Advection Problems: A Fourier Analysis Perspective

ABSTRACTA long‐standing issue in the parallel‐in‐time community is the poor convergence of standard iterative parallel‐in‐time methods for hyperbolic partial differential equations (PDEs), and for advection‐dominated PDEs more broadly. Here, a local Fourier analysis (LFA) convergence theory is derived for the two‐level variant of the iterative parallel‐in‐time method of multigrid reduction‐in‐time (MGRIT). This closed‐form theory allows for new insights into the poor convergence of MGRIT for advection‐dominated PDEs when using the standard approach of rediscretizing the fine‐grid problem on the coarse grid. Specifically, we show that this poor convergence arises, at least in part, from inadequate coarse‐grid correction of certain smooth Fourier modes known as characteristic components, which was previously identified as causing poor convergence of classical spatial multigrid on steady‐state advection‐dominated PDEs. We apply this convergence theory to show that, for certain semi‐Lagrangian discretizations of advection problems, MGRIT convergence using rediscretized coarse‐grid operators cannot be robust with respect to CFL number or coarsening factor. A consequence of this analysis is that techniques developed for improving convergence in the spatial multigrid context can be re‐purposed in the MGRIT context to develop more robust parallel‐in‐time solvers. This strategy has been used in recent work to great effect; here, we provide further theoretical evidence supporting the effectiveness of this approach.

Coarse-grid operator optimization in multigrid reduction in time for time-dependent Stokes and Oseen problems

Coarse-grid operator optimization in multigrid reduction in time for time-dependent Stokes and Oseen problems

Parallel-in-time integration of the shallow water equations on the rotating sphere using Parareal and MGRIT

Despite the growing interest in parallel-in-time methods as an approach to accelerate numerical simulations in atmospheric modeling, improving their stability and convergence remains a substantial challenge for their application to operational models. In this work, we study the temporal parallelization of the shallow water equations on the rotating sphere combined with time-stepping schemes commonly used in atmospheric modeling due to their stability properties, namely an Eulerian implicit-explicit (IMEX) method and a semi-Lagrangian semi-implicit method (SL-SI-SETTLS). The main goal is to investigate the performance of parallel-in-time methods, namely Parareal and Multigrid Reduction in Time (MGRIT) when these well-established schemes are used on the coarse discretization levels and provide insights on how they can be improved for better performance. We begin by performing an analytical stability study of Parareal and MGRIT applied to a linearized ordinary differential equation depending on some temporal parallelization parameters, including the choice of a coarse scheme. Next, we perform numerical simulations of two standard tests in atmospheric modeling to evaluate the stability, convergence, and speedup provided by the parallel-in-time methods compared to a fine reference solution computed serially. We also conduct a detailed investigation on the influence of artificial viscosity and hyperviscosity approaches, applied on the coarse discretization levels, on the performance of the temporal parallelization. Both the analytical stability study and the numerical simulations indicate a poorer stability behavior when SL-SI-SETTLS is used on the coarse levels, compared to the IMEX scheme. With the IMEX scheme, a better trade-off between convergence, stability, and speedup compared to serial simulations can be obtained under proper parameters and artificial viscosity choices, opening the perspective of the potential competitiveness for realistic models.

Task graph-based performance analysis of parallel-in-time methods

In this paper, we present a performance model based on task graphs for various iterative parallel-in-time (PinT) methods. PinT methods have been developed to speed up the simulation time of time-dependent problems using modern parallel supercomputers. The performance model is based on a data-driven notation of the methods, from which a task graph is generated. Based on this task graph and a distribution of time points across processes typical for PinT methods, a theoretical lower runtime bound for the method can be obtained, as well as a prediction of the runtime for a given number of processes. In particular, the model is able to cover the large parameter space of PinT methods and make predictions for arbitrary parameter settings. Here, we describe a general procedure for generating task graphs based on three iterative PinT methods, namely, Parareal, multigrid-reduction-in-time (MGRIT), and the parallel full approximation scheme in space and time (PFASST). Furthermore, we discuss how these task graphs can be used to analyze the performance of the methods. In addition, we compare the predictions of the model with parallel simulation times using five different PinT libraries.

Multigrid Reduction in Time for Chaotic Dynamical Systems

Multigrid Reduction in Time for Chaotic Dynamical Systems

Efficient Multigrid Reduction-in-Time for Method-of-Lines Discretizations of Linear Advection

Parallel-in-time methods for partial differential equations (PDEs) have been the subject of intense development over recent decades, particularly for diffusion-dominated problems. It has been widely reported in the literature, however, that many of these methods perform quite poorly for advection-dominated problems. Here we analyze the particular iterative parallel-in-time algorithm of multigrid reduction-in-time (MGRIT) for discretizations of constant-wave-speed linear advection problems. We focus on common method-of-lines discretizations that employ upwind finite differences in space and Runge-Kutta methods in time. Using a convergence framework we developed in previous work, we prove for a subclass of these discretizations that, if using the standard approach of rediscretizing the fine-grid problem on the coarse grid, robust MGRIT convergence with respect to CFL number and coarsening factor is not possible. This poor convergence and non-robustness is caused, at least in part, by an inadequate coarse-grid correction for smooth Fourier modes in space-time known as characteristic components. We propose an alternative coarse-grid operator that provides a better correction of these modes. This coarse-grid operator is related to previous work and uses a semi-Lagrangian discretization combined with an implicitly treated truncation error correction. Theory and numerical experiments show the proposed coarse-grid operator yields fast MGRIT convergence for many of the method-of-lines discretizations considered, including for both implicit and explicit discretizations of high order. Parallel results demonstrate speed-up over sequential time-stepping.

Asynchronous Truncated Multigrid-Reduction-in-Time

In this paper, we present the new “asynchronous truncated multigrid-reduction-in-time” (AT-MGRIT) algorithm for introducing time parallelism to the solution of discretized time-dependent problems. The new algorithm is based on the multigrid-reduction-in-time (MGRIT) approach, which, in certain settings, is equivalent to another common multilevel parallel-in-time method, Parareal. In contrast to Parareal and MGRIT that both consider a global temporal grid over the entire time interval on the coarsest level, the AT-MGRIT algorithm uses truncated local time grids on the coarsest level, each grid covering certain temporal subintervals. These local grids can be solved completely in an independent way from each other, which reduces the sequential part of the algorithm and, thus, increases parallelism in the method. Here, we study the effect of using truncated local coarse grids on the convergence of the algorithm, both theoretically and numerically, and show, using challenging nonlinear problems, that the new algorithm consistently outperforms classical Parareal/MGRIT in terms of time to solution.

MGRIT-Based Multi-Level Parallel-in-Time Electromagnetic Transient Simulation

In this paper, we present an approach for multi-level parallel-in-time (PinT) electromagnetic transient (EMT) simulation. We evaluate the approach in the context of power electronics system-level simulation. While PinT approaches to power electronics simulations based on two-level algorithms have been thoroughly explored in the past, multi-level PinT approaches have not yet been investigated. We use the multigrid-reduction-in-time (MGRIT) method to parallelize a dedicated EMT simulation tool which is capable of switching between different converter models as it operates. The presented approach yields a time-parallel speed-up of up to 10 times compared to the sequential-in-time implementation. We also show that special care has to be taken to synchronize the time grids with the electronic components’ switching periods, indicating that further research into the usage of different models from adequate model hierarchies is necessary.

Weighted relaxation for multigrid reduction in time

AbstractCurrent trends in computer architectures now mean that faster computation speed must come primarily from increased concurrency, not faster clock speeds, which are stagnating. Thus, this situation creates bottlenecks for serial algorithms, including the well‐known bottleneck for sequential time‐integration, where each individual time‐value (i.e., time‐step) is computed sequentially. One approach to alleviate this and achieve parallelism in time is with multigrid. In this work, we consider multigrid‐reduction‐in‐time (MGRIT), a multilevel method applied to the time dimension that computes multiple time‐steps in parallel. Like all multigrid methods, MGRIT relies on the complementary relationship between relaxation on a fine‐grid and a correction from the coarse grid to solve the problem. All current MGRIT implementations are based on unweighted‐Jacobi relaxation; here we introduce the concept of weighted relaxation to MGRIT. We derive new convergence bounds for weighted relaxation, and use this analysis to guide the selection of relaxation weights. Numerical results then demonstrate that by choosing appropriate non‐unitary relaxation weights, one can achieve faster convergence rates and lower iteration counts for MGRIT when compared with unweighted relaxation. In most cases, weighted relaxation yields a 10%–20% saving in iterations, which is significant when using large high‐performance computers. For A‐stable integration schemes, results also illustrate that under‐relaxation can restore convergence in some cases where unweighted relaxation is not convergent.

Multigrid reduction in time for non-linear hyperbolic equations

Time-parallel algorithms seek greater concurrency by decomposing the temporal domain of a partial differential equation, providing possibilities for accelerating the computation of its solution. While parallelisation in time has allowed remarkable speed-ups in applications involving parabolic equations, its effectiveness in the hyperbolic framework remains debatable: growth of instabilities and slow convergence are both strong issues in this case, which often negate most of the advantages from time-parallelisation. Here, we focus on the Multigrid Reduction in Time algorithm, investigating in detail its performance when applied to non-linear conservation laws with a variety of discretisation schemes. Specific attention is given to high-accuracy Weighted Essentially Non-Oscillatory reconstructions, coupled with Strong Stability Preserving integrators, which are often the discretisations of choice for such equations. A technique to improve the performance of MGRIT when applied to a low-order, more dissipative scheme is also outlined. This study aims at identifying the main causes for degradation in the convergence speed of the algorithm and finds the Courant-Friedrichs-Lewy limit to be the principal determining factor.

Algorithm 1016

In this article, we introduce the Python framework PyMGRIT, which implements the multigrid-reduction-in-time (MGRIT) algorithm for solving (non-)linear systems arising from the discretization of time-dependent problems. The MGRIT algorithm is a reduction-based iterative method that allows parallel-in-time simulations, i.e., calculating multiple time steps simultaneously in a simulation, using a time-grid hierarchy. The PyMGRIT framework includes many different variants of the MGRIT algorithm, ranging from different multigrid cycle types and relaxation schemes, various coarsening strategies, including time-only and space-time coarsening, and the ability to utilize different time integrators on different levels in the multigrid hierachy. The comprehensive documentation with tutorials and many examples and the fully documented code allow an easy start into the work with the package. The functionality of the code is ensured by automated serial and parallel tests using continuous integration. PyMGRIT supports serial runs suitable for prototyping and testing of new approaches, as well as parallel runs using the Message Passing Interface (MPI). In this manuscript, we describe the implementation of the MGRIT algorithm in PyMGRIT and present the usage from both a user and a developer point of view. Three examples illustrate different aspects of the package itself, especially running tests with pure time parallelism, as well as space-time parallelism through the coupling of PyMGRIT with PETSc or Firedrake.

A multigrid-reduction-in-time solver with a new two-level convergence for unsteady fractional Laplacian problems

The multigrid-reduction-in-time (MGRIT) technique has proven to be successful in achieving higher run-time speedup by exploiting parallelism in time. The goal of this article is to develop and analyze a MGRIT algorithm using FCF-relaxation with time-dependent time-grid propagators to seek the finite element approximations of unsteady fractional Laplacian problems. The multigrid with line smoother proposed in Chen et al. (2016) is chosen to be the spatial solver. Motivated by Southworth (2019), we provide a new temporal eigenvalue approximation property and then deduce a generalized two-level convergence theory which removes the previous unitary diagonalization assumption on the fine and coarse time-grid propagators required in Yue et al. (2019). Numerical computations are included to confirm the theoretical predictions and demonstrate the sharpness of the derived convergence upper bound.

Optimizing multigrid reduction‐in‐time and Parareal coarse‐grid operators for linear advection

AbstractParallel‐in‐time methods, such as multigrid reduction‐in‐time (MGRIT) and Parareal, provide an attractive option for increasing concurrency when simulating time‐dependent partial differential equations (PDEs) in modern high‐performance computing environments. While these techniques have been very successful for parabolic equations, it has often been observed that their performance suffers dramatically when applied to advection‐dominated problems or purely hyperbolic PDEs using standard rediscretization approaches on coarse grids. In this paper, we apply MGRIT or Parareal to the constant‐coefficient linear advection equation, appealing to existing convergence theory to provide insight into the typically nonscalable or even divergent behavior of these solvers for this problem. To overcome these failings, we replace rediscretization on coarse grids with improved coarse‐grid operators that are computed by applying optimization techniques to approximately minimize error estimates from the convergence theory. One of our main findings is that, in order to obtain fast convergence as for parabolic problems, coarse‐grid operators should take into account the behavior of the hyperbolic problem by tracking the characteristic curves. Our approach is tested for schemes of various orders using explicit or implicit Runge–Kutta methods combined with upwind‐finite‐difference spatial discretizations. In all cases, we obtain scalable convergence in just a handful of iterations, with parallel tests also showing significant speed‐ups over sequential time‐stepping.

Multigrid reduction in time with Richardson extrapolation

Multigrid reduction in time with Richardson extrapolation

Parallel-in-time simulation of an electrical machine using MGRIT

We apply the multigrid-reduction-in-time (MGRIT) algorithm to an eddy current simulation of a two-dimensional induction machine supplied by a pulse-width-modulation signal. To resolve the fast-switching excitations, small time steps are needed, such that parallelization in time becomes highly relevant for reducing the simulation time. The MGRIT algorithm is an iterative method that allows calculating multiple time steps simultaneously by using a time-grid hierarchy. It is particularly well suited for introducing time parallelism in the simulation of electrical machines using existing application codes, as MGRIT is a non-intrusive approach that essentially uses the same time integrator as a traditional time-stepping algorithm. However, the key difficulty when using time-stepping routines of existing application codes for the MGRIT algorithm is that the cost of the time integrator on coarse time grids must be less expensive than on the fine grid to allow for speedup over sequential time stepping on the fine grid. To overcome this difficulty, we consider reducing the costs of the coarse-level problems by adding spatial coarsening. We investigate effects of spatial coarsening on MGRIT convergence when applied to two numerical models of an induction machine, one with linear material laws and a full nonlinear model. Parallel results demonstrate significant speedup in the simulation time compared to sequential time stepping, even for moderate numbers of processors.

A space-time parallel algorithm with adaptive mesh refinement for computational fluid dynamics

This paper describes a space-time parallel algorithm with space-time adaptive mesh refinement (AMR). AMR with subcycling is added to multigrid reduction-in-time (MGRIT) in order to provide solution efficient adaptive grids with a reduction in work performed on coarser grids. This algorithm is achieved by integrating two software libraries: XBraid (Parallel time integration with multigrid. https://computation.llnl.gov/projects/parallel-timeintegration-multigrid ) and Chombo (Chombo software package for AMR applications—design document, 2014). The former is a parallel time integration library using multigrid and the latter is a massively parallel structured AMR library. Employing this adaptive space-time parallel algorithm is Chord (Comput Fluids 123:202–217, 2015), a computational fluid dynamics (CFD) application code for solving compressible fluid dynamics problems. For the same solution accuracy, speedups are demonstrated from the use of space-time parallelization over the time-sequential integration on Couette flow and Stokes’ second problem. On a transient Couette flow case, at least a $$1.5\times $$ speedup is achieved, and with a time periodic problem, a speedup of up to $$13.7\times $$ over the time-sequential case is obtained. In both cases, the speedup is achieved by adding processors and exploring additional parallelization in time. The numerical experiments show the algorithm is promising for CFD applications that can take advantage of the time parallelism. Future work will focus on improving the parallel performance and providing more tests with complex fluid dynamics to demonstrate the full potential of the algorithm.

On “Optimal” h‐independent convergence of Parareal and multigrid‐reduction‐in‐time using Runge‐Kutta time integration

SummaryAlthough convergence of the Parareal and multigrid‐reduction‐in‐time (MGRIT) parallel‐in‐time algorithms is well studied, results on their optimality is limited. Appealing to recently derived tight bounds of two‐level Parareal and MGRIT convergence, this article proves (or disproves) hx‐ and ht‐independent convergence of two‐level Parareal and MGRIT, for linear problems of the form , where is symmetric positive definite and Runge‐Kutta time integration is used. The theory presented in this article also encompasses analysis of some modified Parareal algorithms, such as the θ‐Parareal method, and shows that not all Runge‐Kutta schemes are equal from the perspective of parallel‐in‐time. Some schemes, particularly L‐stable methods, offer significantly better convergence than others as they are guaranteed to converge rapidly at both limits of small and large htξ, where ξ denotes an eigenvalue of and ht time‐step size. On the other hand, some schemes do not obtain h‐optimal convergence, and two‐level convergence is restricted to certain regimes. In certain cases, an factor change in time step ht or coarsening factor k can be the difference between convergence factors ρ≈0.02 and divergence! The analysis is extended to skew‐symmetric operators as well, which cannot obtain h‐independent convergence and, in fact, will generally not converge for a sufficiently large number of time steps. Numerical results confirm the analysis in practice and emphasize the importance of a priori analysis in choosing an effective coarse‐grid scheme and coarsening factor. A Mathematica notebook to perform a priori two‐grid analysis is available at https://github.com/XBraid/xbraid‐convergence‐est.

Multilevel Convergence Analysis of Multigrid-Reduction-in-Time

This paper presents a multilevel convergence framework for multigrid-reduction-in-time (MGRIT) as a generalization of previous two-grid estimates. The framework provides a priori upper bounds on th...

Multigrid‐reduction‐in‐time for Eddy Current problems

AbstractParallel‐in‐time methods have shown success for reducing the simulation time of many time‐dependent problems. Here, we consider applying the multigrid‐reduction‐in‐time (MGRIT) algorithm to a voltage‐driven eddy current model problem.

A parallel-in-time algorithm for variable step multistep methods

This paper presents a multigrid reduction in time (MGRIT) algorithm for achieving time parallelism using multistep backward difference formula (BDF) methods on variably-spaced temporal grids. This MGRIT approach transforms the linear multistep methods into single step methods applied to groups of time steps. Stability considerations are addressed through lowering of the order on coarse grids. The methods are presented for fixed and variable time step formulations. Numerical results show moderate speedups for the heat equation as well as two IEEE power grid test problems characterized by nonlinear differential algebraic equations (DAE) of index 1. The performance of MGRIT with BDF is compared to MGRIT with Runge-Kutta for both the fixed and variable step methods of the same order.