Efficient physics-based software matched or exceeded the throughput of three machine-learning surrogates in a new benchmark of electrical power-flow calculations. It also produced substantially smaller errors against the grid’s physical constraints. The result turns attention to a basic choice in any speed claim: which conventional implementation serves as the comparison.[1]
Benjamin Donnot and colleagues compared seven CPU solvers, two GPU physics solvers and three published machine-learning surrogates across 15 networks containing 14 to 70,000 buses, or electrical connection points. Their findings appear in an October 2026 preprint, with benchmark code available publicly.[1]
First, know what problem is being solved
An AC power-flow calculation takes a network and its generation and load conditions, then determines voltages and power flows consistent with the electrical equations. A learned surrogate estimates that relationship from training data; a numerical solver works directly with the constraints. Evaluating both speed and physical error shows whether faster answers meet the application’s requirements.[1]
The researchers checked outputs against Kirchhoff’s current law, which requires current to balance at each network connection. This independently measured residual avoids making agreement with one reference program the sole test of correctness.[1]
What the benchmark actually compared
| Class | Number tested | Key question |
|---|---|---|
| CPU physics solvers | 7 | Does a strong baseline change the speed claim? |
| GPU physics solvers | 2 | Can batched numerical equations run efficiently? |
| ML surrogates | 3 | How do throughput and physical residuals compare? |
The hidden variable was the baseline itself
The seven CPU implementations differed in throughput by about 2.5–3 orders of magnitude on identical inputs—approximately 316–1,000 times. A surrogate can therefore look faster than one conventional solver while losing that advantage against another. The range makes baseline selection part of the result, rather than an incidental detail.[1]
The team’s batched GPU solver, gpusim2grid, also takes advantage of parallel processing. In the reported comparisons, sufficiently parallelised CPU computation or GPU physics matched or exceeded the tested learned surrogates’ throughput while producing errors orders of magnitude smaller.[1]
The task here is power flow, which calculates the state resulting from a proposed operating condition. Optimal power flow adds decisions, such as generator dispatch, to find a preferred state under constraints. The benchmark’s conclusions concern the first task; optimisation, control and demand forecasting require separate comparisons.[1]
A speed result needs an accuracy requirement
The preprint covers selected implementations, hardware and operating cases. Its practical use is to compare throughput at an acceptable physical-error threshold, including the effects of batching. A method suitable for approximate screening may face a different threshold from one used to establish a network’s operating state.[1]
For grid-software teams, the immediate implication is concrete: include efficient parallel physics implementations before deciding that a learned approximation buys useful speed. The public benchmark provides a way to make that comparison reproducible.[1]
Sources & further reading
- Benchmarking CPU, GPU, and ML Power-Flow Solvers from 14 to 70,000 Buses Benjamin Donnot and colleagues, arXiv preprint · Accessed 24 Oct 2026
- gpusim2grid code and benchmark Grid2op GitHub repository · Accessed 24 Oct 2026