Understanding how heat forms and moves inside nanoscale transistors requires more than conventional circuit-level models. An ab initio quantum transport simulation can resolve interactions between electrons and atomic vibrations, helping researchers examine device behavior at the scale where quantum and thermal effects matter. But the calculations are exceptionally demanding, and communication between processors can become as limiting as computation itself.
A data-centric redesign of a state-of-the-art solver addressed that bottleneck. By reorganizing how simulation data is distributed and moved, the team enabled self-consistent electro-thermal modeling of devices containing more than 10,000 atoms. The work offers a broader lesson for high-performance computing: at extreme scale, performance depends not only on faster processors, but also on structuring algorithms around data movement.
Why nanoscale devices need atomistic electro-thermal models
Fin field-effect transistors (FinFETs) are only nanometers wide and less than 100 nanometers in length. At these dimensions, device behavior is influenced by quantum mechanics and by heat generated during operation. When a voltage is applied between a transistor’s source and drain, electrons flow through the device. They can transfer energy to the surrounding crystal lattice, setting its atoms vibrating. These vibrations, known as phonons, carry heat through the material.
This self-heating, also called Joule heating, can affect transistor performance. Predicting where heat is generated and how it dissipates requires models that account for both electron and phonon transport. The study uses density functional theory (DFT) with the non-equilibrium Green’s function (NEGF) formalism. DFT provides an atom-level description without relying on empirical parameters, while NEGF models transport under non-equilibrium operating conditions.
The computational bottleneck: coupling physics across data
The solver calculates electron and phonon Green’s functions, mathematical quantities used to describe transport, and scattering self-energies that represent interactions between the two. These calculations are coupled: the electron and phonon results feed into one another, so the solver repeatedly updates them until the system converges. Depending on device geometry and operating bias, convergence can require 20 to 100 iterations.
Many individual Green’s function calculations can be performed independently for different energy and momentum points. The scattering calculations are more complicated because they connect those points. As the atom count and simulation resolution increase, processors must exchange large amounts of intermediate data. In the original approach, this communication could grow to petabytes per iteration for realistic transistor configurations, making larger simulations impractical even when substantial compute resources were available.
This distinction matters for system integrators and HPC users: distributing more work across nodes does not guarantee faster execution if the data required by that work must be repeatedly transferred across the network. Communication also consumes memory and can limit the ability to scale a workload efficiently.
How a data-centric redesign reduced communication
Instead of treating data movement as an implementation detail, the redesigned solver made it explicit. The team represented the computation as a dataflow graph, separating the mathematical operations from the movement of data between them. That representation made it possible to examine dependencies, reorganize work, and apply different data layouts without rewriting the underlying scientific computation.
A key change was the way scattering calculations were divided among processes. The original scheme organized much of the work around energy and momentum points. The data-centric version instead partitioned work by atom positions and energy ranges, then used collective data exchanges to provide each process with the information needed for its portion of the calculation.
Because interactions require neighboring atoms, a process may also need data for atoms outside its assigned subset. The revised scheme accounts for those neighboring values when distributing the workload. In the reported communication model, this approach reduced communication volume by as much as a factor of 136 compared with the original implementation. It also reduced the number of MPI communication calls in the scattering scheme to a constant number of collective operations.
The dataflow representation supported additional optimizations within each node:
- GPU-aware computation: The team mapped computations to GPUs and overlapped independent work using automatically generated CUDA streams.
- Matrix-operation optimization: Data layout and computation order were changed to make small matrix operations more efficient, including batching suitable multiplications.
- Mixed precision: Selected scattering calculations used lower-precision operations, while accumulation remained in double precision. The Green’s function calculations retained the precision needed to preserve accuracy.
- Input staging: Chunked distribution of material data reduced startup time on the tested Piz Daint system from around 30 minutes at full scale to under two minutes.
What the performance results demonstrate
The redesigned solver was evaluated on the Piz Daint and Summit supercomputers. On Summit, it sustained 85.45 petaflops per second in double precision across 4,560 nodes, using 27,360 GPUs, and reached 90.89 petaflops per second in mixed precision. These figures describe the reported application performance, not a general performance guarantee for other workloads or systems.
More important for device modeling, the solver handled a realistic structure containing 10,240 atoms with higher-resolution physical parameters than could be used in comparable runs of the original code. The reported results describe simulations with more than 10,000 atoms and a time-to-solution per atom improved by up to a factor of 140. The authors also reported that the restructured code could simulate a device more than ten times larger in atom count, with the same physical accuracy, in 14 times less time than the original code required for a 1,000-atom system on the same number of CPUs and GPUs.
Practical implications for simulation and HPC teams
For engineers working with computationally intensive models, the central takeaway is that the algorithm’s data dependencies deserve the same attention as its arithmetic. A data-centric view can reveal opportunities to reduce communication, improve data locality, and better match workloads to CPUs, GPUs, and interconnects. It can also help separate domain-level equations from platform-specific performance tuning, making optimization less dependent on changing the scientific code itself.
For semiconductor research, the immediate benefit is greater scope for atomistically resolved analysis of self-heating in realistic transistor structures. More detailed simulations can help investigate electro-thermal behavior that simpler models may not capture. The work does not remove the need for careful validation or system-specific tuning; rather, it demonstrates how reorganizing computation and communication can make a demanding physical model tractable at larger scales.
Conclusion
Ab initio quantum transport simulations place heavy demands on both compute capacity and data movement. By restructuring the solver around explicit dataflow and communication-aware workload distribution, the researchers significantly reduced communication and time-to-solution while scaling to devices with more than 10,000 atoms. For technical decision-makers, the practical lesson extends beyond transistor modeling: at extreme scale, efficient movement of data is a core part of the computational design.