[Paper Review] Traffic Management Applications for Stateful SDN Data Plane

Carmelo Cascone, Luca Pollini+2 more|arXiv (Cornell University)|Jun 23, 2015

Software-Defined Networks and 5G7 references4 citations

TL;DR

This paper proposes OpenState, an extension to OpenFlow that enables stateful forwarding in the SDN data plane, allowing switches to autonomously manage traffic policies using local state transitions triggered by packet arrivals and timers. The authors demonstrate two traffic management applications—forwarding consistency and failure recovery—showcasing up to 400ms reduction in processing delay and near-instantaneous recovery with zero controller involvement, significantly outperforming traditional OpenFlow in latency and packet loss under failure scenarios.

ABSTRACT

The successful OpenFlow approach to Software Defined Networking (SDN) allows network programmability through a central controller able to orchestrate a set of dumb switches. However, the simple match/action abstraction of OpenFlow switches constrains the evolution of the forwarding rules to be fully managed by the controller. This can be particularly limiting for a number of applications that are affected by the delay of the slow control path, like traffic management applications. Some recent proposals are pushing toward an evolution of the OpenFlow abstraction to enable the evolution of forwarding policies directly in the data plane based on state machines and local events. In this paper, we present two traffic management applications that exploit a stateful data plane and their prototype implementation based on OpenState, an OpenFlow evolution that we recently proposed.

Motivation & Objective

• To address the performance bottleneck of centralized OpenFlow controllers in real-time traffic management applications.
• To reduce control path latency and signaling overhead in network recovery and load balancing scenarios.
• To enable application-level control over forwarding behavior granularity and state evolution directly in the data plane.
• To design scalable, controller-agnostic solutions for failure resilience and consistent forwarding using local state machines.

Proposed method

• Extends OpenFlow with a state table preceding flow tables, allowing switches to maintain and transition between custom states based on packet-level events and timers.
• Uses a Mealy machine abstraction to define state transitions and forwarding actions in response to local events such as packet arrivals and timers.
• Implements the OpenState protocol as an OpenFlow 1.3 Experimenter extension, with a prototype switch and controller stack.
• Deploys two applications: forwarding consistency via stateful session tracking and failure recovery via switch-to-switch signaling without controller intervention.
• Evaluates performance using real-world topology data (Norway backbone) and compares OpenState against OpenFlow with and without Open vSwitch (OVS) optimization.
• Measures processing delay, packet loss, and recovery time under varying traffic loads and controller RTT conditions.

Experimental results

Research questions

• RQ1 Can stateful forwarding in the data plane reduce control path latency in traffic management applications compared to traditional OpenFlow?
• RQ2 How does OpenState enable fine-grained, application-defined forwarding consistency without relying on controller-based flow table updates?
• RQ3 To what extent can failure recovery be achieved without controller involvement using only local state transitions and switch-to-switch signaling?
• RQ4 What is the performance gain of OpenState over OpenFlow in terms of processing delay and packet loss under high-load and failure scenarios?
• RQ5 Can OpenState maintain low processing overhead while supporting complex, scalable traffic management policies?

Key findings

• OpenState reduces switch processing delay to just a few milliseconds even at 2000 requests per second, while traditional OpenFlow incurs up to 400ms of delay under the same load.
• With a 12ms controller RTT, OpenFlow causes up to 80 lost packets per second under failure conditions, whereas OpenState maintains zero packet loss due to controller-independent recovery.
• Failure recovery in OpenState is effectively instantaneous, as packets are bounced back immediately upon failure detection, with no dependency on controller response time.
• The performance gap between OpenFlow and OpenState persists even when using Open vSwitch, indicating that kernel-space optimization alone cannot overcome the fundamental latency of controller-dependent control paths.
• OpenState enables application-level control over session granularity and lifetime in forwarding consistency, surpassing the limitations of OpenFlow’s fixed hash-based load balancing.
• The stateful data plane model based on Mealy machines allows for scalable, efficient, and programmable traffic management with minimal controller involvement.