In-Band Synchronization for Distributed SDN Control Planes

L. Schiff, S. Schmid, P. Kuznetsov
Appears in: 
CCR January 2016

Control planes of forthcoming Software-Defined Networks (SDNs) will be distributed : to ensure availability and faulttolerance, to improve load-balancing, and to reduce overheads, modules of the control plane should be physically distributed. However, in order to guarantee consistency of network operation, actions performed on the data plane by different controllers may need to be synchronized, which is a nontrivial task. In this paper, we propose a synchronization framework for control planes based on atomic transactions, implemented in-band, on the data-plane switches. We argue that this in-band approach is attractive as it keeps the failure scope local and does not require additional out-of-band coordination mechanisms. It allows us to realize fundamental consensus primitives in the presence of controller failures, and we discuss their applications for consistent policy composition and fault-tolerant control-planes. Interestingly, by using part of the data plane configuration space as a shared memory and leveraging the match-action paradigm, we can implement our synchronization framework in today’s standard OpenFlow protocol, and we report on our proof-ofconcept implementation.

Public Review By: 
Katerina Argyraki

Software Defined Networking (SDN) advocates a logically centralized control plane, however, for scalability and fault-tolerance reasons, this must be implemented on top of multiple, physically separate controllers; how should these controllers synchronize with each other to avoid leaving the network in an undesirable state? The conceptually straightforward approach would be to have the controllers directly exchange synchronization messages; this paper explores a jazzier alternative: the controllers use part of the data-plane configuration space as transactional shared memory (in particular, to implement an atomic compare-and-swap operation). The paper shows that this approach can be implemented on top of OpenFlow (by leveraging the OpenFlow bundling feature). It also outlines how an example control-plane application — one that configures load-balancing — would benefit from the resulting transactional semantics. The reviewers appreciated the originality of the proposal. They did wish for clearer arguments on why this is the right way to do controller synchronization, as well as a quantitative analysis of the amount of required data-plane resources — but these are forgivable flaws in a paper that addresses a hard and relevant problem in a fresh, I-wish-I-had-thought-of-it way.