Papers for

data center infrastructure managers

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.

TurboProm speeds up metrics monitoring while cutting cloud costs

TurboProm: Low Cost and High Performance Metrics Observability at Scale

Abstract: Many large enterprise and cloud deployments rely on metrics observability solutions (e.g., Prometheus) to monitor key performance indicators of system health (e.g., CPU, memory, network, app-level statistics). Monitoring and analyzing these metrics presents a significant challenge in terms of cost-latency tradeoffs at scale. Ideally, system operators would like immediately deployable and backwards compatible solutions to improve the cost-latency tradeoffs without significant impact on the fidelity of their observability applications. Unfortunately, existing solutions including state-of-art timeseries databases and custom approximate querying solutions fail on one or more aspects. In this paper, we present the design and implementation of TurboProm, a backwards-compatible drop-in accelerator for metrics observability deployments. TurboProm recasts metrics analytics tasks using a semantic-preserving summary view rather than classical query-centric view. Instead of estimating query results on raw timeseries metrics data, TurboProm uses semantic-preserving summaries that enable high-fidelity analytics with significant cost-latency improvements. We present a practical implementation of TurboProm that can be retrofitted to any existing observability deployment. We evaluate TurboProm on diverse real and synthetic workloads against state-of-art solutions and show that it can provide significant reduction in query latency and cost. TurboProm is open-source at https://github.com/ProjectASAP/ASAPQuery.

Sat 10 OctDatabasesDistributed, Parallel, and Cluster ComputingNetworking and Internet Architecture
The gist
Many big companies use tools like Prometheus to monitor how their computer systems are working by collecting lots of data points. But handling and analyzing this data quickly and cheaply can be hard when there is a lot of it. The authors present TurboProm, a tool that can be added to existing systems without changing them, which summarizes this data in a smart way to keep the details accurate while making queries faster and cheaper. They tested TurboProm with real and simulated data and found it reduces delays and costs significantly compared to current solutions.
Open → 2610.14483v1

Gpu takes control to speed up network ai without cpu delays

Toward Intelligent Networks via AI-Aware GPU-Native Packet Processing

Abstract: The integration of inline Artificial Intelligence (AI) models into critical network infrastructure is fundamentally bottlenecked by the high latency and synchronization overhead of CPU-mediated packet processing. While legacy GPU offload and recent CPU-bypass frameworks attempt to bridge this gap, they remain trapped in proprietary ecosystems or still rely on the host CPU and coarse-grained batching to coordinate stateful telemetry and AI pipeline execution. In this paper, we propose AGP, a novel framework that promotes the GPU from a passive accelerator to a primary data-path controller, answering what changes architecturally when the GPU autonomously owns the complete packet-to-inference pipeline. By enabling GPU-native packet processing, contention-free in-GPU stateful aggregation, and a persistent mega-kernel for continuous AI inference, AGP removes the CPU from the critical path. Our evaluation demonstrates that native in-GPU packet processing sustains line-rate throughput while being over 6.1x more power-efficient. Furthermore, our integrated Intrusion Detection System (IDS) stress test eliminates the legacy CPU-GPU synchronization tax, reducing end-to-end latency by 7.9x (up to 35x p99) and accelerating whole-system inference throughput by 9.3x using only ~2% of the GPU's thread capacity.

Thu 8 OctNetworking and Internet Architecture
The gist
Network systems often slow down because CPUs have to handle every packet before AI can analyze it, causing delays. The authors present AGP, a new method that lets GPUs directly process network packets and run AI models without waiting for the CPU. This setup greatly reduces delays and uses less power while keeping up with high-speed data. The authors showed that their system can detect threats much faster with lower resource use compared to traditional methods.
Open → 2610.12139v1