Configuration changes are a common source of instability in networks, leading to broken connectivity, forwarding loops, and access control violations. Even when the initial and final states of the network are correct, the update process often steps through intermediate states with incorrect behaviors. These problems have been recognized in the context of specific protocols, leading to a number of point solutions. However, a piecemeal attack on this fundamental problem, while pragmatic in the short term, is unlikely to lead to significant long-term progress. Software-Defined Networking (SDN) provides an exciting opportunity to do better. Because SDN is a clean-slate platform, we can build general, reusable abstractions for network updates that come with strong semantic guarantees. We believe SDN desperately needs such abstractions to make programs simpler to design, more reliable, and easier to validate using automated tools. Moreover, we believe these abstractions should be provided by a runtime system, shielding the programmer from these concerns. We propose two simple, canonical, and effective update abstractions, and present implementation mechanisms. We also show how to integrate them with a network programming language, and discuss potential applications to program verification.

Abstract—OS virtualization and cloud computing have radically changed the way Internet services are deployed: enterprises share third-party datacenters, deploying existing applications with minimal changes. Recent measurements reveal a lack of traffic isolation capabilities within the datacenter with network performance exhibiting high variability. We advocate addressing this problem by allowing applications to express their own forwarding logic using OpenFlow to achieve application specific optimal performance. We present an OpenFlow implementation within the Mirage application synthesis framework, in the form of library implementations of a modular controller and an extensible OpenFlow-enabled switch, able to expose the underlying network infrastructure to cloud applications. By linking into the application, this provides a safe yet highly extensible framework for programming network control that, although unoptimised, still provides reasonable performance when compared with existing controllers. I.

For the past 30 years, networks have been built the same way: out of special-purpose devices running distributed algorithms that provide functionality such as topology discovery, routing, traffic monitoring, and access control. Recent

Abstract—The vantage points of routers along end-to-end paths in the Internet have long made them a compelling target for additional functionality. In this paper, we describe a new method for router data plane programmability that is simple, general, flexible and safe and enables complex network services to be built and deployed. Our method targets network processor (NP)and FPGA-based routers, and is based on two central ideas: (1) primitive functions for routers that are designed for specific target service domains, and (2) a primitive-aware programming language that is expressive, easy to use and easy to analyze. To demonstrate our method, we describe a set of primitive functions in the context of three diverse domains — network measurement, real-time applications and traffic engineering. Next, we describe Morpheme, our primitive-aware programming language, and show how it can be statically analyzed to safeguard router processor and memory resources. We demonstrate the efficacy of our method by implementing the primitive functions in the Click modular router [1] and a prototype Morpheme compiler. Through a series of microbenchmark experiments, we substantiate the capabilities of our prototype implementation. I.

Abstract—Software Defined Networking (SDN in short) is reshaping the future of computer networks. By decoupling control and data planes, SDN technologies allow a more flexible management of network infrastructures, whose resources may be operated by means of a well defined programming interface. Several approaches have been recently proposed to implement the SDN concept. OpenFlow is maybe the most prominent SDN component, having been supported by several device vendors. This paper discusses a practical experience in designing an OpenFlow controller for a Mobile Cloud Management system. We present the programming model and the designed abstraction and discuss the lesson learned. Index Terms—Software-Defined Networking, OpenFlow controller, scalability, programming model I.

MPLS was an attempt to simplify network hardware while improving the flexibility of network control. Software-Defined Networking (SDN) was designed to make further progress along both of these dimensions. While a significant step forward in some respects, it was a step backwards in others. In this paper we discuss SDN’s shortcomings and propose how they can be overcome by adopting the insight underlying MPLS. We believe this hybrid approach will enable an era of simple hardware and flexible control. Categories and Subject Descriptors

These authors contributed equally to this work The behavior of a Software-Defined Network is controlled by programs, which like all software, will have bugs – but this programmatic control also enables new ways to debug networks. This paper introduces ndb, a prototype network debugger inspired by gdb, which implements two primitives useful for debugging an SDN: breakpoints and packet backtraces. We show how ndb modifies forwarding state and logs packet digests to rebuild the sequence of events leading to an errant packet, providing SDN programmers and operators with a valuable tool for tracking down the root cause of a bug.