[Paper Review] Memory-Efficient Performance Monitoring on Programmable Switches with Lean Algorithms

Zaoxing Liu, Samson Zhou+3 more|arXiv (Cornell University)|Nov 16, 2019

Software-Defined Networks and 5G35 references4 citations

TL;DR

This paper proposes lean algorithms for memory-efficient performance monitoring on programmable switches by leveraging sublinear sketching techniques that track top-k problematic flows—such as those with high latency, loss, or retransmissions—using just 40KB of memory, achieving ~82% detection of the top 100 issue-causing flows in real-world traces.

ABSTRACT

Network performance problems are notoriously difficult to diagnose. Prior profiling systems collect performance statistics by keeping information about each network flow, but maintaining per-flow state is not scalable on resource-constrained NIC and switch hardware. Instead, we propose sketch-based performance monitoring using memory that is sublinear in the number of flows. Existing sketches estimate flow monitoring metrics based on flow sizes. In contrast, performance monitoring typically requires combining information across pairs of packets, such as matching a data packet with its acknowledgment to compute a round-trip time. We define a new class of \emph{lean} algorithms that use memory sublinear in both the size of input data and the number of flows. We then introduce lean algorithms for a set of important statistics, such as identifying flows with high latency, loss, out-of-order, or retransmitted packets. We implement prototypes of our lean algorithms on a commodity programmable switch using the P4 language. Our experiments show that lean algorithms detect $\sim$82\% of top 100 problematic flows among real-world packet traces using just 40KB memory.

Motivation & Objective

• Address the challenge of scalable, real-time network performance monitoring in resource-constrained switches and NICs.
• Overcome the limitations of per-flow state tracking, which is infeasible at scale due to memory and computation constraints.
• Design algorithms that use memory sublinear in both input size and number of flows to enable efficient online monitoring without end-host access.
• Enable detection of high-impact flows contributing to latency, packet loss, out-of-order delivery, and retransmissions in datacenter and carrier networks.
• Provide a theoretical foundation and practical implementation for a new class of sketch-based performance monitoring tools on commodity programmable switches.

Proposed method

• Define a new class of 'lean algorithms' that use memory sublinear in both the number of flows and input data size.
• Introduce a streaming model where performance monitoring functions must satisfy a 'flow-additive' property and allow sublinear estimation per flow.
• Leverage sketching data structures (e.g., Count-Min, Bloom filters) as building blocks to estimate key performance metrics with bounded error.
• Design specific lean algorithms for detecting flows with high latency, packet loss, out-of-order packets, and retransmissions using minimal state.
• Implement prototypes in P4 on a commodity programmable switch (e.g., Tofino) using stateful memory and optimized match-action tables.
• Minimize resource usage by reusing hash values and metadata across sketches, reducing hash bit requirements and memory footprint.

Experimental results

Research questions

• RQ1 Can we design performance monitoring algorithms that use memory sublinear in both the number of flows and input data size?
• RQ2 Which performance monitoring functions satisfy the flow-additive property and allow sublinear per-flow estimation?
• RQ3 How accurately can lean algorithms detect the top-k most influential flows (e.g., those with high latency or loss) using minimal memory?
• RQ4 What is the practical memory and accuracy trade-off when applying lean algorithms to real-world packet traces on commodity switches?
• RQ5 Can a unified sketching framework be designed to support multiple performance metrics simultaneously in a resource-constrained environment?

Key findings

• The proposed lean algorithms detect approximately 82% of the top 100 most problematic flows in real-world packet traces using only 40KB of memory.
• The theoretical framework proves that any performance monitoring function satisfying flow-additivity and single-flow sublinearity can be monitored with memory sublinear in both input size and number of flows.
• Implementation on a commodity programmable switch using P4 demonstrates low resource usage, with Table 2 showing minimal overhead compared to a default switch implementation.
• The approach enables real-time, in-network performance monitoring without requiring end-host access, making it suitable for public clouds and carrier networks.
• The method supports multiple performance metrics—including latency, loss, out-of-order delivery, and retransmissions—within a single, unified sketching framework.
• The work establishes memory lower bounds of Ω(N) for deterministic monitoring of certain statistics, justifying the need for probabilistic, sublinear approaches in practice.