An adaptive parareal algorithm

Abstract

In this paper, we consider the problem of accelerating the numerical simulation of time dependent problems by time domain decomposition. The available algorithms enabling such decompositions present severe efficiency limitations and are an obstacle for the solution of large scale and high dimensional problems. Our main contribution is the improvement of the parallel efficiency of the parareal in time method. The parareal method is based on combining predictions made by a numerically inexpensive solver (with coarse physics and/or coarse resolution) with corrections coming from an expensive solver (with high-fidelity physics and high resolution). At convergence, the algorithm provides a solution that has the fine solver’s high-fidelity physics and high resolution. In the classical version, the fine solver has a fixed high accuracy which is the major obstacle to achieve a competitive parallel efficiency. In this paper, we develop an adaptive variant that overcomes this obstacle by dynamically increasing the accuracy of the fine solver across the parareal iterations. We theoretically show that the parallel efficiency becomes very competitive in the ideal case where the cost of the coarse solver is small, thus proving that the only remaining factors impeding full scalability become the cost of the coarse solver and communication time. The developed theory has also the merit of setting a general framework to understand the success of several extensions of parareal based on iteratively improving the quality of the fine solver and re-using information from previous parareal steps. We illustrate the actual performance of the method in stiff ODEs, which are a challenging family of problems since the only mechanism for adaptivity is time and efficiency is affected by the cost of the coarse solver.

1. Introduction

Solving complex models with high accuracy and within a reasonable computing time has motivated the search for numerical schemes that exploit efficiently parallel computing architectures. In this paper, the model consists of a Partial Differential Equation (PDE) set on a domain $\mathcal{D}$. In this context, one of the main ideas to parallelize a simulation is to break the problem into subproblems defined over subdomains of a partition of $\mathcal{D}$. The domain can potentially have high dimensionality and be composed of different variables like space, time, velocity or even more specific variables for some problems. While there exist algorithms with very good scalability properties for the decomposition of the spatial variable in elliptic and saddle-point problems (see [1] or [2] for an overview), the same cannot be said for the decomposition of time of even simple systems of ODEs. This is despite the fact that research on time domain decomposition is currently very active and has by now a history of at least 50 years (back to at least [3]) during which several algorithms have been explored (see [4] for an overview). As a consequence, time domain decomposition is to date only a secondary option when it comes to deciding what algorithm/method distributes the tasks in a parallel cluster.

The main goal of this work is to address this efficiency limitation in the framework of one particular scheme: the parareal in time algorithm. The method was first introduced in [5] and has been well accepted by the community because it is easily applicable to a relatively large spectrum of problems. (Some specific difficulties are nevertheless encountered on certain types of PDEs as reported in, e.g., [6], [7] for hyperbolic systems or [8], [9] for hamiltonian problems). Another ingredient for its success is that, even though its scalability properties are limited, they are in general competitive in comparison with other methods. Without entering into very specific details of the algorithm at this stage, we can summarize the procedure by saying that we build iteratively a sequence to approximate the exact solution of the problem by a predictor–corrector algorithm. At every iteration, predictions are made by a solver which has to be as numerically inexpensive as possible since it is run on the full time interval. It usually involves coarse physics and/or coarse resolution. Corrections involve an expensive solver with high-fidelity physics and high resolution which is propagated in parallel over small time subdomains. In the classical version of parareal, the fine solver has a fixed high accuracy across all iterations. It is set to the one that we would use to solve the dynamics at the desired accuracy with a purely sequential solver. It is well-known that this point is the major obstacle to achieve better parallel efficiency. In this paper, we propose an adaptive variant where the accuracy of the fine solver is increased across the iterations. Our main goal is to show that this new point of view overcomes the obstacle of the cost of the fine solver and that the only remaining factors limiting high performance become the cost of the coarse solver and communication time. We refer to, e.g., [10] for contributions on the lowering of the cost of that coarse solver.

We present in Section 2 the new adaptive point of view. This requires to formulate an idealized version of the parareal algorithm in an infinite dimensional function space where the fine propagations are replaced by the exact ones (Section 2.2). Since this scheme is obviously not implementable in practice, we formulate a feasible “perturbed” version that involves approximations of the exact propagations at increasing accuracy across the iterations (Section 2.3). The accuracies are tightened in such a way that the feasible adaptive algorithm converges at the same rate as the ideal one and with a near-minimal numerical cost. The identified tolerances involve quantities that are difficult to estimate in practice. In addition, they may not be optimal because they are derived from a theoretical convergence analysis based on abstract conditions for the coarse and fine solvers. We bridge this gap between theory and actual implementation by proposing practical guidelines to set these tolerances. We next explain in Section 2.4 how the new formulation invites to use adaptive schemes not only in the time variable, but also in other variables that may be involved in the dynamics. The performance of the algorithm could also be enhanced by re-using informations from previous iterations in order to limit the cost of internal solvers. The techniques for this will strongly depend on the nature of the specific problem. We discuss common situations in Appendix. We close Section 2.5 by listing the main advantages of the new framework and how the classical parareal paradigm can be formulated with the optics of the new standpoint.

The parallel performance of the adaptive scheme is difficult to predict a priori but in Section 3 we carry a discussion where we show that it will always be superior to the classical approach. In the idealized situation where the cost of the coarse solver and communication delays are negligible, we show that the algorithm would exhibit a very high parallel efficiency.

We emphasize that our theory is general in the sense that it is applicable to ODEs and also to PDEs involving time, space and possibly other variables. We defer to a future work the presentation of a numerical PDE example since it requires the deployment of space–time adaptive methods which is a challenging topic in itself and the techniques usually depend very specifically on the problem nature. Instead, we illustrate the performance of the algorithm on stiff ODEs in Section 4. They are a challenging family of problems because the only source of adaptivity is time and they do not allow to use a very inexpensive coarse solver. The tested ODEs are the Brusselator, the Van der Pol, the Oregonator equations, and an SEIR model which has very recently been proposed in [11] to model the spread of the COVID-19 virus in the Wuhan city area. The code to reproduce our results (and experiment with other ODEs) is available online.1 Our first two examples are relatively stiff, while the other two are highly stiff, and serve to illustrate the limitations of the approach. We show that in the relatively stiff problems, the adaptive parareal algorithm performs between 2 to 3 times better than the classical one when the solution is approximated at high accuracy. In addition, we confirm in these two examples that the only remaining obstacles to achieve a very competitive performance are the cost of the coarse solver and communication time between processors. Due to the nature of the algorithm, it is not clear how to overcome these limitations, especially the one coming from the coarse solver. This issue will come at the forefront for future research since, as our two highly stiff examples illustrate, the cost of the coarse solver may even prevent from obtaining any speed-up at all. We show that if we could find an inexpensive coarse solver, perhaps based on empirical data or on good back-of the envelope calculations, our adaptive algorithm would yield interesting speeds-ups even in highly stiff cases.

In addition to the improvement in parallel efficiency (except, of course, in the above discussed extreme cases), the adaptive version of parareal brings an important conceptual novelty to the field of time domain decomposition which is the one of error controlled computations. By this we mean that the deviation of the numerical result from the exact continuous solution is certifiably quantified and set to meet a given target accuracy with respect to a problem relevant norm. This requires the formulation of the algorithm at an infinite dimensional level as is done in this paper. This point of view is fundamentally different from the fully discrete setting in which the parareal algorithm has always been thought of in practice. That is, we first fix a discretization (often on a uniform grid) and then speed-up the computation of the discrete evolution with parareal. In this way, we do not have any rigorous control of the error with respect to the actual continuous solution and we do not have any systematic procedure to minimize the number of degrees of freedom.

We conclude this introduction by some bibliographical remarks. To the best of our knowledge, the current abstract and broad formulation of an adaptive version of parareal has never been proposed in the literature. However, previous works have instantiated in a variety of particular applications the idea of re-using information from previous parareal iterations, either with the purpose of improving the quality of the fine solver or to build an initial guess of internal iterative routines. Among the most relevant ones stand the coupling of the parareal algorithm with spatial domain decomposition (see[12], [13], [14]), the combination of the parareal algorithm with iterative high order methods in time like spectral deferred corrections (see [15], [16], [17]). Parareal has also been combined with multigrid iterative techniques which, in addition, involve a hierarchy of space–time meshes (see [18], [19]). In a similar spirit, we can also cite applications of the parareal algorithm to solve optimal control problems where information from previous steps is used (see [12], [20]). In Appendix, we briefly explain in what sense the above strategies can be seen as particular instances of the current approach and how our viewpoint could help to give them more solid theoretical foundations. The idea of re-using information as a starting guess for internal iterative solvers is also discussed in the Appendix. It has been explored in several different works, e.g. [17], [18], and [21] provides a convergence analysis in simple situations (a more complete analysis will be proposed in a forthcoming work).

2. An adaptive parareal algorithm

In this section, after introducing some preliminary notations in Section 2.1, we formulate an ideal parareal scheme on an infinite dimensional functional setting (Section 2.2). We then present feasible realizations involving a fine solver whose accuracy is adaptively increased across the iterations (Section 2.3). We prove that the feasible adaptive algorithm converges at the same rate as the ideal one provided that the tolerances of the fine solver are increased at certain rate which will be discussed. Finally, we discuss how the new paradigm can be realized thanks to adaptive schemes and/or the re-use of information from previous steps (Section 2.4 and Appendix). In Section 2.5, we connect the new adaptive formulation with the classical parareal algorithm and list the main advantages of the new standpoint.

2.1. Setting and preliminary notations

Let $\mathbb{U}$ be a Banach space of functions defined over a domain $\Omega \subset {\mathbb{R}}^d$ ($d\ge 1$), e.g. $\mathbb{U}=L^2\left(\Omega \right)$. Let

$$\mathcal{E}:[0,T]\times [0,T]\times \mathbb{U}\to \mathbb{U}$$

be a propagator, that is, an operator such that, for any given time $t\in [0,T]$, $s\in [0,T-t]$ and any function $w\in \mathbb{U}$, $\mathcal{E}(t,s,w)$ takes $w$ as an initial value at time $t$ and propagates it at time $t+s$. We assume that $\mathcal{E}$ satisfies the semi group property

$$\mathcal{E}(r,t-r,w)=\mathcal{E}(s,t-s,\mathcal{E}(r,s-r,w)),\forall w\in \mathbb{U},\forall (r,s,t)\in {[0,T]}^3,r<s<t.$$

We further assume that $\mathcal{E}$ is implicitly defined through the solution $u\in {\mathcal{C}}^1([0,T],\mathbb{U})$ of the time-dependent problem

$$u^{\prime }\left(t\right)+\mathcal{A}\left(t,u\left(t\right)\right)=0,t\in [0,T],$$ (1)

where $\mathcal{A}$ is an operator from $[0,T]\times \mathbb{U}$ into $\mathbb{U}$ with adequate regularity we shall detail latter. Then, given any $w\in \mathbb{U}$, $\mathcal{E}(t,s,w)$ denotes the solution to (1) at time $t+s$ with initial condition $w$ at time $t\ge 0$. In our problem of interest, we study the evolution given by (1) when the initial condition is $u\left(0\right)\in \mathbb{U}$. Note that $\mathcal{E}$ could also be associated to a discretized version of the evolution equation or be defined through an operator that is not necessary related to an evolution equation (see [22]).

Since, in general, the problem does not have an explicit solution, we seek to approximate it at a given target accuracy. For any initial value $w\in \mathbb{U}$, any $t\in [0,T[$, $s\in [0,T-t]$ and any $\zeta >0$ we denote by $[\mathcal{E}(t,s,w);\zeta ]$ an element of $\mathbb{U}$ that approximates $\mathcal{E}(t,s,w)$ such that we have

$$\Vert \mathcal{E}(t,s,w)-[\mathcal{E}(t,s,w);\zeta ]\Vert \le \zeta s(1+\Vert w\Vert ),$$ (2)

where, here and in the following, $\Vert \cdot \Vert$ denotes the norm in $\mathbb{U}$. Any realization of $[\mathcal{E}(t,s,w);\zeta ]$ involves three main ingredients:

• (i)a numerical scheme to discretize the time dependent problem (1) (e.g. an Euler scheme in time),
• (ii)a certain expected error size associated with the choice of the discretization (e.g. error associated with the time step size of the Euler scheme),
• (iii)a numerical implementation to solve the resulting discrete systems (e.g. conjugate gradient, Newton method, SSOR, …).

In the following, we will use the term solver to denote a particular choice for (i), (ii) and (iii). Given a solver $\mathcal{S}$, we will use the same notation as for the exact propagator $\mathcal{E}$ to express that $\mathcal{S}(t,s,w)$ is an approximation of $\mathcal{E}(t,s,w)$ with a certain accuracy $\zeta$. In other words, we can write $\mathcal{S}(t,s,w)=[\mathcal{E}(t,s,w);\zeta ]$.

2.2. An idealized version of the parareal algorithm

We introduce a decomposition of the time interval $[0,T]$ into $\underset{\_}{N}$ subintervals $[T_N,T_{N+1}]$, $N=0,\dots ,\underset{\_}{N}-1$. Without loss of generality, we will take them of uniform size $\Delta T=T∕\underset{\_}{N}$ which means that $T_N=N\Delta T$ for $N=0,\dots ,\underset{\_}{N}$. For a given target accuracy $\eta >0$, the primary goal of the parareal in time algorithm is to build an approximation $\tilde{u}\left(T_N\right)$ of $u\left(T_N\right)$ such that

$$\underset{1\le N\le \underset{\_}{N}}{max}\Vert u\left(T_N\right)-\tilde{u}\left(T_N\right)\Vert \le \eta .$$ (3)

The classical way to achieve this is to set

$$\tilde{u}\left(T_N\right)={\mathcal{S}}_{\text{seq}}(0,T_N,u\left(0\right))=[\mathcal{E}(0,T_N,u\left(0\right));\zeta ],1\le N\le \underset{\_}{N},$$

where ${\mathcal{S}}_{\text{seq}}$ is some sequential solver in $[0,T]$ with $\zeta =\eta ∕\left(T(1+\Vert u\left(0\right)\Vert )\right)$ in (2). Since this comes at the cost of solving over the whole time interval $[0,T]$, the main goal of the parareal in time algorithm is to speed up the computing time, while maintaining the same target accuracy $\eta$. This is made possible by first decomposing the computations over the time domain. Instead of solving over $[0,T]$, we perform $\underset{\_}{N}$ parallel solves over each interval $(T_N,T_{N+1}]$ of size $\Delta T$. We next introduce an idealized version of it which will not be feasible in practice but will be the starting point of subsequent implementable versions. The algorithm relies on the use of a solver $\mathcal{G}$ (known as the coarse solver) with the following properties involving the operator

$$\delta \mathcal{G}≔\mathcal{E}-\mathcal{G}.$$

Hypotheses (H): There exists constants ${\epsilon }_{\mathcal{G}}^{\phantom{\ast }},C_c,C_d>0$ such that for any function $x,y\in \mathbb{U}$ and for any $t\in [0,T[$ and $s\in [0,T-t]$,

$$\mathcal{G}(t,s,x)=[\mathcal{E}(t,s,x),{\epsilon }_{\mathcal{G}}^{\phantom{\ast }}]\iff \Vert \delta \mathcal{G}(t,s,x)\Vert \le s(1+\Vert x\Vert ){\epsilon }_{\mathcal{G}}^{\phantom{\ast }}$$ (4a)

$$\Vert \mathcal{G}(t,s,x)-\mathcal{G}(t,s,y)\Vert \le (1+C_{c}s)\Vert x-y\Vert ,$$ (4b)

$$\Vert \delta \mathcal{G}(t,s,x)-\delta \mathcal{G}(t,s,y)\Vert \le C_{d}s{\epsilon }_{\mathcal{G}}^{\phantom{\ast }}\Vert x-y\Vert$$ (4c)

Note that these hypothesis are the classical abstract formulations of the properties of numerical schemes related to stability and accuracy. Hypothesis (4b) is a Lipschitz condition and the quantity ${\epsilon }_{\mathcal{G}}^{\phantom{\ast }}$ is a small constant which, in the case of a Euler scheme, would be equal to the time step size.

The idealized version of the algorithm consists in building iteratively a series ${\left(y_k^N\right)}_k$ of approximations of $u\left(T_N\right)$ for $0\le N\le \underset{\_}{N}$ following the recursive formula

$$\left\{\begin{array}{c}\begin{array}{ccc}\hfill y_0^{N+1}& =\mathcal{G}(T_N,\Delta T,y_0^N),\hfill & \hfill 0\le N\le \underset{\_}{N}-1\\ \hfill y_{k+1}^{N+1}& =\mathcal{G}(T_N,\Delta T,y_{k+1}^N)+\mathcal{E}(T_N,\Delta T,y_k^N)\hfill \\ \hfill & -\mathcal{G}(T_N,\Delta T,y_k^N),\hfill & \hfill 0\le N\le \underset{\_}{N}-1,k\ge 0,\\ \hfill y_0^0& =u\left(0\right).\hfill \end{array}\hfill \end{array}\right)$$ (5)

At this point, several comments are in order. The first one is that the computation of $y_k^N$ only requires propagations with $\mathcal{E}$ over intervals of size $\Delta T$. As follows from (5), for a given iteration $k$, $\underset{\_}{N}$ propagations of this size are required, each of them over distinct intervals $[T_N,T_{N+1}]$ of size $\Delta T$, each of them with independent initial conditions. Since they are independent from each other, they can be computed over $\underset{\_}{N}$ parallel processors and the original computation over $[0,T]$ is decomposed into parallel computations over $\underset{\_}{N}$ subintervals of size $\Delta T$. The second observation is that the algorithm may not be implementable in practice because it involves the exact propagator $\mathcal{E}$. Feasible instantiations consist of replacing $\mathcal{E}(T_N,\Delta T,y_k^N)$ by some approximation $[\mathcal{E}(T_N,\Delta T,y_k^N),{\zeta }_k^N]$ with a certain accuracy ${\zeta }_k^N$ which has to be carefully chosen. We will come to this point in the next section. The third observation is to note that, in the current version of the algorithm, for all $N=0,\dots ,\underset{\_}{N}$, the exact solution $u\left(T_N\right)$ is obtained after exactly $k=N$ parareal iterations. This number can be reduced when we only look for an approximate solution with accuracy $\eta$. Depending on the problem, the final number of iterations $K\left(\eta \right)$ can actually be much smaller than $\underset{\_}{N}$. The convergence result of Theorem 2.1 and its proof are helpful to understand the main mechanisms driving the convergence of the algorithm and explaining its behavior. To present it, we introduce the shorthand notation for the error norm

$$E_k^N≔\Vert u\left(T_N\right)-y_k^N\Vert ,k\ge 0,0\le N\le \underset{\_}{N},$$

and the quantities

$$\mu =\frac{e^{C_{c}T}}{C_d}\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert u\left(T_N\right)\Vert ),\text{and}\tau ≔C_{d}T{e}^{-C_c\Delta T}{\epsilon }_{\mathcal{G}}.$$

Theorem 2.1

If $\mathcal{G}$ and $\delta \mathcal{G}$ satisfy Hypothesis (4) , then,

$$\underset{0\le N\le \underset{\_}{N}}{max}\Vert u\left(T_N\right)-y_k^N\Vert \le \mu \frac{{\tau }^{k+1}}{(k+1)!},\forall k\ge 0.$$ (6)

Proof

The proof is in the spirit of existing results from the literature (see [5], [23], [24], [25]) but it is instructive to give it for subsequent developments in the paper. We introduce the following quantities

$$\left\{\begin{array}{cc}\alpha \hfill & ≔C_d{\epsilon }_{\mathcal{G}}^{\phantom{\ast }}\Delta T\hfill \\ \beta \hfill & ≔1+C_c\Delta T\hfill \\ \gamma \hfill & ≔\Delta T{\epsilon }_{\mathcal{G}}^{\phantom{\ast }}\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert u\left(T_N\right)\Vert )\hfill \end{array}\right)$$ (7)

as shorthand notations for the proof.

If $k=0$, using definition (5) for $y_0^N$, we have for $0\le N\le \underset{\_}{N}-1$,

$$E_0^{N+1}=\Vert y_0^{N+1}-u\left(T_{N+1}\right)\Vert =\Vert \mathcal{G}(T_N,\Delta T,y_0^N)-\mathcal{E}(T_N,\Delta T,u\left(T_N\right))\Vert \le \Vert \mathcal{G}(T_N,\Delta T,y_0^N)-\mathcal{G}(T_N,\Delta T,u\left(T_N\right))\Vert +\Vert \mathcal{G}(T_N,\Delta T,u\left(T_N\right))-\mathcal{E}(T_N,\Delta T,u\left(T_N\right))\Vert \le (1+C_c\Delta T)E_0^N+\Delta T{\epsilon }_{\mathcal{G}}^{\phantom{\ast }}(1+\Vert u\left(T_N\right)\Vert )\le \beta E_0^N+\gamma ,$$

where we have used (4a), (4b) to derive the second to last inequality.

For $k\ge 1$, starting from (5), we have

$$y_k^{N+1}-u\left(T_{N+1}\right)=\mathcal{G}(T_N,\Delta T,y_k^N)+\mathcal{E}(T_N,\Delta T,y_{k-1}^N)-\mathcal{G}(T_N,\Delta T,y_{k-1}^N)-\mathcal{E}(T_N,\Delta T,u\left(T_N\right))=\mathcal{G}(T_N,\Delta T,y_k^N)-\mathcal{G}(T_N,\Delta T,u\left(T_N\right))+\delta \mathcal{G}(T_N,\Delta T,y_{k-1}^N)-\delta \mathcal{G}(T_N,\Delta T,u\left(T_N\right)).$$

Taking norms and using (4b), (4c), we derive

$$E_k^{N+1}\le \beta E_k^N+\alpha E_{k-1}^N,$$

Following [25], we consider the sequence ${\left(e_k^N\right)}_{N,k\ge 0}$ defined recursively as follows. For $k=0$,

$$e_0^N=\left\{\begin{array}{cc}0,\hfill & \text{if }N=0\hfill \\ \beta e_0^{N-1}+\gamma ,\hfill & \text{if }N\ge 1\hfill \end{array}\right)$$ (8)

and for $k\ge 1$,

$$e_k^N=\left\{\begin{array}{cc}0,\hfill & \text{if }N=0\hfill \\ \alpha e_{k-1}^{N-1}+\beta e_k^{N-1},\hfill & \text{if }N\ge 1.\hfill \end{array}\right)$$ (9)

Since $E_k^N\le e_k^N$ for $k\ge 0$ and $N=0,\dots ,\underset{\_}{N}$, we analyze the behavior of $\left(e_k^N\right)$ to derive a bound for $E_k^N$. For this, we consider the generating function

$${\rho }_k\left(\xi \right)=\sum _{N\ge 0}{e}_k^N{\xi }^N.$$

From (8), (9) we get

$$\left\{\begin{array}{c}{\rho }_k\left(\xi \right)=\alpha \xi {\rho }_{k-1}\left(\xi \right)+\beta \xi {\rho }_k\left(\xi \right),k\ge 1\hfill \\ {\rho }_0\left(\xi \right)=\gamma \frac{\xi }{1-\xi }+\beta \xi {\rho }_0\left(\xi \right),\hfill \end{array}\right)$$

from which we derive

$${\rho }_k\left(\xi \right)=\gamma {\alpha }^k\frac{{\xi }^{k+1}}{(1-\xi )}\frac{1}{{(1-\beta \xi )}^{k+1}},k\ge 0.$$

Since, $\beta \ge 1$, we can bound the term $(1-\xi )$ in the denominator by $(1-\beta \xi )$. Next, using the binomial expansion

$$\frac{1}{{(1-\beta \xi )}^{k+2}}=\sum _{j\ge 0}\left(\genfrac{}{}{0ex}{}{k+1+j}{j}\right){\beta }^j{\xi }^j$$ (10)

and identifying the term in ${\xi }^N$ in the expansion, we derive the bound

$$e_k^N\le \gamma {\alpha }^k{\beta }^{N-k-1}\left(\genfrac{}{}{0ex}{}{N}{k+1}\right).$$

Hence, using definition (7) for $\alpha ,\beta$ and $\gamma$,

$$E_k^N\le e_k^N\le \frac{{(1+C_c\Delta T)}^{N-k-1}\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert u\left(T_N\right)\Vert )}{C_d(k+1)!}{\left[C_d{\epsilon }_{\mathcal{G}}{e}^{-C_c\Delta T}{T}_N\right]}^{k+1},$$

which ends the proof of the theorem. □

Note that at least one step is not sharp in the above proof: it is the step where $1-\xi$ is replaced by $1-\beta \xi$. Note also that $\tau$ is the quantity driving convergence and its speed.

Introducing the quantity

$${\overline{\epsilon }}_{\mathcal{G}}≔\frac{e^{C_c\Delta T}}{C_{d}T},$$

we can write

$$\tau =\frac{{\epsilon }_{\mathcal{G}}}{{\overline{\epsilon }}_{\mathcal{G}}}$$

and we note that a sufficient condition to converge is that

$$\tau <1\iff {\epsilon }_{\mathcal{G}}^{\phantom{\ast }}<{\overline{\epsilon }}_{\mathcal{G}}.$$ (11)

In other words, ${\overline{\epsilon }}_{\mathcal{G}}$ is the minimal accuracy that the coarse solver has to satisfy in order to guarantee convergence of the ideal parareal algorithm. In the following, we will work under the assumption that ${\epsilon }_{\mathcal{G}}^{\phantom{\ast }}$ satisfies (11).

As we will see in the next section, ${\overline{\epsilon }}_{\mathcal{G}}$ plays also a critical role in certain convergence properties of the perturbed algorithm so we finish this section by discussing the behavior of ${\overline{\epsilon }}_{\mathcal{G}}$ depending on several scenarios. First, $C_c$ and $C_d$ are Lipschitz constants (fixed by the properties of the evolution problem) so they could be potentially large numbers. As a result, ${\overline{\epsilon }}_{\mathcal{G}}$ could be a large number and condition (11) would not be very stringent. The value of ${\overline{\epsilon }}_{\mathcal{G}}$ can be small for very long time simulations where $T$ becomes large or if $\Delta T$ becomes small compared to $C_c$ (that is, if the number $\underset{\_}{N}$ of processors becomes large).

2.3. Feasible realizations of the parareal algorithm

Feasible versions of algorithm (5) involve approximations of $\mathcal{E}(T_N,\Delta T,y_k^N)$ with a certain accuracy ${\zeta }_k^N$. This leads to consider algorithms of the form

$$\left\{\begin{array}{c}\begin{array}{ccc}\hfill y_0^{N+1}& =\mathcal{G}(T_N,\Delta T,y_0^N),\hfill & \hfill 0\le N\le \underset{\_}{N}-1\\ \hfill y_{k+1}^{N+1}& =\mathcal{G}(T_N,\Delta T,y_{k+1}^N)+[\mathcal{E}(T_N,\Delta T,y_k^N);{\zeta }_k^N]\hfill \\ \hfill & -\mathcal{G}(T_N,\Delta T,y_k^N),\hfill & \hfill 0\le N\le \underset{\_}{N}-1,k\ge 0,\\ \hfill y_0^0& =u\left(0\right).\hfill \end{array}\hfill \end{array}\right)$$ (12)

Since no feasible version will converge at a better rate than (6), we analyze here what is the minimal accuracy ${\zeta }_k^N$ that preserves it. A result in this direction is given in the following theorem. It requires to introduce the quantity

$${\nu }_p≔\frac{\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert y_p^N\Vert )}{\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert u\left(T_N\right)\Vert )},\forall p\ge 0.$$

which tends to $1$ as $p\to \infty$.

Theorem 2.2

Let $\mathcal{G}$ and $\delta \mathcal{G}$ satisfy Hypothesis (4) . Let $k\ge 0$ be any given positive integer. If for all $0\le p<k$ and all $0\le N<\underset{\_}{N}$ , the approximation $\left[\mathcal{E}(T_N,\Delta T,{\zeta }_p^N)\right]$ has accuracy

$${\zeta }_p^N\le {\zeta }_p≔\frac{{\epsilon }_{\mathcal{G}}^{p+2}}{(p+1)!{\nu }_p},$$ (13)

then the ${\left(y_k^N\right)}_N$ of the feasible parareal scheme (12) satisfy

$$\underset{0\le N\le \underset{\_}{N}}{max}\Vert u\left(T_N\right)-y_k^N\Vert \le \mu \frac{{\tilde{\tau }}^{k+1}}{(k+1)!},$$ (14)

with

$$\tilde{\tau }≔\tau +{\epsilon }_{\mathcal{G}}.$$

Let us make a couple of remarks before giving the proof of the theorem. First, the sufficient condition to converge is now

$$\tilde{\tau }<1\iff {\epsilon }_{\mathcal{G}}^{\phantom{\ast }}<\frac{{\overline{\epsilon }}_{\mathcal{G}}}{1+{\overline{\epsilon }}_{\mathcal{G}}}$$ (15)

so the minimal accuracy required for the coarse solver is stronger than in (11) for the ideal case. Note however that when ${\overline{\epsilon }}_{\mathcal{G}}$ is small (roughly, ${\overline{\epsilon }}_{\mathcal{G}}\le 1$), the condition on ${\epsilon }_{\mathcal{G}}^{\phantom{\ast }}$ is similar in the ideal and perturbed case.

Second, comparing (6), (14), the rate of convergence $\tilde{\tau }$ of the feasible parareal algorithm deviates from $\tau$, the ideal one, by a factor

$$\frac{\tilde{\tau }}{\tau }=\frac{\tau +{\epsilon }_{\mathcal{G}}}{\tau }=1+\frac{e^{C_c\Delta T}}{C_{d}T}=1+{\overline{\epsilon }}_{\mathcal{G}}.$$

The parameter ${\overline{\epsilon }}_{\mathcal{G}}$ plays again a critical role in the convergence properties and determines whether convergence is close to the ideal rate $\tau$, or deviates from it by a potentially important factor.

Proof

The proof follows the same lines as the one for Theorem 2.1 and $E_k^N$, $\alpha ,\beta ,\gamma$ are defined exactly as before. In addition, it will be useful to introduce the sequence

$$\left\{\begin{array}{cc}{g}_k\hfill & ={\zeta }_k\Delta T\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert y_k^N\Vert ),\forall k\ge 0\hfill \\ g_{-1}\hfill & =\gamma \hfill \end{array}\right)$$

We concentrate on the case $k\ge 1$ since the case $k=0$ is identical as in Theorem 2.1. For $k\ge 1$, using (12), we have

$$y_k^{N+1}-u\left(T_{N+1}\right)=\mathcal{G}(T_N,\Delta T,y_k^N)-\mathcal{G}(T_N,\Delta T,u\left(T_N\right))-\mathcal{G}(T_N,\Delta T,y_{k-1}^N)+\mathcal{G}(T_N,\Delta T,u\left(T_N\right))+[\mathcal{E}(T_N,\Delta T,y_{k-1}^N);{\zeta }_{k-1}^N]-\mathcal{E}(T_N,\Delta T,u\left(T_N\right))=\mathcal{G}(T_N,\Delta T,y_k^N)-\mathcal{G}(T_N,\Delta T,u\left(T_N\right))+\delta \mathcal{G}(T_N,\Delta T,y_{k-1}^N)-\delta \mathcal{G}(T_N,\Delta T,u\left(T_N\right))+[\mathcal{E}(T_N,\Delta T,y_{k-1}^N);{\zeta }_{k-1}^N]-\mathcal{E}(T_N,\Delta T,y_{k-1}^N).$$

Taking norms, using (4b), (4c) and the definition (2) applied to $[\mathcal{E}(T_N,\Delta T,y_{k-1}^N);{\zeta }_{k-1}^N]$, we derive

$$E_k^{N+1}\le [1+C_c\Delta T]E_k^N+C_d\Delta T{\epsilon }_{\mathcal{G}}^{\phantom{\ast }}{E}_{k-1}^N+{\zeta }_{k-1}^N\Delta T\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert y_{k-1}^N\Vert )\le \beta E_k^N+\alpha E_{k-1}^N+g_{k-1}.$$

Similarly to Theorem 2.1, we introduce the sequence ${\left({\tilde{e}}_k^N\right)}_{N,k\ge 0}$ defined for $k=0$ as ${\tilde{e}}_0^N=e_0^N$ for all $N\ge 0$ and for $k\ge 1$,

$${\tilde{e}}_k^N=\left\{\begin{array}{cc}0,\hfill & \text{if }N=0\hfill \\ \alpha {\tilde{e}}_{k-1}^{N-1}+\beta {\tilde{e}}_k^{N-1}+g_{k-1},\hfill & \text{if }N\ge 1\hfill \end{array}\right)$$

The associated generating function ${\tilde{\rho }}_k$ satisfies

$$\left\{\begin{array}{cc}{\tilde{\rho }}_k\left(\xi \right)\hfill & =\alpha \xi {\tilde{\rho }}_{k-1}\left(\xi \right)+\beta \xi {\tilde{\rho }}_k\left(\xi \right)+g_{k-1}\frac{\xi }{1-\xi },\forall k\ge 1,\hfill \\ {\tilde{\rho }}_0\left(\xi \right)\hfill & ={\rho }_0\left(\xi \right)=\frac{\gamma \xi }{(1-\xi )(1-\beta \xi )}.\hfill \end{array}\right)$$

Hence

$${\tilde{\rho }}_k\left(\xi \right)=\left(\frac{\alpha \xi }{1-\beta \xi }\right){\tilde{\rho }}_{k-1}\left(\xi \right)+\frac{\xi }{(1-\xi )(1-\beta \xi )}{g}_{k-1}={\left(\frac{\alpha \xi }{1-\beta \xi }\right)}^k{\tilde{\rho }}_0\left(\xi \right)+\frac{\xi }{(1-\xi )(1-\beta \xi )}\sum _{\ell =0}^{k-1}{\left(\frac{\alpha \xi }{1-\beta \xi }\right)}^{\ell }{g}_{k-1-\ell }$$

By replacing again at the denominator the factor $(1-\xi )$ by $(1-\beta \xi )$ and using the binomial expansion (10), we derive the bound

$${\tilde{\rho }}_k\left(\xi \right)\le \gamma {\alpha }^k{\xi }^{k+1}\sum _{j\ge 0}\left(\genfrac{}{}{0ex}{}{k+1+j}{j}\right){\beta }^j{\xi }^j+\sum _{\ell =0}^{k-1}{\alpha }^{\ell }{\xi }^{\ell +1}{g}_{k-1-\ell }\sum _{j\ge 0}\left(\genfrac{}{}{0ex}{}{\ell +1+j}{j}\right){\beta }^j{\xi }^j,=\sum _{j\ge 0}\sum _{\ell =0}^k{\alpha }^{\ell }{g}_{k-1-\ell }{\beta }^j\left(\genfrac{}{}{0ex}{}{\ell +1+j}{j}\right){\xi }^{\ell +1+j}$$

where we have used that $g_{-1}=\gamma$. The coefficient associated to the term ${\xi }^N$ above gives the inequality

$${\tilde{e}}_k^N\le \sum _{\ell =0}^k{\alpha }^{\ell }{g}_{k-1-\ell }{\beta }^{N-\ell -1}\left(\genfrac{}{}{0ex}{}{N}{\ell +1}\right),\forall k\ge 1,$$

From the definition of ${\zeta }_{\ell }$, we have that

$$g_{\ell }\le \frac{\Delta T{\epsilon }_{\mathcal{G}}^{\ell +2}}{(\ell +1)!}\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert u\left(T_N\right)\Vert ).$$

Therefore, recalling the definition (7) of $\alpha ,\beta$ and $\gamma$, we derive

$${\tilde{e}}_k^N\le \frac{{\epsilon }_{\mathcal{G}}^{k+1}\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert u\left(T_N\right)\Vert )}{C_d}\sum _{\ell =0}^k{\left(C_d\Delta T\right)}^{\ell +1}\frac{{(1+C_c\Delta T)}^{N-\ell -1}}{(k-\ell )!}\left(\genfrac{}{}{0ex}{}{N}{\ell +1}\right)\le \frac{{\epsilon }_{\mathcal{G}}^{k+1}\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert u\left(T_N\right)\Vert )}{C_d}\sum _{\ell =0}^k{\left(C_{d}T{e}^{-C_C\Delta T}\right)}^{\ell +1}\frac{e^{C_{C}T}}{(\ell +1)!(k-1-\ell )!}\le \frac{\underset{0\le N\le \underset{\_}{N}}{max}(1+\Vert u\left(T_N\right)\Vert )e^{C_{c}T}}{C_d(k+1)!}{\left((1+C_{d}T{e}^{-C_c\Delta T}){\epsilon }_{\mathcal{G}}\right)}^{k+1}=\mu \frac{{\tilde{\tau }}^{k+1}}{(k+1)!},$$

where we have used the definition of $\mu$ and $\tilde{\tau }$ in the last line. This inequality ends the proof since $E_k^N\le {\tilde{e}}_k^N$ for $N=0,\dots ,\underset{\_}{N}$. □

2.4. Practical realization of $[\mathcal{E}(T_N,\Delta T,y_k^N),{\zeta }_k^N]$

Since the accuracy ${\zeta }_k^N$ needs to improve with $k$, the most natural way to build the approximations $[\mathcal{E}(T_N,\Delta T,y_k^N),{\zeta }_k^N]$ is with adaptive techniques and with adaptive refinements at every step $k$. The implementation ultimately rests on the use of a posteriori error estimators. It opens the door to local time step adaptation in the parareal algorithm as well as spatial coarsening or refinement if the problem involves additional spatial variables.

In principle, as ${\zeta }_k^N$ decreases with $k$, the numerical cost increases in terms of degrees of freedom and also in terms of computing time. This actually reveals the key idea of this new approach which is that we would like that only the last fine solver is expensive and the cost of the previous ones is a small fraction of the cost of the last one (we refer to the next sub-section for a more precise statement). By re-using information from previous iterations, we can limit the cost of internal solvers required in $[\mathcal{E}(T_N,\Delta T,y_k^N),{\zeta }_k^N]$ and enhance the speed-up. This depends of course on the nature of the specific problem. We discuss several common situations in Appendix.

2.5. Connection to the classical formulation of the parareal algorithm and advantages of the current view-point

In the original version of the algorithm, $\mathcal{E}(T_N,\Delta T,y_k^N)$ is approximated with an accuracy ${\zeta }_k^N={\zeta }_{\mathcal{F}}$ which is kept constant in $N$ and across the parareal iterations $k$. This has usually been done by using a solver $\mathcal{F}$ defined in the same spirit as $\mathcal{G}$, but satisfying Hypothesis (4) with a better accuracy ${\epsilon }_{\mathcal{F}}<{\epsilon }_{\mathcal{G}}^{\phantom{\ast }}$. We have in this case

$$[\mathcal{E}(T_N,\Delta T,y_k^N);{\zeta }_{\mathcal{F}}]=\mathcal{F}(T_N,\Delta T,y_k^N)$$

and we recover the classical algorithm (see [26] and [27])

$$\left\{\begin{array}{c}\begin{array}{ccc}\hfill y_0^{N+1}& =\mathcal{G}(T_N,\Delta T,y_0^N),\hfill & \hfill 0\le N\le \underset{\_}{N}-1\\ \hfill y_{k+1}^{N+1}& =\mathcal{G}(T_N,\Delta T,y_{k+1}^N)\hfill \\ \hfill & +\mathcal{F}(T_N,\Delta T,y_k^N)-\mathcal{G}(T_N,\Delta T,y_k^N),\hfill & \hfill 0\le N\le \underset{\_}{N}-1,k\ge 0,\\ \hfill y_0^0& =u\left(0\right).\hfill \end{array}\hfill \end{array}\right)$$

Compared to this classical version of the parareal algorithm, the adaptive approach offers the following important advantages:

• 1.The algorithm converges to the exact solution $u\left(T_N\right)$ and not to the solution achieved by the fixed chosen fine solver $\mathcal{F}(0,T_N,u\left(0\right))$ (indeed, for any $N$, ${\zeta }_k^N⟶0$ as $k⟶\infty$).
• 2.For a final target accuracy $\eta$, the parallel efficiency will always be superior to the classical approach (see Section 3).
• 3.We minimize the computational resources (degrees of freedom) because we identify the minimal required accuracies at each iteration (see Eq. (13)). Early iterations use a loose tolerance, thus avoiding unnecessary work due to oversolving, while later iterations use tighter tolerances to deliver accuracy.
• 4.The dynamical refinements of the fine solver invite to incorporate adaptive solvers with a posteriori error estimators to the parareal scheme.

3. Parallel efficiency

It is difficult to give accurate a priori estimations for the speed-up and efficiency of the method due to its adaptive nature so the actual performance can only be established through relevant examples. In Section 4, we give some results for the case of the Brusselator system. Despite this difficulty in estimation, we make some general remarks in this section, which aim primarily at highlighting the relevance of the cost of the coarse solver. The speed-up is defined as the ratio

$${\mathbf{speed\; -\; up}}_{\text{AP}∕\text{seq}}(\eta ,[0,T])≔\frac{{\mathbf{cost}}_{\text{seq}}(\eta ,[0,T])}{{\mathbf{cost}}_{\text{AP}}(\eta ,[0,T])}$$ (16)

between the cost to run a sequential fine solver achieving a target accuracy $\eta$ with the cost to run an adaptive parareal algorithm providing at the end the same target accuracy $\eta$. The parallel efficiency of the method is then defined as the ratio of the above speed up with the number of processor which gives a target of 1 to any parallel solver:

$${\mathbf{eff}}_{\text{AP}∕\text{seq}}(\eta ,[0,T])≔\frac{{\mathbf{speed\; -\; up}}_{\text{AP}∕\text{seq}}(\eta ,[0,T])}{\underset{\_}{N}}.$$

Assume that $g_k^N$ and $f_k^N$ are the numerical costs to realize $\mathcal{G}(T_N,\Delta T,y_k^N)$ and $[\mathcal{E}(T_N,\Delta T,y_k^N),{\zeta }_k^N]$. Since the tolerances ${\zeta }_k^N$ decrease with $k$, we have $f_0^N<\cdots <f_{K\left(\eta \right)}^N$. Neglecting the communication delays, the cost of the adaptive solver is

$${\mathbf{cost}}_{\text{AP}}(\eta ,[0,T])=\sum _{k=0}^{K\left(\eta \right)}\sum _{N=0}^{\underset{\_}{N}-1}{g}_k^N+\sum _{k=0}^{K\left(\eta \right)-1}\sum _{N=0}^{\underset{\_}{N}-1}{f}_k^N.$$

The classical parareal algorithm involves, at every iteration $k\in \{0,\dots ,K\left(\eta \right)\}$ propagations at the highest accuracy ${\zeta }_{K\left(\eta \right)}^N$. Thus its cost is

$${\mathbf{cost}}_{\text{CP}}(\eta ,[0,T])=\sum _{k=0}^{K\left(\eta \right)}\sum _{N=0}^{\underset{\_}{N}-1}{g}_k^N+K\left(\eta \right)\sum _{N=0}^{\underset{\_}{N}-1}{f}_{K\left(\eta \right)}^N,$$

from which it directly follows that (at least if, with obvious notation, $K_{AP}\left(\eta \right)=K_{CP}\left(\eta \right)$)

$${\mathbf{eff}}_{\text{AP}∕\text{seq}}(\eta ,[0,T])>{\mathbf{eff}}_{\text{CP}∕\text{seq}}(\eta ,[0,T]).$$

Thus the parallel performance of the adaptive algorithm is at least the one of the classical version. Note that this holds even when communications are not negligible since there is the same amount of information exchange in both algorithms.

We next give a more quantitative statement on an admittedly idealized setting. Assume that the cost of the coarse solve is negligible, that there is no communication delay and that the cost to realize $[\mathcal{E}(T_N,\Delta T,y_k^N),{\zeta }_k^N]$ is

$$f_k^N=\Delta T{\left({\zeta }_k^N\right)}^{-1∕\alpha }.$$ (17)

This assumption for the cost is, for instance, reasonable when we use an explicit time-stepping method of order $\alpha >0$. It would also hold for an implicit method where a direct solver can be used. Note that $\alpha$ could actually depend on $k$ but we stick to this simple model for clarity of exposition.

Proposition 3.1

If $f_k^N=\Delta T{\left({\zeta }_k^N\right)}^{-1∕\alpha }$ , for some $\alpha >0$ and if the cost of the coarse solver is negligible with respect to $f_k^N$ for any $k\ge 0$ , then

$${\mathbf{eff}}_{\text{AP}∕\text{seq}}(\eta ,[0,T])=\frac{1-{\tau }^{1∕\alpha }}{1-{\tau }^{K\left(\eta \right)∕\alpha }}\sim \frac{1}{(1+{\epsilon }_{\mathcal{G}}^{1∕\alpha })}.$$

Therefore

$${\mathbf{speed\; -\; up}}_{\text{AP}∕\text{seq}}(\eta ,[0,T])\sim \underset{\_}{N}\frac{1}{(1+{\epsilon }_{\mathcal{G}}^{1∕\alpha })}.$$

Proof

The cost of the scalable adaptive parareal scheme after $K\left(\eta \right)$ iterations is

$${\mathbf{cost}}_{\text{AP}}(\eta ,[0,T])=\Delta T\sum _{k=0}^{K\left(\eta \right)-1}{\zeta }_k^{-1∕\alpha }$$ (18)

Since we are in a range where the scheme converges, the quantity ${max}_{0\le N\le \underset{\_}{N}}\Vert y_k^N\Vert$ is bounded and thus there exists $0<\underset{\_}{c}\le 1\le \overline{c}$ such that $\underset{\_}{c}\le {\nu }_k\le \overline{c}$ for all $k\ge 0$. We will account for this with the notation ${\nu }_k\sim 1$. Note that in fact $\underset{\_}{c}$ and $\overline{c}$ are close to one. Let us start with the simple case $\alpha =1$ and denote $\underset{\_}{K}=K\left(\eta \right)-1$:

$${\mathbf{cost}}_{\text{AP}}(\eta ,[0,T])=\Delta T\sum _{k=0}^{\underset{\_}{K}}{\zeta }_k^{-1}=\Delta T{\zeta }_{K\left(\eta \right)-1}^{-1}\left(1+\frac{{\epsilon }_{\mathcal{G}}^{\phantom{\ast }}}{\underset{\_}{K}}+\frac{{\epsilon }_{\mathcal{G}}^2}{\underset{\_}{K}(\underset{\_}{K}-1)}+\cdots +\frac{{\epsilon }_{\mathcal{G}}^{\underset{\_}{K}-1}}{\underset{\_}{K}!}\right)$$

we thus derive

$${\mathbf{cost}}_{\text{AP}}(\eta ,[0,T])\le \Delta T{\zeta }_{K\left(\eta \right)-1}^{-1}(1+{\epsilon }_{\mathcal{G}}^{\phantom{\ast }})$$

In the general case ($\alpha >1$), the same is true with

$${\mathbf{cost}}_{\text{AP}}(\eta ,[0,T])\le \Delta T{\zeta }_{K\left(\eta \right)-1}^{-1∕\alpha }(1+{\epsilon }_{\mathcal{G}}^{1∕\alpha })$$

Up to this last factor, the current conclusion is that the global cost of the parareal procedure is equal to the last fine solver on each sub-interval with size $\Delta T$ (both the coarse and the previous fine propagations are negligible).

Since the accuracy that is obtained at the end of the parareal procedure (see (14)) is of the same order as the accuracy provided with classical parareal solver (compare with (6)), it follows that if we now take the last target accuracy ${\zeta }_{K\left(\eta \right)-1}^{-1∕\alpha }$ of the adaptive algorithm as the accuracy of the fine scheme in the classical parareal algorithm, the cost would be

$${\mathbf{cost}}_{\text{CP}}(\eta ,[0,T])=K\left(\eta \right)\Delta T{\zeta }_{K\left(\eta \right)-1}^{-1∕\alpha },$$

Therefore,

$$\frac{{\mathbf{cost}}_{\text{AP}}(\eta ,[0,T])}{{\mathbf{cost}}_{\text{CP}}(\eta ,[0,T])}\sim \frac{1}{K\left(\eta \right)}(1+{\epsilon }_{\mathcal{G}}^{1∕\alpha }).$$ (19)

In addition, we know that when the cost of the coarse solver is negligible,

$${\mathbf{speed\; -\; up}}_{\text{CP}∕\text{seq}}(\eta ,[0,T])=\frac{{\mathbf{cost}}_{\text{seq}}(\eta ,[0,T])}{{\mathbf{cost}}_{\text{CP}}(\eta ,[0,T])}=\frac{\underset{\_}{N}}{K\left(\eta \right)},$$ (20)

Dividing (20) by (19) yields

$${\mathbf{speed\; -\; up}}_{\text{AP}∕\text{seq}}(\eta ,[0,T])\sim \underset{\_}{N}\frac{1}{(1+{\epsilon }_{\mathcal{G}}^{1∕\alpha })}$$

and

$${\mathbf{eff}}_{\text{AP}∕\text{seq}}(\eta ,[0,T])\sim \frac{1}{(1+{\epsilon }_{\mathcal{G}}^{1∕\alpha })}.\square$$

In the ideal setting of Proposition 3.1:

• •The parallel efficiency of the adaptive parareal algorithm does not depend on the final number of iterations. This is in contrast to the classical version whose efficiency decreases with the final number of iterations $K\left(\eta \right)$ as $1∕K\left(\eta \right)$.
• •The efficiency behaves like $1-o\left({\epsilon }_{\mathcal{G}}^{\phantom{\ast }}\right)$ in the adaptive version, and $o\left({\epsilon }_{\mathcal{G}}^{\phantom{\ast }}\right)$ rapidly goes to zero with ${\epsilon }_{\mathcal{G}}^{\phantom{\ast }}$. As soon as ${\epsilon }_{\mathcal{G}}^{\phantom{\ast }}$ becomes negligible with respect to 1, we will be in the range of full scalability.

We emphasize that, obviously, the above idealized setting will never hold in practice, but the result is interesting in its own right since it highlights that the cost of the fine solver is no longer the main obstacle for full scalability in the adaptive setting: the cost of the coarse solver becomes now the major obstruction towards full efficiency.

4. Numerical tests

4.1. Guidelines for a practical implementation

Practical choice of ${\zeta }_k^N$.

Formula (13) of the convergence analysis of Section 2.3 gives an estimate for ${\zeta }_k^N$ that one could in principle use for the implementation. However, these tolerances may not be optimal because they are derived from a theoretical convergence analysis based on abstract conditions for the coarse and fine solvers. This was confirmed during our numerical tests where we observed that using estimates (13) for ${\zeta }_k^N$ did not deliver satisfactory enough results. This is the reason why it is necessary to devise a practical rule to set ${\zeta }_k^N$. We have explored the following choice: if $\eta$ is the final target accuracy, the classical parareal algorithm is usually run with a solver that delivers a slightly higher accuracy, say $\eta ∕2$. Assume that the classical algorithm converges in $K_{\text{CP}}\left(\eta \right)=K$ iterations. We propose to build the tolerances of ${\zeta }_k^N$ in such a way to target that $K_{\text{AP}}\left(\eta \right)=K_{\text{CP}}\left(\eta \right)$ and such that the cost of the last fine propagation is of the order of the sum of the previous ones. This motivates to set

$${\zeta }_k^N=\left\{\begin{array}{cc}{\epsilon }_{\mathcal{G}}^{1-\frac{k+1}{K}}{\left(\frac{\eta }{2}\right)}^{\frac{k+1}{K}},\hfill & \text{if }k<K\hfill \\ \eta ∕2,\hfill & \text{if }k\ge K.\hfill \end{array}\right)$$

The numerical example of the next section uses these tolerances.

Load balancing.

For simplicity of exposition, the algorithm has so far been discussed for $\underset{\_}{N}$ subintervals of uniform size $\Delta T$. However, this decomposition may lead to a task imbalance because some time intervals may have more complex dynamics than others, requiring more degrees of freedom, thus more computational time. In order to balance tasks as efficiently as possible, we dynamically adapt the size of the $\underset{\_}{N}$ subintervals in a way to have the fine solver propagations as balanced as possible among processors.

4.2. Results for several stiff ODEs

We apply our adaptive algorithm to several stiff ODEs where the only mechanism for adaptivity is time. Our results illustrate that our approach improves the speed-up and efficiency with respect to the classical non-adaptive parareal method. We also show that the main element affecting performance is no longer the cost of the fine solver but the cost of the coarse solver. In extreme cases, this cost may even prevent any speed-up at all (see Section 4.2.3) and puts this obstruction at the forefront for future research. The code to reproduce the numerical results is available online at:

https://plmlab.math.cnrs.fr/mulahernandez/parareal-adaptive

Other ODEs can easily be tested as indicated in the instructions.

Note that the algorithm could also be applied to PDEs but we defer the presentation of numerical examples to future works since this requires full space–time adaptive techniques which are a topic in itself since they are challenging to formulate and deploy and very specific to each type of problem.

4.2.1. The brusselator system

We consider the brusselator system

$$\left\{\begin{array}{c}{x}^{\prime }=A+x^{2}y-(B+1)x\hfill \\ y^{\prime }=Bx-x^{2}y,\hfill \end{array}\right)$$

with initial condition $x\left(0\right)=0$ and $y\left(0\right)=1$. This is a stiff ODE that models a chain of chemical reactions. It was already studied in a previous work on the parareal algorithm (see [25]). The system has a fixed point at $x=A$ and $y=B∕A$ which becomes unstable when $B>1+A^2$ and leads to oscillations. We place ourselves in this oscillatory regime by setting $A=1$ and $B=3$. The dynamics present large velocity variations in some time subintervals, making the use of adaptive time-stepping schemes particularly desirable for an appropriate treatment of the transient.

For the coarse solver, we set

$${\epsilon }_{\mathcal{G}}=0.1,$$

and use an explicit Runge–Kutta method of order 5 with an adaptive time-stepping (see [28]). For the fine solver, we use the implicit Runge–Kutta method of the Radau IIA family of order 5 with adaptive time-stepping (see [29], [30]). Both integrators are available in the ODE integration library of Scipy2 which we have used in our library.

As already discussed, the target accuracies ${\zeta }_k^N$ should be ensured by rigorous a posteriori error estimators. However, these type of estimators are unfortunately not available in the Scipy library and we are not aware of any mainstream library with this capability. As a surrogate, we have used the above mentioned classical ODE integrators that only guarantee local accuracy between time-steps $t_n\to t_{n+1}$, but not global accuracy between macro intervals $[T_N,T_{N+1}]$ (composed of several time-steps). The local accuracy can be specified in the library routine via the parameters atol and rtol of the function scipy.integrate.solve_ivp. To relate this local accuracy control to the global one, we have built a priori a “chart” mapping accuracies of the solver on macro-intervals against the tolerance parameters atol and rtol of the library. To simplify, these two parameters have been set to be equal ($atol=rtol$) and their value is fixed according to the chart. As an example, we provide a chart for $T=20$ for the scheme of the fine solver in Fig. 1. The dots are computed values: for a given value of the parameter $atol$, we examine the accuracy $\epsilon$ of the solver. We then interpolate the points with a cubic spline interpolation. This way, for a given intermediate accuracy ${\zeta }_k^N$ in the parareal algorithm, we can easily adapt the parameter value $atol$ that is required.

Fig. 1.

Mapping of the accuracies $\epsilon$ against the tolerance parameters ($atol=rtol$) of the library. The dots are computed values: for a given value of the parameter, we examine the accuracy $\epsilon$ of the solver. We then interpolate the points with a cubic spline interpolation. This way, for a given intermediate accuracy ${\zeta }_k^N$ in the algorithm, we can infer the parameter value $atol$ and $rtol$. Case $T=20$, integrator of the fine solver.

We use formula (16) to compare the speed-up of the classical and adaptive parareal algorithm in terms of the number of operations involved in the numerical solution (communication delays have not been taken into account). For the costs $g_k^N$ and $f_k^N$, we take into account:

• •the number of time steps (which is adaptively increased as we tightened the accuracy),
• •the number of right-hand side evaluations,
• •for the fine solver, we additionally count the number of evaluations of the Jacobian matrix and of the number of linear system inversions.

In Fig. 2, we plot the obtained speed-up for different configurations:

Fig. 2.

Speed-up in comparison to running a sequential fine solver as a function of the number of processors $\underset{\_}{N}$. Dashed lines: classical parareal. Continuous lines: Adaptive parareal.

• •the final time $T$ varies from $100$ to $900$,
• •the final target accuracy is $\eta =10^{-6}$ or $\eta =10^{-8}$,
• •the number of processors $\underset{\_}{N}$ varies from 10 to 100.

As anticipated in Section 3, the speed-up of the adaptive parareal is always superior to the one of the classical parareal. We observe that the gain is marginal for a moderate accuracy ($\eta =10^{-6}$) but it is about 2.5 times larger for $\eta =10^{-8}$. Note that sometimes the speed-up does not increase monotonically as the number of processors $\underset{\_}{N}$ increases. Also, the speed-up generally increases with $\underset{\_}{N}$ but the increase is rather moderate.

The values significantly differ from the range of full scalability and we next explain why this is mainly due to the cost of the coarse solver. Since the problem is stiff and we consider relatively long time intervals, it has been necessary to use a sufficiently accurate coarse solver. This explains our choice of an explicit Runge–Kutta scheme of order 5. To illustrate the impact of its cost, let us fix $T=500$, $\eta =10^{-8}$ and $\underset{\_}{N}=50$ (other parameters would yield similar conclusions). We compare the speed-up and efficiency when we count or do not count the cost of the coarse solver in Table 1. Obviously, when we do not count the cost of the coarse solver, the performance of both algorithms improves but it is particularly increased in the case of the adaptive version. If the cost of $\mathcal{G}$ was negligible, it would deliver a very satisfactory efficiency of $75.52\text{\%}$. This is five times larger than what the classical parareal would yield. This analysis illustrates that the major obstacle to achieve competitive scalabilities is no longer the cost of the fine solver like in the classical version, but the cost of the coarse propagator.

Table 1.

Brusselator: Impact of the cost of the coarse solver. Speed-up and efficiency with $T=500$, $\eta =10^{-8}$ and $\underset{\_}{N}=50$.

Speed-up	Classical parareal	Adaptive parareal
With cost $\mathcal{G}$	4.06	7.38
Without cost $\mathcal{G}$	7.38	37.76
Efficiency	Classical parareal	Adaptive parareal
With cost $\mathcal{G}$	8%	14.76%
Without cost $\mathcal{G}$	14.76%	75.52%

We next give some insight on the differences in the convergence behavior of both algorithms. We fix $T=20$, $\eta =10^{-8}$ and $\underset{\_}{N}=20$ and plot in Fig. 3 the convergence history of the parareal solution in terms of:

Fig. 3.

Brusselator: Convergence history of the errors for $T=20$, $\eta =10^{-8}$ and $\underset{\_}{N}=20$. Top: classical parareal. Bottom: adaptive parareal. Left: errors of the fine solver at every fine time-step. Right: maximum parareal error at each iteration $k$.

• •the errors of the fine solver at every fine time-step
• •
  the maximum error of the parareal solution at the macro-intervals

  $$\underset{N}{max}\Vert u\left(T_N\right)-y_k^N\Vert$$

Note that the maximum error in the adaptive scheme steadily decreases to the desired accuracy whereas the error in the classical scheme degrades at iteration $k=1$ before converging. This type of behavior has been observed for all other configurations and we conjecture that an important difference in accuracy between the coarse and the fine solver at early stages of the algorithm may be the cause. Finally, an inspection of the error of the fine solver shows that the adaptive algorithm succeeds to reduce the error at every time $t$ in a much more uniform way than the classical algorithm.

4.2.2. The Van der Pol oscillator

We next consider the Van der Pol oscillator

$$\left\{\begin{array}{c}{x}^{\prime }=y\hfill \\ y^{\prime }=\mu (1-x^2)y-x,\hfill \end{array}\right)$$

with initial condition $x\left(0\right)=2$ and $y\left(0\right)=0$. When $\mu =0$, this equation is a simple nonstiff harmonic oscillator. When $\mu >0$, the system has a limit cycle and becomes stiffer and stiffer as its value is increased. For our tests, we set $\mu =4$ which is already a relatively stiff case.

Like in the example of the Brusselator system, we set ${\epsilon }_{\mathcal{G}}=0.1$ for the coarse solver and use an explicit Runge–Kutta method of order 5 with an adaptive time-stepping (see [28]). For the fine solver, we use the implicit Runge–Kutta method of the Radau IIA family of order 5 with adaptive time-stepping.

In Fig. 4, we plot the obtained speed-up for different configurations:

Fig. 4.

Van der Pol: speed-up in comparison to running a sequential fine solver as a function of the number of processors $\underset{\_}{N}$. Dashed lines: classical parareal. Continuous lines: Adaptive parareal.

• •the final time $T$ is $1000$ or $2000$,
• •the final target accuracy is $\eta =10^{-6}$ or $\eta =10^{-8}$,
• •the number of processors $\underset{\_}{N}$ varies from 10 to 100.

Like in the previous example, the adaptive algorithm outperforms the nonadaptive version in terms of speed-up. However, the gain is marginal for moderate accuracies $\eta =10^{-6}$. For high accuracy $\eta =10^{-8}$, the adaptive algorithm improves the speed-up by a factor of about 2 to 3 times with respect to the classical one. The improvement is more significant for large $T$.

In Table 2, we illustrate that the coarse solver is again the main bottleneck to reach high parallel efficiency in the adaptive algorithm: we examine the speed-up and efficiency for $T=2000$, $\eta =10^{-8}$ and $\underset{\_}{N}=40$ when we take and do not take into account the cost of the coarse solver.

Table 2.

Van der Pol: Impact of the cost of the coarse solver. Speed-up and efficiency with $T=2000$, $\eta =10^{-8}$ and $\underset{\_}{N}=40$.

Speed-up	Classical parareal	Adaptive parareal
With cost $\mathcal{G}$	4.54	11.14
Without cost $\mathcal{G}$	6.61	32.63
Efficiency	Classical parareal	Adaptive parareal
With cost $\mathcal{G}$	11.35%	27.8%
Without cost $\mathcal{G}$	16.5%	81.56%

4.2.3. Discussion on extremely challenging cases of highly stiff ODEs: Oregonator and SEIR epidemic model

In extreme cases, the cost of the coarse solver may prevent any speed-up at all (see Section 4.2.3) and puts this obstruction at the forefront for future research. A prominent case are highly stiff ODEs. In the provided code, we can observe this fact in the case of the Oregonator system of equations. In view of the ongoing pandemic of COVID-19 at the time when this article was written, we have also tested an SEIR epidemic model which has very recently been proposed in [11] as a simple model for the spread of the virus in the Wuhan city area. The model captures the effect of the presence of individual reaction to the risk of infection and governmental action. If we run the parareal algorithm for the latter model, an integrator of type LSODA [31] for both coarse and fine solvers seems well adapted since it alternates between Adams or BDF integration for nonstiff and stiff parts and it has automatic stiffness detection. To reach a target accuracy $\eta =5.10^{-6}$, it has been necessary to set ${\epsilon }_{\mathcal{G}}=5.10^{-2}$, making the cost of the coarse solver too expensive to yield any parallel efficiency. However, if we could find an inexpensive coarse solver, perhaps based on empirical data or on good back-of the envelope calculations, our adaptive parareal algorithm would yield interesting speeds-ups. For example, with $N=10$ processors, we would get a speed-up of 3.79 (versus 1.4) in the nonadaptive version.

5. Conclusions and perspectives

The new adaptive formulation of the parareal algorithm opens the door to improve significantly the parallel efficiency of the method provided that the cost of the coarse solver is moderate. The increasing target tolerances which have to be met at each step allows to use online stopping criteria involving a posteriori estimators. The developed methodology remains theoretical since we have not quantified the impact of communication delays between processors nor potential memory issues (note however that the load balancing is devised with the purpose of equilibrating tasks and memory). In the framework of the ANR project “Ciné-Para (ANR-15-CE23-0019)”, we are working on these issues that are of a different level of theory and involve different collaborators. This will be the topic of another paper. In addition to this, several extensions based on the current findings are subject of ongoing works, in particular, the coupling of the adaptive parareal with adaptive space–time schemes, the coupling of parareal with internal iterative solvers like in the discussion of Appendix A.3 of the Appendix, and also the development of inexpensive coarse solvers.

Appendix. Enriching the input information with previous iterations

Usually, solvers to realize $[\mathcal{E}(T_N,\Delta T,y_k^N),{\zeta }_k^N]$ are built using only ${\mathbb{I}}_k^N=\{T_N,\Delta T,y_k^N\}$ as input information. We account for this idea with the notation

$$\mathcal{S}(T_N,\Delta T,y_k^N)\underset{({\mathbb{I}}_k^N,{\mathbf{cost}}_k^N)}{\overset{}{⟶}}[\mathcal{E}(T_N,\Delta T,y_k^N);{\zeta }_k^N],$$

and the numerical cost, denoted ${\mathbf{cost}}_k^N$, increase as ${\zeta }_k^N$ is tightened. In this section, we discuss how to enhance the gain in efficiency of the adaptive algorithm by discussing ways to increase the accuracy of the solver $[\mathcal{E}(T_N,\Delta T,y_k^N),{\zeta }_k^N]$ across the iterations while maintaining the cost to realize it as independent as possible from ${\zeta }_k^N$, $N$, and $k$. For this, one possibility is to enrich ${\mathbb{I}}_k^N$ with data produced during the previous parareal iterations (although it would of course be at the cost of increasing the storage requirements).

Let ${\mathbb{P}}_k^N$ denote the intermediate information that has been produced at iteration $k$ between $[T_N,T_{N+1}]$ and by ${\mathbb{P}}_k≔{\cup }_{N=0}^{\underset{\_}{N}-1}{\mathbb{P}}_k^N$ all the information produced at step $k$. Using ${\tilde{\mathbb{I}}}_k^N=\{{\mathbb{I}}_k^N,{\mathbb{P}}_k^{N-1},\dots ,{\mathbb{P}}_k^0,{\mathbb{P}}_{k-1},\dots ,{\mathbb{P}}_0\}$, as input information, the idea is to see whether it could be possible to find a solver $\mathcal{S}$ such that

$$\mathcal{S}(T_N,\Delta T,y_k^N)\underset{({\tilde{\mathbb{I}}}_k^N,\mathbf{cost})}{\overset{}{⟶}}[\mathcal{E}(T_N,\Delta T,y_k^N);{\zeta }_k^N]$$ (21)

with a constant and small complexity $\mathbf{cost}$. Note that using the enriched set of information ${\tilde{\mathbb{I}}}_k^N$ means that we want to learn from the previous approximations of $u\left(T_{N+1}\right)$ given by $[\mathcal{E}(T_N,\Delta T,y_p^N),{\zeta }_p^N]$, $0\le p\le k-1$, to start the current algorithm closer to $u\left(T_{N+1}\right)$. After each parareal iteration, we thus improve the accuracy, without increasing the work for solving because we start from a better input, accumulated from the previous parareal iterations.

In the rest of this section, we describe three relevant scenarios where we can approximate $\mathcal{E}(T_N,\Delta T,y_k^N)$ by trying to build a scheme in the spirit of (21). The first two examples have already been presented in the literature and concern the coupling of parareal with spatial domain decomposition (Appendix A.1) and with iterative high-order time integration schemes (Appendix A.2). In these two cases, there is to date no complete convergence analysis since it remains to show that (i) $\mathcal{E}(T_N,\Delta T,y_k^N)$ is approximated with accuracy ${\zeta }_k$ and (ii) the $\mathbf{cost}$ of the solver is really constant through the parareal steps. In addition to these two applications, we mention a third scenario where the convergence analysis can be fully proven. It concerns the solution of time-dependent problems involving internal iterative schemes at every time step. This idea was first analyzed in [21] in a restricted setting. It has also been applied in the framework of the MGRIT algorithm that couples parareal with multigrid iterative schemes (see [19]). In Appendix A.3, we give the main setting and defer the analysis for a forthcoming paper.

A.1. Parareal coupled with spatial domain decomposition

Here, we consider a solver $\mathcal{S}=DDM$ which involves spatial domain decomposition over $[T_N,T_{N+1}]$ [13], [14]. We assume that $DDM$ involves a time discretization with a small time step $\delta t<\Delta T$. Let $\underset{\_}{n}$ be the number of time steps on each interval $[T_N,T_{N+1}]$ so that we have the relations $\Delta T=\underset{\_}{n}\delta t$ and $T=\underset{\_}{N}\Delta T=\underset{\_}{N}\underset{\_}{n}\delta t$ and the total number of time steps in $[0,T]$ is $\underset{\_}{\underset{\_}{n}}≔\underset{\_}{N}\underset{\_}{n}$. The domain decomposition iterations act on a partition $\Omega ={\cup }_{l=1}^L{\Omega }_l$ of the domain. For $0\le n\le \underset{\_}{n}$, we denote by $u_k^{N,n,j}$ the solution produced by $DDM$ at time $t=T_N+n\delta t$ after $j\ge 0$ domain decomposition iterations. The notation $J^{\ast }$ will denote the last iteration (fixed according to some stopping criterion). At $j=0$, these iterations need to be initialized at the interfaces $\partial {\Omega }_l,1\le l\le L$. The idea explored in, e.g., [13], [14], is to take the values $u_{k-1}^{N,n,J^{\ast }}{|}_{\partial {\Omega }_l}$ at these interfaces as a starting guess for $0\le n\le \underset{\_}{n}$ so that

$${\tilde{\mathbb{I}}}_k^N=\{{\mathbb{I}}_k^N,\{u_{k-1}^{N,n,J^{\ast }}{|}_{\partial {\Omega }_l},0\le n\le \underset{\_}{n}\}\}.$$

From [13], [14], there is numerical evidence that the computations of $DDM(T_N,\Delta T,y_k^N)$ using ${\tilde{\mathbb{I}}}_k^N$ yield $[\mathcal{E}(T_N,\Delta T,y_k^N);{\zeta }_k^N]$ after a reduced number of iterations $J^{\ast }$ which is independent of $k$. Thus $\mathbf{cost}$ would be kept constant and

$$u_k^{N,\underset{\_}{n},J^{\ast }}=DDM(T_N,\Delta T,y_k^N)\underset{({\tilde{\mathbb{I}}}_k^N,\mathbf{cost})}{\overset{}{⟶}}[\mathcal{E}(T_N,\Delta T,y_k^N);{\zeta }_k^N],$$

where the above “$\mathbf{cost}$” is much small than the cost of the fine solver.

A.2. Parareal coupled with iterative high-order time integration schemes

Spectral Deferred Correction (SDC, [32]) is an iterative time integration scheme. Starting from an initial guess of $u\left(t\right)$ at discrete points, the method adds successive corrections to this guess. The corrections are found by solving an associated evolution equation. Under certain conditions, the correction at every step increases by one the accuracy order of the time discretization.

We carry here a simplified discussion on how to build $[\mathcal{E}(T_N,\Delta T,y_k^N);{\zeta }_k^N]$ when $\mathcal{S}=SDC$ and connect it to the so-called Parallel Full Approximation Scheme in Space-Time (PFASST, [33], [34]). For a given time interval $[T_N,T_{N+1}]$, let us consider its $\underset{\_}{n}+1$ associated Gauss–Lobatto points ${\left\{t_{N,n}\right\}}_{n=0}^{\underset{\_}{n}}$ and quadrature weights ${\left\{{\omega }_n\right\}}_{n=0}^{\underset{\_}{n}}$. The Gauss–Lobatto points are such that $t_{N,0}=T_N$ and $t_{N,\underset{\_}{n}}=T_{N+1}$. Let us denote $u_k^{N,n,j}$ the approximation of $u\left(t_{N,n}\right)$ at parareal iteration $k$ after $j\ge 0$ SDC iterations. Assuming that one uses an implicit time-stepping scheme to solve the corrector equations involved in this method, $u_k^{N,n+1,j}$ is given by

$$u_k^{N,n+1,j}=u_k^{N,n,j}+(t_{N,n+1}-t_{N,n})\left(\mathcal{A}(t_{N,n+1},u_k^{N,n+1,j})-\mathcal{A}(t_{N,n+1},u_k^{N,n+1,j-1})\right)$$

$$+\sum _{m=0}^{\underset{\_}{n}}{\omega }_m\mathcal{A}(t_{N,m},u_k^{N,m,j-1}),1\le j,0\le n\le \underset{\_}{n}-1,$$

$$u_k^{N,0,j}=y_k^N$$

$$u_k^{N,n,0}\text{ given for }0\le n\le \underset{\_}{n}\text{.}$$

To speed-up computations, one of the key elements is the choice of the starting guesses $u_k^{N,n,0},0\le n\le \underset{\_}{n}$. Without entering into very specific details, the PFASST algorithm is a particular instantiation of the above scheme when $J^{\ast }=1$ and $u_k^{N,n,0}$ uses information produced at the previous parareal iteration $k-1$. Therefore, PFASST falls into the present framework in the sense that it produces

$$u_k^{N,\underset{\_}{n},1}=SDC(T_N,\Delta T,y_k^N)$$

with

$${\tilde{\mathbb{I}}}_k^N=\{T_N,\Delta T,y_k^N,{\mathbb{P}}_{k-1}\}$$

and it is expected that $u_k^{N,\underset{\_}{n},1}=[\mathcal{E}(T_N,\Delta T,y_k^N);{\zeta }_k^N]$.

An additional component of PFASST is that the algorithm also tries to improve the accuracy of the coarse solver $\mathcal{G}$ using SDC iterations built with ${\tilde{\mathbb{I}}}_N^k$. This has not been taken into account in our adaptive parareal algorithm (12).

Another algorithm that progressively improves the quality of the fine solver across iterations is MGRIT, which couples parareal with multigrid iterative methods (see [17], [18]. The PFASST algorithm has also been coupled with multigrid techniques in [17].

A.3. Coupling with internal iterative schemes

Any implicit discretization of problem (1) leads to discrete linear or nonlinear systems of equations which are often solved with iterative schemes. When they are involved as internal iterations within the parareal algorithm, one could try to speed them up by building good initial guesses based on information from previous parareal iterations. We illustrate this idea in the simple case where:

• • $\mathcal{A}(t,\cdot )$ is a linear differential operator in $\mathbb{U}$ complemented with suitable boundary conditions,
• •we use an implicit Euler scheme for the time discretization.

A sequential solution of problem (1) with the implicit Euler scheme goes as follows. At each time $t^{N,n}=T_N+n\delta t$, the solution $u\left(t^{N,n}\right)$ is approximated by the function $u^{N,n}\in \mathbb{U}$ which is itself the solution to

$$\mathcal{B}\left(u^{N,n}\right)=g^{N,n},$$

where $g^{N,n}=u^{N,n-1}+\delta tf\left(t^{N,n}\right)$ and

$$\mathcal{B}\left(v\right)≔v+\delta t\mathcal{A}(t^{N,n},v),\forall v\in \mathbb{U}.$$

Note that $\mathcal{B}$ depends on time but our notation does not account for it in order not to overload the notations.

After discretization of $\mathbb{U}$, the problem classically reduces to solving a linear system of the form

$$\mathbf{B}{\overline{u}}^{N,n}={\overline{g}}^{N,n},$$

for the unknown ${\overline{u}}^{N,n}$ in some discrete subspace $S$ of $\mathbb{U}$. Usually, the above system is solved either by means of a conjugate gradient method or by a Richardson iteration of the form

$$\left\{\begin{array}{cc}\hfill & {\overline{u}}^{N,n,j}=(\mathbf{Id}+\omega \mathbf{PB}){\overline{u}}^{N,n,j-1}+\omega \mathbf{P}\overline{b},j\ge 1\hfill \\ \hfill & {\overline{u}}^{N,n,0}\in S\text{ given.}\hfill \end{array}\right)$$

Here, $\omega$ is a suitably chosen relaxation parameter and $\mathbf{P}$ can be seen as a pre-conditioner. The internal iterations $j$ are stopped whenever a certain criterion is met (it could be an a posteriori estimator) and we denote by $J_{N,n}$ their final number. Obviously, $J_{N,n}$ depends on the starting guess for which a usual choice is to take the solution at the previous time, that is

$${\overline{u}}^{N,n,0}={\overline{u}}^{N,n-1,J_{N,n-1}}.$$

In order to achieve our goal, i.e. maintaining a low cost while increasing the accuracy at each parareal step, we can now reuse information from previous parareal iterations for the starting guess. In [21], two options are explored. The first is

$$\left\{\begin{array}{cc}{\overline{u}}_k^{N,n,0}={\overline{u}}_k^{N,n-1,J_{N,n-1,k}},\hfill & \text{if }k=0\hfill \\ {\overline{u}}_k^{N,n,0}={\overline{u}}_{k-1}^{N,n,J_{N,n,k-1}},\hfill & \text{if }k\ge 1,\hfill \end{array}\right)$$

and the second, less natural choice,

$$\left\{\begin{array}{cc}{\overline{u}}_k^{N,n,0}={\overline{u}}_k^{N,n-1,J_{N,n-1,k}},\hfill & \text{if }k=0\hfill \\ {\overline{u}}_k^{N,n,0}={\overline{u}}_{k-1}^{N,n,J_{N,n,k-1}}+{\overline{u}}_k^{N,n-1,J_{N,n,k}}-{\overline{u}}_{k-1}^{N,n-1,J_{N,n-1,k-1}},\hfill & \text{if }k\ge 1.\hfill \end{array}\right)$$

In the first case, we take over the internal iterations at the point where they were stopped in the previous parareal iteration $k-1$. In addition to this, in the second case, the term $u_k^{N,n-1,J_{N,n,k}}-u_{k-1}^{N,n-1,J_{N,n-1,k-1}}$ tries to better take the dynamics of the process into account. Note that the use of solutions that have been produced in the previous parareal iterations is at the expense of additional memory requirements. It might also be at the cost of a certain increase in the complexity locally at certain times. However, [21] shows in a restricted setting that these starting guesses (in particular the second) have interesting potential to enhance the speed-up of the parareal algorithm. A general theory on this aspect will be presented in a forthcoming work.