Aug 2026· International Conference on Statistical and Scientific Database Management· 0 citations· 5 references
Computer Science
TL;DR
WADO is presented, a distributed write-once-read-many (WORM) object-store runtime for data-centric workloads that closes this gap through three coordinated mechanisms: scope-centric processing, explicit pipeline decomposition, and interference-aware explicit parallelism.
Abstract
AI-driven scientific workloads increasingly depend on data-intensive input pipelines, where deep learning frameworks must ingest and transform large datasets from hierarchical HPC storage. Existing system-centric data services improve movement and locality between the parallel file system (PFS), node-local storage, and memory. However, they do not directly optimize how input pipeline operations execute across scopes, stage overlap, and resource-specific parallelism. As scale grows, this gap causes worker stalls, contention, and poor hardware utilization. We present WADO, a distributed write-once-read-many (WORM) object-store runtime for data-centric workloads that closes this gap through three coordinated mechanisms: scope-centric processing, explicit pipeline decomposition, and interference-aware explicit parallelism. WADO dynamically maps operations to execution scopes, overlaps stages such as I/O, communication, and transformations, and applies contention-aware concurrency control to match hardware behavior at runtime. Our evaluation shows three main findings: (1) scope-centric processing preserves throughput under scale, improving mixed-operation throughput by up to 1.65 × ; (2) explicit pipeline decomposition converts serialized wait into overlapped progress, delivering up to 2.16 × higher sustained bandwidth; and (3) interference-aware explicit parallelism improves effective bandwidth by up to 4.4 × by avoiding oversubscription collapse. On Unet3D model training, these mechanisms translate to end-to-end gains, improving data loading performance by 4.1 × compared to baseline PyTorch on Lustre, and 1.51 × compared to DYAD, enabled by deeper pipelining, adaptive parallelism, and near-data transformation offloading.
The AI hardware boom has driven modern data centers toward HPC-style architectures centered on GPU clusters, RDMA-capable networks, and high-throughput NVMe storage. While designed primarily for training and inference, this infrastructure also creates new opportunities for designing the next generation of scalable database systems for analytical workloads on top of such data centers. In particular, the combination of GPU-centric computation, fast networking, and fast storage enables disaggregated architectures that extend beyond single-node, GPU-memory-resident execution.
This paper discusses the challenges and design considerations of analytical query processing on such disaggregated GPU-centric systems. We examine how modern networks and storage enable distributed execution and out-of-memory processing, and how their interaction shapes end-to-end performance. Our recent results show that naïve use of existing I/O abstractions can underutilize both compute and I/O bandwidth due to insufficient overlap between computation and data movement. We therefore identify effective I/O-computation overlap as a key requirement for fully exploiting the AI data center stack, and outline future research directions for next-generation analytical database architectures.
Ji-Gao Luo, Nils Boeschen, Muhammad El-Hindi et al.· Datenbank-Spektrum· 0 citations
While ByteDance's database infrastructure continues to serve bursty user traffic, emerging large-scale interactive applications generate increasingly write-intensive workloads spanning all stages of the data lifecycle. In production environments, we observe that these workloads are consistently bottlenecked by a common write-path inefficiency rooted in cache-miss-induced remote page fetches. In compute-storage disaggregated architectures, such remote page accesses introduce substantial I/O latency that dominates write performance. To address this bottleneck, we propose Write Operation Pushdown (WOP), a framework that eliminates Fetch-Before-Write (FBW) from the write path by pushing eligible writes to the storage layer for asynchronous execution. WOP leverages the redo-flush path to push down write operations and enhances the storage layer for semantic-aware execution. WOP supports high pushdown capacity with minimal memory footprint through Lightweight Metadata Tracking. WOP preserves correctness and consistency in distributed deployments via carefully designed mechanisms. To prevent read stalls introduced by asynchronous execution, WOP integrates a Fetch-After-Write (FAW) optimization with localized, on-demand replay. Across production workloads, WOP achieves up to 3.33× throughput improvement. On synthetic benchmarks, WOP improves throughput by up to 6.7× and reduces average latency by up to 85.2%. These results show that WOP significantly enhances write efficiency in industrial-scale workloads while preserving correctness in disaggregated deployments.
Hao Wu, Lu-Tong Zhang, Xin-Ying Zheng et al.· Proceedings of the VLDB Endo...· 0 citations
LLM inference has become an essential service, yet it imposes unprecedented demands on memory bandwidth, computational density, and communication efficiency. While IMC is a promising solution to the memory wall issue, the heterogeneous data dynamicity of LLM requires complementary resources to handle intermediate data generated during run-time. Furthermore, the massive number of parameters in LLM necessitates scale-up architectures where on-chip data movement is often the primary performance bottleneck. This article presents a hardware-software co-design framework that unifies distributed compute, memory, and communication into a seamless processing-communication fabric. On the hardware side, we propose a scalable architecture, named LEAP, that integrates IMC PE, NMC PE, and INC. This allows each hardware layer to execute specialized tasks: IMC for static weights, NMC for dynamic data, and INC for partial result reduction. On the software side, we introduce a partitioning, mapping, and scheduling framework optimized for key metrics in LLM serving, including throughput and latency. To address the distinct computational intensities of the prefill and decode phases, we present a prefill-decode disaggregation approach that dynamically reconfigures PE organizations to maximize resource utilization. Compared to commercial GPU platforms, the proposed architecture provides a throughput and an energy efficiency improvement of $\geq{}1.52\times$ and $24.91\times$, respectively.
The scale of data-intensive workloads in intelligent datacenters has grown rapidly in recent years, intensifying the need for efficient data movement within disaggregated memory pools across memory and storage subsystems. However, most existing solutions focus primarily on optimizing communication between compute nodes and data nodes, overlooking fine-grained management of in-pool data flows. Furthermore, prevailing data swap strategies often suffer from high overhead, limited parallelism, and a lack of adaptivity to dynamic workloads, especially for bursty data access patterns in heterogeneous memory pools. To address these issues, this paper introduces MEDO, a high-parallelism data offloading system for disaggregated memory pools. MEDO leverages a novel multi-stream data offloading architecture, featuring parallel data streams and approximate LRU queues, to maximize throughput and efficiently handle diverse workloads. Additionally, MEDO incorporates a lightweight, adaptive offloading agent that dynamically optimizes data placement decisions and fine-grained system configurations. Our prototype achieves up to 3.6 × latency reduction on real-world data services compared with baselines and can reduce in-pool memory usage by up to 50% on state-of-the-art disaggregated memory systems.
Jing Wang, Han-Zhang Yang, Chao Li et al.· Proceedings of the Internati...· 0 citations
The design of NLock enables an efficient local hand-over mechanism and in turn, achieves substantial performance advantages by co-optimizing lock design with modern NUMA architectures, and is evaluated against state-of-the-art locking mechanisms and concurrent data structures.
Brahmaiah Gandham, Praveen Alapati, Aman Iftekhar· International journal of par...· 0 citations
Sorting is a core operator in large-scale data systems. As data increasingly exceeds main memory, external merge sort is essential, yet many implementations over-allocate memory and over-parallelize, decreasing efficiency. We present
CrocSort
, a byte-balanced parallel external merge sort with configurable memory and per-phase thread settings. Using analysis and experiments, we derive practical resource-configuration rules for selecting these settings from input size, memory budget, and thread cap. To balance parallel merge under skew, CrocSort reuses run sparse indexes for range partitioning to create a virtual total order over records. CrocSort also uses offset-value codes and related optimizations to reduce comparison work and, for prefix-redundant workloads, intermediate I/O volume. Across TPC-H and synthetic workloads on modern NVMe systems, CrocSort completes sorting at memory budgets where production systems abort, and the planner reduces unnecessary resource allocation compared to the greedy maximal approach across both tight- and ample-memory regimes.
Riki Otaki, Charles Benello, Fuheng Zhao et al.· Proceedings of the VLDB Endo...· 0 citations
We use cookies to run the site and, with your consent, for analytics and to show ads.
See our Cookie Policy.
