Every modern processor exposes hundreds of live measurements: performance counters for instructions retired and cache misses, per-core power and temperature sensors, interconnect and memory-bus statistics. Teams that build power models or debug clusters log these streams at high rates across many cores, and the volume quickly overwhelms the tracing path. This proposal builds a lossless compressor for such streams. A small learned predictor, shaped by the chip's physical layout, forecasts each next reading. An arithmetic coder then spends few bits on readings the predictor got right. The compressor runs on the same silicon it is measuring.
That last condition is what makes the problem new. Prior learned compressors for structured streams were evaluated by replaying logs on a server. On-chip, the compressor competes with the workload for the same caches, memory bus, and power budget, so it changes the very counters it records. We claim that the right predictor is the one that minimizes total cost on the real device: bits sent plus how much the compressor disturbs the workload. Under that accounting, we expect a mostly linear predictor that follows the chip's layout to beat both generic codecs and a full spatio-temporal graph network, with a tiny nonlinear graph correction worth its cost only during contention and thermal-throttling episodes. We also argue that the predictor must use integer arithmetic. The reason is correctness, not speed: the encoder on the chip and the decoder on a workstation must compute bit-identical predictions, or arithmetic decoding fails.
Core Claim and What Is New
The closest work is Atom, which treats wide-area network traffic as a dynamic graph. A spatio-temporal graph neural network (a model that passes messages between neighboring nodes while also tracking each node's history) predicts a Gaussian mean and variance for the next value, and arithmetic coding turns those predictions into bits. Atom reports reduction factors of 2.6× to 4.2×, 50% to 65% better than GZIP, on Abilene, Geant and Campus, using 200 KB to 600 KB models on server CPUs. We reuse Atom's predict-then-code mechanism. We change three things. The data is on-chip telemetry, where the graph is the floorplan and the interconnect rather than a routing map. The evaluation runs on the device being traced, and it counts the compressor's own interference. The predictor is a hierarchy whose expensive part is used only when a measured cost model says it pays for itself.
Two other lines of work motivate this design. Reveal collects about 150 hardware signals on V100/H100 clusters and copes with the volume by dropping 40% of the signals through correlation pruning, at under 1.5% CPU overhead. That shows the volume problem is real and that today's answer is to discard data. Walker et al. reach a power-model error of 2.8% (mean absolute percentage error) on an ODROID-XU3 big.LITTLE board, but only by logging many performance counters plus thermal sensors. Better power models consume more telemetry.
Two further results constrain the design. DRACO shows that operation count misleads on memory-bound hardware: adding multiply-accumulates cut MobileNetV1 latency by 42.6%. So we will not choose predictors by FLOPs; we measure their cost on the device. Banner et al. show that 4-bit post-training quantization needs clipping and bias correction to avoid large accuracy loss (ResNet101 drops to 62.6% naively and recovers to 75.0% with corrections). In lossless predictive coding, however, a worse prediction costs only extra bits and never changes the decoded data. That makes telemetry compression an unusually forgiving setting for aggressive integer quantization.
Research Program
The physical graph has nodes for cores, cluster-shared caches, memory controllers and on-die sensors. Edges link components that share a cache, a voltage/frequency domain, a thermal neighborhood or an interconnect hop. Each node carries a vector of counter deltas per sampling interval. The predictor has two stages, and both stages compute identical integer predictions on the encoder and decoder sides. The first stage is a graph-sparse vector autoregression: next values are predicted linearly from a node's own recent history and its graph neighbors' history, with coefficients refit periodically and sent as side information. The second stage is a small spatio-temporal graph network, in the gated-recurrent style of T-GCN. It predicts a correction to the linear prediction and the spread of the residual, which the arithmetic coder uses. A gate fires the second stage per window when recent coding loss under stage one is high, for example during bursts of cache invalidations or frequency throttling. The gate's decision is coded as one flag, so the decoder can follow it.
We train and select configurations with a single on-device objective. For a configuration $c$,
$$J(c) = \frac{B(c)}{B_0} + \lambda \, \frac{T_{\text{traced}}(c) - T_{\text{untraced}}}{T_{\text{untraced}}},$$
where $B(c)$ is the bits produced, $B_0$ is the bits from GZIP, $T$ is the host workload's measured runtime with and without the compressor running, and $\lambda$ sets how much slowdown an operator will trade for bandwidth. We also report the distortion the compressor causes in the counters themselves: the shift in the cache-miss and power distributions relative to untraced runs. That distortion is the observer effect that replay-based evaluation cannot see.
The study rests on three analyses. The first is a replay-versus-device gap: we measure compression ratio and cost in server replay, as Atom did, and again on-device, and report how much the ranking of methods changes. The second is an integer-determinism study: we run float and integer predictors across encoder and decoder hardware and count decoding failures. The third is a quantization sweep (INT8 and INT4 predictor weights) that measures the bit-rate cost of each precision level.
Baselines
The naive reference is raw logging and GZIP, the default tooling Atom compares against. Beating it is necessary but not interesting. A stronger generic reference is per-counter delta coding followed by an adaptive entropy coder, which captures simple temporal smoothness at near-zero compute.
The strongest classical competitor is the graph-sparse vector autoregression with arithmetic coding running alone, which is our own first stage. It uses the same physical prior at a fraction of a neural network's cost. It doubles as the main ablation: the gated graph network must reduce $J$ beyond this stage alone, or the neural part is not justified.
The strongest existing learned method is Atom retrained on our telemetry with its published architecture. Its only reported numbers are on network traffic (2.6× to 4.2× reduction, 50% to 65% over GZIP); there is no reported result on Lacuna for learned compression of on-chip hardware telemetry. We will first reproduce Atom on Abilene, Geant and Campus to confirm the implementation lands in that range, then run it on telemetry.
A graph-free baseline uses a per-counter gated recurrent predictor of matched size. It isolates whether the floorplan graph contributes anything.
All methods see the same traces and the same training split by workload, with unseen workloads held out. Each gets the same hyperparameter search budget and is measured on the same device under the same sampling rate. Beating a baseline means a lower $J$ at three settings of $\lambda$ spanning bandwidth-dominated to overhead-dominated regimes, with bits within 5% of the best method in each setting. Separately, we must show on-device overhead no higher than Reveal's reported under-1.5% CPU overhead.
Why not just…?
Why not just use GZIP or another generic codec? Generic codecs treat the stream as flat bytes and cannot use the fact that a cache-miss burst on one core predicts traffic at the shared cache and heat on its neighbor. Atom's 50% to 65% gain over GZIP on topologically structured traffic suggests the same headroom exists here. Our GZIP and delta-coding baselines measure it directly on telemetry, where there is no prior number.
Why not just a linear predictor with arithmetic coding? This is the real threat. Telemetry may be close enough to linear that the graph network adds little. We do not argue around it; the linear stage is built into the design and is the default. The gated-ablation experiment settles the question: if the neural correction never lowers $J$ outside throttling and contention windows, the finding is that a layout-shaped linear coder is the right deployed tool. We would report that as the result.
Why not just drop redundant counters, as Reveal does? Dropping counters is lossy in a way that harms later analysis. A model such as Walker et al.'s depends on the counter set chosen after the fact, and pruning decided at collection time cannot anticipate that. We will fit a Walker-style power model on full versus Reveal-pruned versus losslessly compressed telemetry at equal bandwidth and compare the modeling error.
Why not just stream raw data off the chip and compress it elsewhere? That moves the cost to the export link, which is exactly what saturates at high sampling rates across many cores. The objective $J$ includes the bandwidth term so this trade-off is measured, not assumed. Setting $\lambda$ high recovers the raw-streaming regime as a special case.
Proposed Experiments
Platforms are a big.LITTLE Arm board in the ODROID-XU3 class, matching Walker et al.'s setting with per-cluster power and per-core thermal sensors, and a multi-GPU node exposing counters similar to Reveal's signal set. Workloads are native runs of the SPEC, PARSEC and GAPBS suites that gem5 supports, which keeps a later link to simulator traces possible. We add co-located workload pairs to induce contention, and thermal stress runs to induce throttling. Metrics are bits per sample, compression ratio versus GZIP, encoder energy per megabyte from the board's power sensors, host slowdown, counter-distribution shift, and decode failures.
Three checks decide the outcome. First, the replay-versus-device ranking gap: if methods rank the same in both settings, the observer-effect claim fails. Second, the gated graph network versus the linear stage alone at equal measured cost: this decides whether the spatio-temporal graph component is needed. Third, float versus integer predictors across heterogeneous encoder and decoder hardware: any nonzero decode-failure rate for float predictors would establish integer arithmetic as a correctness requirement, not just an efficiency choice. A downstream check confirms that power models fit on decoded telemetry match those fit on raw telemetry, as losslessness guarantees, while Reveal-style pruning at equal bandwidth does not.
References
- Atom: Neural Traffic Compression with Spatio-Temporal Graph Neural Networks
- Detecting Anomalies in Machine Learning Infrastructure via Hardware Telemetry
- Accurate and stable empirical CPU power modelling for multi- and many-core systems
- DRACO: Co-Optimizing Hardware Utilization, and Performance of DNNs on Systolic Accelerator
- Post training 4-bit quantization of convolutional networks for rapid-deployment
- T-GCN: A Temporal Graph Convolutional Network for Traffic Prediction
- The gem5 Simulator: Version 20.0+