TL;DR
QiankunNet-cuSCI is a fully GPU-accelerated framework that eliminates the severe CPU-GPU bottlenecks plaguing state-of-the-art quantum chemistry simulations. By migrating configuration generation and global deduplication entirely to GPUs and introducing a memory-centric runtime, it achieves up to a $2.32\times$ end-to-end speedup and maintains over 90% parallel efficiency at scale.
What Problem Does This Paper Address?
Accurately solving the Schrödinger equation for complex many-body quantum systems is one of the holy grails of computational chemistry, but it is notoriously difficult due to exponential computational complexity. Recently, combining Neural Network Quantum States (NNQS) with Selected Configuration Interaction (SCI) methods has emerged as a powerful approach to tackle this challenge with high accuracy.
However, existing state-of-the-art frameworks suffer from an architectural imbalance. While the AI inference part scales efficiently on GPUs, the non-AI components—specifically, generating coupled electronic configurations and performing global deduplication to remove redundant states—remain bottlenecked on the CPU. As the number of GPUs increases, the CPU spends too much time managing data and communicating across nodes, leaving powerful GPUs underutilized and capping the size of chemical systems that can be simulated.
Methods
The authors introduce QiankunNet-cuSCI, a framework designed to keep the entire SCI workflow resident on the GPU.
The framework introduces three core system-level innovations:
- Fine-Grained CUDA Kernels for Configuration Generation: Instead of relying on the CPU to evaluate Slater-Condon rules (which determine non-zero matrix elements), the authors co-designed a compressed data layout called Excitation Tables. This layout reduces the memory footprint of the Hamiltonian matrix by 15 orders of magnitude, allowing custom CUDA kernels to perform massive, independent bitwise operations directly on the GPU.
- Distributed Sort-Based Deduplication: To eliminate inter-node redundancy without a centralized CPU bottleneck, the framework uses a distributed, sort-based regular sampling algorithm. It leverages GPU-optimized Radix Sort and deterministic sampling to ensure a perfectly load-balanced data exchange across multiple GPUs.
- GPU Memory-Centric Execution Model: Fully accelerating the pipeline exposes a "memory wall," as intermediate configurations can easily exceed a single GPU's VRAM. The authors implement a macro-pipeline that processes data in streaming mini-batches and uses asynchronous double-buffering to overlap compute with host-to-device (H2D/D2H) data transfers.
Datasets
The framework was evaluated across a diverse set of chemical systems categorized by their qubit counts:
- Small-scale ($\le 30$ qubits): $\text{C}_2$, $\text{N}_2$ (under minimal STO-3G basis sets), $\text{LiH}$, $\text{LiF}$, $\text{LiCl}$, and $\text{Li}_2\text{O}$. These were verified against exact Full Configuration Interaction (FCI) benchmarks from the PySCF library.
- Medium-scale ($30 \sim 64$ qubits): $\text{C}_2\text{H}_4\text{O}$, $\text{H}_2\text{O}$, and larger basis set (cc-pVDZ) variants of $\text{C}_2$ and $\text{N}_2$.
- Large-scale (84 qubits): The Chromium dimer ($\text{Cr}_2$), a heavily correlated system used to stress-test the framework at scale.
Key Insights and Ideas
- The Sorting vs. Hashing Insight: Quantum configuration data consists of dense integers (bitmasks). While hash-based deduplication causes severe thread divergence and atomic collision penalties on GPUs, sort-based methods (like Radix Sort) are exceptionally well-suited for parallel GPU architectures.
- Super-Linear Weak Scaling: In weak scaling tests, the authors observed a surprising parallel efficiency of up to 163.7%. This happens because as the problem scales across more nodes, the global redundancy rate increases dramatically (over 66% at 64 GPUs). Because the distributed deduplication algorithm eliminates this redundancy early, the actual computational workload per GPU in the expensive AI inference stage decreases as more nodes are added.
Key Results
- End-to-End Speedups: On a cluster of 64 NVIDIA A100 GPUs, QiankunNet-cuSCI achieved an end-to-end speedup of $1.88\times$ for the $\text{Cr}_2$ system and $2.32\times$ for the $\text{N}_2$ system compared to the highly optimized CPU-GPU baseline.
- Kernel Acceleration: The custom GPU configuration generation kernel achieved up to a $432\times$ speedup over a 128-core CPU implementation.
- Scalability: The framework maintained over 90% parallel efficiency in strong scaling tests up to 64 GPUs.
- Memory Wall Broken: For the $\text{C}_2\text{H}_4\text{O}$ system, the theoretical peak memory required was 70 GB (which would cause an Out-Of-Memory error on a 40GB A100). The memory-centric runtime successfully capped the measured peak at 37.5 GB without stalling the execution pipeline.
Limitations and Future Work
While QiankunNet-cuSCI successfully shifts the primary performance bottleneck back to on-device AI inference, the authors note that intermediate data structures still exert significant memory pressure. Future work will focus on developing even more sophisticated memory management strategies to compress these structures. Additionally, they plan to explore advanced network communication methods to further minimize latency when scaling to ultra-large clusters beyond 64 GPUs.
Summary updated