[Paper Review] A Distributed SDN Control Plane for Consistent Policy Updates

Marco Canini, Petr Kuznetsov+2 more|arXiv (Cornell University)|May 31, 2013

Software-Defined Networks and 5G20 references3 citations

TL;DR

This paper proposes a distributed SDN control plane that ensures per-packet consistent policy updates through a transactional interface, enabling concurrent, fault-tolerant policy composition. It introduces the Consistent Policy Composition (CPC) problem and presents two protocols—FixTag and ReuseTag—achieving optimal tag complexity of $f+2$ for $f$-resilient systems, with ReuseTag enabling total ordering via replicated state machines for conflict resolution.

ABSTRACT

Software-defined networking (SDN) is a novel paradigm that out-sources the control of packet-forwarding switches to a set of software controllers. The most fundamental task of these controllers is the correct implementation of the \emph{network policy}, i.e., the intended network behavior. In essence, such a policy specifies the rules by which packets must be forwarded across the network. This paper studies a distributed SDN control plane that enables \emph{concurrent} and \emph{robust} policy implementation. We introduce a formal model describing the interaction between the data plane and a distributed control plane (consisting of a collection of fault-prone controllers). Then we formulate the problem of \emph{consistent} composition of concurrent network policy updates (short: the \emph{CPC Problem}). To anticipate scenarios in which some conflicting policy updates must be rejected, we enable the composition via a natural \emph{transactional} interface with all-or-nothing semantics. We show that the ability of an $f$-resilient distributed control plane to process concurrent policy updates depends on the tag complexity, i. e., the number of policy labels (a.k.a. \emph{tags}) available to the controllers, and describe a CPC protocol with optimal tag complexity $f+2$.

Motivation & Objective

• To address the challenge of concurrent, consistent policy updates in a distributed, fault-prone SDN control plane.
• To formalize the problem of consistent composition of concurrent network policy updates (CPC Problem) with all-or-nothing semantics for conflict resolution.
• To design a fault-tolerant, distributed protocol that maintains per-packet consistency during policy updates, ensuring no packet is processed under a mixture of old and new policies.
• To minimize tag complexity—the number of policy labels used—while ensuring resilience to up to $f$ controller failures.
• To establish theoretical foundations for robust, scalable SDN control by linking SDN to distributed computing models such as software transactional memory (STM).

Proposed method

• Formalizing the interaction between the data plane and a distributed control plane using a model of fault-prone controllers and packet-level consistency.
• Introducing the CPC abstraction inspired by software transactional memory (STM), providing a transactional interface with all-or-nothing semantics for policy updates.
• Designing the FixTag protocol, a wait-free algorithm that applies updates directly to the data plane and resolves conflicts incrementally, with linear tag complexity in the number of updates.
• Proposing the ReuseTag protocol, which uses the replicated state-machine approach to enforce total order on updates, achieving optimal tag complexity $f+2$ for $f$-resilience.
• Using atomic read-modify-write operations on SDN ports as a minimal system requirement for consistent updates, proven necessary in Appendix A.
• Analyzing trade-offs between concurrency, message overhead, and memory usage in switch controllers, showing that optimal tag complexity comes at the cost of sequential update execution in ReuseTag.

Experimental results

Research questions

• RQ1 Can a distributed SDN control plane ensure per-packet consistency during concurrent policy updates while tolerating controller failures?
• RQ2 What is the minimal tag complexity required for an $f$-resilient distributed control plane to achieve consistent policy composition?
• RQ3 How can conflicting policy updates be resolved without affecting in-flight packets, ensuring transactional semantics in a network context?
• RQ4 To what extent can concurrent policy updates be supported in a fault-tolerant, distributed SDN control plane without sacrificing consistency?
• RQ5 What fundamental system primitives (e.g., atomic operations) are necessary to enable consistent network updates in a distributed setting?

Key findings

• The ReuseTag protocol achieves optimal tag complexity of $f+2$ for an $f$-resilient system, proving that this bound is tight.
• The FixTag protocol enables concurrent updates with linear tag complexity in the number of updates, but does not achieve optimal tag complexity.
• The paper proves that consistent network updates are impossible without atomic read-modify-write operations on SDN ports, establishing a minimal system requirement.
• The CPC abstraction successfully models real-world network management by combining sequential composition intuition with optimistic update application, ensuring correctness under concurrency and failures.
• The ReuseTag protocol reduces to sequential update installation in the worst case, highlighting a fundamental trade-off between tag efficiency and concurrency.
• The work establishes a formal connection between SDN control and distributed computing models such as software transactional memory (STM), enabling cross-domain insights.