Paper deep dive
RoofLang: Enabling AI-Driven Architecting of LLM Inference Systems
Ziyue Yang, Yuting Jiang, Lei Qu, Peng Cheng
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 9/16/2026, 8:59:27 AM
Summary
The paper introduces RoofLang, a domain-specific language (DSL) designed to enable AI-driven autonomous architecting of Large Language Model (LLM) inference systems. Unlike existing profiling-based optimization methods that are confined to existing software stacks, RoofLang provides a general workload representation, a verifiable mutation space, and an implementation-independent evaluator based on discrete-event simulation. The authors demonstrate that RoofLang can reveal significant performance gaps between models, such as DeepSeek V4-series models achieving up to 39.5x higher peak decode throughput than competitors due to compact KV-cache designs. Additionally, an AI optimizer agent using RoofLang discovered new architectures that improved throughput and interactivity of DeepSeek V4 Pro on NVIDIA B300 by 6.23-50.1%.
Entities (11)
Relation Signals (10)
Ziyue Yang → affiliatedwith → Shanghai Xingyunzhili Artificial Intelligence Institute
confidence 95% · Ziyue Yang 1∗ ... 1 Shanghai Xingyunzhili Artificial Intelligence Institute
Peng Cheng → affiliatedwith → Microsoft Research
confidence 95% · Peng Cheng 2 Microsoft Research, Redmond, WA, USA
RoofLang → enables → AI-driven LLM inference system architecting
confidence 95% · To enable the AI-driven LLM inference system architecting loop, we argue that a general workload representation... We present the RoofLang domain-specific language (DSL) that provides these features.
DeepSeek V4 Pro → runson → NVIDIA B300
confidence 95% · improved both throughput and interactivity of DeepSeek V4 Pro on NVIDIA B300 by 6.23-50.1%.
RoofLang → uses → Discrete Event Simulation
confidence 95% · evaluates the resulting organizations with a roofline-based discrete-event simulator.
RoofLang → uses → compute graph
confidence 95% · RoofLang represents workloads and hardware as graphs... The compute graph is an input to RoofLang
RoofLang → uses → hardware graph
confidence 95% · Another input to RoofLang is the hardware graph... It specifies the available compute and memory components
DeepSeek V4-series → →
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:AI is beginning to make substantive contributions to LLM inference optimization. Existing AI optimizations are predominantly profiling-based. Profiling-bound feedback confines the search to the capabilities and performance of an existing software stack, preventing a fundamentally better architecture of LLM inference systems from being identified. To enable the AI-driven LLM inference system architecting loop, we argue that a general workload representation, a verifiable mutation space, and an implementation-independent evaluator are required. We present the RoofLang domain-specific language (DSL) that provides these features. In our evaluation, RoofLang reveals that DeepSeek V4-series models could achieve 3.5-39.5$\times$ higher peak decode throughput than other representative models. This gap is disproportionate to their total parameter counts and arises largely from compact KV-cache designs that support larger batches and reduce memory traffic. A persistent optimizer agent further discovered several new architectures that improved both throughput and interactivity of DeepSeek V4 Pro on NVIDIA B300 by 6.23-50.1%.
Tags
Links
- Source: https://arxiv.org/abs/2609.12551v1
- Canonical: https://arxiv.org/abs/2609.12551v1
Trouble viewing inline? Open PDF directly →
Full Text
46,807 characters extracted from source content.
Expand or collapse full text
ROOFLANG: ENABLING AI-DRIVEN ARCHITECTING OF LLM INFERENCE SYSTEMS Ziyue Yang 1∗ Yuting Jiang 1 Lei Qu 1 Peng Cheng 2 1 Shanghai Xingyunzhili Artificial Intelligence Institute, Shanghai, China 2 Microsoft Research, Redmond, WA, USA ABSTRACT AI is beginning to make substantive contributions to LLM inference optimization. Existing AI optimizations are predominantly profiling-based. Profiling-bound feedback confines the search to the capabilities and performance of an existing software stack, preventing a fundamentally better architecture of LLM inference systems from being identified. To enable the AI-driven LLM inference system architecting loop, we argue that a general workload representation, a verifiable mutation space, and an implementation-independent evaluator are required. We present the ROOFLANG domain-specific language (DSL) that provides these fea- tures. In our evaluation, ROOFLANG reveals that DeepSeek V4-series models could achieve 3.5–39.5× higher peak decode throughput than other representative models. This gap is disproportionate to their total parameter counts and arises largely from compact KV-cache designs that support larger batches and reduce memory traffic. A persistent optimizer agent further discovered several new ar- chitectures that improved both throughput and interactivity of DeepSeek V4 Pro on NVIDIA B300 by 6.23–50.1%. § https://github.com/yzygitzh/rooflang https://yzygitzh.github.io/rooflang 1INTRODUCTION AI systems are beginning to take on substantive parts of large language model (LLM) inference optimization. Recent agents and automated workflows optimize kernels, compiler-generated code, framework configurations, and serving paths, turning implementation-level performance engineer- ing into a machine-actionable task (Ouyang et al., 2025; Xing et al., 2026; Andrews & Witteveen, 2025; Gai et al., 2026; MIT HAN Lab, 2026; Yeon et al., 2026). This emerging capability is an im- portant component of recursive self-improvement (RSI) of LLMs (Schmidhuber, 2007; Zhang et al., 2026). Most existing approaches organize this work around profiling. Profiling identifies hotspots in a current implementation and provides a clear verifier for whether a local change helps (Andrews & Witteveen, 2025; Gai et al., 2026; MIT HAN Lab, 2026; Unger et al., 2022). This feedback loop is productive, but its potential is constrained by the software stack being profiled. A fundamentally different architecture may better satisfy the serving objective yet remain unrealizable with the current stack because required features are absent or their implementations are insufficiently optimized. It would be desirable for AI to architect LLM inference systems from scratch and continuously opti- mize them. Closing such an autonomous loop requires a general representation of LLM workloads, a verifiable action space for architecting, and a mechanism to evaluate resulting architectures and provide feedback. These actions can organize computation and data through graph transformations, sharding, placement, communication, and memory choices for a target workload and hardware plat- form, potentially yielding more fundamental gains than tuning a fixed implementation surface. To realize this vision, we present the ROOFLANG domain-specific language (DSL), which pro- vides these features. RoofLang represents workloads and hardware as graphs, provides semantics- ∗ Correspondence to: Ziyue Yang <yzylivezh@hotmail.com>. 1 arXiv:2609.12551v1 [cs.DC] 11 Sep 2026 Provide verified LLM inference workload and its initial architecture in RoofLang 1 AI generates new architecture 2 Evaluate the new architecture with RoofLang Simulation 3 Figure 1: AI-driven autonomous architecting loop enabled by RoofLang. preserving graph transformations and placement primitives as architecting actions, and evaluates the resulting organizations with a roofline-based discrete-event simulator. The evaluator exposes compute, memory, network, dependency, contention, lifetime, and capacity costs while reducing interference from software-stack implementation details. Given a verified initial workload and ar- chitecture, an AI agent can propose new valid architecting actions and iteratively improve them using simulation feedback, closing the autonomous loop to explore meaningful architecting choices, as demonstrated in Figure 1. Our evaluation reveals two salient findings. First, DeepSeek V4-series models could achieve 3.5– 39.5× higher peak decode throughput than other representative models. Total parameter counts alone cannot explain this gap. Instead, the advantage arises largely from compact KV-cache designs that support larger batches and reduce memory traffic. Second, a persistent optimizer agent discov- ered several new architectures that improved both throughput and interactivity of DeepSeek V4 Pro on NVIDIA B300 by 6.23–50.1%. Together, these results expose model-level design insights and show that RoofLang can guide AI toward useful system architectures. Our main contributions are as follows: • A practical DSL for autonomous LLM inference system architecting. RoofLang com- bines general graph representations, a semantics-preserving action space, and a roofline- based evaluator in an AI-accessible loop. • An analysis of state-of-the-art models and architecting choices. We study how model, workload, and hardware characteristics affect graph organization, placement, sharding, memory, communication, and their trade-offs. • An evaluation of autonomous architecting by AI. We compare AI-driven exploration with heuristic grid search and examine how an agent uses simulation feedback to generate meaningful architecting choices. 2ROOFLANG DESIGN 2.1OVERVIEW Architecting an LLM inference system can be viewed as organizing computation and data to opti- mize a target objective. Autonomous architecting can be realized with the following three elements: • A general workload representation. A format sufficiently general to describe LLM infer- ence workloads without committing to a specific software stack. • Verifiable architecting actions. This capability is necessary to ensure that architecting actions made by autonomous processes are valid. • An architecture evaluator. A mechanism for evaluating the quality of an architecting ac- tion while minimizing interference from factors unrelated to architecting, such as software- stack implementation details. Given these elements and a verified input workload, an AI agent can generate valid architecting actions, whose evaluation result then provides feedback for revising those actions, enabling an au- tonomous loop for AI-driven architecting. Compute graphs provide a general workload representation, as widely used in modern AI frame- works (Abadi et al., 2016). Verified graph optimizers such as Unity demonstrate how graph substi- tutions can preserve semantics while changing computation and parallelization (Unger et al., 2022). 2 Our approach combines graph-based workload and hardware representations, constrained transfor- mation and placement primitives, and roofline-based simulation (Williams et al., 2009). This combi- nation evaluates architecting choices from analytical workload attributes and hardware specifications without requiring profiled operator implementations. We therefore present the RoofLang DSL, which provides these features for AI-driven architecting of LLM inference systems. Figure 2 gives an overview. A correct and externally supplied com- pute graph is first rewritten through semantics-preserving transformations. Placement combines the transformed compute graph with a hardware graph by assigning operators and tensors to hardware resources. Further semantics-preserving transformations can refine the transformed and tagged com- pute graph, including its communication realization. Finally, the transformed and tagged compute graph and the hardware graph are evaluated by roofline-based simulation, which emits a trace as feedback for subsequent architecting actions. Compute Graph Hardware Graph Simulation Trace Compute Graph (Transformed) Compute Graph (Transformed, Tagged) Compute Graph (Transformed, Tagged) Semantics-preserving Transformation Placement Semantics-preserving Transformation Simulation Figure 2: RoofLang DSL overview. The following subsections introduce the different components of the RoofLang DSL. 2.2COMPUTE GRAPH The compute graph is an input to RoofLang and provides a way to generally describe an LLM inference workload. It must be supplied externally, and its provider is responsible for guaranteeing that it faithfully and correctly represents the workload. Each node in the compute graph is a compute node that represents an operation, e.g., attention, GEMM, etc. A node specifies its input and output tensors and has analytical workload attributes such as tensor shapes and dtypes, FLOPs, and data movement. Compute nodes are classified as side-effect-free or side-effecting: a side-effect-free node is observable only through its output ten- sors, whereas a side-effecting node may also modify externally observable state. Each edge in the compute graph represents a data dependency from an output tensor of one operation to an input tensor of another. 2.3HARDWARE GRAPH Another input to RoofLang is the hardware graph, which provides a way to generally describe the target hardware platform for LLM inference. It specifies the available compute and memory com- ponents and the fabrics that connect them. The graph is supplied externally, and its provider is responsible for guaranteeing that it faithfully and correctly represents the target hardware. Each node in the hardware graph is either a compute device (e.g., CPUs, accelerators, NICs, switches, etc.) that has peak FLOPs for each supported precision or a memory device (e.g., DRAM, HBM, SSDs, etc.) that has a specified capacity. Each edge in the hardware graph represents a fabric 3 Table 1: Placement primitives. PrimitiveFunction operator.set_computeAssigns an operator to the compute device and, optionally, the underlying stream/queue on which it executes. tensor.set_memoryAssigns a tensor to the memory device in which it is stored. Table 2: Semantics-preserving transformation primitives. PrimitiveFunction graph.add_control_edgeAdds a happens-before dependency between two kernels. graph.remove_control_edgeRemoves a control edge between two kernels. graph.insert_identityInsert an identity operator between two kernels. graph.remove_identityRemove an identity operator between two kernels. graph.fuse_kernelsReplaces a subgraph with an operator denoting the same composition at the external boundary, using pre-defined rules, e.g., qk-norm-rope fusion. graph.split_kernel Replaces an operator with an equivalent partitioned or repli- cated subgraph and proper communication operators, using pre-defined rules. Examples for splitting a (m, k)× (k, n) GEMM are: • split-by-m: scatter–GEMMs–gather • split-by-k: scatter–GEMMs–reduce • split-by-n: broadcast–GEMMs–gather graph.dup_kernelReplicates a side-effect-free operator whose outputs are broadcasted, i.e., operator-broadcast⇒ broadcast-operators. graph.dedup_kernelMerge multiple same side-effect-free operators which accept broadcasted inputs, i.e., broadcast-operators⇒ operator-broadcast. graph.merge_gather_scatterReplaces a gather-scatter subgraph with per-operator-pair direct data edges if splitting dimensions of both operators are the same, else with an all-to-all operator. graph.merge_gather_broadcastReplaces a gather-broadcast subgraph with an all-gather operator. graph.merge_reduce_scatterReplaces a reduce-scatter subgraph with a reduce-scatter operator. graph.merge_reduce_broadcastReplaces a reduce-broadcast subgraph with an all-reduce operator. connection (e.g., PCIe, Ethernet, etc.) and has communication properties, including bandwidth and latency. 2.4PLACEMENT Placement lowers a compute graph onto a hardware graph, tags operators with compute devices and tensors with memory devices, so that it can be evaluated by the simulator. This is realized by two placement primitives summarized in Table 1. Note that placement is also semantics-preserving. 2.5SEMANTICS-PRESERVING TRANSFORMATION RoofLang implements semantics-preserving transformations through a set of primitives over the compute graph, summarized in Table 2. Each primitive applies a pre-defined, structurally con- strained rewrite whose stated preconditions preserve the modeled observations. 4 Executing a transformation updates the analytical attributes of the affected operators and tensors. For example, operator FLOPs and bytes transferred, as well as tensor shapes and communication volumes, are recomputed for the transformed subgraph. Placement and semantics-preserving trans- formation can be composed to express common LLM inference architecting actions. For example, RoofLang can encode the following actions, with the relevant primitives shown explicitly: • Prefill–decode (PD) disaggregation: the primitives operator.set compute and tensor.set memory assign prefill and decode computation, together with exchanged state, to distinct compute and memory devices (Zhong et al., 2024). • KV-cache lifecycle: graph.dupkernel and graph.dedupkernel can be used to control the granularity of KV recomputation and caching, while identity oper- ators such as ToNvme, ToDram, and ToHbm can be inserted or removed with graph.insert identity and graph.removeidentity to describe different KV-cache memory-tier policies (Sheng et al., 2023; Kwon et al., 2023). • Sharding: graph.splitkernel, operator.setcompute, tensor.set memory, and communication merging primitives can be used to re- alize typical model sharding mechanisms, including tensor parallelism (TP), context parallelism (CP), data parallelism (DP), expert parallelism (EP), and pipeline parallelism (P) (Narayanan et al., 2021; Jacobs et al., 2023; Lepikhin et al., 2020). 2.6SIMULATION The simulator executes the transformed and tagged compute graph as a topology-aware discrete- event simulation (DES). It obtains a topological order, releases a kernel when all data and control predecessors have completed and its assigned stream is available, and schedules start and comple- tion events on a priority queue. Each completion updates successor readiness, tensor liveness, and resource occupancy, so the trace represents dependency- constrained execution rather than a static sum of operator costs. Memory footprints of inputs, outputs, and weights are tracked with operator entry and exit events. The simulator reports the peak live bytes for each memory device and raises an out-of-memory diagnostic when a capacity is exceeded. For an operator K placed on compute device d, RoofLang models compute, local-memory, and networking costs, respectively. For compute cost, with q indexing dtypes, F K,q denoting FLOPs, and P d,q denoting the device peak FLOP/s at dtype q, T compute (K,d) = X q F K,q P d,q .(1) For local-memory cost, including tensor reads from and writes to local memory, T memory (K,d) = X t∈R K B read K,t β read d,t + X t∈W K B write K,t β write d,t ,(2) where the byte terms include the modeled input, weight, and output read/write fractions. For networking cost, including remote accesses and explicit communication, data are routed through the directed hardware fabrics. The corresponding network cost is T network (K) = α K + max ℓ∈L K B K,ℓ β ℓ , remote tensor access, V K B eff,K ,collective communication, (3) with latency α K , link bytes B K,ℓ , link bandwidth β ℓ , and collective volume V K and effective par- ticipant bandwidth B eff,K . In the no-contention baseline, the operator duration is the bottleneck component, assuming ideal full overlap among compute, local-memory, and networking costs (with byte and rate units chosen consistently), T K = maxT compute ,T memory ,T network .(4) 5 Table 3: Models used in RoofLang evaluation. ModelParametersLayersAttentionFFN DeepSeek V4 Flash284BA13B43CSA + HCA1 shared and top-6 of 256 routed experts GLM-5.3744BA40B78DSA + MLA3 dense layers, 1 shared and top-8 of 256 routed experts DeepSeek V4 Pro1.6TA49B61CSA + HCA1 shared and top-6 of 384 routed experts Kimi K32.8TA104B93KDA + MLA1 dense layer, 2 shared and top-16 of 896 routed experts Table 4: Model-specific numerical precision configuration in RoofLang evaluation. ModelKVAttentionFFN DeepSeek V4 FlashFP8 main cache and FP4 index cacheFP8FP4 GLM-5.3FP8 main cache and FP8 index cacheBF16FP8 DeepSeek V4 ProFP8 main cache and FP4 index cacheFP8FP4 Kimi K3FP8 MLA cache and BF16 KDA statesFP8 MLA and BF16 KDAFP4 Collective communication uses a theoretical α+β model rather than a packet-level schedule (Hock- ney, 1994). The α term is the maximum path latency among the participating ranks, i.e., the weighted diameter of their data propagation graph. The β term is an aggregate bandwidth esti- mated heuristically from the hardware topology. Its effective value is further controlled by the fabric resource-sharing mechanism described below, so concurrent transfers reduce the available band- width according to contention. The DES models resource sharing while events are active. Operators consuming a compute device or a fabric receive normalized, capacity-weighted shares: if c i is an operator’s resource cap and A r is the active set consuming resource r, its share is c i / max(1, P j∈A r c j ). When sharing occurs among multiple operators, the simulated cost during the sharing interval extends proportionately until the set of sharing operators changes. This gives a reasonable estimation of scenarios where multiple operators share a single resource. 3EVALUATION 3.1ROOFLANG EFFICACY ON REPRESENTATIVE LLMS AND HARDWARE 3.1.1SETUP Models. We evaluate four representative models: DeepSeek V4 Flash, GLM-5.3, DeepSeek V4 Pro, and Kimi K3 (DeepSeek-AI et al., 2026; GLM-5-Team et al., 2026; Z.ai, 2026; Kimi Team et al., 2026). Tables 3 and 4 summarize their model structures and their numerical precision configurations, respectively. For simplicity, we omit KV-cache appending and speculative-decoding structures from all four models, as well as the multimodal components of Kimi K3. Hardware. Table 5 summarizes four representative hardware platforms: NVIDIA H200, NVIDIA GH200, NVIDIA B300, and NVIDIA GB300. We assume NVLink for scale-up networking and InfiniBand for scale-out networking. For NVIDIA H200 and NVIDIA GH200, they cannot do native FP4, and we assume they can emulate FP4 as fast as FP8. The modeled peak rates, memory capacities, and interconnect parameters are derived from NVIDIA specifications (NVIDIA, n.d.; 2026a;b; 2025). Workload. Table 6 summarizes the workload space evaluated, including stages, contexts, GPU counts, parallelism dimensions, and batch sizes. For GPU counts, we select 8 and 64 to probe the efficacy of larger scale-up networking scope. For context length, we select 64K as it is the dominant long-context regime according to a recent study Lee et al. (2026), and we select 1M as it is the maximum supported by the evaluated models (DeepSeek-AI et al., 2026; Z.ai, 2026; Kimi Team et al., 2026). We adopt context parallelism (CP) instead of tensor parallelism (TP) because sequence-wise sharding is better suited to long contexts and avoids the KV-cache replication that TP can induce Lee et al. (2026). We further heuristically let DP×CP = EP, referencing the large-scale inference configuration in the DeepSeek-V3 report DeepSeek-AI et al. (2024). For batch size, we sweep 2 n from n = 0 and stop at the first OOM point. 6 Table 5: Hardware platforms used in RoofLang evaluation. Platform FP4 TFLOP/s FP8 TFLOP/s BF16 TFLOP/s TF32 TFLOP/s HBM GB HBM BW GB/s NVLink BW GB/s NVLink max scope InfiniBand BW GB/s NVIDIA H2001,9791,9799894951444,800450850 NVIDIA GH2001,9791,9799894951444,90045025650 NVIDIA B30013,5004,5002,2501,1252887,7509008100 NVIDIA GB30015,0005,0002,5001,2502888,00090072100 Table 6: Workload configuration search space in RoofLang evaluation. ConfigurationValues Stageprefill, decode (1-step) Context64K, 1M GPU counts8, 64 ParallelismDP, CP, P, EP, where EP× P = DP× CP× P = n GPUs Batch size2 n until OOM, n≥ 0 Simulation. We run the discrete-event simulation (DES) as described in Section 2.6. Across the overall execution timeline, we assume that computation and communication overlap perfectly through fine-grained overlapping (DeepSeek-AI et al., 2024), and derive the final throughput and in- teractivity from the overlapped timeline. We further assume that routed tokens are ideally balanced across MoE experts. 3.1.2RESULTS Figures 3 and 4 plot the resulting throughput–interactivity Pareto frontiers for prefill and decode, respectively. Frontier shape. Across models, contexts, hardware platforms, and GPU counts, the curves exhibit the expected throughput–interactivity shape: higher throughput coincides with lower interactivity, and vice versa. Frontier endpoints. The left endpoints for prefill correspond to large-batch, high-arithmetic- intensity configurations, and their throughput values are primarily bounded by model compute FLOPs divided by GPU FLOP rates. The right endpoints of decode correspond to small-batch, interactivity-oriented configurations, and their interactivity values are primarily bounded by the activated-parameter bytes per step divided by HBM bandwidth. Decode throughput. Among the plotted curves for 64 NVIDIA GB300 GPUs, at 64K-context and 1M-context, respectively, DeepSeek V4 Flash reaches 9.6× and 16.7× the peak decode throughput of GLM-5.3. The corresponding ratios over Kimi K3 are 25.2× and 39.5×. For DeepSeek V4 Pro, the 64K and 1M ratios are 3.5× and 5.3× over GLM-5.3, and 9.3× and 12.4× over Kimi K3. These gaps arise in large part from per-decode-token memory overhead. For batch size B, we calculate this overhead as M decode = P + BT KV B ,(5) where P is the encoded model-weight size and T KV is the per-request total KV-cache read. The peak decode throughput in Figure 4 is thus largely determined by the per-decode-token memory traffic in Tables 7 and 8. Models with smaller per-request KV-cache footprints can sustain larger batches, more effectively amortizing model-weight traffic in the memory-bound regime. Smaller per-request KV-cache traffic further reduces M decode and amplifies this throughput advantage. Interconnect sensitivity. Larger scale-up networking domains enable faster MoE token routing and are more beneficial when MoE routing traffic dominates. This aligns with the expected bot- tleneck shifting between attention and MoE. For prefill, computation dominates, so MoE routing traffic can be readily hidden at reasonably large batch sizes without substantially affecting inter- activity. For decode, KV-cache traffic under CP is carried by aggregation collectives and runs at 7 04M8M12M tokens/s/user 0 40K 80K 120K 160K tokens/s/GPU 8-gpus 04M8M12M tokens/s/user 64-gpus deepseek-v4-flash-64k-prefill 04M8M12M tokens/s/user 0 25K 50K 75K 100K tokens/s/GPU 8-gpus 04M8M12M tokens/s/user 64-gpus deepseek-v4-flash-1m-prefill 01M2M3M tokens/s/user 0 10K 20K 30K 40K tokens/s/GPU 8-gpus 01M2M3M tokens/s/user 64-gpus glm-5.3-64k-prefill 01M2M3M tokens/s/user 0 5K 10K 15K 20K 25K tokens/s/GPU 8-gpus 01M2M3M tokens/s/user 64-gpus glm-5.3-1m-prefill 01M2M3M4M tokens/s/user 0 15K 30K 45K 60K tokens/s/GPU 8-gpus 01M2M3M4M tokens/s/user 64-gpus deepseek-v4-pro-64k-prefill 01M2M3M4M tokens/s/user 0 7K 14K 21K 28K 35K tokens/s/GPU 8-gpus 01M2M3M4M tokens/s/user 64-gpus deepseek-v4-pro-1m-prefill 0250K500K750K tokens/s/user 0 4K 8K 12K 16K tokens/s/GPU 8-gpus 0250K500K750K tokens/s/user 64-gpus kimi-k3-64k-prefill 0250K500K750K tokens/s/user 0 500 1K 1.5K 2K tokens/s/GPU 8-gpus 0250K500K750K tokens/s/user 64-gpus kimi-k3-1m-prefill H200GH200B300GB300 Figure 3: Throughput (token/s/GPU) - interactivity (token/s/user) pareto frontier for prefill. similar bandwidth over scale-up and scale-out networks. As the KV cache grows, MoE token rout- ing accounts for a smaller fraction of the total overhead because attention time increases and the routing traffic itself decreases with the lower sustainable batch size, leaving less end-to-end room for a larger scale-up networking domain to improve performance. The decode curves in Figure 4 follow the KV-cache traffic and batch sizes at peak throughput reported in Tables 7 and 8. 8 0300600900 tokens/s/user 0 25K 50K 75K 100K tokens/s/GPU 8-gpus 0300600900 tokens/s/user 64-gpus deepseek-v4-flash-64k-decode 0300600900 tokens/s/user 0 3K 6K 9K 12K 15K tokens/s/GPU 8-gpus 0300600900 tokens/s/user 64-gpus deepseek-v4-flash-1m-decode 0100200300 tokens/s/user 0 3K 6K 9K 12K tokens/s/GPU 8-gpus 0100200300 tokens/s/user 64-gpus glm-5.3-64k-decode 0100200300 tokens/s/user 0 200 400 600 800 tokens/s/GPU 8-gpus 0100200300 tokens/s/user 64-gpus glm-5.3-1m-decode 050100150200 tokens/s/user 0 10K 20K 30K 40K tokens/s/GPU 8-gpus 050100150200 tokens/s/user 64-gpus deepseek-v4-pro-64k-decode 050100150200 tokens/s/user 0 1K 2K 3K 4K tokens/s/GPU 8-gpus 050100150200 tokens/s/user 64-gpus deepseek-v4-pro-1m-decode 0255075100 tokens/s/user 0 1K 2K 3K 4K tokens/s/GPU 8-gpus 0255075100 tokens/s/user 64-gpus kimi-k3-64k-decode 0255075100 tokens/s/user 0 90 180 270 360 tokens/s/GPU 8-gpus 0255075100 tokens/s/user 64-gpus kimi-k3-1m-decode H200GH200B300GB300 Figure 4: Throughput (token/s/GPU) - interactivity (token/s/user) pareto frontier for decode. 3.2AI-DRIVEN AUTONOMOUS ARCHITECTING 3.2.1SETUP We implement a simple optimizer agent by running Claude Code persistently in non-interactive mode, without a preset turn limit (Anthropic, n.d.), thereby realizing the autonomous loop in Fig- ure 1. Following DeepSeek’s official Claude Code integration guide, we configure DeepSeek V4 Pro 9 Table 7: Per-decode-token memory overhead at 64K context (64 NVIDIA GB300 GPUs). Model Per-request parameters traffic Per-request KV-cache footprint Per-request KV-cache traffic Peak batch size Per-decode-token memory traffic DeepSeek V4 Flash2.277 MiB0.192 GiB0.033 GiB65,5360.035 GiB GLM-5.3173.618 MiB2.906 GiB0.250 GiB4,0960.419 GiB DeepSeek V4 Pro24.811 MiB0.275 GiB0.055 GiB32,7680.079 GiB Kimi K3175.897 MiB1.065 GiB1.065 GiB8,1921.237 GiB Table 8: Per-decode-token memory overhead at 1M context (64 NVIDIA GB300 GPUs). Model Per-request parameters traffic Per-request KV-cache footprint Per-request KV-cache traffic Peak batch size Per-decode-token memory traffic DeepSeek V4 Flash36.439 MiB3.034 GiB0.414 GiB4,0960.450 GiB GLM-5.32,777.892 MiB46.500 GiB2.711 GiB2565.423 GiB DeepSeek V4 Pro396.984 MiB4.344 GiB0.608 GiB2,0480.996 GiB Kimi K32,814.346 MiB13.721 GiB13.721 GiB51216.469 GiB as the primary model and DeepSeek V4 Flash as the lightweight and subagent model (DeepSeek-AI, n.d.). We let the optimizer agent improve the DeepSeek V4 Pro implementation in RoofLang. In each opti- mization session, we provide the agent with the RoofLang source repository, including the DeepSeek V4 Pro implementation, together with the baseline results from Section 3.1. The agent is instructed to keep seeking new device placements and semantics-preserving graph transformations that im- prove the throughput–interactivity Pareto frontier according to simulation feedback. It continues this loop until it decides to stop. 3.2.2RESULTS We discuss three representative cases below. Cost- and head-aware contiguous P partition. Balancing P stages solely by layer count can leave the embedding-bearing first stage or output-head-bearing last stage on the critical path. The agent therefore calibrated stage costs from traces and enumerated legal contiguous partitions that re- duced either or both boundary-stage loads without changing layer order or P degree. For DeepSeek V4 Pro decode-64K on 256 B300 GPUs with batch 4,096, EP=16, and P=16, it replaced the bal- anced partition (4× 13, 3× 3) with (3, 4× 14, 2). Accounting for the extra embedding and output- head work reduced the maximum stage span and improved both throughput and interactivity by 20.3%. DP–CP routed-expert splitting. The agent split each routed expert along the existing DP-major, CP-minor token shards and applied graph.split kernel to the expert up and down projec- tions, creating one copy per DP×CP shard. This allowed same-dimension Gather–Scatter pairs to be replaced by rank-local data edges, removing redundant local token materialization while preserv- ing routing and expert ownership. Because the split incurs additional expert-weight reads, it was en- abled only when each copy had at least 1,024 routed tokens and EP was at most eight. For DeepSeek V4 Pro prefill-8K on eight B300 GPUs with batch 512, the large prefill token volume amortized the extra weight traffic, and removing the local Gather–Scatter traffic improved both throughput and interactivity by 6.23%. Node-local expert replication. The agent replicated selected experts across the two nodes of an EP=16 stage, so routed-token dispatch and combine paths used node-local NVLink rather than cross-node InfiniBand. The change preserves expert computation but trades additional expert- weight reads and HBM capacity for lower exposed routing communication, and was applied only to communication-bound cases. For DeepSeek V4 Pro prefill-1M on 16 B300 GPUs with batch 1 and CP=EP=16, the large routed-token shards made inter-node communication dominant; node-local routing reduced that bottleneck and improved both throughput and interactivity by 50.1%. 10 4RELATED WORK 4.1INFERENCE PERFORMANCE MODELING Inference performance models span analytical abstractions and high-fidelity simulators.The Roofline model bounds performance using arithmetic intensity and hardware compute and band- width ceilings (Williams et al., 2009), while LLM-Viewer and Calculon apply analytical modeling to LLM inference (Yuan et al., 2024; Isaev et al., 2023). Simulation systems incorporate more ex- ecution detail: ASTRA-sim models distributed computation and communication, Vidur simulates LLM serving workloads, Frontier uses discrete-event simulation with timing and memory mod- els calibrated against concrete serving stacks, and KernelSight-LM augments a kernel-level roofline model with learned efficiency factors and embeds it in a discrete-event serving simulator (Won et al., 2023; Agrawal et al., 2024; Feng et al., 2026; Yao et al., 2026). These methods trade evaluation cost and generality for different levels of fidelity, but performance estimation alone does not establish semantic equivalence between candidate architectures. Verified graph optimization addresses this complementary requirement. Unity jointly optimizes algebraic transformations and parallelization for distributed DNN training using a unified parallel computation graph (Unger et al., 2022). ROOFLANG combines a constrained mutation space with a roofline-based evaluator derived from analytical workload attributes and hardware specifications, without requiring profiled operator im- plementations. Its focus is this combination for AI-driven LLM inference system architecting, rather than transformation verification alone. Human verification remains necessary for the initial input graphs and the transformation contracts; subsequent exploration is restricted to placement opera- tions and semantics-preserving transformations under their stated preconditions. 4.2KERNEL AGENTS AND OTHER EFFORTS FOR RSI Kernel agents and related efforts toward recursive self-improvement (RSI) close optimization loops around executable implementations (Schmidhuber, 2007; Zhang et al., 2026). SGLang exposes pro- filing tools and agent-facing developer skills (SGLang, n.d.; 2026), while Kernel Design Agents and KDA-Pilot organize repository-scale kernel optimization around task contracts, correctness gates, profiling evidence, and repeated benchmarking (MIT HAN Lab, 2026; BBuf, 2026). KernelBench and FlashInfer-Bench evaluate generated kernels through execution and performance tests (Ouyang et al., 2025; Xing et al., 2026), while GPU Kernel Scientist and KernelPro iteratively optimize kernels using profiling feedback (Andrews & Witteveen, 2025; Gai et al., 2026). AMD GEAK pro- vides a related industrial agentic workflow (An et al., 2026). InferenceBench extends this approach to open-ended inference-server optimization (Yeon et al., 2026). OptiFlow optimizes collective communication by combining LLM-generated data-movement programs in a DSL, deterministic scheduling, and iterative refinement using real-hardware feedback (Long et al., 2026). These sys- tems either manipulate real code directly or derive feedback from performance samples collected on real hardware, rather than using an implementation-independent architectural oracle. This implementation-grounded feedback is concrete, but it couples the search space to the available kernels, compiler, framework, and hardware. A design may remain unreachable or appear inferior when its required features are absent or poorly optimized in the current stack. ROOFLANG decou- ples architectural design from concrete implementation details by evaluating graph organizations with hardware specifications and roofline relations. It can therefore search for designs that are in- trinsically more efficient under theoretical resource limits before implementation quality biases the comparison. After an architecture is selected, kernel agents and framework-level tools can optimize its concrete implementation. 5CONCLUSION, LIMITATIONS, AND FUTURE DIRECTIONS ROOFLANG is an initial step toward enabling AI-driven architecting of LLM inference systems. The DSL combines expert-authored compute and hardware graphs, explicit placement and commu- nication, semantics-preserving transformations, and a roofline-based discrete-event simulator. Its evaluation yields two central insights. First, DeepSeek V4-series models could achieve 3.5–39.5× 11 higher peak decode throughput than other representative models, despite no commensurate differ- ence in total parameter counts. This advantage arises largely from compact KV-cache designs that support larger batches and reduce memory traffic. Second, a persistent optimizer agent discovered several new architectures that improved both throughput and interactivity of DeepSeek V4 Pro on NVIDIA B300 by 6.23–50.1%. Together, these findings indicate that a verification-constrained an- alytical model can expose useful model-level insights and guide architectural exploration before implementation-specific optimization. Despite this progress, three limitations currently bound the autonomy, modeling fidelity, and scala- bility of ROOFLANG. Initial-input verification.ROOFLANG currently assumes that the initial compute and hardware graphs are correct. This concentrates but does not eliminate the need for human verification. Future work should automate initial-input construction and validation, for example by deriving compute graphs from official baseline implementations and checking them against execution traces. Modeling fidelity. The current models simplify behaviors that can materially affect performance. They assume ideal MoE load balance and omit KV-cache appending, speculative-decoding struc- tures, and Kimi K3’s multimodal components. Future extensions should represent these behaviors explicitly and calibrate them against measured implementations while preserving the existing muta- tion and equivalence contracts. Simulation scalability. The current discrete-event simulator does not scale efficiently to the largest configurations. Simulating Kimi K3 on 128 GPUs can require hours and hundreds of gi- gabytes of memory, which makes repeated agentic optimization impractical. Future work should reduce event and state materialization, reuse unchanged subgraphs across candidates, and introduce scalable parallel or approximate evaluation without weakening correctness checks. REFERENCES Mart ́ ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek G. Murray, Benoit Steiner, Paul Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: A system for large- scale machine learning. In 12th USENIX Symposium on Operating Systems Design and Implemen- tation, p. 265–283, 2016. URL https://w.usenix.org/conference/osdi16/ technical-sessions/presentation/abadi. Amey Agrawal, Nitin Kedia, Jayashree Mohan, Ashish Panwar, Nipun Kwatra, Bhargav S. Gula- vani, Ramachandran Ramjee, and Alexey Tumanov. Vidur: A large-scale simulation framework for LLM inference. In Proceedings of Machine Learning and Systems, volume 6, p. 351– 366, 2024. URL https://proceedings.mlsys.org/paper_files/paper/2024/ hash/b74a8de47d2b3c928360e0a011f48351-Abstract-Conference.html. Zihao An, Yue Liu, Chao Xu, Ethan Yang, Hongtao Meng, Chushi Chen, Puyuan Yang, Subrah- manya Pavankumar Dubaguntta, Saptarshi Majumder, Umang Pandey, Aditya Kumar Singh, Fan Wang, Zheng Yao, Qiong Zhu, Yixiong Huo, Dan Li, Ji Liu, Zeping Li, Ziqiong Liu, Arthur Huang, Fuwei Yang, Pratik Prabhanjan Brahma, Dong Li, Zicheng Liu, and Emad Bar- soum. GEAK v4: From faster kernels to faster workloads. AMD Developer Central tech- nical article, July 2026. URL https://w.amd.com/en/developer/resources/ technical-articles/2026/geak-v4.html. Martin Andrews and Sam Witteveen. GPU Kernel Scientist: An LLM-driven framework for iterative kernel optimization. arXiv preprint arXiv:2506.20807, 2025. URL https://arxiv.org/ abs/2506.20807. Anthropic. CLI reference. Claude Code documentation, n.d. URL https://code.claude. com/docs/en/cli-usage. Accessed September 3, 2026. 12 BBuf. KDA-Pilot: Evidence-first autonomous GPU-kernel optimization campaigns for SGLang. GitHub repository, 2026. URL https://github.com/BBuf/KDA-Pilot. Accessed September 3, 2026. DeepSeek-AI.Integrate with Claude Code.DeepSeek API documentation, n.d.URL https://api-docs.deepseek.com/quick_start/agent_integrations/ claude_code/. Accessed September 3, 2026. DeepSeek-AI et al. DeepSeek-V3 technical report. arXiv preprint arXiv:2412.19437, 2024. URL https://arxiv.org/abs/2412.19437. DeepSeek-AI et al. DeepSeek-V4: Towards highly efficient million-token context intelligence. arXiv preprint arXiv:2606.19348, 2026. URL https://arxiv.org/abs/2606.19348. Yicheng Feng, Xin Tan, Yangtao Deng, Yimin Jiang, Yibo Zhu, and Hong Xu. Frontier: Towards comprehensive and accurate LLM inference simulation. arXiv preprint arXiv:2605.21312, 2026. URL https://arxiv.org/abs/2605.21312. Jiading Gai, Shuai Zhang, Kaj Bostrom, Jin Huang, Vihang Patil, Haoyang Fang, Bernie Wang, Huzefa Rangwala, and George Karypis. Optimizing CUDA like a human: Micro-profiling tools as expert surrogates for LLM-based GPU kernel optimization. arXiv preprint arXiv:2606.26453, 2026. URL https://arxiv.org/abs/2606.26453. GLM-5-Team et al.GLM-5: From vibe coding to agentic engineering.arXiv preprint arXiv:2602.15763, 2026. URL https://arxiv.org/abs/2602.15763. Roger W. Hockney. The communication challenge for MPP: Intel Paragon and Meiko CS-2. Parallel Computing, 20(3):389–398, 1994. doi: 10.1016/S0167-8191(06)80021-9. Mikhail Isaev, Nic McDonald, Larry Dennison, and Richard W. Vuduc. Calculon: A methodology and tool for high-level co-design of systems and large language models. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, p. 1–14, 2023. doi: 10.1145/3581784.3607102. Sam Ade Jacobs, Masahiro Tanaka, Chengming Zhang, Minjia Zhang, Shuaiwen Leon Song, Samyam Rajbhandari, and Yuxiong He. DeepSpeed Ulysses: System optimizations for enabling training of extreme long sequence transformer models. arXiv preprint arXiv:2309.14509, 2023. URL https://arxiv.org/abs/2309.14509. Kimi Team et al. Kimi K3: Open frontier intelligence. arXiv preprint arXiv:2607.24653, 2026. URL https://arxiv.org/abs/2607.24653. Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E. Gonzalez, Hao Zhang, and Ion Stoica. Efficient memory management for large language model serving with PagedAttention. In Proceedings of the 29th Symposium on Operating Systems Prin- ciples, p. 611–626, 2023. doi: 10.1145/3600006.3613165. Seonghee Lee, Sungsoo Ha, Omri Almog, and Lucas Wilkinson. Efficient decode context par- allelism with vllm for long context workloads. vLLM Blog, August 2026. URL https: //vllm.ai/blog/2026-08-07-decode-context-parallelism. Dmitry Lepikhin, HyoukJoong Lee, Yuanzhong Xu, Dehao Chen, Orhan Firat, Yanping Huang, Maxim Krikun, Noam Shazeer, and Zhifeng Chen. GShard: Scaling giant models with conditional computation and automatic sharding. arXiv preprint arXiv:2006.16668, 2020. URL https: //arxiv.org/abs/2006.16668. Fei Long, Ziyue Yang, Kaihui Gao, Shuai Wang, Li Chen, Zhixiong Niu, Ran Shu, Wenxue Cheng, Peng Cheng, Yongqiang Xiong, and Dan Li. OptiFlow: Towards LLM-driven optimization of collective communication algorithms. In Proceedings of the 10th Asia-Pacific Workshop on Net- working, p. 73–81. ACM, 2026. doi: 10.1145/3820441.3820452. MIT HAN Lab. Kernel design agents. GitHub repository, 2026. URL https://github.com/ mit-han-lab/kernel-design-agents. Accessed September 3, 2026. 13 Deepak Narayanan, Mohammad Shoeybi, Jared Casper, Patrick LeGresley, Mostofa Patwary, Vi- jay Anand Korthikanti, Dmitri Vainbrand, Prethvi Kashinkunti, Julie Bernauer, Bryan Catanzaro, Amar Phanishayee, and Matei Zaharia. Efficient large-scale language model training on GPU clusters using Megatron-LM. In Proceedings of the International Conference for High Perfor- mance Computing, Networking, Storage and Analysis, p. 1–15, 2021. doi: 10.1145/3458817. 3476209. NVIDIA. NVIDIA GB300 NVL72. Product specifications, 2025. URL https://w.nvidia. com/en-us/data-center/gb300-nvl72/. Accessed September 3, 2026. NVIDIA. Grace performance tuning guide. Technical guide, 2026a. URL https://docs. nvidia.com/dccpu/grace-perf-tuning-guide/index.html. Accessed Septem- ber 3, 2026. NVIDIA.NVIDIA HGX AI Factory: NVIDIA Enterprise Reference Architecture.Ref- erence architecture white paper,2026b.URL https://docs.nvidia.com/ enterprise-reference-architectures/hgx-ai-factory/latest/index. html. Accessed September 3, 2026. NVIDIA. NVIDIA H200 GPU. Product specifications, n.d. URL https://w.nvidia.com/ en-us/data-center/h200/. Accessed September 3, 2026. Anne Ouyang, Simon Guo, Simran Arora, Alex L. Zhang, William Hu, Christopher R ́ e, and Azalia Mirhoseini. KernelBench: Can LLMs write efficient GPU kernels? In Proceedings of the 42nd International Conference on Machine Learning, volume 267, p. 47356–47415, 2025. URL https://proceedings.mlr.press/v267/ouyang25a.html. J ̈ urgen Schmidhuber. G ̈ odel machines: Fully self-referential optimal universal self-improvers. In Ben Goertzel and Cassio Pennachin (eds.), Artificial General Intelligence, p. 199–226. Springer, 2007. doi: 10.1007/978-3-540-68677-4 7. SGLang.SGLang .claude/skills.SGLangGitHubrepository,commit d3bae71,2026.URL https://github.com/sgl-project/sglang/tree/ d3bae71e3f1fd983853cae4f95591d4a8545325f/.claude/skills.Accessed September 3, 2026. SGLang.Benchmark and profiling.SGLang documentation, n.d.URL https:// docs.sglang.io/docs/developer_guide/benchmark_and_profiling.Ac- cessed September 3, 2026. Ying Sheng, Lianmin Zheng, Binhang Yuan, Zhuohan Li, Max Ryabinin, Beidi Chen, Percy Liang, Christopher R ́ e, Ion Stoica, and Ce Zhang. FlexGen: High-throughput generative inference of large language models with a single GPU. In Proceedings of the 40th International Conference on Machine Learning, volume 202, p. 31094–31116, 2023. URL https://proceedings. mlr.press/v202/sheng23a.html. Colin Unger, Zhihao Jia, Wei Wu, Sina Lin, Mandeep Baines, Carlos Efrain Quintero Narvaez, Vinay Ramakrishnaiah, Nirmal Prajapati, Pat McCormick, Jamaludin Mohd-Yusof, Xi Luo, Dheevatsa Mudigere, Jongsoo Park, Misha Smelyanskiy, and Alex Aiken. Unity: Accelerat- ing DNN training through joint optimization of algebraic transformations and parallelization. In 16th USENIX Symposium on Operating Systems Design and Implementation, p. 267–284. USENIX Association, 2022. URL https://w.usenix.org/conference/osdi22/ presentation/unger. Samuel Williams, Andrew Waterman, and David Patterson. Roofline: An insightful visual perfor- mance model for multicore architectures. Communications of the ACM, 52(4):65–76, 2009. doi: 10.1145/1498765.1498785. William Won, Taekyung Heo, Saeed Rashidi, Srinivas Sridharan, Sudarshan Srinivasan, and Tushar Krishna. ASTRA-sim2.0: Modeling hierarchical networks and disaggregated systems for large- model training at scale. In 2023 IEEE International Symposium on Performance Analysis of Systems and Software, p. 283–294, 2023. doi: 10.1109/ISPASS57527.2023.00035. 14 Shanli Xing, Yiyan Zhai, Alexander Jiang, Yixin Dong, Yong Wu, Zihao Ye, Charlie Ruan, Yingyi Huang, Yineng Zhang, Liangsheng Yin, Aksara Bayyapu, Luis Ceze, and Tianqi Chen. FlashInfer-Bench: Building the virtuous cycle for AI-driven LLM systems.arXiv preprint arXiv:2601.00227, 2026. URL https://arxiv.org/abs/2601.00227. Xiteng Yao, Taeho Kim, Hengzhi Pei, Xinle Liu, Kyle Ulrich, Leonard Lausen, Ashish Khetan, Xiang Song, George Karypis, and Martin Herbordt. KernelSight-LM: A kernel-level LLM infer- ence simulator. arXiv preprint arXiv:2606.28565, 2026. doi: 10.48550/arXiv.2606.28565. URL https://arxiv.org/abs/2606.28565. Jehyeok Yeon, Ben Rank, and Maksym Andriushchenko. InferenceBench: A benchmark for open- ended LLM inference optimization by AI agents. arXiv preprint arXiv:2607.20468, 2026. URL https://arxiv.org/abs/2607.20468. Zhihang Yuan, Yuzhang Shang, Yang Zhou, Zhen Dong, Zhe Zhou, Chenhao Xue, Bingzhe Wu, Zhikai Li, Qingyi Gu, Yong Jae Lee, Yan Yan, Beidi Chen, Guangyu Sun, and Kurt Keutzer. LLM inference unveiled: Survey and roofline model insights. arXiv preprint arXiv:2402.16363, 2024. URL https://arxiv.org/abs/2402.16363. Z.ai.GLM-5.3.Hugging Face model card, 2026.URL https://huggingface.co/ zai-org/GLM-5.3. Accessed September 3, 2026. Jenny Zhang, Shengran Hu, Cong Lu, Robert Lange, and Jeff Clune. Darwin G ̈ odel Machine: Open-ended evolution of self-improving agents. In The Fourteenth International Conference on Learning Representations, 2026. URL https://iclr.c/virtual/2026/poster/ 10007327. Yinmin Zhong, Shengyu Liu, Junda Chen, Jianbo Hu, Yibo Zhu, Xuanzhe Liu, Xin Jin, and Hao Zhang. DistServe: Disaggregating prefill and decoding for goodput-optimized large language model serving.In 18th USENIX Symposium on Operating Systems Design and Implemen- tation, p. 193–210, 2024. URL https://w.usenix.org/conference/osdi24/ presentation/zhong-yinmin. 15