Pith. sign in

REVIEW 5 major objections 4 minor 43 references

FLARE: A Dataflow-Aware and Scalable Hardware Architecture for Neural-Hybrid Scientific Lossy Compression

T0 review · 5 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A 28-nm chip design runs neural-hybrid lossy compression up to 96× faster than CPU and GPU pipelines.

desk verdict A serious accelerator architecture undermined by an evaluation that never reports FLARE's own compression ratio, so the headline speedups conflate architecture with rate-distortion. read the letter →

arxiv 2507.01224 v1 pith:RHPTKZH3 submitted 2025-07-01 cs.DC

Wenqi Jia , Ying Huang , Jian Xu , Zhewen Hu , Sian Jin , Jiannan Tian , Yuede Ji , Miao Yin This is my paper
classification cs.DC
keywords dataflowoptimizationscalablearchitecturelossycompressionhigh-performancescientificcomputingneural-hybridhardwareacceleratorsystolicarrayoperatorfusion
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

FLARE is a proposed hardware architecture that runs neural-hybrid scientific lossy compression—a method that combines hand-designed interpolation, quantization, and entropy coding with a small neural network that learns to correct prediction errors—entirely on a dedicated accelerator. The paper argues that this hybrid workload is memory-bound on CPUs and GPUs, so even a custom chip with no algorithmic changes can be much faster and more energy-efficient. The central claim is that a single FLARE core, synthesized at 1 GHz in 28 nm at 7.38 W, compresses and decompresses the Nyx, Miranda, and Hurricane datasets 3.50× to 96.07× faster and with 24.51× to 520.68× better energy efficiency than CPU-only, GPU-only, and CPU-GPU versions of the same algorithm. If correct, this would be the first scalable hardware design for neural-hybrid scientific compression, and it would make high-ratio lossy compression practical at HPC data rates.

What carries the argument

The load-bearing mechanism is the FLARE Computing Core, a modular datapath with four parts: a 32 MB SRAM buffer, a Prediction Engine with M 1-D systolic arrays that interpolate and quantize data blocks, a Neural Engine with a 128×128 2D PE array for neural training and inference, and a Codec Engine with ALU-based Huffman coding. Two actions make the pipeline possible. First, the look-ahead computation order replaces breadth-first, level-by-level processing with depth-first, block-granular processing, so partial results are reused in SRAM instead of being written to DRAM. Second, slice-wise normalization is folded into the convolution kernel by rewriting the weights as $W'[k_x,k_y,o] = W[k_x,k_y,o]/(\max_i-\min_i)$ and the bias accordingly, which removes the separate normalization sweep. FIFO1 and FIFO2 smooth the non-uniform output of the look-ahead order so downstream engines never stall.

What would settle it

Measure the compressed bitstream sizes FLARE actually produces on Nyx, Miranda, and Hurricane at error bound $10^{-3}$ and compare them with the 387×, 16,000×, and 20× ratios reported for the CPU-only and CPU-GPU baselines; if FLARE's ratios are substantially lower, the runtime and energy speedups compare different compression workloads, not the same algorithm on different hardware.

Watch

Extended reading notes

Core claim

On the paper's own terms, FLARE shows that the memory bottlenecks of neural-hybrid lossy compression are architectural, not algorithmic, and can be removed with three coordinated techniques. A look-ahead, depth-first computation order processes partial blocks across interpolation levels, reusing reconstructed data on-chip and cutting the SRAM capacity requirement by 3.46× for a fixed 32×32×32 block size. A slice-wise instance normalization replaces global normalization and is algebraically folded into the first convolution layer through updated weights and biases, so normalized data streams straight into the neural engine. These two changes let the FLARE Computing Core—prediction systolic arrays, a 2D neural PE array, and an ALU-based Huffman codec—run as a pipelined-parallel pipeline with up to 10× less off-chip data movement. The reported result is that a 28 nm, 1 GHz core dissipating 7.38 W delivers the speedups and energy-efficiency gains summarized above.

Load-bearing premise

The claimed speedups assume FLARE and the CPU or GPU baselines compress to the same file size and reconstruction quality at the same error bound, but the paper never reports FLARE's own compression ratio.

Editorial extensions

If this is right

  • The look-ahead order cuts on-chip SRAM demand by 3.46×, which is the concrete resource saving that makes a single-chip accelerator for level-wise interpolation feasible.
  • Operator fusion removes the global-normalization barrier, so prediction, entropy coding, and neural training or inference can overlap in a fine-grained pipeline instead of waiting on each other.
  • Scaling the number of 1-D systolic arrays (M) per core and the number of cores (N) gives two independent axes of scalability; the reported data-size and workload experiments show runtime decreasing with both until a neural-engine or dataset-specific bottleneck appears.
  • Because the same ordering and fusion apply on both the compression and decompression paths, the architecture yields speedups in both directions rather than trading one for the other.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: the look-ahead order is not tied to the specific neural module, so it could be borrowed by other level-wise prediction compressors on CPUs and GPUs to cut cache misses and DRAM traffic without new silicon.
  • Editorial inference: the paper's 10× data-movement reduction is computed before accounting for neural-network training and inference traffic; an end-to-end DRAM traffic measurement would give a stronger, more conservative test of the architecture.
  • Editorial inference: slice-wise normalization reaches the same PSNR as global normalization only after 5–6 training epochs, which suggests a software-only speed-quality trade-off: cheaper normalization for slightly longer training, independent of any hardware.
  • Editorial inference: an FPGA prototype with a real host interface would test whether the 7.38 W and 1 GHz synthesis results survive integration into an HPC node, since the paper's measurements stop at the synthesized core.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 4 minor

Summary. The paper proposes FLARE, a custom hardware architecture for neural-hybrid scientific lossy compression based on the NeurLZ algorithm. The architecture combines three ideas: a look-ahead computation order to reduce intermediate SRAM usage, slice-wise instance normalization fused into the convolution operator to avoid global normalization passes, and a modular, scalable computing core with pipelined and parallel dataflow. The authors evaluate the design with a cycle-accurate simulator, RTL synthesis in 28nm at 1GHz, and power estimation, and report runtime speedups of 3.50x to 96.07x and energy efficiency improvements of 24.51x to 520.68x over CPU-only, GPU-only, and CPU-GPU implementations of NeurLZ.

Significance. If substantiated, FLARE would be a significant contribution: it is the first proposed ASIC for neural-hybrid scientific lossy compression and it addresses a real bottleneck in HPC data reduction. The algebraic derivation in Eqs. (1)-(6) is exact and self-contained, and the hardware evaluation methodology (RTL synthesis, PrimeTime PX, Cacti, TimeLoop) is credible. However, the headline performance claims are not yet interpretable because the comparison does not hold the compression ratio fixed, FLARE's own compression ratio is never reported, and the baseline power methodology is absent. The significance of the architecture therefore remains to be established rather than demonstrated.

major comments (5)
  1. [Section 2.2 and Section 4.3] The runtime and energy speedups are computed against baselines that produce very different compression ratios at the same error bound. Section 2.2 reports CPU-only/GPU-only/CPU-GPU ratios of 387x/25x/387x on Miranda, 16,000x/31x/16,000x on Nyx, and 20x/16x/20x on Hurricane. Section 4.1 reports only PSNR-versus-epoch curves and never gives FLARE's compression ratio or compressed size on any dataset. Consequently, a speedup over the GPU-only baseline may largely reflect a rate-distortion difference, such as compressing Nyx at 31x instead of 16,000x, rather than architectural acceleration. The paper must report FLARE's compression ratio at the same error bound and provide an equal-compression-ratio or rate-distortion-matched comparison; otherwise the 3.50x-96.07x runtime and 24.51x-520.68x energy ranges in Section 4.3 are not valid measures of the architecture.
  2. [Section 4.2 and Section 4.3] The energy efficiency comparison is not supported by a stated methodology for the CPU and GPU baselines. FLARE's 7.38 W is a synthesized ASIC estimate from RTL and Cacti, but the paper does not describe how baseline power was measured or estimated, whether DRAM and interconnect power are included in the FLARE number, or whether the CPU/GPU numbers include full-system power. Energy efficiency improvements of 24.51x to 520.68x therefore mix quantities obtained under different measurement assumptions. The authors should specify the baseline power measurement method and the component scope of the FLARE power estimate.
  3. [Section 3.2] The claim that slice-wise normalization enables on-the-fly streaming is not supported by the algorithm as written. Eq. (1) uses max_i and min_i for the entire i-th slice, which are not known until the whole slice has been produced. The text states that 'each normalized slice can be streamed directly to the neural component on the fly,' but this requires either a second pass over each slice or buffering the entire slice until its min and max are known. The paper does not quantify the extra SRAM usage or the pipeline bubble this causes, which is load-bearing for the claimed fully pipelined dataflow and memory reduction.
  4. [Section 3.1 and Figure 4] The look-ahead computation order assumes 'interpolation operations are inherently independent across blocks' and relies on block-wise independence. For spline- or cubic-interpolation-based prediction in the SZ-style pipeline, values at block boundaries typically require neighboring reconstructed points as halos. No halo analysis is provided, and the interpolation stencil and boundary handling are not specified. If halo dependencies exist, the claimed 3.46x SRAM reduction and the data-movement savings in Figure 11 may be overestimated. A concrete halo analysis or a precise statement of the interpolation stencil is needed.
  5. [Section 4.4 and Figure 11] The 10x off-chip data movement reduction is computed after excluding all neural network training and inference data access, as stated in the footnote to Figure 11. This is one of the three major sources of memory traffic identified in Section 2.3. The claim should either include the neural traffic or be explicitly scoped to non-neural traffic; as presented, the '10x reduction' headline is incomplete.
minor comments (4)
  1. [Figure 9] The figure has many panels with unclear axis labels; the y-axis units and the meaning of the three rows of plots should be labeled explicitly in each panel or in a clear legend.
  2. [Figure 5] The bar labels in the SRAM capacity figure are difficult to read and the horizontal axis is not clearly defined; please add readable value labels and axis captions.
  3. [Section 4.4] The sentence 'after M = 4, the runtime reaches its minimum despite additional systolic arrays' is not quite supported by Figure 10(a), where compression runtime continues to decrease slightly from M=4 to M=6; please reconcile the text with the plotted values.
  4. [Section 3.2] The notation max_i and min_i is introduced without a formal definition of the slice index convention; please define the slice and its boundaries explicitly.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central algebraic derivation is exact and the performance claims are measured against external or independent baselines, not derived from fitted inputs.

full rationale

The paper's core derivation is the slice-wise normalization with operator fusion in Section 3.2. Equations (1)-(6) are exact algebraic rewrites: substituting D_N from Eq. (1) into the convolution Eq. (2), factoring out (max_i - min_i), and absorbing the slice statistics into the modified weights W' and bias b' gives Eqs. (4)-(6) with no hidden fitted parameter. The compression-quality claim in Section 4.1 is an empirical comparison with the external SZ3 baseline and with the previously published NeurLZ algorithm, not a prediction derived from the architecture. The runtime and energy speedups in Section 4.3 are obtained from cycle-accurate simulation, Verilog RTL synthesis, and place-and-route power estimation compared against CPU-only, GPU-only, and CPU-GPU implementations; these are measured artifacts rather than consequences of a fitted parameter. The paper does cite the authors' own NeurLZ work as the baseline algorithm, but that citation is not load-bearing in a circular sense: the FLARE speedups stand or fall on the simulator, synthesis, and comparison results, and the SZ3 comparison is external. The main weakness is a reporting omission, namely that FLARE's own compression ratio is never stated while baseline ratios differ widely, which affects interpretability of the speedups but is a soundness and fairness issue, not circularity.

Assumptions & free parameters 7 free parameters · 4 assumptions · 0 invented entities

The free parameters are design choices for the FLARE core, not fitted to the target results. The axioms are assumptions that must hold for the reported speedups to be meaningful.

free parameters (7)
  • on-chip SRAM capacity = 32 MB
    Chosen in Section 4.2 for the FLARE Computing Core; affects performance and area but is not fitted to a target result.
  • number of 1D systolic arrays M = 4
    Selected for the single-core configuration; scaling study in Section 4.4 shows compression runtime saturates after M=4.
  • number of computing cores N = 1
    Single-core configuration used in the main evaluation; workload scaling is tested from 1 to 4.
  • FIFO1 and FIFO2 capacities = 8 MB and 32 MB
    Configured in Section 4.2 to absorb non-uniform output from the look-ahead schedule.
  • Neural Engine PE array size = 128x128
    Design parameter in Table 3; not derived from data.
  • Neural Engine global buffer size = 24 MB
    Design parameter in Table 3.
  • clock frequency = 1 GHz
    Synthesis target at 28nm; all performance numbers depend on this choice.
assumptions (4)
  • domain assumption Interpolation operations are independent across blocks, allowing the look-ahead reordering without changing the compressed output.
    Stated in Section 3.1: 'interpolation operations are inherently independent across blocks'. If false, the reordered schedule changes the reconstructed data and invalidates the equivalence to NeurLZ.
  • domain assumption Slice-wise instance normalization yields compression quality comparable to global normalization.
    Empirically argued in Section 4.1 and Figure 8, but assumed for the architecture evaluation at a fixed error bound.
  • domain assumption The cycle-accurate simulator and synthesized RTL faithfully model the FLARE architecture.
    Section 4.2 states a bit-accurate, cycle-accurate simulator and RTL verification, but no validation against silicon is provided.
  • domain assumption The TimeLoop-optimized neural dataflow is representative of the Neural Engine's actual energy and performance.
    TimeLoop is used in Section 4.2 to explore intra-layer dataflow, but the chosen dataflow configuration is not disclosed.

how reviews work

0 comments
Cite this review

Pith. "Pith review of FLARE: A Dataflow-Aware and Scalable Hardware Architecture for Neural-Hybrid Scientific Lossy Compression." pith.science (2026). https://pith.science/paper/RHPTKZH3

@misc{pith2026250701224,
  author       = {Pith},
  title        = {Pith review of: FLARE: A Dataflow-Aware and Scalable Hardware Architecture for Neural-Hybrid Scientific Lossy Compression},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RHPTKZH3}},
  note         = {Machine review of arXiv:2507.01224}
}
abstract

Scientific simulation leveraging high-performance computing (HPC) systems is crucial for modeling complex systems and phenomena in fields such as astrophysics, climate science, and fluid dynamics, generating massive datasets that often reach petabyte to exabyte scales. However, managing these vast data volumes introduces significant I/O and network bottlenecks, limiting practical performance and scalability. While cutting-edge lossy compression frameworks powered by deep neural networks (DNNs) have demonstrated superior compression ratios by capturing complex data correlations, their integration into HPC workflows poses substantial challenges due to the hybrid non-neural and neural computation patterns, causing excessive memory access overhead, large sequential stalls, and limited adaptability to varying data sizes and workloads in existing hardware platforms. To overcome these challenges and push the limit of high-performance scientific computing, we for the first time propose FLARE, a dataflow-aware and scalable hardware architecture for neural-hybrid scientific lossy compression. FLARE minimizes off-chip data access, reduces bubble overhead through efficient dataflow, and adopts a modular design that provides both scalability and flexibility, significantly enhancing throughput and energy efficiency on modern HPC systems. Particularly, the proposed FLARE achieves runtime speedups ranging from $3.50 \times$ to $96.07 \times$, and energy efficiency improvements ranging from $24.51 \times$ to $520.68 \times$, across various datasets and hardware platforms.

Figures

Figures reproduced from arXiv: 2507.01224 by the authors.

Figure 1
Figure 1. Overview of the state-of-the-art neural-hybrid lossy [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 3
Figure 3. Level-wise, block-based interpolation. The upper [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figure 5
Figure 5. Reduction in SRAM capacity by the proposed com [PITH_FULL_IMAGE:figures/full_fig_p004_5.png] view at source ↗
Figures from the paper (6 more)
Figure 6
Figure 6. Figure 6: Architecture overview of the proposed FLARE. [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]
Figure 7
Figure 7. Figure 7: Illustration of compression and decompression [PITH_FULL_IMAGE:figures/full_fig_p006_7.png]
Figure 8
Figure 8. Figure 8: Algorithm performance curves of our proposed FLARE. [PITH_FULL_IMAGE:figures/full_fig_p007_8.png]
Figure 9
Figure 9. Figure 9: Evaluation of runtime speedup and energy efficiency. [PITH_FULL_IMAGE:figures/full_fig_p008_9.png]
Figure 11
Figure 11. Figure 11: Off-chip data movement reduction of FLARE. [PITH_FULL_IMAGE:figures/full_fig_p008_11.png]
Figure 10
Figure 10. Figure 10: Scalability analysis of the proposed FLARE. [PITH_FULL_IMAGE:figures/full_fig_p008_10.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

43 extracted references · 30 canonical work pages

  1. [1]

    Ann S Almgren, John B Bell, Mike J Lijewski, Zarija Lukić, and Ethan Van Andel

    work page

  2. [2]

    Babak Behzad, Surendra Byna, Prabhat, and Marc Snir. 2019. Optimizing i/o performance of hpc applications with autotuning. ACM Transactions on Parallel Computing (TOPC) 5, 4 (2019), 1–27

    work page 2019

  3. [3]

    Franck Cappello, Allison Baker, Ebru Bozda, Martin Burtscher, Kyle Chard, Sheng Di, Paul Christopher O Grady, Peng Jiang, Shaomeng Li, Erik Lindahl, et al. 2025. Lossy Compression of Scientific Data: Applications Constrains and Requirements. arXiv preprint arXiv:2503.20031 (2025)

    work page Pith review arXiv 2025

  4. [4]

    Sudheer Chunduri, Taylor Groves, Peter Mendygral, Brian Austin, Jacob Balma, Krishna Kandalla, Kalyan Kumaran, Glenn Lockwood, Scott Parker, Steven War- ren, et al. 2019. Gpcnet: Designing a benchmark suite for inducing and measuring contention in hpc networks. In Proceedings of the International Conference for High Performance Computing, Networking, Stor...

    work page 2019

  5. [5]

    P. Deutsch. 1996. RFC1952: GZIP file format specification version 4.3

    work page 1996

  6. [6]

    Sheng Di and Franck Cappello. 2016. Fast Error-Bounded Lossy HPC Data Com- pression with SZ . In 2016 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE Computer Society, Los Alamitos, CA, USA, 730–739. doi:10.1109/IPDPS.2016.11

    doi:10.1109/ipdps.2016.11 2016

  7. [7]

    Sheng Di, Jinyang Liu, Kai Zhao, Xin Liang, Robert Underwood, Zhaorui Zhang, Milan Shah, Yafan Huang, Jiajun Huang, Xiaodong Yu, et al . 2024. A survey on error-bounded lossy compression for scientific datasets. arXiv preprint arXiv:2404.02840 (2024)

    arXiv 2024

  8. [8]

    Jean-loup Gailly and Mark Adler. 2004. zlib Compression Library. http://www. dspace.cam.ac.uk/handle/1810/3486 Accessed: 2025-01-08

    work page 2004

Show all 43 references
  1. [9]

    Kurt Hornik, Maxwell Stinchcombe, and Halbert White. 1989. Multilayer feed- forward networks are universal approximators. Neural networks 2, 5 (1989), 359–366

    1989

  2. [10]

    Yafan Huang, Sheng Di, Guanpeng Li, and Franck Cappello. 2024. cuSZp2: A GPU Lossy Compressor with Extreme Throughput and Optimized Compression Ratio. In SC24: International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE, 1–18

    2024

  3. [11]

    Wenqi Jia, Sian Jin, Jinzhen Wang, Wei Niu, Dingwen Tao, and Miao Yin

  4. [12]

    Wenqi Jia, Youyuan Liu, Zhewen Hu, Jinzhen Wang, Boyuan Zhang, Wei Niu, Junzhou Huang, Stavros Kalafatis, Sian Jin, and Miao Yin. 2024. NeurLZ: On Enhancing Lossy Compression Performance based on Error-Controlled Neural Learning for Scientific Data. arXiv preprint arXiv:2409.0...

    2024 arXiv

  5. [13]

    Nnadikwe Johnson. 2023. Exploring Cutting-Edge Application of Computational Fluid Dynamic in Enhancing and Innovation within the Oil and Gas Sector. (12 2023). doi:10.20944/preprints202312.1113.v1

    2023

  6. [14]

    Yao Kang, Xin Wang, and Zhiling Lan. 2022. Study of workload interference with intelligent routing on dragonfly. In SC22: International Conference for High Performance Computing, Networking, Storage and Analysis . IEEE, 1–14

    2022

  7. [15]

    Sunggon Kim, Alex Sim, Kesheng Wu, Suren Byna, and Yongseok Son. 2023. Design and implementation of I/O performance prediction scheme on HPC systems through large-scale log analysis. Journal of Big Data 10, 1 (2023), 65

    2023

  8. [16]

    Sriram Lakshminarasimhan, Neil Shah, Stephane Ethier, Seung-Hoe Ku, Choong- Seock Chang, Scott Klasky, Rob Latham, Rob Ross, and Nagiza F Samatova. 2013. ISABELA for effective in situ compression of scientific data. Concurrency and Computation: Practice and Experience 25, 4 (2...

    2013

  9. [17]

    Xiao Li, Jaemoon Lee, Anand Rangarajan, and Sanjay Ranka. 2024. Attention Based Machine Learning Methods for Data Reduction with Guaranteed Error Bounds. arXiv:2409.05357 [cs.LG] https://arxiv.org/abs/2409.05357

    2024 arXiv

  10. [18]

    Xin Liang, Sheng Di, Sihuan Li, Dingwen Tao, Bogdan Nicolae, Zizhong Chen, and Franck Cappello. 2019. Significantly improving lossy compression quality based on an optimized hybrid prediction model. InProceedings of the International Conference for High Performance Computing, ...

    2019

  11. [19]

    Xin Liang, Kai Zhao, Sheng Di, Sihuan Li, Robert Underwood, Ali M Gok, Jiannan Tian, Junjing Deng, Jon C Calhoun, Dingwen Tao, et al. 2022. Sz3: A modular framework for composing prediction-based error-bounded lossy compressors. IEEE Transactions on Big Data 9, 2 (2022), 485–498

    2022

  12. [20]

    Peter Lindstrom. 2014. Fixed-rate compressed floating-point arrays. IEEE trans- actions on visualization and computer graphics 20, 12 (2014), 2674–2683

    2014

  13. [21]

    Peter Lindstrom and Martin Isenburg. 2006. Fast and efficient compression of floating-point data. IEEE transactions on visualization and computer graphics 12, 5 (2006), 1245–1250

    2006

  14. [22]

    Jinyang Liu, Sheng Di, Sian Jin, Kai Zhao, Xin Liang, Zizhong Chen, and Franck Cappello. 2023. Scientific error-bounded lossy compression with super-resolution neural networks. In 2023 IEEE International Conference on Big Data (BigData) . IEEE, 229–236

    2023

  15. [23]

    Jinyang Liu, Sheng Di, Kai Zhao, Sian Jin, Dingwen Tao, Xin Liang, Zizhong Chen, and Franck Cappello. 2021. Exploring autoencoder-based error-bounded compression for scientific data. In 2021 IEEE International Conference on Cluster Computing (CLUSTER). IEEE, 294–306

    2021

  16. [24]

    Jinyang Liu, Sheng Di, Kai Zhao, Xin Liang, Zizhong Chen, and Franck Cappello

  17. [25]

    Jinyang Liu, Jiannan Tian, Shixun Wu, Sheng Di, Boyuan Zhang, Robert Under- wood, Yafan Huang, Jiajun Huang, Kai Zhao, Guanpeng Li, et al. 2024. CUSZ-i: High-Ratio Scientific Lossy Compression on GPUs with Optimized Multi-Level Interpolation. In SC24: International Conference ...

    2024

  18. [26]

    Youyuan Liu, Wenqi Jia, Taolue Yang, Miao Yin, and Sian Jin. 2024. Enhancing Lossy Compression Through Cross-Field Information for Scientific Applications. In SC24-W: Workshops of the International Conference for High Performance Com- puting, Networking, Storage and Analysis ....

    2024

  19. [27]

    Zarija Lukić, Casey W Stark, Peter Nugent, Martin White, Avery A Meiksin, and Ann Almgren. 2015. The Lyman 𝛼 forest in optically thin hydrodynamical simulations. Monthly Notices of the Royal Astronomical Society 446, 4 (2015), 3697–3724

    2015

  20. [28]

    McCalpin

    John D. McCalpin. 2023. Bandwidth Limits in the Intel Xeon Max (Sapphire Rapids with HBM) Processors. In High Performance Computing, Amanda Bienz, Michèle Weiland, Marc Baboulin, and Carola Kruse (Eds.). Springer Nature Switzerland, Cham, 403–413

    2023

  21. [29]

    Gerald A Meehl, George J Boer, Curt Covey, Mojib Latif, and Ronald J Stouf- fer. 2000. The coupled model intercomparison project (CMIP). Bulletin of the American Meteorological Society 81, 2 (2000), 313–318

    2000

  22. [30]

    Jose Oñorbe, FB Davies, Z Lukić, JF Hennawi, and D Sorini. 2019. Inhomogeneous reionization models in cosmological hydrodynamical simulations. Monthly Notices of the Royal Astronomical Society 486, 3 (2019), 4075–4097

    2019

  23. [31]

    Angshuman Parashar, Priyanka Raina, Yakun Sophia Shao, Yu-Hsin Chen, Victor A Ying, Anurag Mukkara, Rangharajan Venkatesan, Brucek Khailany, Stephen W Keckler, and Joel Emer. 2019. Timeloop: A systematic approach to dnn accelerator evaluation. In 2019 IEEE international sympos...

    2019

  24. [32]

    Arnab K Paul, Olaf Faaland, Adam Moody, Elsa Gonsiorowski, Kathryn Mohror, and Ali R Butt. 2020. Understanding hpc application i/o behavior using system level statistics. In 2020 IEEE 27th International Conference on High Performance Computing, Data, and Analytics (HiPC) . IEE...

    2020

  25. [33]

    Reinaldo R Rosa. 2020. Data Science Strategies for Multimessenger Astronomy. Anais da Academia Brasileira de Ciências 93 (2020), e20200861

    2020

  26. [34]

    Jean Sexton, Zarija Lukic, Ann Almgren, Chris Daley, Brian Friesen, Andrew Myers, and Weiqun Zhang. 2021. Nyx: A massively parallel amr code for compu- tational cosmology. The Journal of Open Source Software 6, 63 (2021), 3068. 9 Jia and Yin, et al

    2021

  27. [35]

    Dingwen Tao, Sheng Di, Zizhong Chen, and Franck Cappello. 2017. Significantly Improving Lossy Compression for Scientific Data Sets Based on Multidimen- sional Prediction and Error-Controlled Quantization . In 2017 IEEE International Parallel and Distributed Processing Symposiu...

    2017 doi

  28. [36]

    Dingwen Tao, Sheng Di, Xin Liang, Zizhong Chen, and Franck Cappello. 2019. Optimizing lossy compression rate-distortion from automatic online selection between SZ and ZFP. IEEE Transactions on Parallel and Distributed Systems 30, 8 (2019), 1857–1871

    2019

  29. [37]

    Jiannan Tian, Sheng Di, Kai Zhao, Cody Rivera, Megan Hickman Fulp, Robert Underwood, Sian Jin, Xin Liang, Jon Calhoun, Dingwen Tao, et al. 2020. Cusz: An efficient gpu-based error-bounded lossy compression framework for scientific data. In Proceedings of the ACM International ...

    2020

  30. [38]

    Tonellot, Zizhong Chen, and Franck Cappello

    Kai Zhao, Sheng Di, Maxim Dmitriev, Thierry-Laurent D. Tonellot, Zizhong Chen, and Franck Cappello. 2021. Optimizing Error-Bounded Lossy Compression for Scientific Data by Dynamic Spline Interpolation . In 2021 IEEE 37th International Conference on Data Engineering (ICDE) . IE...

    2021

  31. [39]

    Kai Zhao, Sheng Di, Xin Lian, Sihuan Li, Dingwen Tao, Julie Bessac, Zizhong Chen, and Franck Cappello. 2020. SDRBench: Scientific Data Reduction Bench- mark for Lossy Compressors . In 2020 IEEE International Conference on Big Data (Big Data) . IEEE Computer Society, Los Alamit...

    2020

  32. [40]

    Jacob Ziv and Abraham Lempel. 1977. A universal algorithm for sequential data compression. IEEE Transactions on information theory 23, 3 (1977), 337–343. 10

    1977

  33. [2013]

    The Astrophysical Journal 765, 1 (2013), 39

    Nyx: A massively parallel amr code for computational cosmology. The Astrophysical Journal 765, 1 (2013), 39

    2013

  34. [2022]

    In SC22: International Conference for High Performance Com- puting, Networking, Storage and Analysis

    Dynamic Quality Metric Oriented Error Bounded Lossy Compression for Scientific Datasets . In SC22: International Conference for High Performance Com- puting, Networking, Storage and Analysis . IEEE Computer Society, Los Alamitos, CA, USA, 1–15. doi:10.1109/SC41404.2022.00067

    arXiv

  35. [2024]

    In Proceedings of the 14th Workshop on AI and Scientific Computing at Scale Using Flexible Computing Infrastructures (Pisa, Italy) (Flex- Science’24)

    GWLZ: A Group-wise Learning-based Lossy Compression Framework for Scientific Data. In Proceedings of the 14th Workshop on AI and Scientific Computing at Scale Using Flexible Computing Infrastructures (Pisa, Italy) (Flex- Science’24). Association for Computing Machinery, New Yo...

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.