Papers for

data center architects

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Upper bounds on data access rates for coded distributed storage systems

Bounds on the Service Rates of Linear Codes and their Connections to Combinatorial Designs

Abstract: The service rate region of a distributed storage system describes the set of concurrent demand vectors that can be served without overloading any individual server, and is a fundamental measure of how effectively redundancy is used. In this paper, we investigate aggregate service rates in distributed data storage systems based on linear codes over arbitrary finite fields. We first derive an upper bound on the aggregate service rate for an arbitrary subset of $t$ data objects in terms of the dual distance and the sizes of their smallest recovery sets. For systematic generator matrices, this bound simplifies to an expression depending only on the code length, the dual distance, and the cardinality of the selected subset. This result extends existing bounds and provides a subset-wise formulation of the First Dual Distance Bound. We then establish conditions under which this upper bound is attained. We apply our results to several important families of linear codes, including MDS codes, Reed-Muller codes, constacyclic codes, and extended Golay codes, and obtain exact values of the maximum aggregate service rates for the corresponding subsets of data objects.

Mon 19 OctInformation Theory
The gist
Distributed storage systems keep data across many servers to protect against loss and improve access. The authors study how much data can be served at once without overloading any server when data is stored using special linear codes. They find new upper limits on how many requests for multiple data pieces can be handled simultaneously based on code properties. This helps understand the efficiency of redundancy in real systems and when these limits can actually be reached.
Open → 2610.26683v1

Agentic AI speeds up design of diverse computing systems efficiently

Agentic AI for Heterogeneous System Design Across Chip, Scale-Up, and Scale-Out Domains

Abstract: The design space of modern AI/HPC systems has expanded rapidly across compute architectures, including GPUs, dataflow processors, and RISC-V accelerators; memory tech- nologies, including HBM, GDDR, and SRAM; and interconnects such as NVLink, UALink, Infinity Fabric, InfiniBand, Slingshot, and Ultra Ethernet. No single architecture is optimal across LLM training, LLM serving, and AI-coupled HPC workloads, while the resulting combinatorial design space is too large for manual exploration. We present ArchAgent, a hierarchical multi- agent framework in which an LLM-based planner decomposes system design into chip, scale-up, and scale-out subproblems, each handled by specialist agents. A deterministic analytical evaluator closes the loop, ensuring that all performance estimates are derived from analytical models rather than generated by the LLM. On a mixed AI+HPC workload under a 1 MW power budget, ArchAgent discovers heterogeneous designs that achieve a 1.93x weighted geometric mean speedup over a homogeneous GPU baseline, while requiring only 18 evaluations compared with 100 evaluations for hill climbing, which achieves 1.65x speedup.

Fri 16 OctHardware ArchitectureDistributed, Parallel, and Cluster Computing
The gist
Designing modern computing systems is complicated because there are many types of chips, memory, and network connections to choose from, and no single setup works best for all tasks. The authors created ArchAgent, a smart system that breaks down the design challenge into smaller parts and uses specialized helpers to find the best combination. It checks its ideas with accurate models rather than guessing. ArchAgent finds better designs faster than older methods, saving time and energy while improving performance.
Open → 2610.23724v1

Distributed dna storage reduces reading time and cost depending on code and partition

The Coverage Depth Problem in Distributed DNA Data Storage

Abstract: Random sampling in DNA sequencing produces repeated reads, increasing retrieval latency and sequencing cost. We study the coverage-depth problem for full-message recovery in distributed DNA storage under noiseless uniform sampling, where strands are partitioned among $M$ containers and one strand is independently sampled with replacement from each container per round. For arbitrary linear codes and ordered partitions, we derive exact formulas for the recovery-time distribution and expectation. We prove that MDS codes, whenever they exist, are optimal for every fixed partition, and establish a universal lower bound on the expected total read cost together with its equality conditions. For MDS codes, we identify container-size regimes that yield genuine savings in total reads and regimes that provide only parallelism without changing the asymptotic sequencing cost. For simplex codes, we prove that the $q$-ary simplex code is, up to isomorphism, the unique single-container minimizer among codes with the same parameters, resolving a recent conjecture by Bertuzzo, Ravagnani, and Yaakobi. We further construct a partition attaining the minimum total read cost and derive bounds for intermediate and balanced partitions. These results clarify when distributed sampling reduces latency alone and when it also reduces sequencing cost.

Fri 2 OctInformation Theory
The gist
Reading information stored in DNA often involves reading the same pieces repeatedly, which slows things down and costs more. The authors studied how dividing DNA data into separate containers affects the time and cost to read it all. They found exact ways to calculate how long it takes to recover the full message, and showed that some codes are best at minimizing reading cost. Their work explains when dividing data lowers only the waiting time and when it also saves money.
Open → 2610.02931v1

Torch-PIM speeds up deep learning by smartly moving work to memory cores

Torch-PIM: Automated Profile-Guided PIM Offloading for PyTorch

Abstract: Modern deep learning (DL) workloads are limited by data movement, and processing-in-memory (PIM) targets this bottleneck by placing compute units near the memory. However, PyTorch and other DL frameworks lack compiler support for making this decision on the code they lower: existing offloading frameworks target hand-written C/C++ programs, while those that address DL fix the candidate set to a list of operator types before lowering. We present Torch-PIM, a compiler framework that uses profile-guided optimization (PGO) to decide host-versus-PIM placement over the loop nests that progressive lowering materializes. Every parallel loop nest the pipeline emits enters the candidate space, and each is assessed in two stages: the amount of work it carries, and its memory boundedness. Every quantity the assessment consumes is profiled on the host or obtained from the multi-level intermediate representation (MLIR) of the code. Across PIM configurations of 32 to 128 cores, Torch-PIM's offloading decisions yield speedups of up to 8.6x on tensor operators, 2.9x on MLP, 4.4x on Attention, 5.1x on GPT-J-6B, and 3.6x on LLaMA-7B over CPU-only execution.

Mon 28 SeptHardware ArchitectureDistributed, Parallel, and Cluster Computing
The gist
Deep learning often slows down because data has to move a lot between memory and processors. The authors created Torch-PIM, a tool that automatically decides which parts of a deep learning program should run close to memory to save time. It looks carefully at the program’s loops and uses information from running the program to make these choices. Using Torch-PIM can make common deep learning tasks run several times faster compared to only using the main processor.
Open → 2609.34657v1

Trillion-parameter AI models hosted efficiently with flash storage

Trillion-Parameter MoE in a Box: Decoupling Memory Provisioning with High-Bandwidth Flash

Abstract: An MoE appliance for trillion-parameter models at low concurrency must host terabytes of weights on one node and serve prefill and decode with fixed resources. Combining operator analysis of two trillion-parameter MoE models, a measured expert routing trace, and agentic serving traces over multiple turns, we explore a design space spanning High-Bandwidth Flash (HBF) and DRAM configurations, bandwidth exposure, and near-data compute. We find that state bandwidth and HBF transport form two largely orthogonal knees and address two provisioning questions. Q1: Once weights move to HBF, what bandwidth-to-capacity ratio does DRAM require? With a 256-GB floor for the state tier, both models meet a $1.10\times$ completion time target at ratios of only $1.4$--$4.0~\mathrm{s}^{-1}$, roughly an order of magnitude below HBM3e's $33.3~\mathrm{s}^{-1}$. Q2: As HBF internal bandwidth scales with capacity, must bandwidth to the host scale proportionally? Six HBF packages expose 384~GB/s per package to the host, 2.30~TB/s aggregate and 62.5\% below the 6.14~TB/s full exposure reference, while more packages reduce required bandwidth per package at the same target.

Mon 14 SeptHardware Architecture
The gist
Very large AI models with trillions of parameters need enormous memory to work well. The authors studied how high-speed flash storage can be used together with smaller amounts of fast memory (DRAM) to host these massive models on a single machine. They found ways to balance memory size and data transfer speeds so the models perform almost as fast as if they used expensive high-bandwidth memory. This could make deploying huge AI models more practical and cost-effective.
Open → 2609.15636v1