Dynasor: Multi-Domain High-Performance Systems

• Dynasor is a collection of high-performance systems spanning molecular dynamics correlation, LLM inference scheduling, and sparse tensor decomposition.
• It leverages specialized methodologies like Fourier-based correlation analyses, entropy-based reasoning metrics, and optimized memory layouts.
• Each variant demonstrates significant efficiency and throughput improvements, validated by real-world case studies and experimental comparisons.

Dynasor refers to several distinct, high-performance systems and software packages developed for advanced scientific workloads, including atomistic simulation analysis, LLM reasoning-aware serving, and tensor computation. Despite sharing a name, each instantiation targets fundamentally different research domains—molecular dynamics correlation function extraction, LLM inference scheduling, or sparse tensor decomposition—yet all demonstrate domain-leading architectural concepts and optimized implementations. This article systematically reviews the three principal Dynasor systems documented in the research literature.

1. Dynasor for Molecular Dynamics: Correlation Functions and Scattering Analysis

The original and most widely adopted Dynasor is a computational framework for extracting time- and space-dependent correlation functions from molecular dynamics (MD) simulation trajectories. Developed as an open-source Python package with a high-performance C backend, Dynasor enables quantitative comparison of atomistic simulations with experimental scattering observables (X-ray, neutron, electron) and provides a comprehensive post-processing suite for materials modeling (Fransson et al., 2020, Berger et al., 27 Mar 2025).

Mathematical Formalism

Key quantities computed by Dynasor include the static and dynamic structure factors, intermediate scattering functions, current correlation functions, and their probe-specific weighted counterparts. For a system of $N$ atoms with positions $\mathbf{r}_i(t)$, the principal formulas are:

• Instantaneous particle density (Fourier space):

$$n(\mathbf{q},t) = \sum_{i=1}^N e^{i \mathbf{q} \cdot \mathbf{r}_i(t)}$$

• Intermediate scattering function:

$$F(\mathbf{q}, t) = \frac{1}{N} \langle n(\mathbf{q}, t) n(-\mathbf{q}, 0) \rangle$$

• Static and dynamic structure factors:

$$S(\mathbf{q}) = F(\mathbf{q}, 0), \quad S(\mathbf{q}, \omega) = \int_{-\infty}^\infty F(\mathbf{q}, t) e^{-i \omega t} dt$$

• Current correlation functions:

$$C_{L/T}(\mathbf{q}, t) = \frac{1}{N} \langle \mathbf{j}_{L/T}(\mathbf{q}, t) \cdot \mathbf{j}_{L/T}(-\mathbf{q}, 0) \rangle,$$

where longitudinal and transverse microscopic currents are defined via projection onto and orthogonal to $\mathbf{q}$.

• Probe-specific dynamic structure factor:

$$S_{\mathrm{probe}}(\mathbf{q}, \omega) = \sum_{\alpha,\beta} w_\alpha(\mathbf{q}) w_\beta(\mathbf{q}) S_{\alpha\beta}(\mathbf{q},\omega),$$

with atomic form factors or scattering lengths used as weights for X-ray, electron, or neutron contrast (Berger et al., 27 Mar 2025).

Additional methods include spectral energy density (SED) mapping for phonon dispersion, and phonon mode-projection via harmonic eigenvector decomposition.

Algorithmic and Implementation Aspects

• Software stack: Layered C (OpenMP/OpenACC) and Python interface, supporting LAMMPS, GROMACS, NAMD, and a wide range of trajectory formats via ASE/MDAnalysis (Berger et al., 27 Mar 2025).
• Computational kernels: $O(N_\text{atoms} \times N_q \times N_t)$ scaling for density/current computations; parallelized array operations.
• Numerical methods: Time-correlation accumulation with sliding-window averaging; Filon’s rule for Fourier transforms of non-uniformly sampled data; Fermi–Dirac and other windowing techniques.
• Phonon analysis: Damped harmonic oscillator fitting in both time and frequency domains for extraction of phonon frequencies and lifetimes.

Key Capabilities and Extensions

• Support for direct comparison between simulation and scattering experiments (e.g., via form-factor application).
• Multi-component partial correlation extraction (including custom charge/mass weights).
• Mode projection onto arbitrary phonon eigenmodes, with automated DHO analysis.
• Extensible API for new trajectory formats and custom correlation function modules.

Representative Case Studies

• Ni$_3$Al alloys: Raw vs. X-ray weighted $S(q)$ matching powder XRD; partial $S_{\alpha\beta}(q)$ capturing elemental ordering.
• Oxide perovskites: Electron-weighted $S(\mathbf{q})$ for diffuse scattering; phonon mode autocorrelations reveal overdamped tilt dynamics.
• Halide perovskites: X-ray and neutron weighted $S(q)$ tracking structural transitions and inelastic contrasts (Berger et al., 27 Mar 2025).

Significance arises from Dynasor's ability to produce observables that match experimental data and to provide atomistic-level dynamic insight, bridging first-principles simulation and experimental measurement (Fransson et al., 2020, Berger et al., 27 Mar 2025).

2. Dynasor for LLM Serving: Reasoning-Aware Scheduling and Certaindex

Dynasor also denotes a reasoning-aware, high-throughput LLM serving system that integrates algorithmic control over test-time reasoning workloads—including Self-Consistency (SC), Monte Carlo Tree Search (MCTS), and Internalized Chain-of-Thought (ICoT)—while optimizing accuracy, compute cost, and service latency (Fu et al., 2024).

Layered System Architecture

• Reasoning Program Abstraction: User-defined programs implement execute(knob) (e.g., generate k reasoning chains) and update_certaindex() (compute certainty signal).
• Application Runtime: Intra-program scheduler that dynamically chooses the size of the next compute allocation or decides to early-exit based on the certainty metric.
• System Runtime: Inter-program scheduler orchestrates batch (gang) scheduling, approximate shortest-job-first ordering, starvation prevention, cache management, and GPU backend execution.

Certaindex: Statistical Proxy for Answer Stability

Dynasor introduces the certaindex, an algorithm-agnostic, lightweight certainty metric, calculated as:

• Entropy-based: For SC/Rebase, cluster $n$ output paths into $m$ groups $C_i$, define empirical entropy

$$\mathcal{H} = -\sum_{i=1}^m \frac{|C_i|}{n} \log\left(\frac{|C_i|}{n}\right)$$

and certainty

$$\tilde{\mathcal{H}} = 1 - \frac{\mathcal{H}}{\log n}$$

• Reward-based: For MCTS, take the mean (or max in Rebase) reward over all paths.

High certaindex values indicate stabilization of reasoning outcomes, serving as the basis for dynamic resource reallocation or early termination.

Scheduler Mechanisms

• Intra-program: Adaptive scaling of reasoning iterations/branches, terminating when certaindex exceeds threshold $\tau$.
• Inter-program: Batch all requests for each reasoning program (gang scheduling), prioritize programs by remaining work (approximate shortest-job-first), ensure deadline fairness.

Performance and Impact

• Achieves up to 50% compute reduction and 3.3× throughput increase in real workloads, with no loss in accuracy (Fu et al., 2024).
• Gang scheduling reduces mean latency by 20–30%; intra-program dynamic allocation achieves up to 60% latency reduction in self-consistency tasks.
• Integrates with vLLM, SGLang, TensorRT; supports multi-tenant GPU clusters; leverages prefix KV-cache sharing and CUDA Graph optimizations.

This architecture enables reasoning-aware early exits and dynamic scaling, substantially improving LLM inference efficiency and service-level objective attainment.

3. Dynasor for Sparse Tensor Decomposition: Dynamic Memory Layout (FLYCOO) and spMTTKRP Acceleration

A third system, Dynasor, targets sparse tensor decomposition—specifically, the acceleration of the Sparse Matricized Tensor-Times-Khatri-Rao Product (spMTTKRP) on multi-core CPUs (Wijeratne et al., 2023). spMTTKRP dominates the cost in CP-ALS algorithms for multiway data analysis.

FLYCOO Memory Layout

• Super-shards and shards: Nonzeros partitioned by each mode into super-shards (grouped by index intervals) and within these, into shards (contiguous blocks).
• Per-nonzero metadata: Each nonzero is indexed both by original tensor coordinates and by its location in each mode's shard partition.
• Double-buffering and remapping: After each mode's spMTTKRP operation, nonzeros are dynamically remapped into shard-aligned buffers for the next mode, enabling mode-wise sweeps without global tensor reordering.

Parallel and Lock-Free Algorithm

• Static super-shard scheduling: Assigns super-shards to threads to minimize load imbalance, achieving at most a $4/3$-factor over optimal maximum per-thread load.
• Lock-free concurrency: Each thread exclusively updates a disjoint set of output rows in the factor matrices, eliminating the need for atomic synchronization.

Complexity and Performance

• Arithmetic intensity: $O(R)$ flops and memory operations per nonzero; dynamic remapping overhead amortized.
• Memory efficiency: $O(|T| + R \sum_n I_n)$ overall memory footprint, allowing the algorithm to succeed in limited-memory environments where competing methods fail.
• Empirical scaling: On 56-thread Xeon platforms, achieves $2.1\times$–$9.0\times$ speedup over leading implementations (ALTO, HiCOO, STeF) with geometric mean $6.37\times$ improvement; robust to increased rank and memory-constrained scenarios.

This system is notable for the co-design of memory layout (FLYCOO), perfectly balanced static sharding, and mode-to-mode remapping to eliminate both contention and global memory reshuffles (Wijeratne et al., 2023).

4. Comparative Table: Major Dynasor Systems

Domain	Target Problem	Key Innovations
MD Correlation	Extraction of $S(\mathbf{q},\omega)$, $C(\mathbf{q},\omega)$	Probe-aware weighting, SED, phonon mode projection
LLM Serving	Reasoning-aware scheduling, SC/MCTS	Certaindex metric, gang scheduling, dynamic scaling
Tensor Decomposition	Accelerated spMTTKRP on CPU	FLYCOO, static super-shard assignment, remapping

5. Significance and Future Directions

The multiplicity of Dynasor systems across scientific computing domains underscores the convergence of advanced data layouts, scheduling techniques, and physics-inspired statistical proxies to accelerate both simulation analysis and AI inference. Each implementation demonstrates that co-design of data/compute abstractions with workload-specific numerical analysis can yield orders-of-magnitude improvements in measurable throughput, efficiency, and interpretability.

Each variant continues to evolve: Dynasor 2 for MD is actively updated for improved experimental concordance and richer correlation function analysis (Berger et al., 27 Mar 2025); the LLM-serving Dynasor integrates new scheduling policies and support for emerging reasoning algorithms (Fu et al., 2024); and the tensor computation Dynasor exemplifies the future of lock-free, locality-optimized sparse workloads (Wijeratne et al., 2023).

Continued convergence of these design patterns across HPC, ML, and simulation analysis pipelines is anticipated, and each Dynasor system provides architecturally generalizable techniques for other domains.