EXaCTz: Guaranteed Extremum Graph and Contour Tree Preservation for Distributed- and GPU-Parallel Lossy Compression

Abstract: This paper introduces EXaCTz, a parallel algorithm that concurrently preserves extremum graphs and contour trees in lossy-compressed scalar field data. While error-bounded lossy compression is essential for large-scale scientific simulations and workflows, existing topology-preserving methods suffer from (1) a significant throughput disparity, where topology correction speeds are on the order of MB/s, lagging orders of magnitude behind compression speeds on the order of GB/s, (2) limited support for diverse topological descriptors, and (3) a lack of theoretical convergence bounds. To address these challenges, EXaCTz introduces a high-performance, bounded-iteration algorithm that enforces topological consistency by deriving targeted edits for decompressed data. Unlike prior methods that rely on explicit topology reconstruction, EXaCTz enforces consistent min/max neighbors of all vertices, along with global ordering among critical points. As such, the algorithm enforces consistent critical-point classification, saddle extremum connectivity, and the preservation of merge/split events. We theoretically prove the convergence of our algorithm, bounded by the longest path in a vulnerability graph that characterizes potential cascading effects during correction. Experiments on real-world datasets show that EXaCTz achieves a single-GPU throughput of up to 4.52 GB/s, outperforming the state-of-the-art contour-tree-preserving method (Gorski et al.) by up to 213x (with a single-core CPU implementation for fair comparison) and 3,285x (with a single-GPU version). In distributed environments, EXaCTz scales to 128 GPUs with 55.6\% efficiency (compared with 6.4\% for a naive parallelization), processing datasets of up to 512 GB in under 48 seconds and achieving an aggregate correction throughput of up to 32.69 GB/s.

• The paper introduces EXaCTz, which enforces localized scalar-ordering constraints rather than explicitly constructing topology to preserve critical points, extremum graphs, and contour trees after error-bounded lossy compression.
• The method guarantees 100% CP, extremum-graph, and contour-tree recall across tested datasets and compressors, while reaching up to 32.69 GB/s on a 512 GB field and up to 213× the serial speed of TopoA.
• The paper proves convergence within N·Dmax iterations using reduced vulnerability graphs, although practical runs are far faster than the bound and the approximately 8× memory overhead remains a deployment limitation.

Error-bounded lossy compressors such as SZ3, ZFP, and cuSZp deliver high throughput and strict pointwise error bounds, but they provide no assurance that topological descriptors of the decompressed scalar field remain correct. This paper introduces EXaCTz (2604.01397), a distributed- and GPU-parallel correction algorithm that concurrently preserves extremum graphs and full contour trees after error-bounded lossy compression. The method avoids explicit topology construction, enforces a small set of scalar-ordering constraints through bounded monotonic edits, and—unlike prior iterative topology-correcting methods—derives an explicit worst-case upper bound on the number of correction iterations.

Motivation and Problem Statement

Extremum graphs encode connectivity among critical points via integral paths, while contour trees describe the hierarchical evolution of level sets. Both are essential downstream descriptors; in cosmology, for example, extremum graphs capture dark matter halo connectivity and contour trees encode the hierarchical structure of the cosmic web. The authors demonstrate that even with pointwise error guarantees, compression can distort these structures enough to cause false identification of halos or miscalculated accretion histories. On a $512^3$ NYX snapshot compressed with SZ3 at relative error $10^{-4}$, contour tree recall drops to 0.52 and extremum graph recall to 0.77 without any correction; on the Combustion dataset, contour tree recall falls as low as 0.20–0.25 depending on the base compressor. These numbers substantiate the claim that pointwise bounds alone are insufficient for topology-dependent analyses.

The paper identifies three limitations in existing topology-preserving compression. First, a large performance gap: methods that explicitly construct or repeatedly reconstruct contour trees operate at MB/s throughput versus GB/s for modern compressors (e.g., preserving the simplified contour tree of a $512^3$ cosmology snapshot with TopoA takes over 16 minutes). Second, limited descriptor coverage: prior work targets either contour trees, Morse–Smale complexes, or segmentations individually, not extremum graphs concurrently with contour trees. Third, iterative correction schemes such as MSz and DMTz prove convergence but give no explicit bound on iteration count, making worst-case runtime unpredictable.

Method

Constraints derived from ExTreeM

EXaCTz builds on ExTreeM's result that the merge tree computed from an extremum graph is provably identical to the merge tree computed from the full scalar field: for every threshold $c$, there is a bijection between sublevel-set components and components of the thresholded extremum graph. Rather than constructing topology, EXaCTz enforces three constraint families on the edited field $g$ (initialized from the decompressed data $\hat{f}$):

• EG constraints — critical point types and locations must match the original field, saddle–extrema connectivity must be preserved, and each vertex's steepest ascending/descending neighbors must remain unchanged (saddles additionally require preserved ordering against all neighbors).
• Saddle constraints — the global relative ordering among all saddles must be identical between $\hat{f}$ and $f$.
• Event constraints — the extrema selected by Extremum Graph Pairing at each merge/split event (the lowest connected minimum per join saddle, symmetrically for splits) must remain unchanged.

Since both join and split trees are preserved under C1–C3, the contour tree is preserved. Violations are detected iteratively and corrected by monotonically decreasing offending vertex values in fixed steps $\Delta = \xi/N$ ($N=5$, chosen empirically), with overflow edits stored losslessly. Ties are handled via Simulation of Simplicity.

Reformulated event constraints for distributed execution

The original event constraints require tracing integral paths to identify which extrema connect to each saddle—operations that cross partition boundaries and dominate communication cost in distributed memory. The paper's key scalability insight is that once EG constraints hold, enforcing the global scalar ordering among all critical points suffices to guarantee all pairing decisions, eliminating path tracing entirely. Each iteration then only exchanges critical-point values with sorted-order predecessors/successors. The reformulation introduces more localized edits, but measurements show this overhead is modest: up to 1.5× faster correction with only slight OCR degradation across error bounds $10^{-4}$0 to $10^{-4}$1.

Iteration upper bound via vulnerability graphs

The paper models cascading corrections—the phenomenon where fixing one flipped pair induces new flips in neighbors—with a three-stage graph construction. The weak vulnerability graph $10^{-4}$2 contains directed edges for adjacent pairs within $10^{-4}$3 in value (a prerequisite for any order flip); it is inherently acyclic since edges point from larger to smaller values. The strong vulnerability graph $10^{-4}$4 prunes edges that are unconditionally safe given monotonic decreasing edits. The reduced vulnerability graph $10^{-4}$5 traces cascades only from actual flip seeds present in the decompressed data. The main theorem states convergence within $10^{-4}$6 iterations, proved by induction on vertex depth in $10^{-4}$7. Empirically the bound is very loose: e.g., on NYX ($10^{-4}$8), the theoretical maximum is 2,805 iterations while only 25 occur; on AT, 85 theoretical versus 3 actual. The reduced graph also captures how rare true flips are—edit ratios typically fall below 5% of vertices despite weak-vulnerability fractions reaching 35–38%. The authors note the bound assumes all flip pairs eventually trigger edits and leave tighter bounds as future work.

Evaluation

Experiments ran on NERSC Perlmutter nodes with NVIDIA A100 GPUs, using datasets from 4 MB to 512 GB across cosmology, combustion, molecular simulation, and turbulence domains, with five base compressors (SZ3, ZFP, cuZFP, MGARD-GPU, cuSZp) plus TTHRESH and SPERR in appendices. Baselines are TopoA (contour-tree-preserving) and pMSz (Morse–Smale segmentation-preserving).

Setting	Key result
Serial CPU vs. TopoA	Up to 213× speedup; up to 2.65× higher OCR
Single GPU	All corrections ≤1.6 s; up to 3.85 GB/s (e.g., Combustion/SZ3)
Strong scaling (1024³, 16 GPUs)	64.1% efficiency; 99.5% at 2 GPUs
Weak scaling (128 GPUs)	55.6% efficiency (vs. 6.4% originally); >80% up to 64 GPUs
Largest dataset (512 GB Turbulence $10^{-4}$9)	Correction ≤48 s; aggregate throughput up to 32.69 GB/s
Topology preservation	CP/EG/CT recall = 1.00 on all datasets

In serial comparison, TopoA exceeded a one-hour limit on the $512^3$0 turbulence dataset where EXaCTz finished in roughly 17–21 seconds; the reported 213× speedup is measured against that one-hour cap, which should be read as a lower bound on the ratio rather than a completed-runtime comparison. On quality, EXaCTz achieves perfect recall on all three metrics everywhere, whereas TopoA leaves residual extremum-graph errors (EG recall 0.96 on AT and Combustion) despite exact contour trees, and pMSz reaches only partial preservation (e.g., CT recall 0.62 on NYX). The appendix confirms perfect preservation across all tested base compressors, including cases where cuSZp degraded CT recall to 0.25 before correction—a notable finding that high-throughput GPU compressors introduce severe topological inconsistencies.

An important caveat applies to cuZFP experiments: because cuZFP lacks strict pointwise error bounds, the effective $512^3$1 is taken as the observed maximum absolute error, so its results are not directly comparable in guarantee strength. ZFP-family compressors also induce more distortions (up to 224 correction iterations on Combustion/ZFP), reflecting their block-transform structure.

Limitations and Open Questions

The paper concedes several limitations directly relevant to interpreting its results. Memory footprint is approximately 8× the raw data size (original field, decompressed field, critical point indices, sorted orders, extremum graph connectivity), capping single-GPU inputs at ~5 GB on A100s and posing a challenge for memory-constrained in situ pipelines. The theoretical iteration bound is loose by one to two orders of magnitude relative to practice; tightening it toward empirical convergence behavior remains open. Distributed operation still requires global exchange of critical-point values for ordering violation detection, so localized or hierarchical synchronization strategies could further reduce communication. Additionally, the practical use of the vulnerability-graph machinery—for example, as a guide to selecting error bounds—is proposed but not developed.

Conclusion

EXaCTz demonstrates that exact extremum graph and contour tree preservation is compatible with high-throughput lossy compression when topology construction is replaced by localized scalar-ordering constraints grounded in the ExTreeM equivalence theorem. Its contributions span algorithm design (constraint-based correction without explicit topology), theory (an explicit iteration upper bound via reduced vulnerability graphs), and systems (distributed/GPU parallelism achieving GB/s-scale correction on datasets up to 512 GB). The combination of guaranteed 100% structural recall and correction costs comparable to base compression times materially narrows the gap between topology-aware and conventional lossy compression, though the loose worst-case bound and substantial memory overhead temper the practical deployment picture.