Parallel-in-Time Integration
Parallel-in-time methods extract concurrency from the time direction, iterating across the whole time interval rather than marching strictly sequentially.
Breaking the sequential barrier
Time integration is naturally sequential: the state at one step depends on the previous one, so time marching cannot be parallelized directly. As spatial parallelism saturates on very large machines, this sequential time dimension becomes a bottleneck for long simulations. Parallel-in-time (PinT) methods add a new axis of concurrency by solving over the entire time interval iteratively, letting many processors work on different time slices at once.
The methods do not remove the sequential dependence entirely; instead they replace it with an iteration that converges to the sequential solution while exposing parallelism at each iterate.
The Parareal method
Parareal, the best-known PinT scheme, splits the time interval into slices and uses two propagators: a cheap, coarse integrator run sequentially to give a rough prediction across all slices, and an expensive, fine integrator run in parallel on each slice starting from the coarse prediction. A correction sweep updates the slice endpoints, and the process iterates. Speedup arises because the costly fine solves run concurrently while only the cheap coarse solve is sequential.
Limits and other schemes
Speedup is bounded by the ratio of coarse to fine cost and by the number of iterations to converge, which grows for advection-dominated and highly oscillatory problems where PinT struggles. Multigrid-in-time methods such as MGRIT generalize the idea to a full time-multigrid hierarchy, improving robustness. PinT is most effective for diffusive and parabolic problems.
- Adds concurrency along the time axis
- Parareal: coarse sequential predictor, fine parallel corrector
- Speedup limited by coarse/fine cost ratio and iteration count
- Effective for diffusive problems, harder for advection
As fusion simulations push toward long integrations on large machines, parallel-in-time methods offer a route to further scaling once spatial parallelism is exhausted.