---
abstract: 'We explore an approach due to Nievergelt of decomposing a time-evolution equation along the time dimension and solving it in parallel with as little communication as possible between the processors. This method computes a map from initial conditions to final conditions locally on slices of the time domain, and then patches these operators together into a global solution using a single communication step. A basic error analysis is given, and some comparisons are made with other parallel in time methods. Based on the assumption that parallel computation is cheap but communication is very expensive, it is shown that this method can be competitive for some problems. We present numerical simulations on graphics chips and on traditional parallel clusters using hundreds of processors for a variety of problems to show the practicality and scalability of the proposed method.'
author:
- 'Andrew T. Barker$^\ast$[^1]\'
bibliography:
- 'minimal.bib'
title: A minimal communication approach to parallel time integration
---

parallel in time, parareal, domain decomposition, parallel computing

65L05, 65M55, 65Y05, 65Y10

Introduction
============

Consider two different computations. $$\textnormal{Use forward Euler to advance a single scalar ODE by a billion timesteps,}
  \label{sequential}$$ and $$\textnormal{Use forward Euler to advance a billion uncoupled ODEs by one timestep.}
  \label{parallel}$$ Implemented in the standard, straightforward way, the problems and require about the same number of floating point operations. However, each operation in depends on the one before it, while the operations of can all be performed independently. In particular, relies on the clock speed of a single processor, while depends on the number of processors. Hardware is moving in the direction of increased concurrency and parallelism, and computational science is moving with it, so that processing units are proliferating and becoming very cheap, while clock speed will remain expensive.

The catch in the description of is the word "uncoupled." For useful problems in scientific computing, problems are rarely completely uncoupled, which means that different parallel processes will have to communicate somehow. That leads us to consider a third class of problem, namely $$\textnormal{Add a billion numbers, each in distinct (and distant) physical locations.}
  \label{reduce}$$ In addition to the floating point operations, problems of type require a great deal of communication, which is already expensive on current hardware. On future hardware we anticipate that this cost will be the dominant one, and that good algorithms will avoid problems of this type as much as possible.

In this paper we take these trends in hardware seriously, perhaps even taking them to an extreme. In particular, we assume that computations of type are not just very cheap but essentially free. We assume that problems of type are more expensive. Most importantly, we assume that problems of type , namely communication, are <span>*very*</span> expensive, so expensive that we will do a thousand or a million problems of type in order to avoid doing one problem of type .

In 1964 Nievergelt presented an approach to the solution of time-dependent differential equations that divides the time domain into slices which are assigned to different processors @nievergeltparallel. His approach never attracted much attention because of its high computational cost in terms of floating point operations, but we revisit it here with an eye toward communication cost instead, a factor which was not predicted to be important when Nievergelt was writing. We present three numerical examples for this method (which we believe are the first actual parallel implementations of the method), and we argue that the Nievergelt approach minimizes total communication among all parallel in time algorithms.

The basic idea of the Nievergelt approach is to <span>*construct*</span> a propagation operator on each slice, that is, a map from initial conditions to final conditions, in a way that is embarrassingly parallel but requires a great deal of computation. These maps are composed with a <span>*single*</span> reduce operation of type at the very end of the computation. As presented here this method has only limited applicability and in particular is difficult to apply to large systems of nonlinear equations. However, because of its simplicity and its lack of communication, we present it as an instructive example of what kinds of algorithms will minimize communication in future computing environments where parallel computations will become much cheaper in comparison to communication.

Some context {#context}
============

Most parallel algorithms for evolution equations exploit parallelism in space, often with very impressive speedup and scalability. Here we focus on parallelism in time, and in particular we will focus on applications where the computational resources are abundant and total time to solution is the primary concern.

One way to exploit parallel computation in the time integration is to use a predictor–corrector framework where the correctors run in parallel one or more steps behind the predictors @christliebparallel. The primary purpose of parallelism in this case is to improve the accuracy of the time integration rather than to speed it up, and this method is not suitable for use on a large number of processors.

Some methods based on the matrix exponential are well-suited to parallelism and require minimal communication between processors. One early effort in this direction is from Gallopoulos and Saad @gallopoulosefficient, who describe a parallel Krylov subspace method for approximating the matrix exponential. A more recent approach is the paraexp method of Gander and Güttel for linear initial value problems with constant coefficients @ganderparaexp, which uses a time-domain decomposition together with a "near-optimal exponential propagator" to parallelize the solve, with results that show good speedup on up to eight processors. A similar method is due to Hochbruck and Ostermann @hochbruckexponentialrk, where again a linear initial value problem can be split into several independent problems, where the division is based on quadrature of the variation-of-constants formula. These approaches depend on the matrix exponential, so that they are not suitable for problems with a coefficient that varies in time, while we will see that the Nievergelt approach is suitable for such a problem. Similarly, the contour integral quadrature approach of Sheen et. al. @sheenparallel relies on the Laplace transform and so cannot be used with varying coefficients, and in addition this method is restricted to parabolic problems. The similar Dunford-Cauchy integral approach to approximating the matrix exponential in @gavrilyukexponentially has similar restrictions. We also mention that none of the above papers include numerical results on more than eight parallel processors.

The parareal scheme has been applied on a large number of processors, is suitable for non-constant coefficient problems, and has been used very effectively to get speedup for a variety of time-dependent problems @lionsresolution [@madayparareal; @ganderanalysis]. In this approach the time domain is split into subintervals which are each assigned to processors. An iteration involving a fine time-stepping scheme (which determines the desired accuracy) and a coarse scheme (which facilitates fast transfer of information between subdomains) is repeated until the error is small. The parareal methodology has been applied to many types of problems with great success, including for problems in structural and fluid dynamics in @farhattime and @fischerparareal, for an ocean model in @liumodified, and for reaction–diffusion problems in @duarteparareal, among many other practical and more theoretical studies. The computational cost of the parareal method can be impressively reduced by combining it with the Spectral Deferred Correction method, but this does nothing to reduce the cost of communication @minionhybrid.

The approach of Nievergelt that we discuss here is similar to the parareal method in terms of the target applications, namely small systems of differential equations integrated over a very long time interval where spatial parallelization is not easy, but computational resources are abundant. However, the Nievergelt approach requires the same amount of communication as a <span>*single iteration*</span> of the parareal method, measured in terms of total amount of data communicated (or in terms of number of sends and receives). Although minimal communication is our main goal, we also note that this method will not require a coarse propagator, something that is not always easy to construct. Finally, the parareal algorithm as well as many of the matrix exponential or Laplace transform based approaches work relatively poorly or not at all for hyperbolic problems @farhattime [@ganderanalysismodified; @gandercharacteristics], while we will see that the Nievergelt approach behaves well for the wave equation.

The price we pay for all of these good properties is that the computational cost of Nievergelt is very high when measured simply in terms of floating point operations. However, almost all of the computations can be done in parallel, so given our (admittedly extreme) assumptions on the computational environment, the Nievergelt approach is competitive for some problems.

In the next section we approach questions of accuracy and scalability in the context of a very simple numerical model problem in order to clarify the properties of the Nievergelt method. Then in section \[sec:costmodel\] we present some results on graphics processing units, for which the Nievergelt algorithm is well suited, and discuss the costs and potential parallel speedup of the method in more depth. In Section \[analysis\], we take a slightly more theoretical look at the method and provide some error analysis. We apply the method to some larger and slightly more realistic problems on standard parallel hardware in Section \[pdesection\], and we end with some concluding remarks.

A simple example {#methods}
================

To make the discussion concrete, consider the model nonlinear initial value problem $$y' = y^2, \quad y(0) = 1,
  \label{scalarmodel}$$ which has exact solution $$y = \frac{1}{1 - t}.$$ We will avoid the singularity at time $ t = 1 $ and consider this problem on the time interval $ {\mathcal T}= [0, T] $ with final time $ T = 1/2 $. We assume the quantity of interest is simply $ y(T) $ and we calculate all our (absolute) errors with respect to that.

Now we subdivide $ {\mathcal T}$ into subparts $ {\mathcal T}_j = [T_{j-1}, T_j], j = 1 \ldots N $ where $ T_0 = 0, T_N = T $. On each part $ {\mathcal T}_j $ we consider an initial value problem $$y' = y^2, \quad y(T_{j-1}) = \lambda_{j-1}
  \label{localivp}$$ on $ {\mathcal T}_j $. Of course in general $ \lambda_{j-1} $ is unknown, so we conceptually solve the problem for all possible $ \lambda_{j-1} $, constructing not just a scalar value $ y(T_n) $ but a mapping $ \phi^j $ that takes initial values to final values.

We assume $ \lambda_{j-1} $ is known to lie in some range $ \Xi = [a, b] $. We call $ \Xi $ the <span>*initial value space*</span> and sample points inside $ \Xi $ to get a discrete set $ \Xi_h $. Then, for each $ \xi \in \Xi_h $ we run the initial value problem . When the initial value $ \lambda_{j-1} $ becomes known (communicated to us from the previous processor in the final step of the algorithm), we use interpolation to calculate $ \lambda_j $.

\[foursubdomains\]

To understand how the interpolation process affects accuracy, we represent the initial value space $ \Xi = [0,2] $ as a Lagrange interpolant on the $ M $ Chebyshev nodes in this interval. We present some accuracy results in Table \[foursubdomains\]. Intuitively we wish to balance the time–discretization errors with interpolation errors that are of the same order to get an efficient method. Since Chebyshev interpolation is spectrally accurate, we see in Table \[foursubdomains\] that we need just 5 or 6 Chebyshev points is enough to get $ 10^{-4} $ accuracy. Also see Figure \[errorpartition\], which shows the component of error related to interpolation as the time integration proceeds. We remark that the number of subdomains $ N $ does not significantly affect these results.

![The error of the Nievergelt approach with $ \Delta t = 10^{-4} $ on a log scale on the vertical axis plotted against time on the horizontal axis. The solid line is the error with plain backward Euler timestepping and no parallel framework, while the dotted line shows the error using $ M = 6 $ Chebyshev points. The left figure has 3 parallel time intervals, and the right has 4 parallel time intervals. The interpolation does add to the error, but the amount is comparable to the original time discretization error.<span data-label="errorpartition"></span>](errorpartitionlog.eps "fig:"){width="45.00000%"} ![The error of the Nievergelt approach with $ \Delta t = 10^{-4} $ on a log scale on the vertical axis plotted against time on the horizontal axis. The solid line is the error with plain backward Euler timestepping and no parallel framework, while the dotted line shows the error using $ M = 6 $ Chebyshev points. The left figure has 3 parallel time intervals, and the right has 4 parallel time intervals. The interpolation does add to the error, but the amount is comparable to the original time discretization error.<span data-label="errorpartition"></span>](errorpartitionlog4.eps "fig:"){width="45.00000%"}

\[errorcomparison\]

For comparison we also solve this problem using a parareal method @madayparareal. The parareal algorithm proceeds by iteratively applying the correction equation $$\lambda_{j+1}^{k+1} = G_{\Delta T}^j(\lambda_j^{k+1}) + g_{\Delta t}^j(\lambda_j^k) - G_{\Delta T}^j(\lambda_j^k),
  \label{pararealcorrection}$$ where $ \lambda_j^k $ is the initial value for time slice (or processor) $ j $ in iteration $ k $, $ g_{\Delta t} $ is a standard time stepping method with a short timestep, and $ G_{\Delta T} $ is a (cheap) coarse time stepping method with larger timestep $ \Delta t $. To understand the two compared algorithms visually, see Figures \[minimalscheduling\] and \[pararealscheduling\], where we present the scheduling of the Nievergelt and parareal algorithms as in the figures in @minionhybrid. Here we have made an analogy between the fine propagator of parareal and the construction of the map from initial to final conditions in the Nievergelt approach, but we should note that this latter operation is much more expensive (by a constant factor of $ M $). However, like the fine propagation of parareal, the construction of this map is embarrassingly parallel, requiring no synchronization. Also, we have compared the coarse propagator of parareal to the interpolation in Nievergelt. These are quite different operations, and it is not obvious exactly how their costs compare, but they play similar roles in the algorithm. It is clear from these figures that Nievergelt involves significantly fewer communications, especially as the number of parareal iterations increases.

\[scale=1.0\] (-0.5, 0.0) – node\[below=0.5cm\] <span>processor</span> (6.5, 0.0); (0.0, -0.5) – node\[left\] <span>time</span> (0.0, 4.5);

/in <span>0.0/0, 1.0/1, 2.0/2, 3.0/3, 4.0/4, 5.0/5</span> <span>(0.0, 0.0) rectangle (1.0, 3.0); (, 0.0) node\[below\] ;</span>

/in <span>1.0/3.0, 2.0/3.25, 3.0/3.5, 4.0/3.75, 5.0/4.0</span> <span>(0.0, 0.0) rectangle (1.0, 0.25); (,) circle (0.1);</span>

\[scale=1.0\] (-0.5, 0.0) – node\[below=0.5cm\] <span>processor</span> (6.5, 0.0); (0.0, -0.5) – node\[left\] <span>time</span> (0.0, 5.0);

/in <span>0.0/0, 1.0/1, 2.0/2, 3.0/3, 4.0/4, 5.0/5</span> <span>(0.0, 0.0) rectangle (1.0, 1.0); (, 0.0) node\[below\] ;</span>

/in <span>1.0/1.0, 2.0/1.25, 3.0/1.5, 4.0/1.75, 5.0/2.0</span> <span>(0.0, 0.0) rectangle (1.0, 0.25);</span>

/in <span>1.0/1.25, 2.0/1.5, 3.0/1.75, 4.0/2.0, 5.0/2.25</span> <span>(0.0, 0.0) rectangle (1.0, 1.0);</span>

/in <span>2.0/2.5, 3.0/2.75, 4.0/3.0, 5.0/3.25</span> <span>(0.0, 0.0) rectangle (1.0, 0.25);</span>

/in <span>2.0/2.75, 3.0/3.0, 4.0/3.25, 5.0/3.5</span> <span>(0.0, 0.0) rectangle (1.0, 1.0);</span>

/in <span>3.0/4.0, 4.0/4.25, 5.0/4.5</span> <span>(0.0, 0.0) rectangle (1.0, 0.25); (,) circle (0.1);</span>

/in <span>1.0/1.0, 2.0/1.25, 3.0/1.5, 4.0/1.75, 5.0/2.0</span> <span>(,) circle (0.1);</span>

/in <span>2.0/2.5, 3.0/2.75, 4.0/3.0, 5.0/3.25</span> <span>(,) circle (0.1);</span>

The results of the comparison are given in Table \[errorcomparison\]. Here we use backward Euler as both the fine and coarse propagator, with fine discretization size $ \Delta t $ and coarse discretization size $ \Delta T $, and $ k $ represents the number of parareal iterations used. More iterations gives better accuracy, but recall that each iteration of parareal requires as much communication as the entire Nievergelt algorithm, and in Table \[errorcomparison\] we see that even for this simple problem it usually takes a few iterations to get to discretization error.

To end this section we summarize the Nievergelt approach in pseudocode in Figure \[pseudocode\].

A graphics card implementation and cost model {#sec:costmodel}
=============================================

\[tab:gpuresults\]

One possible use case for the Nievergelt method is on general purpose graphical processing units, which are highly parallel and energy efficient computing units that are widely and cheaply available due to their use in gaming hardware. Effectively using this hardware is a challenge because they are most efficient when the computational task can be broken down into very many independent threads, which is precisely what the Nievergelt algorithm does. In Table \[tab:gpuresults\] we show the speedup of using the parallel capabilities of the GPU over the same computation performed in serial on the CPU, with times recorded in microseconds, for the nonlinear scalar initial value problem, for various timestep sizes $ \Delta t $. We partition the time interval into $ N $ time slices, for each of which we compute the map from initial to final conditions independently. For each of the $ N $ time slices we propagate $ M $ initial conditions so that we can use $ MN $ completely independent threads on the GPU. The computation is finished by doing some cheap interpolation on the CPU. We are using backward Euler for the timestepping and Chebyshev interpolation with $ M $ nodes (chosen to insure that the total error in the Nievergelt method is comparable to time discretization error) and doing all computations in single precision. In each case the error for the Nievergelt implementation is comparable to the discretization error due to timestepping. The timing results include all the time required to allocate memory, build the initial value arrays, transfer data to and from the GPU, and to perform the interpolation that evaluates the map from initial to final conditions. The CPU and GPU tests are run on the same machine, which has a six core AMD Opteron CPU and an nVidia Tesla C2075 GPU. This experiment demonstrates the potential for using the inherent parallelism of the graphics card to solve the problem faster than is possible with the CPU of the same machine, even though many more floating point operations are required.

\[tab:tauparameters\]

One possible model for the cost (in terms of time to solution) for the Nievergelt method using the GPU implementation is $$C_G = \frac{M n}{N} \tau_F + N \tau_N + \tau_K
  \label{gpucostmodel}$$ where $ \tau_F $ is the time to advance a single timestep using backward Euler for a single initial value problem, $ \tau_N $ is a measure of the cost of applying the map that has been constructed (the final communication and interpolation step), and $ \tau_K $ represents some fixed GPU startup costs. Predicting the time to solution for the experiments in Table \[tab:gpuresults\] using parameter values from Table \[tab:tauparameters\] shows good agreement, as you can see in the last column of Table \[tab:gpuresults\].

The corresponding serial cost is simpler, given by $$C_C = n {\tau_F^{\text{cpu}}}.
  \label{serialcostmodel}$$ The speedup $ C_C / C_G $ can then be written $$\frac{C_C}{C_G} = \frac{n {\tau_F^{\text{cpu}}}}{Mn \tau_F / N + N \tau_N + \tau_K} \approx \frac{Nn \kappa_F}{Mn + N^2 \kappa_N}.$$ where we have ignored the lower order term $ \tau_K $ because we are interested in the extreme case of large $ n $ and $ N $ and we have defined $ \kappa_F = {\tau_F^{\text{cpu}}}/ \tau_F $ and $ \kappa_N = \tau_N / \tau_F $. In order to balance time discretization with interpolation errors, we will assume $ M \approx n^\alpha $ for $ \alpha < 1 $. In fact in model problem with Chebyshev interpolation we could choose $ M \approx \log(n) $ but we will not assume we have such an exponentially convergent scheme in general. Then if for fixed problem size $ n $ we choose $ N^2 \approx \kappa_N^{-1} n^{\alpha + 1} $ we get $$\frac{C_C}{C_G} \approx \frac{\kappa_N^{-1/2} n^{(3 + \alpha)/2} \kappa_F}{n^{\alpha+1} + n^{\alpha + 1}} = \left( \frac{ \kappa_F} {2 \kappa_N^{1/2}} \right) n^{(1-\alpha)/2}$$ which implies that for $ \alpha < 1 $, the larger the problem is, the more speedup we can get.

Similar to the cost model analysis of a parareal–type method in @farhattime [Section 3], we see that the traditional parallel efficiency for our method is not as good as usual space–based parallelism. However, the goal is to make the best use of an available GPU that otherwise would not be doing useful work, and we see that it is possible to get speedup in this case.

Error analysis {#analysis}
==============

Nievergelt proves some error bounds on his approach in @nievergeltparallel, using forward Euler and linear interpolation. We want to say something about the error in a slightly more abstract setting, with correspondingly abstract assumptions.

To begin, fix $ j $ and consider the interval $ {\mathcal T}_j = [T_{j-1}, T_j] $. Let $ g^j $ be the exact solution operator that maps an initial condition at $ t = T_{j-1} $ to a final condition at $ t = T_j $, and let $ g^j_{\Delta t} $ be a standard time-discretization method that approximates $ g^j $. We will assume that our problem is well posed in the sense that $ g^j $ is Lipschitz as a function of the initial conditions, $$| g^j(\xi_1) - g^j(\xi_2) | \leq K | \xi_1 - \xi_2 |, \quad \xi_1, \xi_2 \in \Xi.
  \label{flipschitz}$$

We evaluate $ g^j_{\Delta t} $ for many initial conditions in order to construct an interpolating function $ \phi^j_{\Delta t} $ which approximates the map $ g^j_{\Delta t} $ using some standard interpolation technique. (The map $ g^j_{\Delta t} $ in turn approximates the exact operator $ g^j $, which is of course what we really want.) Denote the true solution at $ t = T_{j-1} $ by $ \lambda_{j-1}^* $, but of course we will instead have an approximation to this value communicated from a previous processor, denoted by $ \lambda_{j-1} $. We will also use $ g $ and $ g_{\Delta t} $ without superscripts to denote propagators on the whole time interval $ {\mathcal T}= [T_0, T_N] $, and $ \phi_{\Delta t} $ will be the Nievergelt method used over the entire time domain (including several interpolations).

We begin our analysis by considering the error at the end of the fixed time domain $ {\mathcal T}_j $: $$\begin{aligned}
  | \phi^j_{\Delta t} (\lambda_{j-1}) - g^j(\lambda_{j-1}^*) | \leq | \phi^j_{\Delta t} (\lambda_{j-1}) &- g^j_{\Delta t}(\lambda_{j-1}) | + | g^j_{\Delta t}(\lambda_{j-1}) - g^j(\lambda_{j-1}) | \notag \\
  & + | g^j(\lambda_{j-1}) - g^j(\lambda_{j-1}^*) |,
  \label{errorsplitting}\end{aligned}$$ where the first term is recognized as a standard interpolation error, the second term is a standard time discretization error, and the third term depends on how accurately the solution was computed on the previous time-slice $ {\mathcal T}_{j-1} $. Beginning with this last term and using , we have $$|g^j(\lambda_{j-1}) - g^j(\lambda_{j-1}^*) | \leq K | \lambda_{j-1} - \lambda_{j-1}^* | = K | \phi_{\Delta t}^{j-1} (\lambda_{j-1}) - g^{j-1} (\lambda_{j-2}^*) |,$$ which contains exactly the same type of expression as , so that we can use it recursively to get an expression for the final error, $$\begin{aligned}
  | \phi^N_{\Delta t} (\lambda_{N-1}) - g^N(\lambda_{N-1}^*) | &\leq NK \left( \max_j | \phi^j_{\Delta t} (\lambda_{j-1}) - g^j_{\Delta t}(\lambda_{j-1}) | \right. \notag \\
  &\qquad + \left. \max_j | g^j_{\Delta t}(\lambda_{j-1}) - g^j(\lambda_{j-1}) | \right).
  $$

We will require that our time discretization method satisfies $$| g_{\Delta t}^j(\lambda_{j-1}) - g^j(\lambda_{j-1}) | \leq C_1 \frac{1}{N} O(\Delta t^k),
  \label{timecondition}$$ where $ C_1 $ is independent of the time interval $ T_j - T_{j-1} $ and $ k $ is the order of error in the underlying time discretization method, $$| g_{\Delta t}(\lambda_0^*) - g(\lambda_0^*) | \leq D_1(T) O(\Delta t^k).$$ The standard error bounds for many time discretization methods (including linear multistep methods) have $ D_1 $ growing <span>*exponentially*</span> with the length of the time interval that we are integrating over, so that is not hard to satisfy @atkinsonnumerical [@henricidiscrete].

The analogous condition for the interpolation is easy to state but perhaps harder to interpret. It is $$| \phi_{\Delta t}^j (\lambda_{j-1}) - g_{\Delta t}^j (\lambda_{j-1}) | \leq C_2 \frac{1}{N} O(\Delta \xi^\ell),
  \label{interpolationcondition}$$ where $ \ell $ again represents the order of error of the underlying interpolation on the initial value space: $$| \phi_{\Delta t} (\lambda_0^*) - g_{\Delta t} (\lambda_0^*) | \leq D_2(T) O(\Delta \xi^\ell).$$ Here we are assuming that the interpolating function to the time discretization operator is more accurate if the time integration is over a short interval than if it is over a long interval (cf. @nievergeltparallel). If we use polynomial interpolation, standard results give us $$| \phi_{\Delta t}^j (\lambda_{j-1}) - g_{\Delta t}^j (\lambda_{j-1}) | \leq C_3 \Delta \xi^{p+1} \max_{\xi \in \Xi} \left| \frac{\partial^{p+1} g_{\Delta t}^j(\xi)}{\partial \xi^{p+1}} \right|,$$ where $ p $ is the order of the polynomial. The quantity in absolute value can be interpreted as the $ D_2(T) $ above, and in general can be expected to grow very quickly in $ T $, so that is also a very plausible assumption for a wide range of problems—in particular it certainly holds for our simple model problem with linear interpolation.

We put these simple results together in the following

Under the assumptions , and , we have $$| \phi^j_{\Delta t} (\lambda_{j-1}) - g^j(\lambda_{j-1}^*) | \leq O(\Delta \xi^\ell) + O(\Delta t^k),$$ and in particular if we balance interpolation and time discretization errors, the Nievergelt approach recovers the error of the underlying time discretization.

For linear differential equations, the solution is also linear as a function of its initial condition, so that the interpolation error can be made zero using only enough points to construct a basis for the initial condition space, as shown in @nievergeltparallel. In the remainder of the paper we will focus on this simpler case.

We close this section with a few comments on the cost required to achieve this error. The Nievergelt algorithm is very computationally costly in conventional terms. In a sense, we trade off everything else against communication costs, assuming those to be dominant. The result is that floating point operation counts and storage costs are very high. For example, when applied to a nonlinear PDE discretized with $ r $ unknowns, the initial value space will have dimension $ r $. If you sample uniformly in this high–dimensional space, with $ \ell $ points for each of the $ r $ unknowns, then the total number of operations to construct the propagation operator (or storage to store the final conditions) will grow as $ \ell^r $. If parallel operations are truly free we may be willing to pay this cost, or in some cases we may be able to sample much more efficiently than uniformly.

In addition to the computational cost, in many dimensions the choice of how to sample the initial value space and how to perform the interpolation step is not straightforward. If some suitable interpolation can be applied, than the Nievergelt method can in principle be applied and will result in parallel speedup, but in many cases this will not be practical and some other algorithm must be sought.

However, in the remainder of this paper we will consider linear problems, where the storage and cost issues can be greatly reduced and the interpolation issue disappears completely. In particular, if after space discretization we have the system $$\frac{d}{dt} {\mathbf y}= A(t) {\mathbf y}+ {\mathbf b}(t),
  \label{lineardiscrete}$$ then the solution is an affine function of the initial condition $ {\mathbf y}_0 $. With $ M $ points in the spatial discretization, then $ {\mathbf y}_0 = \sum_{j=1}^M y_j e_j $ for the unit basis vectors $ e_j $, and we can solve once with a zero initial condition and solve a homogeneous version of $ M $ times, once for each basis vector. This can be done with no knowledge of the true initial condition coefficients $ y_j $. Then we reconstruct the solution $${\mathbf y}= g_{\Delta t}(0) + \sum_{j=1}^M y_j g_{\Delta t}(e_j).
  \label{linearreconstruct}$$ We use the notation $ g_{\Delta t} $ (rather than $ \phi_{\Delta t} $) because there is no need for interpolation in this linear setting and this technique introduces no additional error beyond rounding error.

The heat equation and wave equation {#pdesection}
===================================

Having examined the Nievergelt approach numerically on a simple scalar initial value problem and done some analysis, we now turn to some results for slightly more complicated problems. First we consider the variable coefficient heat equation $$\frac{\partial y}{\partial t} = \left( 1 + \frac{1}{4} \sin(t) \right) \frac{\partial^2 y}{\partial x^2} + b(t), \quad x \in [0,1]
  \label{heatequation}$$ in one dimension with homogeneous Dirichlet boundary conditions and with $ b(t) $ and the initial conditions chosen so that the true solution is given by $$y = \cos(t) \sin(\pi x).$$ We note that has a nonconstant coefficient and so that methods on exponential quadrature or Laplace transforms @hochbruckexponentialrk [@gavrilyukexponentially; @sheenparallel] and the paraexp method @ganderparaexp are not applicable.

\[heatlong\]

After discretization in space using standard centered finite differences and $ M $ spatial points, can be written in the form . On each parallel time slice we solve this problem $ M + 1 $ times with different initial conditions (and with $ b(t) \neq 0 $ only once) and reconstruct the solution using and a single communication step.

\[paraheat\]

\[heatlongfine\]

Some numerical results are shown in Table \[heatlong\], where we can see a speedup of about 15. Note that we are able to get this speedup partially because we are willing to accept poor spatial resolution. If more points in space are required, we will need many more processors to see speedup, but there is no real barrier to doing this provided the processors are available. Scaling results for a parareal implementation of this problem are shown in Table \[paraheat\]. See also Tables \[heatlongfine\] and \[heatlongfineqb\] which achieve similar speedups for larger problems with more processors.

\[heatlongfineqb\]

\[heatdelay\]

Comparisons of the communication times in Tables \[heatlong\] and \[paraheat\] show that we do not, in fact, live in a world where parallel floating point operations are free compared to communication time, and the Nievergelt algorithm is competitive with parareal only if we require an unrealistically large number of parareal iterations. In Table \[heatdelay\] we simulate additional latency by enforcing a delay of one millisecond for every message that is received from another processor, and it is clear that in this simulated high-latency environment the additional communication steps of the parareal method are a drawback, especially for problems where a large number of iterations might be required. As parallel computations become cheaper relative to communication, the Nievergelt approach becomes more and more promising in comparison to the parareal method.

The parareal algorithm is reported to work relatively poorly for second–order problems and for hyperbolic problems @farhattime [@ganderanalysismodified; @gandercharacteristics; @ganderkrylov], and many of the other time-parallel methods we considered in the introduction are restricted to parabolic problems @hochbruckexponentialrk [@gallopoulosefficient; @sheenparallel]. As our final numerical example we consider the Nievergelt method applied to these types of problems. In @ganderanalysismodified [@ganderkrylov], a version of the parareal algorithm for second–order and hyperbolic algorithms is presented—however, this method requires the communication of more initial conditions from more distant processors (not just the immediately preceding time slice), and so is not competitive in trying to minimize communication.

We will use an example problem from @trefethenspectral, Program 19, which is the wave equation $$\frac{\partial^2 y}{\partial t^2} = \frac{\partial^2 y}{\partial x^2}, \quad x \in [0,1]
  \label{waveequation}$$ with homogeneous Dirichlet boundary conditions and with the initial conditions such that the solution is a single peaked wave propagating to the left. This problem is discretized in space with a spectral method on Chebyshev points, and time-stepping is with the explicit second-order leapfrog method. We will use a varying number $ M $ of spatial points but always choose a timestep of $ \Delta t = 8 / M^2 $ to satisfy a CFL condition. See @trefethenspectral for details for this model problem.

\[wave40\]

The time-domain decomposition proceeds much as it did for the heat equation, the only important difference being that we have two initial conditions (data from the previous timestep and the step before that) to deal with and to transfer from subdomain to subdomain. This has the effect of doubling the initial value space, that is, if we have $ M = 80 $ spatial points, we need to propagate 160 initial conditions to get the full map from initial conditions to final conditions.

Numerical results are shown in Tables \[wave40\] and \[wave80\].

\[wave80\]

Conclusion
==========

We have examined the method of Nievergelt for the parallel solution of time-dependent problems, a method which essentially builds the time propagation operator on each time-slice in parallel with no knowledge of the initial conditions.

It is clear from a viewpoint of counting arithmetic operations that the Nievergelt approach is not efficient, and it may never be suitable for nonlinear problems with a large number of degrees of freedom. However, we are moving to a future where computational cores are essentially free—hundreds of them may be sitting unused on your desktop, and if there is any way to use them profitably it may be worthwhile even if the efficiency is poor. In addition, for some applications the total time to solution is the only concern, and the amount of computational resources spent is less important. It is this kind of hardware environment and these kind of applications that the parareal algorithm was invented to deal with. The Nievergelt method compares well to the parareal algorithm but has the important advantage of always requiring less communication, and it is applicable to more situations than methods based on exponential quadrature or Laplace transforms.

In our work above, we have shown speedup of 3 on 32 processors for a scalar ODE problem, a speedup of 10 on 1024 processors for a variable coefficient heat equation and speedup of 5 on 256 processors for a wave equation. These results are somewhat worse than those in published parareal implementations, but roughly comparable. The original parareal paper @lionsresolution predicted speedups of 8 to 18, and in @liumodified the authors get speedup of 5 or 6 on 200 processors. The best speedups in @farhattime and @farhatimplicit are from 4 to 6. For the different paraexp method, speedups are reported to be from 4 to 6 @ganderparaexp. In addition to speedup on traditional parallel clusters, we have seen that implementing the Nievergelt algorithm on a GPU provides modest speedup, with this case being of particular interest because many computational scientists will have a GPU sitting idle in their desktop while they wait for a CPU to compute their results.

The assumptions that we are using in this work, namely that parallel computation is so cheap as to be nearly free when compared to communication costs, are not satisfied on traditional parallel machines. However, to some extent this assumption holds on modern graphics hardware, and we have shown that algorithms can be designed for a future world where this kind of pattern is more common. Even if the very high computational and storage costs of the Nievergelt method make it impractical in many cases, we argue that something like it could influence at least part of the design of future parallel methods and that understanding this extreme case may point the way to exploiting future hardware where communication costs dominate computational costs. Aside from the model problem at the beginning, we have focused on linear problems, because in this case it is easier to construct and represent the map from initial conditions to final conditions. In the general nonlinear case, using this map will require approximating it and using some high-dimensional interpolation scheme, which may be prohibitively expensive. However, there is no additional communication necessary for nonlinear problems.

We have divided our time domain into slices and assigned each slice to a single processor on a parallel machine, but it is worth noting that there is a great deal more parallelism inherent in the problem than we have exploited. The map from initial to final conditions is constructed by integrating in time a large number of initial conditions given by some discretization of the initial condition space, and in principle each of these time integrations could be done on a separate processor or processing core in parallel. The lack of need for synchronization in the whole algorithm (except at the final step) suggests the possibility of a distributed computing model for some applications.

There are several possible directions for future research. One is to combine the Nievergelt approach with a parareal method in some way, to get a balance of the communication costs versus the greatly added computation of Nievergelt. Another is to do more realistic nonlinear problems so as to more carefully consider the role of interpolation in the method. Ongoing research is to combine the traditional parallel implementation with the GPU implementation to see the potential of the method on heterogeneous systems.

Acknowledgements {#acknowledgements .unnumbered}
================

This work was supported in part by the U.S. National Science Foundation under Grant Number DMS-07-39382. Computational resources were provided by the Louisiana Optical Network Initiative and the Stellar Group at the Center for Computational Technology at Louisiana State University.

[^1]: $^\ast$Email: <span>mathew35@example.net</span>.

{'source': 'arXiv_out/1304'}