Searcharxiv⌕ Search

arXiv · 2610.23086

PairSight: Characterizing and Predicting Operator-Level Interference in GPU Sharing for DNN Inference

Abstract

Serving DNN inference is costly, yet a single task seldom saturates both the compute units and the memory bandwidth of a GPU. GPU sharing raises utilization by co-locating several tasks on one GPU, at the cost of interference among them. Existing systems estimate this interference with binary compute-memory rules, standalone scaling curves, or model-level predictors. However, these estimates rest on a limited understanding of interference. They leave the software and hardware properties of co-located operators largely unexplored and give no slowdown prediction that is both interpretable and accurate. We conduct an operator-level study of interference under SM partitioning and use hardware counters to trace it to contention on the shared memory path, where the slowdown depends jointly on both co-located operators. Based on these findings, we propose PairSight, a hardware-aware interference predictor that learns how the hardware behaviors of co-located tasks interact and predicts the latency of each task before co-location. On six DNN models including LLMs, PairSight predicts latency under sharing with 4.3% mean error, against 19.0% for a compute-memory intensity rule, and adapts to unseen models and inputs with a few samples.

Explore related subjects

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Xiao Liu, Yujia Fu, Yue Yu, Dan Huang. 2026-10-16. PairSight: Characterizing and Predicting Operator-Level Interference in GPU Sharing for DNN Inference. https://arxiv.org/abs/2610.23086

Cite the original work for its findings. Save a collection to share your selection of sources.

KEEP EXPLORING

Related papers

Phase-Scoped Query Layouts for Reference-Preserving Speculative Decoding

Speculative verification changes how a target model batches its queries. In a quantized deployment, that change can alter the generated tokens even when the verification algorithm is mathematically valid. We present a phase-scoped query-to-batch (QB) transformation that preserves an existing greedy reference while retaining batched projections and feed-forward computation. QB represents independent attention queries through matched query and mask views, shares K/V storage, and makes the selected layout part of graph reuse. In a six-session experiment spanning two dates, it reduces speculative request latency relative to explicit per-query attention by 3.06%, 6.17% and 2.83% for Qwen3, SmolLM2 and Llama, with complete reference-output agreement on the fixed panel. A separate 72-context CUDA replay covers three layer positions, both execution phases and query widths one to four; QB and per-query attention agree bitwise at QK, softmax and AV. Controlled Vulkan experiments identify two limits to transferring this local repair. Earlier computation can create consequential state differences, and endpoint-equivalent states need not remain equivalent under component replacement. Independently, the lifted query axis fails a necessary operator-support condition in the frozen Vulkan backend. Together, the results establish a concrete local implementation benefit and distinguish the representation, state and backend conditions that a reference-preserving deployment must satisfy.

cs.PF↗

Caching Policies based on Object Sizes

We evaluate eviction policies that consider the lengths of the objects being cached for different cache sizes (cost) and different workloads. Workloads include the Independent Reference Model and real-world production traces. In particular, hybrid policies are considered for segmented caches. A working-set approximation is developed for SIEVE as well as its length-aware extension.

cs.PF↗

Top-Down Microarchitecture Analysis Without Causal Modelling Is Dangerous!

Top-Down Microarchitecture Analysis (TMA) is the standard for identifying CPU bottlenecks. However, TMA implicitly models performance via a single causal path: Workload(dataset, algorithm) => CPU(CPI) => System(Performance) (microarchitectural efficiency path). It overlooks two hidden causal paths: Workload(dataset, algorithm) => Instructions(Retired) => System(Performance) (algorithmic efficiency path) and Workload(dataset, algorithm) => Instructions(Retired) => CPU(CPI) => System(Performance) (microarchitecture-algorithm efficiency path). This causal blindness often misleads architects into futile hardware optimizations. To address this, we propose Causal Top-Down Microarchitecture Analysis (CTMA). Utilizing the object causal model, CTMA explicitly models these three causal paths among the workload, instructions, CPU, and system. We validate CTMA across Intel, AMD, and ARM platforms. Our experiments reveal counterintuitive insights: (1) CPI Profiling Blindness: Algorithmic instruction bloat can double elapsed time while the CPI profile remains frozen. (2) Over-Speculation Congestion: Throttling the Frontend paradoxically improves performance in pointer-chasing algorithms. (3) ILP Window Collapse: Extreme data topologies shift bottlenecks from Backend ROB capacity to Frontend fill-rate starvation. (4) Op-Cache SMT Overlap: Ultra-small footprints yield SMT speedups on Intel but cause severe thrashing on AMD. (5) "Ghost State" Artifact: Stale pipeline mitigations on Intel Xeon Gold 5120T artificially boost performance by 22.75% on SPEC CPU2017 and 42.2% on SPEC CPU2026. Based on this, we propose a dynamic speculation throttling mechanism.

cs.PF↗