streaming decompression

This work addresses the high latency introduced by traditional decompression in scientific data analysis, which undermines the storage and transmission benefits of compression. To overcome this limitation, the authors propose a multi-stage, error-bounded decompression and homomorphic analysis framework. By abstracting a generic compression pipeline, the framework enables hierarchical partial decompression and introduces homomorphic operation algorithms tailored to three representative scientific analysis tasks, allowing computations to be performed directly on intermediate compressed representations without full decompression. Implemented atop four mainstream compressors and evaluated across five real-world datasets, the approach consistently reduces data access latency and significantly improves analytical efficiency across diverse workloads.

Formal verification of compressed neural networks—particularly under quantization and pruning—for edge-device deployment suffers from low efficiency and poor adaptability to structural modifications. Method: We propose the first MUC (Minimal Unsatisfiable Core)-guided incremental formal verification framework, which uniformly models both parameter updates and architectural changes, enabling efficient reuse of prior verification knowledge. Our approach employs SMT encoding coupled with MUC-driven incremental solving to preserve functional equivalence while substantially accelerating verification. Contribution/Results: The framework achieves over 90% verification reuse rate and speeds up verification by multiple times compared to conventional non-incremental methods. Crucially, it overcomes a key limitation of existing incremental verifiers—which support only quantization and not structural pruning—thereby enabling rigorous, scalable, and reliable verification of diverse model compression techniques. This significantly enhances the trustworthiness and deployability of compressed models on resource-constrained edge devices.

Large language model (LLM) training incurs severe I/O and network bandwidth pressure due to massive checkpoint tensors—often hundreds of gigabytes—posing storage and transmission bottlenecks. To address this, we propose LMC, a lossless tensor compressor specifically designed for LLM checkpoints. LMC integrates byte-level grouping, incremental differencing, and Huffman coding, accelerated via multi-threaded parallelism to achieve high compression ratios with minimal latency. Crucially, this work presents the first systematic characterization of the dynamic evolution of tensor compressibility throughout LLM training. Experimental evaluation on 16-core systems shows LMC attains compression and decompression throughputs of 2.78 GiB/s and 3.76 GiB/s, respectively—significantly outperforming BZ2—while drastically reducing CPU overhead. This enables more frequent checkpointing, effectively alleviating storage capacity and network bandwidth constraints in large-scale LLM training.

This work proposes the first feedback-driven decompilation framework that integrates dynamic function-level validation with large language models (LLMs) to address the longstanding limitation of traditional decompilers, whose output—while readable—often fails to recompile or faithfully reproduce the original binary’s behavior, thereby undermining reliability in software modernization and vulnerability repair. The approach extracts minimal compilable contexts, performs in-place hot-swapping of reconstructed functions into the original binary, and employs fine-grained differential tracing to iteratively guide the LLM in correcting semantic deviations. Evaluated on Coreutils and Binutils, the method achieves 100% function-level compilability, behavioral consistency of 99.55% and 99.89%, and successfully repairs 76.56% and 79.74% of logical errors, respectively—even on fully stripped binaries, maintaining over 96% consistency and significantly mitigating LLM-induced semantic hallucinations.

Token-level verification in speculative decoding of large language models suffers from low efficiency. Method: This paper proposes a block-level joint verification mechanism that strictly preserves output distribution equivalence and incurs zero accuracy loss, while improving verification efficiency. It provides the first theoretical proof and realization of optimality in expected token yield—guaranteeing performance no worse than conventional token-level verification—and designs a parallel verification algorithm grounded in probabilistic consistency analysis, enabling seamless integration into existing speculative decoding frameworks. Contribution/Results: As the first verification paradigm combining deterministic acceleration, zero computational overhead, and strong theoretical guarantees, it achieves stable end-to-end inference speedups of 5%–8% across diverse tasks and datasets, without increasing implementation complexity or sacrificing model performance.

This work addresses the growing mismatch between the rapid expansion of genomic data and the limited decompression throughput of conventional formats like gzip, which also lack efficient GPU-based random access. The authors propose the first fully GPU-resident LZ77 decompression pipeline that integrates a compact coordinate index with a range-based decompression strategy, enabling bit-accurate decoding while overcoming GPU memory constraints. Built upon the ACEAPEX parallel LZ77 codec, the approach combines GPU-accelerated entropy decoding and match parsing. Experimental results demonstrate exceptional performance: FASTQ decompression achieves 260 GB/s; single random accesses take only 0.362 ms—six times faster than samtools; the index size is reduced by 6.3×; and range decompression of a 50 GB genome reaches 165.7 GB/s.

To address performance bottlenecks and architectural fragmentation arising from the mismatch between GPU-accelerated model training and CPU-centric secure verification in distributed machine learning, this paper proposes the first GPU-native encrypted integrity verification framework. Methodologically, it deeply integrates cryptographic verification logic into the GPU execution pipeline, leverages specialized hardware units (e.g., XMX/Tensor Cores) for parallelized cryptographic computation, and introduces a hardware-agnostic unified verification primitive alongside a cross-vendor compatible execution architecture. Key contributions include: (1) the first GPU-native, high-throughput integrity verification; (2) low-overhead verification for models exceeding 100 GB—achieving ≥8.2× speedup over CPU-based approaches; and (3) a reserved secure channel mechanism for seamless integration with trusted execution environments (TEEs). The framework significantly enhances both security guarantees and system efficiency in heterogeneous distributed training infrastructures.

RDMA offers low latency and high throughput but suffers from a weak memory model lacking formal foundations, hindering the construction of correct, composable multi-node concurrent objects. Method: We introduce LOCO—the first RDMA-native multi-node object library supporting formal verification—bridging shared-memory and distributed programming paradigms. To address RDMA consistency modeling challenges, we design Mowgli, a modular, declarative verification framework that decouples proof logic from the memory model and enables systematic correctness proofs leveraging locality properties. Contribution/Results: LOCO achieves performance comparable to custom RDMA systems while drastically simplifying the programming model. All core components are fully formally verified. LOCO provides a high-reliability, high-performance infrastructure foundation for data centers, HPC, and AI/ML workloads.

This work addresses the limited optimization potential of eBPF programs due to the kernel’s single-pass JIT compilation strategy and the security risks associated with expanding the trusted computing base (TCB) through kernel modifications. The authors propose Kops, an interface that enables new eBPF operations without altering the kernel core, by coordinating a user-space compiler with a lightweight kernel module. Each operation comprises a verifier-checkable eBPF proof sequence and corresponding native instruction emission, decoupling proof validation from native code generation for the first time. This approach preserves a minimal TCB while enabling hardware-aware optimizations and optional whole-program native replacement for enhanced performance. Built upon eBPF verification, JIT infrastructure, Lean 4 formal verification, and x86-64/ARM64 instruction tuning, the implementation introduces seven EInsn native operations, achieving up to 24% speedup in microbenchmarks, 12% in real-world applications, and a 2.358× acceleration with full program replacement.

This work addresses memory exhaustion and I/O bottlenecks in processing petabyte-scale image datasets—such as 1.4 PB electron microscopy volumes or 150 TB organ atlases—by introducing a streaming single-pass architecture based on a sweep execution model. The approach aligns disk reads with a one-dimensional sweep order and combines windowed operations with overlap-aware tiling to enable efficient processing under tight memory constraints. A domain-specific language (DSL) is designed to automatically optimize window sizes, fuse pipeline stages, and schedule multi-pass sweeps at compile time and runtime. The system supports Zarr, HDF5, and slice-based formats without requiring full-image residency in memory, achieving significantly higher throughput, near-linear I/O scaling, and predictable memory usage while seamlessly integrating with existing segmentation and morphological analysis toolchains.