Simulating how an absorbed photon's energy moves through a molecule means tracking electrons and vibrations together. These calculations run out of memory long before they run out of compute. One of the best current tools stores the joint quantum state as a matrix product state (MPS): a chain of small tensors, one per vibrational mode or electronic site, linked by indices whose size, the "bond dimension" $m$, sets the accuracy. Its time-evolution algorithm, time-dependent density matrix renormalization group (TD-DMRG), sweeps back and forth along that chain one site at a time. Large-language-model systems work has spent the last few years solving a structurally similar problem: models too big for GPU memory are kept in host RAM and streamed over the PCIe bus, and transfers are hidden behind computation.
We propose to build a TD-DMRG engine that keeps the whole MPS and its cached "environment" tensors in host RAM. It streams them to the GPU in sweep order. For each site, it decides whether to pin the tensor in GPU memory, stream it, or recompute it from a nearby checkpoint. This exploits a property LLM offloading lacks: the access order of a DMRG sweep is fully known in advance. Prefetching therefore never mispredicts, and offloading introduces no approximation. Results should match an in-memory run to floating-point round-off. The open question is purely one of timing, which we can model and test: does per-site compute, which grows with $m^3$, cover per-site transfer, which grows with $m^2$, on real hardware?
Core Claim
Exciton-phonon coupling supplies the workload and data-transfer latency supplies the method. The workload comes from N-Mode Quantized Anharmonic Vibronic Hamiltonians for Matrix Product State Dynamics, which runs nonadiabatic MPS dynamics in which vibrations and electrons stay coupled throughout. It reports convergence for a six-mode maleimide model at "a bond dimension of $m=75$ and a local Hilbert space of $N_{\text{max}}=20$." It also names memory, and the entanglement blow-up caused by poor site ordering, as the barriers to larger molecules.
The method comes from double-buffered chunk streaming in FPDT and from the transfer-versus-compute switching in Fiddler. Fiddler uses an analytic latency model to choose between moving weights and moving activations.
Our claim is that a per-site cost model, re-evaluated as bond dimensions grow during time evolution, can schedule pin, stream, and recompute decisions well enough to meet three targets:
- Exact TD-DMRG on a single GPU reaches bond dimensions several times larger than fit in its memory.
- Wall time per sweep stays within a small factor of an idealized in-memory run.
- Hardware with weak double-precision throughput is the most favourable case for hiding transfers, not the least.
The condition comes from comparing per-site compute and transfer times. Let $m$ be the local bond dimension, $d$ the local basis size ($N_{\text{max}}$), $D_W$ the bond dimension of the Hamiltonian written as a matrix product operator, $F$ the GPU's sustained floating-point rate, and $B$ the PCIe bandwidth. Moving one environment tensor costs about $16\,m^2 D_W$ bytes in complex double precision. Contracting it into the local update costs about $c\,m^3 d\,D_W$ flops for a small constant $c$. The transfer is therefore hidden when
$$ \frac{t_{\text{compute}}}{t_{\text{transfer}}} \approx \frac{c\, m\, d\, B}{16\, F} \ge 1 . $$
The ratio grows linearly in $m d$ because compute is cubic in $m$ and data is quadratic. It also falls as $F$ rises: a faster double-precision GPU needs a larger $m$ before overlap is complete. The reviewer worry in the file, that hiding works only when $T_{\text{compute}} \ge T_{\text{transfer}}$ (the sensitivity FPDT itself reports), thus becomes a threshold in $m d$ that depends on the hardware and can be measured. We fit $c$ empirically rather than assume it.
What Is New Relative to Prior Work
The vibronic-dynamics papers motivate the work but do not constrain the design. The n-mode MPS paper computes entirely in memory. Excited states of chromophores and vibronic interactions, with its EVspectrum code, avoids storing the Hamiltonian by computing its action on the fly over distributed MPI memory, but it must still hold the full state vector. Exciton–phonon information flow truncates its hierarchy of auxiliary density matrices heuristically and never measures memory or transfer cost. Driving enhanced exciton transfer by automatic differentiation borrows PyTorch from machine learning but only for toy networks that fit easily on one device. None of these papers treats data movement as the object of design.
The offloading papers supply techniques, and they also show which designs to avoid. PowerInfer, DynamicInfer, AdapMoE and SpeCache all depend on predicting which neurons, experts or cache entries will be active. AdapMoE reports roughly 90% prefetch accuracy, so mispredictions are a standing cost. These methods also accept small accuracy losses from sparsity.
We take neither path, deliberately. Quantum dynamics depends on exact phases (the vibration-assisted resonance effect hinges on matching an energy gap to a vibrational quantum). Dropping small amplitudes risks breaking that coherence and leaking norm. We therefore offload without pruning and without speculation. DMRG's fixed sweep order makes this possible, which no LLM workload offers.
DynamicInfer's "CPU anchor" result also constrains the design. There, 86% of the forward pass was spent waiting on host threads. Following that warning, the CPU only stores tensors in our design; it never computes on them.
The piece neither literature contains is the third option, recompute, which is the DMRG analogue of activation checkpointing. Left environments are rebuilt anyway as a sweep moves right. Right environments, built during the previous sweep, must either be fetched or regenerated from a stored checkpoint a few sites ahead. When PCIe is the bottleneck, spending spare GPU compute to regenerate a tensor beats waiting for it.
Research Program
We will build the engine on a GPU tensor library with pinned host buffers and two asynchronous copy streams, one for prefetch and one for write-back. Each host-RAM tensor is in one of three states: pinned on the GPU, streamed, or checkpointed so it can be recomputed.
Before each sweep, a planner reads the current bond dimensions along the chain and evaluates the cost model at each site. It then solves a small scheduling problem: minimize predicted stall time subject to the GPU memory budget. The model is the display equation above, extended with SVD cost and recompute cost, and its constants are fitted from one profiling sweep. Bond dimensions grow during dynamics, so the plan is re-solved every sweep. This adaptivity mirrors DynamicInfer's case against static profiling, but our trigger is a known quantity rather than a learned predictor.
We will then add the one physics-side lever the planner can pull: the order in which modes are placed along the chain. The n-mode paper notes that ordering drives entanglement growth. We will test whether ordering by mode mutual information also yields smoother bond-dimension profiles that are easier to schedule. This part is exploratory and secondary.
Baselines
The naive reference is the same TD-DMRG code run entirely in GPU memory, on the problem sizes where that fits. This reference gives the ideal time per sweep and the exact observables every other configuration must reproduce. Beyond that size, it fails with an out-of-memory error; recording where that happens defines the memory wall.
The strongest existing practical competitor is a CPU-only TD-DMRG run in large host RAM with multithreaded linear algebra. This is what a practitioner without a large GPU would actually do, it has no transfer cost at all, and the n-mode MPS work operates in this in-memory style. We will give it the same machine and all cores, and use a tuned linear-algebra library. No reported wall-clock or throughput result for TD-DMRG appears on Lacuna, so this baseline must be measured by us. The only reported reference point is the convergence setting ($m=75$, $N_{\text{max}}=20$ for maleimide), which fixes the accuracy target. Beating this baseline means at least a 3× lower time per sweep at matched $m$, with observables agreeing to round-off.
The systems baseline is CUDA unified memory, where the driver pages tensors to and from host RAM on demand, using the same kernels. It is the zero-engineering way to exceed GPU memory, and it is the closest competitor to our design.
Two ablations isolate the key ingredient. The first is uniform FPDT-style double buffering: always stream the next site, never pin or recompute. The second is our planner with recompute disabled. Beating these means a measurable cut in GPU idle fraction at bond dimensions where the cost-model ratio is near or below one. All configurations use identical kernels, precision, time step, truncation threshold, and GPU memory budget, and get one tuning pass each.
Why not just…?
Why not just use unified memory and let the driver page? This is the real threat. A sweep's access pattern is sequential, which is the case on-demand paging handles best. However, the driver fetches a page only on first touch, with no knowledge that the next site's tensors are needed now. Under memory pressure it also evicts by recency, which is exactly wrong for a sweep that is about to reverse direction. We expect visible stalls at each site boundary. If unified memory instead comes within 20% of our planner, we will say so, and the contribution narrows to the cost model and the recompute option.
Why not just run on the CPU with lots of RAM? This works and is what people do today. The file's evidence that single-GPU offloading pays off is indirect: PowerInfer reports that an RTX 4090 reached 82% of an A100's token rate on OPT-30B. Our experiment measures directly whether GPU contraction throughput, minus stalls, beats a full CPU node at $m$ in the hundreds.
Why not just scale across several GPUs, or go matrix-free? The matrix-free EVspectrum approach still has to store the full state vector. Distributing a strictly sequential sweep across GPUs gives little parallelism within a single sweep. FPDT's experience, longer contexts on 4 A100s via host offloading, suggests that offloading competes well with simply adding devices. We treat multi-GPU MPI as complementary and do not benchmark against it.
Why not just quantize the tensors or lower $m$? SpeCache found that aggressive low-bit storage loses precise information. It kept full precision for the primary data and used low-bit copies only as a guide for what to fetch. Phase-sensitive dynamics is likely even less tolerant. We will report one single-precision (FP32) control run to quantify this, but the engine's premise is that it changes no numbers.
Proposed Experiments
Correctness comes first. On maleimide, the six-mode model with $N_{\text{max}}=20$ is run at $m=10$, at $m=75$, and beyond. Offloaded and in-memory runs must yield identical autocorrelation functions and absorption spectra to round-off.
Scaling tests follow on larger chains built with the same n-mode construction. These include maleimide models with more modes, and a three-site FMO-like excitonic model with explicit resonant vibrational modes as in the vibration-assisted resonance study. Bond dimension is pushed until each baseline fails or slows sharply. Metrics are time per sweep, GPU idle fraction, PCIe bytes moved, peak GPU memory, and the largest $m$ reachable under a 24 GB budget.
The decisive check is whether the measured overlap ratio at each site follows the linear-in-$m d$ prediction across two GPUs with very different double-precision rates. If the slower-FP64 card hides transfers at a smaller $m$, as the model predicts, the cost model is validated as the right abstraction. If it does not, the planner's premise fails and we will report that.
References
- N-Mode Quantized Anharmonic Vibronic Hamiltonians for Matrix Product State Dynamics
- Training Ultra Long Context Language Model with Fully Pipelined Distributed Transformer
- Fiddler: CPU-GPU Orchestration for Fast Inference of Mixture-of-Experts Models
- Excited states of chromophores and vibronic interactions
- Communication: Exciton–phonon information flow in the energy transfer process of photosynthetic complexes
- Driving enhanced exciton transfer by automatic differentiation
- PowerInfer: Fast Large Language Model Serving with a Consumer-grade GPU
- DynamicInfer: Runtime-Aware Sparse Offloading for LLMs Inference on a Consumer-Grade GPU
- AdapMoE: Adaptive Sensitivity-based Expert Gating and Management for Efficient MoE Inference
- SpeCache: Speculative Key-Value Caching for Efficient Generation of LLMs
- Vibration-assisted resonance in photosynthetic excitation-energy transfer