Benchmarking CPU, GPU, and ML Power-Flow Solvers from 14 to 70,000 Buses

This paper examines whether machine-learning (ML) surrogates accelerate AC power-flow computation relative to well-parallelized CPU solvers and modern batched GPU physics solvers, rather than a single CPU baseline. Power-flow computation determines bus voltages consistent with specified generation, demand, and network parameters, supporting grid operations and training-data generation. The authors argue that baseline selection can reverse conclusions about ML’s usefulness: throughput across the seven CPU implementations tested varies by approximately 2.5–3 orders of magnitude. The benchmark covers 15 grids ranging from 14 to 70,000 buses and compares seven CPU-based Newton–Raphson solvers, two GPU-based physics solvers, and three published graph-neural-network (GNN) surrogates: PowerFlowNet, Graph Neural Solver, and CANOS-PF. The authors also introduce gpusim2grid, which uses CUDA and NVIDIA’s cuDSS sparse solver to execute batched Newton–Raphson iterations entirely on the GPU. By exploiting shared sparsity patterns across scenarios, it avoids CPU–GPU transfers during iterative computation. To verify that the implementations solve the same equations, the authors independently construct a common Kirchhoff’s current law mismatch evaluator and configure the solvers to align network representations and modeling assumptions. Accuracy validation uses 9,000 identical sampled scenarios per grid, with a target tolerance of 10⁻⁸. Five iterations of gpusim2grid achieve a mean mismatch of 8.91 × 10⁻¹⁴ and a worst-case mismatch of 2.31 × 10⁻¹⁰, both comfortably below the tolerance. Four iterations are insufficient, yielding a worst-case mismatch of 1.16 × 10⁻⁴. The pandapower reference achieves a mean mismatch of 5.61 × 10⁻¹¹. Solver robustness nevertheless varies: PowerModels reports 78.57% convergence across its tested grids, while Power Grid Model succeeds only on smaller grids. Throughput experiments vary generation and demand while keeping network topology fixed and optimizing CPU worker counts and GPU batch sizes. Measurements include input updates and CPU–GPU data transfers but exclude initialization, compilation, and disk loading. The CPU experiments comprise approximately 630 million power-flow solves and 4,700 CPU-hours. On the primary benchmark machine, lightsim2grid is the fastest CPU implementation, Graph Neural Solver is the fastest tested ML surrogate, and gpusim2grid is the fastest GPU physics solver. CPU parallelization provides an average speedup of approximately 16-fold over single-core execution. Although the fastest surrogate outperforms a single core of the fastest CPU baseline, it does not outperform the fully parallelized CPU solver. Overall, gpusim2grid and parallelized lightsim2grid match or exceed the tested surrogates’ throughput, with comparable throughput on the largest grids. A separate accuracy comparison uses the IEEE-118 PF-Delta datasets and published GENCO Base results. Under normal operating conditions, mean power-balance loss is 0.0027 for GENCO, compared with 1.1 × 10⁻⁶ for pandapower and 4.9 × 10⁻¹⁴ for gpusim2grid. Physics solvers also substantially outperform GENCO under single and double contingencies. Near-infeasible cases are more challenging, and pandapower’s average is strongly affected by three nonconverging samples. The authors conclude that the tested GNN surrogates have not yet demonstrated a compelling speed–accuracy advantage for standard power-flow computation. This conclusion does not rule out ML benefits in optimization, state estimation, or control. Study limitations include synthetic scenarios, limited hardware coverage, best-observed timings without repeated-run statistics, and the application of unchanged surrogate architectures to grids beyond their training sizes. The GPU implementation is CUDA-only, and occasional cuDSS-related numerical failures have been reported. The findings therefore support broader, carefully matched benchmarking rather than a universal ranking of solvers or a rejection of learned methods.

Can Machine Learning Really Speed Up Power-Flow Computation?

Machine learning promises faster answers to many engineering problems. But speed depends on what you compare it with. A model that beats a single CPU core may look less impressive against a carefully parallelized solver or a physics-based algorithm running on a GPU.

That is the central question in “Benchmarking CPU, GPU, and ML Power-Flow Solvers from 14 to 70,000 Buses,” by Benjamin Donnot, Sami Tazi, Eva Boguslawski, and Nourredine Henka. Their study finds that the tested machine-learning surrogates do not establish a compelling speed–accuracy advantage over well-optimized conventional solvers. More broadly, it shows why choosing the right baseline can change a research conclusion.

Why Power Flow Matters

Power-flow computation determines the bus voltages consistent with a grid’s generation, electricity demand, and network parameters. These calculations support grid operations and generate training data for machine-learning systems. When many scenarios must be evaluated, throughput—the number of cases solved in a given time—becomes important.

Traditional solvers calculate solutions from the network’s physical equations, often using Newton–Raphson iterations. Learned surrogates instead approximate the relationship between inputs and solutions. Their appeal is straightforward: after training, prediction could be faster than repeatedly solving those equations. The challenge is delivering that speed without sacrificing accuracy.

A Benchmark That Looks Beyond One CPU Core

The researchers compare 15 grids ranging from 14 to 70,000 buses. Their benchmark includes seven CPU-based Newton–Raphson implementations, two GPU-based physics solvers, and three published graph-neural-network surrogates: PowerFlowNet, Graph Neural Solver, and CANOS-PF.

The choice of CPU implementation alone makes an enormous difference. Throughput across the seven implementations varies by approximately 2.5 to 3 orders of magnitude. Comparing a learned model with a slow baseline could therefore suggest an advantage that disappears against stronger software.

The experiments vary generation and demand while keeping network topology fixed. CPU worker counts and GPU batch sizes are optimized. Measurements include input updates and CPU–GPU transfers, but exclude initialization, compilation, and disk loading. The CPU experiments involve approximately 630 million power-flow solves and 4,700 CPU-hours.

Bringing Newton–Raphson Fully onto the GPU

The authors introduce gpusim2grid, a physics-based solver using CUDA and NVIDIA’s cuDSS sparse solver. It executes batched Newton–Raphson iterations entirely on the GPU.

Its design exploits shared sparsity patterns across scenarios: with topology fixed, the underlying network calculations retain a common structure. Keeping iterative computation on the GPU avoids repeated CPU–GPU transfers during those iterations. The approach demonstrates that modern hardware can accelerate conventional physics calculations, not just learned predictions.

Checking That Everyone Solves the Same Problem

Timing results mean little if implementations use different network assumptions or accept different errors. To address this, the researchers align modeling choices and independently construct a common Kirchhoff’s current law mismatch evaluator.

Accuracy validation uses 9,000 identical sampled scenarios per grid and a target tolerance of 10⁻⁸. Five gpusim2grid iterations achieve a mean mismatch of 8.91 × 10⁻¹⁴ and a worst-case mismatch of 2.31 × 10⁻¹⁰, both below the tolerance. Four iterations are insufficient, producing a worst-case mismatch of 1.16 × 10⁻⁴. The pandapower reference achieves a mean mismatch of 5.61 × 10⁻¹¹.

Robustness also varies across implementations. PowerModels reports 78.57% convergence across its tested grids, while Power Grid Model succeeds only on smaller grids. Speed is therefore only one part of solver performance.

What the Speed and Accuracy Results Show

On the primary benchmark machine, lightsim2grid is the fastest CPU implementation, Graph Neural Solver is the fastest tested surrogate, and gpusim2grid is the fastest GPU physics solver. CPU parallelization provides an average speedup of approximately 16-fold over single-core execution.

The fastest surrogate beats a single core of the fastest CPU baseline, but not the fully parallelized CPU solver. Overall, gpusim2grid and parallelized lightsim2grid match or exceed the tested surrogates’ throughput, with comparable throughput on the largest grids.

A separate accuracy comparison uses IEEE-118 PF-Delta datasets and published GENCO Base results. Under normal operating conditions, mean power-balance loss is 0.0027 for GENCO, compared with 1.1 × 10⁻⁶ for pandapower and 4.9 × 10⁻¹⁴ for gpusim2grid. Physics solvers also substantially outperform GENCO under single and double contingencies. Near-infeasible cases are harder, and three nonconverging samples strongly affect pandapower’s average.

A Call for Better Comparisons, Not an End to ML

The findings have boundaries. The study uses synthetic scenarios and limited hardware, reports best-observed timings without repeated-run statistics, and applies unchanged surrogate architectures to grids beyond their training sizes. The GPU implementation is CUDA-only, and occasional cuDSS-related numerical failures have been reported.

The conclusion is therefore specific: these tested GNN surrogates have not yet demonstrated a compelling advantage for standard power-flow computation. That does not rule out machine-learning benefits in optimization, state estimation, or control. The lasting lesson is methodological: credible acceleration claims require strong baselines, matched accuracy, and careful accounting of the work being timed.