Tolerance Proportionality and Computational Stability in Adaptive Parallel-in-Time Runge–Kutta Methods

Abstract

In this paper, we investigate how adaptive time-integration strategies can be effectively combined with parallel-in-time numerical methods for solving systems of ordinary differential equations. Our focus is particularly on their influence on tolerance proportionality. We examine various grid-refinement strategies within the multigrid reduction-in-time (MGRIT) framework. Our results show that a simple adjustment to the original refinement factor can substantially improve computational stability and reliability. Through numerical experiments on standard test problems using the XBraid library, we demonstrate that parallel-in-time solutions closely match their sequential counterparts. Moreover, with the use of multiple processors, computing time can be significantly reduced.

1. Introduction

Adaptive numerical methods for solving ordinary differential equations (ODEs) have become a significant topic in numerical analysis. The primary motivation for this approach lies in the challenges posed by stiff ODEs, where sudden changes in certain components may occur, and where explicit methods are subject to severe stability restrictions. Such behavior is common, for example, in models of chemical reactions that involve higher-order reaction terms. The steep gradients necessitate very fine time-stepping, which can substantially slow down the simulation.

It is important to note that realistic chemical reaction systems often involve a large number of reaction steps with widely varying reaction-rate coefficients [1]. Similarly, the semi-discretization of large-scale air pollution models [2] can result in ODE systems with a vast number of unknowns.

To address this, it is essential to identify regions where steep gradients occur, applying small time steps in their vicinity. Several algorithms have been proposed in the literature to construct efficient adaptive refinements (see [3], Section 5.2).

We begin by noting that any spatial semi-discretization of partial differential equations (PDEs) yields a large, stiff system of ordinary differential equations (ODEs). As a result, efficient numerical methods are required—even when the reaction terms are nonstiff.

However, heuristic algorithms for selecting time steps can be prone to instabilities. For instance, it is important to adjust the time steps smoothly by controlling the ratio between successive step sizes. This necessity naturally connects time-step selection with control theory. Indeed, some of the most effective adaptive time-stepping algorithms have been developed using control-theoretic approaches. Further details can be found in the classical works [4,5,6,7]. For a recent approach, we refer readers to [8].

Another strategy for accelerating the numerical solution of ODEs is to use parallel-in-time algorithms. Over the past decade, interest in these methods has been revitalized by the advent of massively parallel computing architectures. In addition to traditional applications involving PDEs [9,10,11,12], recent developments such as neural ordinary differential equations [13] and physics-informed neural networks [14] have further broadened the scope of parallel-in-time methods, especially in machine learning and deep learning contexts [15,16,17,18].

Parallel-in-time methods can be broadly categorized into four main groups: multiple shooting methods; domain decomposition and waveform relaxation methods; space-time multigrid methods; and direct parallel-in-time algorithms. A comprehensive overview of these techniques is provided in the review paper [19] and the monograph [20].

In this work, we focus on the multigrid reduction-in-time (MGRIT) method introduced in [21]. MGRIT is closely related to the parareal algorithm developed in [22] and has since been extended in a variety of directions. These include applications to nonlinear parabolic equations [23], adaptive (variable-step) multistep methods [24], layer-parallel training of deep residual neural networks [25], efficiency improvements via Richardson extrapolation [26], and hyperbolic problems such as linear advection [27].

Adaptive parallel-in-time methods have been explored in [24,26], with a primary focus on metrics such as time versus discretization error and processor versus wall-clock time. However, another important aspect of reliability is how the global error responds to changes in the specified tolerance. Ideally, for problems with regular solutions, a small change in the tolerance should result in a proportionally small change in the error. This property, referred to as tolerance proportionality, is fundamental to computational stability [28].

In Section 2, we introduce the necessary concepts and tools—such as the MGRIT algorithm, basic sequential adaptive strategies, tolerance proportionality, and computational stability—that motivate the modified refinement factor presented in the subsequent section. In Section 3, as the main novelty of the paper, we demonstrate both tolerance proportionality and computational stability in our advanced parallel-in-time method, which builds upon the step-size selection strategy proposed in [24]. The proposed approach is validated through several test problems, including classical ODE systems and systems arising from the discretization of PDEs. All numerical results can be reproduced using the public GitHub repository [29]. Finally, in Section 4, we discuss the advantages, limitations, and corresponding directions for future research.

2. Preliminaries: Main Tools and Requirements

In this section, we introduce the fundamental components of our algorithm and outline the key practical requirements it must fulfill.

2.1. The MGRIT Algorithm

We provide a brief overview of the MGRIT method introduced in [21]. Assume we are given the initial value problem

$$\begin{array}{cc}\hfill u^{\prime }\left(t\right)& =f(t,u(t\left)\right),t\in (0,T),\hfill \\ \hfill u\left(0\right)& =u_0,\hfill \end{array}$$

where f is a given function and $u_0$ is the initial condition. Let $0=t_0<t_1<\dots <t_{N-1}<t_N=T$ be a uniform mesh given on the interval $[0,T]$ with an equidistant step size $\Delta t$.

In standard time-stepping approaches, the solution is approximated using a one-step method

$$\begin{array}{cc}\hfill u_0& =u_0,\hfill \\ \hfill u_{i+1}& ={\Phi }_{i+1}\left(u_i\right)+g_{i+1},i=0,1,\dots ,N-1,\hfill \end{array}$$

where $\Phi$ denotes the one-step update operator, which can be practically any Runge–Kutta method, and g represents the source or correction terms. Since each time point depends on the previous one, this yields a sequential algorithm in time.

In contrast, the MGRIT algorithm iteratively computes an approximation to the solution over the entire time domain, starting from an initial guess. MGRIT is based on multigrid techniques and enables parallelization in the temporal domain. Assume that the right-hand side f is linear, and consider a coarser time grid $0=T_0<T_1<\dots <T_{{\displaystyle \frac{N}{m}}-1}<T_{{\displaystyle \frac{N}{m}}}=T$ with a step size $\Delta T=m\Delta t$. On this coarse grid, we apply another one-step method, denoted by ${\Phi }_{\Delta }$, which is computationally cheap and used to improve the current approximation. The two-grid method, which is equivalent to the parareal method [22], is outlined in Algorithm 1. The relaxation steps are illustrated in Figure 1.

Algorithm 1 Two-grid method.

1: Relaxation by F-relaxation (or FCF-relaxation) 2: Restriction: $r_{\Delta ,i}=u_{mi}-({\Phi }_{mi}\left(u_{mi-1}\right)-g_{mi})$ 3: Solve the problem $v_{\Delta ,i}={\Phi }_{\Delta }\left(v_{\Delta ,i-1}\right)+r_{\Delta ,i}$ in the coarse grid 4: Prolongation: $u_{im}=u_{im}+v_{\Delta ,i}$ 5: Relaxation by F-relaxation

The convergence rate of the two-grid method depends on how accurately the coarse-grid propagator ${\Phi }_{\Delta }$ approximates the result of performing m successive fine-grid steps between two coarse time points. Selecting an optimal coarse-grid propagator remains an active area of research. In many practical settings, the same numerical method is employed on both the fine and coarse grids.

A potential limitation of the two-grid approach is that the coarse grid may still be too fine, rendering Step 3 of Algorithm 1 computationally expensive. This issue can be addressed by recursively applying the same algorithm on increasingly coarser grids, following the classical multigrid paradigm. The resulting recursive structure gives rise to various cycle types, such as V-, W-, and F-cycles, as illustrated in Figure 2. Furthermore, the algorithm can be extended to nonlinear problems using the Full Approximation Scheme (FAS).

The MGRIT algorithm achieves optimal complexity with a runtime of $\mathcal{O}\left(N\right)$ and, unlike traditional time-stepping schemes, is massively parallelizable. In practice, convergence to a sufficiently accurate solution is often attained within a few iterations. The numerical results of strong scaling studies on a linear problem (heat equation) and a nonlinear problem (p-Laplace problem) are presented in [21,23]. These results show that while the sequential one-step method outperforms MGRIT with a small number of processors, significant speedup is achieved when parallel resources are effectively utilized.

The XBraid software package is an implementation of the MGRIT method [30]. It is written in MPI/C with interfaces for C++, Fortran 90, and Python, and is designed to be non-intrusive. This allows users to leverage their existing sequential time-stepping code, while XBraid manages the parallelization. Additionally, XBraid supports time refinement, enabling adaptive time-stepping strategies within the parallel-in-time framework. We used this implementation of the MGRIT method in the experiments presented in the next section.

2.2. Tolerance Proportionality and Computational Stability

If a method and its step size have been chosen properly for a given problem, it typically operates in the asymptotic regime. Thus, if the method order is p, the norm of the local error at time $t_n$ is well approximated by

$$l_n=\psi \left(t_n\right)h_n^p,$$

(1)

where $h_n$ is the current step size and $\psi \left(t\right)$ is the principal error function. The latter is smooth provided that the regularity of the solution is sufficiently high. When the regularity is low, it is often preferable to use a low-order method, i.e., reduce p to match the regularity of the solution so that we again have a local error of the form (1) with a smooth function $\psi (·)$. In adaptive step-size selection based on local error control, the objective is to keep the local error constant, equal to a prescribed tolerance $\mathrm{TOL}$, i.e.,

$$l_n=\psi \left(t_n\right)h_n^p=\mathrm{TOL}\Rightarrow h_n={\left({\displaystyle \frac{\mathrm{TOL}}{\psi \left(t_n\right)}}\right)}^{1/p}.$$

It follows that the “proper” step-size sequence is smooth, and that

$$log{h}_n={\displaystyle \frac{1}{p}}\left(log\mathrm{TOL}-log\psi \left(t_n\right)\right).$$

Hence, if the logarithm of the step-size sequence $\{logh\}$ is plotted vs. time, a change in $\mathrm{TOL}$ merely shifts the graph given by $\{log\psi \}$ vertically. In other words, the proper step-size sequence is a smooth function negatively correlated with the principal error function, with $\{logh\}$ proportional to $log\mathrm{TOL}$.

For these reasons, any step-size selection scheme should aim to replicate these properties. Thus, the generated step-size sequence should be smooth, and if well implemented, the tolerance proportionality should be readily visible in real computations. If the global error accumulation is regular, this implies that the global error should be proportional to the tolerance. This can, however, only be achieved with careful implementation (see, e.g., [28]). In practice, tolerance proportionality means that the global error $u_i-u\left(t_i\right)$ is bounded below and above by the expression

$$c·\mathrm{TOL}\le \parallel u_i-u\left(t_i\right)\parallel \le C·\mathrm{TOL},$$

where the two constants satisfy $c/C\lesssim 1$. Note that this is a fairly rigorous requirement; we not only require that the local error is less than $\mathrm{TOL}$ but also that it is near $\mathrm{TOL}$. Thus, if $\mathrm{TOL}$ is increased or reduced by a small factor, the error must change accordingly, increasing or decreasing in proportion. This is also referred to as computational stability, as the computational algorithm is required to produce accurate approximations in the sense that the error stays near that of previous results. In the present context, we aim to investigate whether it is also possible to retain such properties in parallel integration.

2.3. Classical Recursive Controllers

In sequential computing, the conventional step-size selection scheme is of the form $h_{n+1}={\rho }_n·h_n$, i.e., the step-size sequence is generated recursively along the solution trajectory. Taking logarithms, we obtain a linear recursion,

$$log{h}_{n+1}=log{h}_n+log{\rho }_n,$$

(2)

i.e., we have a simple summation process, referred to as an integral (or I) control. The quantity being summed is the control error $log{\rho }_n$. In the simplest case, one takes

$${\rho }_n={\left({\displaystyle \frac{\parallel e_n\parallel }{\mathrm{TOL}}}\right)}^{1/p},$$

(3)

where $e_n$ is the local error estimate. This changes (2) into

$$log{h}_{n+1}=log{h}_n+{\displaystyle \frac{1}{p}}\left(log\parallel e_n\parallel -log\mathrm{TOL}\right),$$

where the deviation $log\parallel e_n\parallel -log\mathrm{TOL}$ is the control error. The step size keeps changing unless the control error is zero. Note that, in order to generate a smooth step-size sequence, we basically advocate changing the step size every step, no matter how small the change is. Thus, older schemes of step-size halving/doubling typically generate nonsmooth step-size sequences, although it may not be possible to avoid such sequences in connection with multigrid-type step-size refinement.

There are many more advanced alternatives to the elementary controller (3). Some more general recursive controllers have the form

$$h_{n+1}={\rho }_n^{{\beta }_0}{\rho }_{n-1}^{{\beta }_1}{\rho }_{n-2}^{{\beta }_2}·h_n,$$

(4)

where the ${\rho }_i$ is given by (3) and the coefficients ${\beta }_0,{\beta }_1,{\beta }_2$ can be chosen to improve both stability and regularity, notably by using techniques from digital filtering (see [6,7]). Depending on the resulting structure, the controllers may be referred to as proportional–integral (PI control) or proportional–integral–derivative (PID) control. An important aspect is being able to reduce the gain of the controller, as the elementary controller (3) is sometimes prone to generating oscillatory (nonsmooth) step-size sequences. There are also further possibilities that account for previous step-size sequences. The design of the controller should be matched to the type of method and the problem class. Thus, stiff integration can benefit from special implicit methods with dedicated time-step adaptivity.

In the present context, experiments are based on variants of (3) due to the special requirements associated with multigrid refinement.

3. Results

The adaptivity strategy described in [24] starts with an equidistant coarse time grid, which is further refined where necessary based on the error estimator during a given step. The refinement factor r is computed as the ratio of the current step size to the one suggested by the error estimator. Assuming that the step size–error relation is in the asymptotic regime, the refinement factor is constructed from the formula

$$r={\displaystyle \frac{h_n}{h_{n+1}}}=⌈{\left({\displaystyle \frac{\parallel e_n\parallel }{\mathrm{TOL}}}\right)}^{1/p}⌉,$$

(5)

where $e_n$ is the error estimate, $\mathrm{TOL}$ is the user-provided accuracy requirement, and p is the order of the error estimator of the Runge–Kutta method. The ceiling function is motivated by the fact that the subintervals can only be divided into an integer number of smaller subintervals. A schematic concept of the refinement factor r is shown in Figure 3.

The formula (5) without the ceiling function resembles the classical elementary I–controller (3) (cf. [4], Chapter II.4). Therefore, we would expect tolerance proportionality properties similar to those in sequential integration, reducing the losses at the interfaces of intervals with different refinement factors. The importance of smooth step-size sequences lies in the fact that the local errors can be equidistributed, a principle that is usually conducive to uniform global error behavior as a function of $\mathrm{TOL}$.

3.1. ODE Test Problems

The first test problem is the two-compartment dilution process:

$$\begin{array}{cc}\hfill y_1^{\prime }& =-{\displaystyle \frac{1}{5}}{y}_1\hfill \\ \hfill y_2^{\prime }& =-{\displaystyle \frac{2}{5}}(y_2-y_1)\hfill \end{array}$$

(6)

for $t\in [0,20]$, with the exact solution

$$\begin{array}{cc}\hfill y_1& =0.3e^{-0.2t}\hfill \\ \hfill y_2& =0.6(e^{-0.2t}-e^{-0.4t}).\hfill \end{array}$$

The initial values were chosen as the exact solution values at the first step. This linear problem is a standard test case with a known solution, making it ideal for assessing time-discretization accuracy and efficiency.

The second test problem is the classical nonlinear Lotka–Volterra equation:

$$\begin{array}{cc}\hfill y_1^{\prime }& =0.1y_1-0.3y_1{y}_2\hfill \\ \hfill y_2^{\prime }& =0.5(y_1-1)y_2\hfill \end{array}$$

(7)

for $t\in [0,62]$. The initial values were taken as $[1,1]$.

The third problem is the classical van der Pol equation:

$$\begin{array}{cc}\hfill y_1^{\prime }& =y_2\hfill \\ \hfill y_2^{\prime }& =\mu (1-y_1^2)y_2-y_1\hfill \end{array}$$

(8)

with $t\in [0,20]$. The initial values were $[2,0]$. This is also a classical nonlinear test problem because it transitions from nonstiff to stiff behavior as the parameter $\mu$ increases. We chose $\mu =2$ for the nonstiff computation.

3.2. Results for Refinement Factors r, $r_{mod}$, and $r_{exp}$

For the ODE test problems in Section 3.1, smooth step-size sequences produced tolerance proportionality in the sequential case. The MGRIT procedure, together with (5) from the open-source XBraid library [30], was used with the Bogacki–Shampine method to take into account its stability region.

The tolerance proportionality results can be seen in Figure 4, Figure 5 and Figure 6. In Figure 4, Figure 5 and Figure 6, we plot the step-size sequence for each test problem. A reasonable error tolerance proportionality is observed, as the step size on average scales in accordance with the specified error tolerance. At the finest tolerance, $\mathrm{TOL}={10}^{-11}$, the MGRIT-based step-size sequence is also close to that of the sequential integration for the same tolerance.

However, in every test case, a zigzag pattern appears in the step-size sequence, which contrasts with the smooth step-size sequence expected in classical sequential implementation theory [7]. This effect arises since the refinement factor is highly sensitive to small values due to the ceiling function. Pointwise tolerance proportionality therefore suffers, and it is unlikely that the overall method is as efficient as it could be, since local errors are far from equidistributed.

We therefore conclude that it is worth considering alternatives to (5). Thus, we define a modified refinement factor $r_{mod}$ as follows:

$$r_{mod}={\displaystyle \frac{h_n}{h_{n+1}}}=⌈{\left({\displaystyle \frac{\parallel e_n\parallel }{\mathrm{TOL}}}\right)}^{1/p}-c⌉.$$

(9)

Here, the compensating constant is taken as $c\in [0.2,0.4]$ in (9).

3.2.1. The Final Algorithm with $r_{\mathrm{mod}}$

Completing the adaptive MGRIT procedure with this essential modification and summarizing all steps, we apply the following algorithm:

(A1)

Set an initial temporal grid and an initial guess of the solution (see Figure 3).

(A2)

Apply a given Runge–Kutta method in parallel from these initial values, and use multigrid cycles to improve the current approximation of the solution (see Figure 2).

(A3)

Determine the refinement factor for each subinterval on the finest grid based on (9).

(A4)

IF no refinement occurred and the accuracy criterion is satisfied then STOP.

(A5)

ELSE go to Step 2.

For the tests, we used the embedded Runge–Kutta methods (described later) for time stepping and error estimation. We started on a uniform temporal grid and applied three V-cycles between two consecutive refinements. As shown in Figure 7, Figure 8 and Figure 9, the modified refinement largely suppressed the zigzag patterns, resulting in smoother step-size sequences and improved tolerance proportionality.

3.2.2. An Attempt with Exponential-Forgetting Filters

An alternative idea is to reduce the integral gain in (5) from 1 to, say, $2/3$, i.e., change the exponent from $1/p$ to $2/\left(3p\right)$ by constructing another modified refinement factor. As this corresponds to an exponential-forgetting filter, we denote this new refinement factor by $r_{exp}$. However, this does not result in a smoother step-size sequence, although it is well known to have such an effect in the sequential case. Again, this appears to be due to the ceiling function. The corresponding figures can be found in the GitHub repository [29].

3.2.3. Tolerance Proportionality for the Algorithm (A1)–(A5)

In connection with the concept of computational stability discussed in [28], the achieved accuracy is plotted versus $\mathrm{TOL}$. Ideally, a log–log plot would be expected to show a nearly straight line if the step-size sequence accurately tracks the local errors. This tolerance proportionality ensures that a reduction in $\mathrm{TOL}$ leads to a corresponding improvement in the achieved accuracy. This accuracy versus tolerance for the three different approaches is shown in Figure 10, Figure 11 and Figure 12.

Based on Figure 10, Figure 11 and Figure 12, the refinement factor $r_{mod}$ demonstrates the best computational stability while maintaining performance comparable to sequential computation. For sharp tolerances, the results are effectively identical. In contrast, the exponential-forgetting alternative $r_{exp}$ provides less benefit.

Based on Figure 4, Figure 5, Figure 6, Figure 7, Figure 8, Figure 9, Figure 10, Figure 11 and Figure 12, it is qualitatively clear that $r_{mod}$ is the best among the three discussed refinement factors. Naturally, one may ask whether the suppression of zigzag patterns is also beneficial in a quantitative sense. To investigate this, we compare the $r_{mod}$ refinement factor with the less zigzag-prone r refinement factor rather than with the more erratic $r_{exp}$. As shown in

Table 1. Number of time steps after the final refinement for different $\mathrm{TOL}$ values, using refinement factors r and $r_{mod}$, for the ODE test problems (6)–(8).

Problem	TOL	${10}^{-5}$	${10}^{-7}$	${10}^{-9}$	${10}^{-11}$	${10}^{-13}$
(6)	r	128	191	718	3997	$22,562$
	$r_{mod}$	128	169	620	2828	$13,076$
(7)	r	218	855	4237	$22,371$	$107,982$
	$r_{mod}$	184	754	3449	$15,963$	$74,047$
(8)	r	931	3777	$20,432$	$100,043$	$475,284$
	$r_{mod}$	773	3070	$14,090$	$65,258$	$302,692$

, $r_{mod}$ makes the step-size sequences smoother, improves tolerance proportionality, and significantly reduces computational cost.

3.3. PDE Test Problems and Related Results

For the three ODE test problems in Section 3.1, there was no significant difference in runtime between the sequential and MGRIT-based parallel-in-time algorithms using eight processors. However, a notable runtime advantage was observed in the case of partial differential equations (PDEs).

Our test problems for PDEs are special cases of one-dimensional, possibly nonlinear diffusion equations with Dirichlet boundary conditions. Specifically, we consider the following formulation:

$$\begin{array}{cc}\hfill {\partial }_{t}u(t,x)& ={\displaystyle \frac{1}{10}}{\partial }_{xx}\left(u^p(t,x)\right),x\in (0,1),t\in (0,5)\hfill \\ \hfill u(0,x)& =g\left(x\right),x\in (0,1)\hfill \\ \hfill u(t,0)& =g\left(0\right)\mathrm{and}u(t,1)=g\left(1\right),t\in [0,5],\hfill \end{array}$$

(10)

where $g\left(x\right)=10e^{-{(x-0.435576)}^2}-7.27185$. The linear case corresponds to $p=1$, while we take $p=2$ in the nonlinear case. Based on the ODE test results in Section 3.2, we only consider the modified refinement factor $r_{mod}$ using $c=0.4$. In space, we use the classical second-order central difference scheme. For time integration, we use a two-stage, stiffly accurate, L-stable, singly diagonally implicit Runge–Kutta method (see [31], Butcher tableau (221), with the choices $\gamma =(2-\sqrt{2})/2$ and ${\widehat{b}}_2=0$). When selecting the spatial and temporal step sizes, we make sure that the necessary CFL condition is satisfied, both for $p=1$ and $p=2$ in (10). The results related to the tolerance proportionality, achieved accuracy, and runtime can be seen in Figure 13.

Figure 13 demonstrates that both the linear and nonlinear diffusion Equation (10) show good tolerance proportionality and computational stability, as well as the expected qualitative behavior of achieved accuracy versus tolerance. In addition, the expected reduction in runtime due to parallelization is also observed.

4. Discussion

We summarize the main advantages of our proposed method and, for the sake of completeness, also highlight the limitations of the framework, which suggest interesting research directions in their own right.

4.1. Advantages

The computational results in Section 3 indicate that for MGRIT-based adaptive parallel-in-time Runge–Kutta methods, the relevant quality indicators necessary for computational stability are satisfied for the refinement factors $r_{mod}$ and r. As we have seen in the case of the PDE test problems in Section 3.3, these methods significantly outperform sequential methods in terms of computational cost beyond a certain number of processors. Furthermore, based on the qualitative results of the different ODE and PDE test problems, as well as the number of time steps in Table 1, the refinement factor $r_{mod}$ is the preferred approach both qualitatively and quantitatively. Therefore, the approach involving the refinement factor $r_{mod}$ provides a robust and reliable framework for users utilizing high-performance computing simulations.

4.2. Limitations

The first limitation is that, for each test problem, the MGRIT algorithm must be run with an appropriate initial subinterval partitioning to achieve computational stability. Figure 14 illustrates this phenomenon. This characteristic can be seen as analogous to the choice of the initial step size in sequential algorithms (see [4], Chapter II.4, and [32], Section 4.2).

The second limitation may be that our current results have provided satisfactory quality only for nonstiff (or at most mildly stiff) problems. This naturally suggests a research direction focusing on stiff problems. Due to their much larger variation in step sizes, they pose a more significant challenge. Based on the structure of MGRIT methods, it is clear that the analogy of PI- and PID-type controllers (4), which are commonly used in sequential algorithms (for details, see [7]), needs reconsideration in this setting. However, from this theoretical background, we also know that for stiff problems, PI controllers of a different parametrization are needed. An example of this can be seen in Figure 15, which illustrates the case of the stiff van der Pol Equation (8) with $\mu =30$ and initial value $[1.5,3]$ on the time interval $[0,10]$. Using heuristics, we were able to significantly improve the step-size sequence.

4.3. Future Research

A closer examination of the above-mentioned heuristic is needed to fully understand its role in connection with parallel-in-time methods. Based on our observations, we also conclude that by incorporating a stiffness indicator (for details, see [33] and [34], Chapter 21.3) as a measuring and switching mechanism, we may obtain better results for stiff problems in the current framework. Further research in this direction will lead to dedicated methods specifically designed for stiff problems.

All simulation figures (Figure 4, Figure 5, Figure 6, Figure 7, Figure 8, Figure 9, Figure 10, Figure 11, Figure 12, Figure 13, Figure 14 and Figure 15) in this work are fully reproducible using the files available in the GitHub repository [29].