Network Innovation using OpenFlow: A Survey
---
paper_title: OpenFlow: enabling innovation in campus networks

paper_content:

This whitepaper proposes OpenFlow: a way for researchers to run experimental protocols in the networks they use every day. OpenFlow is based on an Ethernet switch, with an internal flow-table, and a standardized interface to add and remove flow entries. Our goal is to encourage networking vendors to add OpenFlow to their switch products for deployment in college campus backbones and wiring closets. We believe that OpenFlow is a pragmatic compromise: on one hand, it allows researchers to run experiments on heterogeneous switches in a uniform way at line-rate and with high port-density; while on the other hand, vendors do not need to expose the internal workings of their switches. In addition to allowing researchers to evaluate their ideas in real-world traffic settings, OpenFlow could serve as a useful campus component in proposed large-scale testbeds like GENI. Two buildings at Stanford University will soon run OpenFlow networks, using commercial Ethernet switches and routers. We will work to encourage deployment at other schools; and We encourage you to consider deploying OpenFlow in your university network too
---
paper_title: A survey of active network research

paper_content:

Active networks are a novel approach to network architecture in which the switches (or routers) of the network perform customized computations on the messages flowing through them. This approach is motivated by both lead user applications, which perform user-driven computation at nodes within the network today, and the emergence of mobile code technologies that make dynamic network service innovation attainable. The authors discuss two approaches to the realization of active networks and provide a snapshot of the current research issues and activities. They illustrate how the routers of an IP network could be augmented to perform such customized processing on the datagrams flowing through them. These active routers could also interoperate with legacy routers, which transparently forward datagrams in the traditional manner.
---
paper_title: OpenFlow: enabling innovation in campus networks

paper_content:

This whitepaper proposes OpenFlow: a way for researchers to run experimental protocols in the networks they use every day. OpenFlow is based on an Ethernet switch, with an internal flow-table, and a standardized interface to add and remove flow entries. Our goal is to encourage networking vendors to add OpenFlow to their switch products for deployment in college campus backbones and wiring closets. We believe that OpenFlow is a pragmatic compromise: on one hand, it allows researchers to run experiments on heterogeneous switches in a uniform way at line-rate and with high port-density; while on the other hand, vendors do not need to expose the internal workings of their switches. In addition to allowing researchers to evaluate their ideas in real-world traffic settings, OpenFlow could serve as a useful campus component in proposed large-scale testbeds like GENI. Two buildings at Stanford University will soon run OpenFlow networks, using commercial Ethernet switches and routers. We will work to encourage deployment at other schools; and We encourage you to consider deploying OpenFlow in your university network too
---
paper_title: NetServ: Active Networking 2.0

paper_content:

We present NetServ, a node architecture for deploying in-network services in the next generation Internet. NetServ-enabled network nodes provide a common execution environment, where network services implemented as modules can be dynamically installed and removed. We demonstrate three such modules. MicroCDN is a dynamic content distribution network (CDN) service which implements a content caching strategy specific to a content provider. The NAT Keep-alive module offloads the processing of keep-alive messages from SIP servers. The Media Relay module allows any NetServ node to act as a media relay, eliminating the need to manage standalone relay servers. NetServ aims to revive the Active Networking vision. It was too far ahead of its time a decade ago, but we believe its time has finally arrived.
---
paper_title: Towards an active network architecture

paper_content:

Active networks allow their users to inject customized programs into the nodes of the network. An extreme case, in which we are most interested, replaces packets with "capsules" - program fragments that are executed at each network router/switch they traverse. Active architectures permit a massive increase in the sophistication of the computation that is performed within the network. They enable new applications, especially those based on application-specific multicast, information fusion, and other services that leverage network-based computation and storage. Furthermore, they will accelerate the pace of innovation by decoupling network services from the underlying hardware and allowing new services to be loaded into the infrastructure on demand. In this paper, we describe our vision of an active network architecture, outline our approach to its design, and survey the technologies that can be brought to bear on its implementation. We propose that the research community mount a joint effort to develop and deploy a wide area ActiveNet.
---
paper_title: Active networking: one view of the past, present, and future

paper_content:

All distributed computing systems face the architectural question of the location (and nature) of programmability in the telecommunications networks, computers, and other peripheral devices comprising them. The perspective of this paper is that network elements should be as programmable as possible, to enable the most flexible distributed computing systems. There has been a persistent confluence among operating systems, programming languages, networking and distributed systems. We demonstrate how these interactions led to what is called "active networking," and in the spirit of "vox audita peril, littera scripta manel" (the spoken word perishes, but the written word remains), include an account of how it was made to happen. Lessons are drawn both from the broader research agenda, and the specific goals pursued in the SwitchWare project. We speculate on likely futures for active networking.
---
paper_title: The SOFTNET project: a retrospect

paper_content:

An experimental multihop packet radio network, SOFTNET, is described. The concept of soft protocols for experimental packet-switched networks is introduced. Using this scheme, network nodes can be easily reprogrammed to provide new user services without interrupting normal operation. The SOFTNET network programming language is described. The hardware and software implementation of the network is outlined. >
---
paper_title: The ’Platform as a Service’ Model for Networking

paper_content:

Decoupling infrastructure management from service management can lead to innovation, new business models, and a reduction in the complexity of running services. It is happening in the world of computing, and is poised to happen in networking. While many have considered this in the context of network virtualization, they all focus on one model - overlaying a virtual network of multiple virtual routers on top of a shared physical infrastructure, each completely isolated from the others through the use of virtualization. In this paper we argue for a different approach, where those running the service are presented with the abstraction of a single router in order to enable them to focus solely on their service rather than worrying about managing a virtual network as well. We discuss the abstraction of a single router, and the challenges of mapping the collection of abstract routers (from different parties) to the distributed and shared physical infrastructure.
---
paper_title: The IEEE P1520 standards initiative for programmable network interfaces

paper_content:

This article discusses the need for standard software interfaces for programming of networks, specifically for service and signaling control, through programming interfaces. The objective is to enable the development of open signaling, control, and management applications as well as higher-level multimedia services on networks. The scope of this effort includes ATM switches, circuit switches, IP routers, and hybrid switches such as those that provide for fast switching of IP packets over an ATM backbone. The basic ideas represented herein are in the process of development as a standard for application programming interfaces for networks under IEEE Standards Project IEEE P1520.
---
paper_title: OpenFlow: enabling innovation in campus networks

paper_content:

This whitepaper proposes OpenFlow: a way for researchers to run experimental protocols in the networks they use every day. OpenFlow is based on an Ethernet switch, with an internal flow-table, and a standardized interface to add and remove flow entries. Our goal is to encourage networking vendors to add OpenFlow to their switch products for deployment in college campus backbones and wiring closets. We believe that OpenFlow is a pragmatic compromise: on one hand, it allows researchers to run experiments on heterogeneous switches in a uniform way at line-rate and with high port-density; while on the other hand, vendors do not need to expose the internal workings of their switches. In addition to allowing researchers to evaluate their ideas in real-world traffic settings, OpenFlow could serve as a useful campus component in proposed large-scale testbeds like GENI. Two buildings at Stanford University will soon run OpenFlow networks, using commercial Ethernet switches and routers. We will work to encourage deployment at other schools; and We encourage you to consider deploying OpenFlow in your university network too
---
paper_title: Carving research slices out of your production networks with OpenFlow

paper_content:

1. SLICED PROGRAMMABLE NETWORKS OpenFlow [4] has been demonstrated as a way for researchers to run networking experiments in their production network. Last year, we demonstrated how an OpenFlow controller running on NOX [3] could move VMs seamlessly around an OpenFlow network [1]. While OpenFlow has potential [2] to open control of the network, only one researcher can innovate on the network at a time. What is required is a way to divide, or slice, network resources so that researchers and network administrators can use them in parallel. Network slicing implies that actions in one slice do not negatively affect other slices, even if they share the same underlying physical hardware. A common network slicing technique is VLANs. With VLANs, the administrator partitions the network by switch port and all traffic is mapped to a VLAN by input port or explicit tag. This coarse-grained type of network slicing complicates more interesting experiments such as IP mobility or wireless handover. Here, we demonstrate FlowVisor, a special purpose OpenFlow controller that allows multiple researchers to run experiments safely and independently on the same production OpenFlow network. To motivate FlowVisor’s flexibility, we demonstrate four network slices running in parallel: one slice for the production network and three slices running experimental code (Figure 1). Our demonstration runs on real network hardware deployed on our production network at Stanford and a wide-area test-bed with a mix of wired and wireless technologies.
---
paper_title: Where is the debugger for my software-defined network?

paper_content:

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.
---
paper_title: Frenetic: a network programming language

paper_content:

Modern networks provide a variety of interrelated services including routing, traffic monitoring, load balancing, and access control. Unfortunately, the languages used to program today's networks lack modern features - they are usually defined at the low level of abstraction supplied by the underlying hardware and they fail to provide even rudimentary support for modular programming. As a result, network programs tend to be complicated, error-prone, and difficult to maintain. This paper presents Frenetic, a high-level language for programming distributed collections of network switches. Frenetic provides a declarative query language for classifying and aggregating network traffic as well as a functional reactive combinator library for describing high-level packet-forwarding policies. Unlike prior work in this domain, these constructs are - by design - fully compositional, which facilitates modular reasoning and enables code reuse. This important property is enabled by Frenetic's novel run-time system which manages all of the details related to installing, uninstalling, and querying low-level packet-processing rules on physical switches. Overall, this paper makes three main contributions: (1) We analyze the state-of-the art in languages for programming networks and identify the key limitations; (2) We present a language design that addresses these limitations, using a series of examples to motivate and validate our choices; (3) We describe an implementation of the language and evaluate its performance on several benchmarks.
---
paper_title: OpenFlow: enabling innovation in campus networks

paper_content:

This whitepaper proposes OpenFlow: a way for researchers to run experimental protocols in the networks they use every day. OpenFlow is based on an Ethernet switch, with an internal flow-table, and a standardized interface to add and remove flow entries. Our goal is to encourage networking vendors to add OpenFlow to their switch products for deployment in college campus backbones and wiring closets. We believe that OpenFlow is a pragmatic compromise: on one hand, it allows researchers to run experiments on heterogeneous switches in a uniform way at line-rate and with high port-density; while on the other hand, vendors do not need to expose the internal workings of their switches. In addition to allowing researchers to evaluate their ideas in real-world traffic settings, OpenFlow could serve as a useful campus component in proposed large-scale testbeds like GENI. Two buildings at Stanford University will soon run OpenFlow networks, using commercial Ethernet switches and routers. We will work to encourage deployment at other schools; and We encourage you to consider deploying OpenFlow in your university network too
---
paper_title: Maestro: A System for Scalable OpenFlow Control

paper_content:

The fundamental feature of an OpenFlow network is that the controller is responsible for the initial establishment of every flow by contacting related switches. Thus the performance of the controller could be a bottleneck. This paper shows how this fundamental problem is addressed by parallelism. The state of the art OpenFlow controller, called NOX, achieves a simple programming model for control function development by having a single-threaded event-loop. Yet NOX has not considered exploiting parallelism. We propose Maestro which keeps the simple programming model for programmers, and exploits parallelism in every corner together with additional throughput optimization techniques. We experimentally show that the throughput of Maestro can achieve near linear scalability on an eight core server machine. Keywords-OpenFlow, network management, multithreading, performance optimization
---
paper_title: Extending Networking into the Virtualization Layer

paper_content:

The move to virtualization has created a new network access layer residing on hosts that connects the various VMs. Virtualized deployment environments impose requirements on networking for which traditional models are not well suited. They also provide advantages to the networking layer (such as software flexibility and welldefined end host events) that are not present in physical networks. To date, this new virtualization network layer has been largely built around standard Ethernet switching, but this technology neither satisfies these new requirements nor leverages the available advantages. We present Open vSwitch, a network switch specifically built for virtual environments. Open vSwitch differs from traditional approaches in that it exports an external interface for fine-grained control of configuration state and forwarding behavior. We describe how Open vSwitch can be used to tackle problems such as isolation in joint-tenant environments, mobility across subnets, and distributing configuration and visibility across hosts.
---
paper_title: A network in a laptop: rapid prototyping for software-defined networks

paper_content:

Mininet is a system for rapidly prototyping large networks on the constrained resources of a single laptop. The lightweight approach of using OS-level virtualization features, including processes and network namespaces, allows it to scale to hundreds of nodes. Experiences with our initial implementation suggest that the ability to run, poke, and debug in real time represents a qualitative change in workflow. We share supporting case studies culled from over 100 users, at 18 institutions, who have developed Software-Defined Networks (SDN). Ultimately, we think the greatest value of Mininet will be supporting collaborative network research, by enabling self-contained SDN prototypes which anyone with a PC can download, run, evaluate, explore, tweak, and build upon.
---
paper_title: NOX: towards an operating system for networks

paper_content:

As anyone who has operated a large network can attest, enterprise networks are difficult to manage. That they have remained so despite significant commercial and academic efforts suggests the need for a different network management paradigm. Here we turn to operating systems as an instructive example in taming management complexity. In the early days of computing, programs were written in machine languages that had no common abstractions for the underlying physical resources. This made programs hard to write, port, reason about, and debug. Modern operating systems facilitate program development by providing controlled access to high-level abstractions for resources (e.g., memory, storage, communication) and information (e.g., files, directories). These abstractions enable programs to carry out complicated tasks safely and efficiently on a wide variety of computing hardware. In contrast, networks are managed through low-level configuration of individual components. Moreover, these configurations often depend on the underlying network; for example, blocking a user’s access with an ACL entry requires knowing the user’s current IP address. More complicated tasks require more extensive network knowledge; forcing guest users’ port 80 traffic to traverse an HTTP proxy requires knowing the current network topology and the location of each guest. In this way, an enterprise network resembles a computer without an operating system, with network-dependent component configuration playing the role of hardware-dependent machine-language programming. What we clearly need is an “operating system” for networks, one that provides a uniform and centralized programmatic interface to the entire network. Analogous to the read and write access to various resources provided by computer operating systems, a network operating system provides the ability to observe and control a network. A network operating system does not manage the network itself; it merely provides a programmatic interface. Applications implemented on top of the network operating system perform the actual management tasks. The programmatic interface should be general enough to support a broad spectrum of network management applications. Such a network operating system represents two major conceptual departures from the status quo. First, the network operating system presents programs with a centralized programming model; programs are written as if the entire network were present on a single machine (i.e., one would use Dijkstra to compute shortest paths, not Bellman-Ford). This requires (as in [3, 8, 14] and elsewhere) centralizing network state. Second, programs are written in terms of high-level abstractions (e.g., user and host names), not low-level configuration parameters (e.g., IP and MAC addresses). This allows management directives to be enforced independent of the underlying network topology, but it requires that the network operating system carefully maintain the bindings (i.e., mappings) between these abstractions and the low-level configurations. Thus, a network operating system allows management applications to be written as centralized programs over highlevel names as opposed to the distributed algorithms over low-level addresses we are forced to use today. While clearly a desirable goal, achieving this transformation from distributed algorithms to centralized programming presents significant technical challenges, and the question we pose here is: Can one build a network operating system at significant scale?
---
paper_title: Ethane: taking control of the enterprise

paper_content:

This paper presents Ethane, a new network architecture for the enterprise. Ethane allows managers to define a single network-wide fine-grain policy, and then enforces it directly. Ethane couples extremely simple flow-based Ethernet switches with a centralized controller that manages the admittance and routing of flows. While radical, this design is backwards-compatible with existing hosts and switches. We have implemented Ethane in both hardware and software, supporting both wired and wireless hosts. Our operational Ethane network has supported over 300 hosts for the past four months in a large university network, and this deployment experience has significantly affected Ethane's design.
---
paper_title: OpenFlow and PCE architectures in Wavelength Switched Optical Networks

paper_content:

The GMPLS protocol suite, originally designed to fully operate in a distributed fashion, is currently the reference control plane for WSONs. Recently, the requirement of effective traffic engineering solutions has lead to the standardization of the PCE architecture, thus joining the distributed GMPLS control plane with a centralized network element devoted to path computation. However, the common need of network carriers to keep the network under a centralized control in strict relationship with the NMS has prevented the wide deployment of GMPLS in currently working optical networks.
---
paper_title: A Path Computation Element (PCE)-Based Architecture

paper_content:

Constraint-based path computation is a fundamental building block for ::: traffic engineering systems such as Multiprotocol Label Switching ::: (MPLS) and Generalized Multiprotocol Label Switching (GMPLS) networks. ::: Path computation in large, multi-domain, multi-region, or multi-layer ::: networks is complex and may require special computational components ::: and cooperation between the different network domains. This document ::: specifies the architecture for a Path Computation Element (PCE)-based ::: model to address this problem space. This document does not attempt to ::: provide a detailed description of all the architectural components, ::: but rather it describes a set of building blocks for the PCE ::: architecture from which solutions may be constructed. This memo ::: provides information for the Internet community.
---
paper_title: Source address validation solution with OpenFlow/NOX architecture

paper_content:

Current Internet is lack of validation on source IP address, resulting in many security threats. The future Internet can face the similar routing locator spoofing problem without careful design. The current in-progress source address validation standard, i.e., SAVI, is not of enough protection due to the solution space constraint. In this article, a mechanism named VAVE is proposed to improve the SAVI solutions. VAVE employs OpenFlow protocol, which provides the de facto standard network innovation interface, to solve source address validation problem with a global view. Significant improvements can be found from our evaluation results.
---
paper_title: Lightweight DDoS flooding attack detection using NOX/OpenFlow

paper_content:

Distributed denial-of-service (DDoS) attacks became one of the main Internet security problems over the last decade, threatening public web servers in particular. Although the DDoS mechanism is widely understood, its detection is a very hard task because of the similarities between normal traffic and useless packets, sent by compromised hosts to their victims. This work presents a lightweight method for DDoS attack detection based on traffic flow features, in which the extraction of such information is made with a very low overhead compared to traditional approaches. This is possible due to the use of the NOX platform which provides a programmatic interface to facilitate the handling of switch information. Other major contributions include the high rate of detection and very low rate of false alarms obtained by flow analysis using Self Organizing Maps.
---
paper_title: Software defined networking: Meeting carrier grade requirements

paper_content:

Software Defined Networking is a networking paradigm which allows network operators to manage networking elements using software running on an external server. This is accomplished by a split in the architecture between the forwarding element and the control element. Two technologies which allow this split for packet networks are For CES and Openflow. We present energy efficiency and resilience aspects of carrier grade networks which can be met by Openflow. We implement flow restoration and run extensive experiments in an emulated carrier grade network. We show that Openflow can restore traffic quite fast, but its dependency on a centralized controller means that it will be hard to achieve 50 ms restoration in large networks serving many flows. In order to achieve 50 ms recovery, protection will be required in carrier grade networks.
---
paper_title: Flexible Access Management System for Campus VLAN Based on OpenFlow

paper_content:

Using a lot of VLANs on campus networks has become popular for deploying many logical networks over minimal fibers/cables. A campus-wide Wi-Fi system, for example, requires a lot of VLANs for separating the access networks from other campus networks and for realizing a sophisticated access control such as guest-/home-users separation and security filtering. The requirement is high especially when a network roaming system, such as eduroam, is introduced. The conventional VLAN based on IEEE802.1Q has some limitations, and the system configuration work is laborious. In this paper, we propose a flexible campus VLAN system based on Open Flow to solve the problems. In addition, we introduce a prototype system and show evaluation results. As the results, we confirm that the proposed system can realize flexible network configurations and sophisticated access control with a much simplified network management work.
---
paper_title: Walk the line: consistent network updates with bandwidth guarantees

paper_content:

New advances in technologies for high-speed and seamless migration of VMs turns VM migration into a promising and efficient means for load balancing, configuration, power saving, attaining a better resource utilization by reallocating VMs, cost management, etc. in data centers. Despite these numerous benefits, VM migration is still a challenging task for providers, since moving VMs requires update of network state, which consequently could lead to inconsistencies, outages, creation of loops and violations of service level (SLA) agreement requirements. Many applications today like financial services, social networking, recommendation systems, and web search cannot tolerate such problems or degradation of service [5, 12]. On the positive side, the emerging trend of Software Defined Networking (SDN) provides a powerful tool for tackling these challenging problems. In SDN, management applications are run by a logically-centralized controller that directly controls the packet handling functionality of the underlying switches. For example, OpenFlow, a recently proposed mechanism for SDN, provides an API that allows the controller to install rules in switches, process data packets, learn the topology changes, and query traffic counters [13]. The ability to run algorithms in a logically centralized location, and precisely manipulate the forwarding layer of switches creates a new opportunity for transitioning the network between two states. In particular this paper studies the question: given a start-
---
paper_title: Consistent updates for software-defined networks: change you can believe in!

paper_content:

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.
---
paper_title: Incremental consistent updates

paper_content:

A consistent update installs a new packet-forwarding policy across the switches of a software-defined network in place of an old policy. While doing so, such an update guarantees that every packet entering the network either obeys the old policy or the new one, but not some combination of the two. In this paper, we introduce new algorithms that trade the time required to perform a consistent update against the rule-space overhead required to implement it. We break an update in to k rounds that each transfer part of the traffic to the new configuration. The more rounds used, the slower the update, but the smaller the rule-space overhead. To ensure consistency, our algorithm analyzes the dependencies between rules in the old and new policies to determine which rules to add and remove on each round. In addition, we show how to optimize rule space used by representing the minimization problem as a mixed integer linear program. Moreover, to ensure the largest flows are moved first, while using rule space efficiently, we extend the mixed integer linear program with additional constraints. Our initial experiments show that a 6-round, optimized incremental update decreases rule space overhead from 100% to less than 10%. Moreover, if we cap the maximum rule-space overhead at 5% and assume the traffic flow volume follows Zipf's law, we find that 80% of the traffic may be transferred to the new policy in the first round and 99% in the first 3 rounds.
---
paper_title: Abstractions for network update

paper_content:

Configuration changes are a common source of instability in networks, leading to outages, performance disruptions, and security vulnerabilities. Even when the initial and final configurations are correct, the update process itself often steps through intermediate configurations that exhibit incorrect behaviors. This paper introduces the notion of consistent network updates---updates that are guaranteed to preserve well-defined behaviors when transitioning mbetween configurations. We identify two distinct consistency levels, per-packet and per-flow, and we present general mechanisms for implementing them in Software-Defined Networks using switch APIs like OpenFlow. We develop a formal model of OpenFlow networks, and prove that consistent updates preserve a large class of properties. We describe our prototype implementation, including several optimizations that reduce the overhead required to perform consistent updates. We present a verification tool that leverages consistent updates to significantly reduce the complexity of checking the correctness of network control software. Finally, we describe the results of some simple experiments demonstrating the effectiveness of these optimizations on example applications.
---
paper_title: Ethane: taking control of the enterprise

paper_content:

This paper presents Ethane, a new network architecture for the enterprise. Ethane allows managers to define a single network-wide fine-grain policy, and then enforces it directly. Ethane couples extremely simple flow-based Ethernet switches with a centralized controller that manages the admittance and routing of flows. While radical, this design is backwards-compatible with existing hosts and switches. We have implemented Ethane in both hardware and software, supporting both wired and wireless hosts. Our operational Ethane network has supported over 300 hosts for the past four months in a large university network, and this deployment experience has significantly affected Ethane's design.
---
paper_title: A safe, efficient update protocol for openflow networks

paper_content:

We describe a new protocol for update of OpenFlow networks, which has the packet consistency condition of [?] and a weak form of the flow consistency condition of [?]. The protocol conserves switch resources, particularly TCAM space, by ensuring that only a single set of rules is present on a switch at any time. The protocol exploits the identity of switch rules with Boolean functions, and the ability of any switch to send packets to a controller for routing. When a network changes from one ruleset (ruleset 1) to another (ruleset 2), the packets affected by the change are computed, and are sent to the controller. When all switches have been updated to send affected packets to the controller, ruleset 2 is sent to the switches and packets sent to the controller are re-released into the network.
---
paper_title: Prototyping Fast, Simple, Secure Switches for Etha

paper_content:

We recently published our proposal for Ethane: A clean- slate approach to managing and securing enterprise networks. The goal of Ethane is to make enterprise networks (e.g. networks in companies, universities, and home offices) much easier to manage. Ethane is built on the premise that the only way to manage and secure networks is to make sure we can identify the origin of all traffic, and hold someone (or some machine) accountable for it. So first, Ethane authenticates every human, computer and switch in the network, and tracks them at all times. Every packet can be immediately identified with its sender. Second, Ethane implements a network-wide policy language in terms of users, machines and services. Before a flow is allowed into the network, it is checked against the policy. Ethane requires two substantial changes to the network: Network switches and routers are replaced with much simpler switches, which are based on flow tables. The switch doesn't learn addresses, doesn't run spanning tree, routing protocols or any access control lists. All it does is permit or deny flows under the control of a central controller. The controller is the second big change. Each network contains a central controller that decides if a flow is to be allowed into the network. It makes its decisions based on a set of rules that make up a policy. One premise of Ethane is that although the network is much more powerful as a whole, the switches are much simpler than conventional switches and routers. To explore whether this is true, we built 4-port Ethane switches in dedicated hardware (on the NetFPGA platform), running at 1Gb/s per port. We have deployed the switches in our network at Stanford University, and demonstrated that despite the simplicity of the switches, Ethane can support a very feature-rich and easy-to-manage network.
---
paper_title: A management method of IP multicast in overlay networks using openflow

paper_content:

Overlay networks stretch a Layer 2 network and increase mobility of virtual machines. VXLAN (Virtual eXtensible LAN) is one of Layer 2 overlay schemes over a Layer 3 net- work proposed in IETF and its definition covers 16M overlay networks or segments which solves 4K limitation of VLANs. However VXLAN uses IP multicast for the isolation of net- work traffic by tenant in the shared network infrastructure. IP multicast requires great amount of resources such as IP multicast table and CPU therefore the scalability is to be limited by handling of IP multicast. We propose to manage IP multicast in overlay networks using OpenFlow instead of using dynamic registration protocol such as IGMP. We describe our implementations of VXLAN controller, edge switch with VXLAN gateway and OpenFlow switch. Our method using OpenFlow eliminates periodical Join/Leave messages and achieves more than 4k tenants in our Layer 2 network at server edges, which was not possible before.
---
paper_title: Outsourcing network functionality

paper_content:

This paper presents an architecture for adding functionality to networks via outsourcing. In this model, the enterprise network only forwards data; any additional processing is performed by external Feature Providers (FPs). FPs provide and manage features, scaling and moving them in response to customer demand, and providing automated recovery in case of failure. Benefits to the enterprise include reduced cost and management complexity, improved features through FP specialization, and increased choice in services. Central to the model are a policy component and a Feature API (FAPI). Policy is specified with features not locations, enabling features to be located anywhere. FAPI enables communication between enterprise and FP control planes to share policy and configure features. We have built a prototype implementation of this architecture called Jingling. Our prototype system incorporates a nation-wide backbone network and FPs located in six sites around the United States.
---
paper_title: Openflow random host mutation: transparent moving target defense using software defined networking

paper_content:

Static configurations serve great advantage for adversaries in discovering network targets and launching attacks. Identifying active IP addresses in a target domain is a precursory step for many attacks. Frequently changing hosts' IP addresses is a novel proactive moving target defense (MTD) that hides network assets from external/internal scanners. In this paper, we use OpenFlow to develop a MTD architecture that transparently mutates host IP addresses with high unpredictability and rate, while maintaining configuration integrity and minimizing operation overhead. The presented technique is called OpenFlow Random Host Mutation (OF-RHM) in which the OpenFlow controller frequently assigns each host a random virtual IP that is translated to/from the real IP of the host. The real IP remains untouched, so IP mutation is completely transparent for end-hosts. Named hosts are reachable via the virtual IP addresses acquired via DNS, but real IP addresses can be only reached by authorized entities. Our implementation and evaluation show that OF-RHM can effectively defend against stealthy scanning, worm propagation, and other scanning-based attack.
---
paper_title: Splendid isolation: a slice abstraction for software-defined networks

paper_content:

The correct operation of many networks depends on keeping certain kinds of traffic isolated from others, but achieving isolation in networks today is far from straightforward. To achieve isolation, programmers typically resort to low-level mechanisms such as Virtual LANs, or they interpose complicated hypervisors into the control plane. This paper presents a better alternative: an abstraction that supports programming isolated slices of the network. The semantics of slices ensures that the processing of packets on a slice is independent of all other slices. We define our slice abstraction precisely, develop algorithms for compiling slices, and illustrate their use on examples. In addition, we describe a prototype implementation and a tool for automatically verifying formal isolation properties.
---
paper_title: OMNI: OpenFlow MaNagement Infrastructure

paper_content:

Managing computer networks is challenging because of the numerous monitoring variables and the difficulty to autonomously configure network parameters. This paper presents the OpenFlow MaNagement Infrastructure (OMNI), which helps the administrator to control and manage OpenFlow networks by providing remote management based on a web interface. OMNI provides flow monitoring and dynamic flow configuration through a service-oriented architecture. OMNI also offers an Application Programming Interface (API) for collecting data and configuring the OpenFlow network. We propose a multi-agent system based on OMNI API that reduces packet loss rates. We evaluate both the OMNI management applications and the multi-agent system performance using a testbed. Our results show that the multi-agent system detects and reacts to a packet-loss condition in less than three monitoring intervals.
---
paper_title: Hierarchical policies for software defined networks

paper_content:

Hierarchical policies are useful in many contexts in which resources are shared among multiple entities. Such policies can easily express the delegation of authority and the resolution of conflicts, which arise naturally when decision-making is decentralized. Conceptually, a hierarchical policy could be used to manage network resources, but commodity switches, which match packets using flow tables, do not realize hierarchies directly. This paper presents Hierarchical Flow Tables (HFT), a framework for specifying and realizing hierarchical policies in software defined networks. HFT policies are organized as trees, where each component of the tree can independently determine the action to take on each packet. When independent parts of the tree arrive at conflicting decisions, HFT resolves conflicts with user-defined conflict-resolution operators, which exist at each node of the tree. We present a compiler that realizes HFT policies on a distributed network of OpenFlow switches, and prove its correctness using the Coq proof assistant. We then evaluate the use of HFT to improve performance of networked applications.
---
paper_title: Dynamic graph query primitives for SDN-based cloudnetwork management

paper_content:

The need to provide customers with the ability to configure the network in current cloud computing environments has motivated the Networking-as-a-Service (NaaS) systems designed for the cloud. Such systems can provide cloud customers access to virtual network functions, such as network-aware VM placement, real time network monitoring, diagnostics and management, all while supporting multiple device management protocols. These network management functionalities depend on a set of underlying graph primitives. In this paper, we present the design and implementation of the software architecture including a shared graph library that can support network management operations. Using the illustrative case of all pair shortest path algorithm, we demonstrate how scalable lightweight dynamic graph query mechanisms can be implemented to enable practical computation times, in presence of network dynamism.
---
paper_title: Source address validation solution with OpenFlow/NOX architecture

paper_content:

Current Internet is lack of validation on source IP address, resulting in many security threats. The future Internet can face the similar routing locator spoofing problem without careful design. The current in-progress source address validation standard, i.e., SAVI, is not of enough protection due to the solution space constraint. In this article, a mechanism named VAVE is proposed to improve the SAVI solutions. VAVE employs OpenFlow protocol, which provides the de facto standard network innovation interface, to solve source address validation problem with a global view. Significant improvements can be found from our evaluation results.
---
paper_title: Openflow random host mutation: transparent moving target defense using software defined networking

paper_content:

Static configurations serve great advantage for adversaries in discovering network targets and launching attacks. Identifying active IP addresses in a target domain is a precursory step for many attacks. Frequently changing hosts' IP addresses is a novel proactive moving target defense (MTD) that hides network assets from external/internal scanners. In this paper, we use OpenFlow to develop a MTD architecture that transparently mutates host IP addresses with high unpredictability and rate, while maintaining configuration integrity and minimizing operation overhead. The presented technique is called OpenFlow Random Host Mutation (OF-RHM) in which the OpenFlow controller frequently assigns each host a random virtual IP that is translated to/from the real IP of the host. The real IP remains untouched, so IP mutation is completely transparent for end-hosts. Named hosts are reachable via the virtual IP addresses acquired via DNS, but real IP addresses can be only reached by authorized entities. Our implementation and evaluation show that OF-RHM can effectively defend against stealthy scanning, worm propagation, and other scanning-based attack.
---
paper_title: Splendid isolation: a slice abstraction for software-defined networks

paper_content:

The correct operation of many networks depends on keeping certain kinds of traffic isolated from others, but achieving isolation in networks today is far from straightforward. To achieve isolation, programmers typically resort to low-level mechanisms such as Virtual LANs, or they interpose complicated hypervisors into the control plane. This paper presents a better alternative: an abstraction that supports programming isolated slices of the network. The semantics of slices ensures that the processing of packets on a slice is independent of all other slices. We define our slice abstraction precisely, develop algorithms for compiling slices, and illustrate their use on examples. In addition, we describe a prototype implementation and a tool for automatically verifying formal isolation properties.
---
paper_title: Lightweight DDoS flooding attack detection using NOX/OpenFlow

paper_content:

Distributed denial-of-service (DDoS) attacks became one of the main Internet security problems over the last decade, threatening public web servers in particular. Although the DDoS mechanism is widely understood, its detection is a very hard task because of the similarities between normal traffic and useless packets, sent by compromised hosts to their victims. This work presents a lightweight method for DDoS attack detection based on traffic flow features, in which the extraction of such information is made with a very low overhead compared to traditional approaches. This is possible due to the use of the NOX platform which provides a programmatic interface to facilitate the handling of switch information. Other major contributions include the high rate of detection and very low rate of false alarms obtained by flow analysis using Self Organizing Maps.
---
paper_title: Design of the multi-level security network switch system which restricts covert channel

paper_content:

The administrator shall implement multilevel security policy in a multilevel security network system. The policy must ensure the information flow from low level host to the same level host or high level host, and prevent the information flow from high level host to low level host, but traditional network is difficult to meet the requirement. This paper proposes a design of multi-level security network switch system. The design adds a module named Filter based on OpenFlow. OpenFlow can control the packets flow of the network, and the Filter can check the packet's content and delay the packets then restrict covert channel. Using OpenFlow and the Filter, the system can implement the multilevel security policy in the scenario of local area network. The experiment verified the feasibility of the design.
---
paper_title: Enabling fast failure recovery in OpenFlow networks

paper_content:

OpenFlow is a novel technology designed at Stanford University which aims at decoupling the controller software from the forwarding hardware of a router or switch. The OpenFlow concept is based on the approach that the forwarding information base (FIB) of a switch can be programmed via a controller which resides at a separate hardware. The goal is to provide a standardized open management interface to the forwarding hardware of a router or switch. The aim of a project SPARC “SPlit ARchitecture Carrier grade networks” is to deploy OpenFlow in carrier grade networks. Reliability is a major issue to deploy OpenFlow in this networks. This work proposes the addition of a fast restoration mechanism in OpenFlow and evaluates the performance by comparing the switchover time and packet loss to existing restoration options in a current OpenFlow implementation.
---
paper_title: Openflow-based server load balancing gone wild

paper_content:

Today's data centers host online services on multiple servers, with a front-end load balancer directing each client request to a particular replica. Dedicated load balancers are expensive and quickly become a single point of failure and congestion. The OpenFlow standard enables an alternative approach where the commodity network switches divide traffic over the server replicas, based on packet-handling rules installed by a separate controller. However, the simple approach of installing a separate rule for each client connection (or "microflow") leads to a huge number of rules in the switches and a heavy load on the controller. We argue that the controller should exploit switch support for wildcard rules for a more scalable solution that directs large aggregates of client traffic to server replicas. We present algorithms that compute concise wildcard rules that achieve a target distribution of the traffic, and automatically adjust to changes in load-balancing policies without disrupting existing connections. We implement these algorithms on top of the NOX OpenFlow controller, evaluate their effectiveness, and propose several avenues for further research.
---
paper_title: Software defined networking: Meeting carrier grade requirements

paper_content:

Software Defined Networking is a networking paradigm which allows network operators to manage networking elements using software running on an external server. This is accomplished by a split in the architecture between the forwarding element and the control element. Two technologies which allow this split for packet networks are For CES and Openflow. We present energy efficiency and resilience aspects of carrier grade networks which can be met by Openflow. We implement flow restoration and run extensive experiments in an emulated carrier grade network. We show that Openflow can restore traffic quite fast, but its dependency on a centralized controller means that it will be hard to achieve 50 ms restoration in large networks serving many flows. In order to achieve 50 ms recovery, protection will be required in carrier grade networks.
---
paper_title: A security enforcement kernel for OpenFlow networks

paper_content:

Software-defined networks facilitate rapid and open innovation at the network control layer by providing a programmable network infrastructure for computing flow policies on demand. However, the dynamism of programmable networks also introduces new security challenges that demand innovative solutions. A critical challenge is efficient detection and reconciliation of potentially conflicting flow rules imposed by dynamic OpenFlow (OF) applications. To that end, we introduce FortNOX, a software extension that provides role-based authorization and security constraint enforcement for the NOX OpenFlow controller. FortNOX enables NOX to check flow rule contradictions in real time, and implements a novel analysis algorithm that is robust even in cases where an adversarial OF application attempts to strategically insert flow rules that would otherwise circumvent flow rules imposed by OF security applications. We demonstrate the utility of FortNOX through a prototype implementation and use it to examine performance and efficiency aspects of the proposed framework.
---
paper_title: VeriFlow: verifying network-wide invariants in real time

paper_content:

Networks are complex and prone to bugs. Existing tools that check configuration files and data-plane state operate offline at timescales of seconds to hours, and cannot detect or prevent bugs as they arise. Is it possible to check network-wide invariants in real time, as the network state evolves? The key challenge here is to achieve extremely low latency during the checks so that network performance is not affected. In this paper, we present a preliminary design, VeriFlow, which suggests that this goal is achievable. VeriFlow is a layer between a software-defined networking controller and network devices that checks for network-wide invariant violations dynamically as each forwarding rule is inserted. Based on an implementation using a Mininet OpenFlow network and Route Views trace data, we find that VeriFlow can perform rigorous checking within hundreds of microseconds per rule insertion.
---
paper_title: On the Flexibility of MPLS Applications over an OpenFlow-Enabled Network

paper_content:

In today's networks, a node usually has a static role that cannot be easily changed without an expensive upgrade. In MPLS architecture, despite the flexible forwarding data plane not tied to a single forwarding technology, each MPLS node has to be dedicated for a specific role depending on its position in the edge or the core of the MPLS network domain. This paper proposes an approach to address the flexibility of an MPLS node to play multiple roles for different MPLS domains built on top of an underlying OpenFlow-enabled physical network. The pipelined approach through tables introduced in the version 1.1 and later of the OpenFlow specification allows the change of the packet processing behavior by just updating the memory structures -- such as the TCAM and hash tables. It exploits the power of the OpenFlow rules-based paradigm to demonstrate the high level programmability to achieve the deossification of an MPLS infrastructure. In order to validate our proposal, we have implemented our approach over a 100Gbps switch box built on network processors and tested it with three applications to evaluate its flexibility. The results show that the local software to hardware update of a Label Switched Path (LSP) can be made in 2.2ms, in average, and the deployment of a Label Switched Router (LSR) application with 400 labels takes only 392.5ms.
---
paper_title: Unifying Packet and Circuit Switched Networks

paper_content:

There have been many attempts to unify the control and management of circuit and packet switched networks, but none have taken hold. In this paper we propose a simple way to unify both types of network using OpenFlow. The basic idea is that a simple flow abstraction fits well with both types of network, provides a common paradigm for control, and makes it easy to insert new functionality into the network. OpenFlow provides a common API to the underlying hardware, and allows all of the routing, control and management to be defined in software outside the datapath.
---
paper_title: Integrated OpenFlow — GMPLS control plane: An overlay model for software defined packet over optical networks

paper_content:

A novel software-defined packet over optical networks solution based on the OpenFlow and GMPLS control plane integration is demonstrated. The proposed architecture, experimental setup, and average flow setup time for different optical flows is reported.
---
paper_title: OpenFlow MPLS and the open source label switched router

paper_content:

Multiprotocol Label Switching (MPLS) [3] is a protocol widely used in commercial operator networks to forward packets by matching link-specific labels in the packet header to outgoing links rather than through standard IP longest prefix matching. However, in existing networks, MPLS is implemented by full IP routers, since the MPLS control plane protocols such as LDP [8] utilize IP routing to set up the label switched paths, even though the MPLS data plane does not require IP routing. OpenFlow 1.0 is an interface for controlling a routing or switching box by inserting flow specifications into the box's flow table [1]. While OpenFlow 1.0 does not support MPLS1, MPLS label-based forwarding seems conceptually a good match with OpenFlow's flow-based routing paradigm. In this paper we describe the design and implementation of an experimental extension of OpenFlow 1.0 to support MPLS. The extension allows an OpenFlow switch without IP routing capability to forward MPLS on the data plane. We also describe the implementation of a prototype open source MPLS label switched router, based on the NetFPGA hardware platform [4], utilizing OpenFlow MPLS. The prototype is capable of forwarding data plane packets at line speed without IP forwarding, though IP forwarding is still used on the control plane. We provide some performance measurements comparing the prototype to software routers. The measurements indicate that the prototype is an appropriate tool for achieving line speed forwarding in testbeds and other experimental networks where flexibility is a key attribute, as a substitute for software routers.
---
paper_title: Packet and circuit network convergence with OpenFlow

paper_content:

IP and Transport networks are controlled and operated independently today, leading to significant Capex and Opex inefficiencies for the providers. We discuss a unified approach with OpenFlow, and present a recent demonstration of a unified control plane for OpenFlow enabled IP/Ethernet and TDM switched networks.
---
paper_title: Application-aware aggregation and traffic engineering in a converged packet-circuit network

paper_content:

We demonstrate a converged OpenFlow enabled packet-circuit network, where circuit flow properties (guarantee d bandwidth, low latency, low jitter, bandwidth-on-demand, fast recovery) provide differential treatment to dynamically aggregated packet flows for voice, video and web traffic.
---
paper_title: MPLS with a simple OPEN control plane

paper_content:

We propose a new approach to MPLS that uses the standard MPLS data plane and an OpenFlow based simpler and extensible control plane. We demonstrate this approach using a prototype system for MPLS Traffic Engineering.
---
paper_title: Why OpenFlow/SDN can succeed where GMPLS failed

paper_content:

OpenFlow & Software Defined Networking (SDN) ideas offer drastically reduced complexity in the control plane, increased programmability and extensibility, and a gradual adoption path; all significant advantages over GMPLS for dynamic interaction between packet and circuit networks.
---
paper_title: Enabling the future optical Internet with OpenFlow: A paradigm shift in providing intelligent optical network services

paper_content:

This paper proposes an optical networking paradigm suitable for future Internet services enabled by OpenFlow. The OpenFlow technology supports the programmability of network functions and protocols by separating the data plane and the control plane, which are currently vertically integrated in routers and switches. OpenFlow facilitates fundamental changes in the behaviour of networks and their associated protocols. This paper introduces an OpenFlow optical network architecture enabled by optical flow, optical flow switching elements and programmable OpenFlow controllers. The proposed solution allows intelligent, user controlled and programmable optical network service provisioning with the capability to operate any user defined network protocol and scenario.
---
paper_title: MPLS-TE and MPLS VPNS with openflow

paper_content:

We demonstrate MPLS Traffic Engineering (MPLS-TE) and MPLS-based Virtual Private Networks (MPLS VPNs) using OpenFlow [1] and NOX [6]. The demonstration is the outcome of an engineering experiment to answer the following questions: How hard is it to implement a complex control plane on top of a network controller such as NOX? Does the global vantage point in NOX make the implementation easier than the traditional method of implementing it on every switch, embedded in the data plane? We implemented every major feature of MPLS-TE and MPLS-VPN in just 2,000 lines of code, compared to much larger lines of code in the more traditional approach, such as Quagga-MPLS. Because NOX maintains a consistent, up-to-date topology map, the MPLS control plane features are quite simple to implement. And its simplicity makes it easy to extend: We have easily added several new features; something a network operator could do to customize their network to meet their customers' needs. ::: The demo consists of two parts: MPLS-TE services and then MPLS VPN driven by a GUI.
---
paper_title: Hedera: Dynamic Flow Scheduling for Data Center Networks

paper_content:

Today's data centers offer tremendous aggregate bandwidth to clusters of tens of thousands of machines. However, because of limited port densities in even the highest-end switches, data center topologies typically consist of multi-rooted trees with many equal-cost paths between any given pair of hosts. Existing IP multipathing protocols usually rely on per-flow static hashing and can cause substantial bandwidth losses due to long-term collisions. ::: ::: In this paper, we present Hedera, a scalable, dynamic flow scheduling system that adaptively schedules a multi-stage switching fabric to efficiently utilize aggregate network resources. We describe our implementation using commodity switches and unmodified hosts, and show that for a simulated 8,192 host data center, Hedera delivers bisection bandwidth that is 96% of optimal and up to 113% better than static load-balancing methods.
---
paper_title: An inter-AS routing component for software-defined networks

paper_content:

Network management is a challenging problem of wide impact with many enterprises suffering significant monetary losses, that can be of millions per hour, due to network issues, as downtime cost. The Software Defined Networks (SDN) approach is a new paradigm that enables the management of networks with low cost and complexity. The SDN architecture consists of a control plane, a forwarding plane and a protocol that enables communication with both planes. The control plane is composed by an Operating System and applications that run on top of it. The forwarding plane contains the switches, routers, and other network equipment. Nowadays, inter-domain routing system presents some critical problems, mainly due to its fully distributed model. Recent research has showed that it would be beneficial to apply the SDN approach to address some of those problems. But it became necessary to build a new mechanism to allow inter-domain routing using SDN. The aim of this paper is to present an inter-domain routing solution using a NOX-OpenFlow architecture, based on some characteristics of the today largely used inter-domain protocol, keeping the SDN architectural principles. Although NOX-OpenFlow was originally created for routing only in enterprise networks, we propose routing beyond those, lifting this undesirable restriction of the original architecture. Our tests show that the built of this kind of application provides a much less complex, less prone to errors, and scalable solution.
---
paper_title: Unifying Packet and Circuit Switched Networks

paper_content:

There have been many attempts to unify the control and management of circuit and packet switched networks, but none have taken hold. In this paper we propose a simple way to unify both types of network using OpenFlow. The basic idea is that a simple flow abstraction fits well with both types of network, provides a common paradigm for control, and makes it easy to insert new functionality into the network. OpenFlow provides a common API to the underlying hardware, and allows all of the routing, control and management to be defined in software outside the datapath.
---
paper_title: Application-aware aggregation and traffic engineering in a converged packet-circuit network

paper_content:

We demonstrate a converged OpenFlow enabled packet-circuit network, where circuit flow properties (guarantee d bandwidth, low latency, low jitter, bandwidth-on-demand, fast recovery) provide differential treatment to dynamically aggregated packet flows for voice, video and web traffic.
---
paper_title: MPLS with a simple OPEN control plane

paper_content:

We propose a new approach to MPLS that uses the standard MPLS data plane and an OpenFlow based simpler and extensible control plane. We demonstrate this approach using a prototype system for MPLS Traffic Engineering.
---
paper_title: Carving research slices out of your production networks with OpenFlow

paper_content:

1. SLICED PROGRAMMABLE NETWORKS OpenFlow [4] has been demonstrated as a way for researchers to run networking experiments in their production network. Last year, we demonstrated how an OpenFlow controller running on NOX [3] could move VMs seamlessly around an OpenFlow network [1]. While OpenFlow has potential [2] to open control of the network, only one researcher can innovate on the network at a time. What is required is a way to divide, or slice, network resources so that researchers and network administrators can use them in parallel. Network slicing implies that actions in one slice do not negatively affect other slices, even if they share the same underlying physical hardware. A common network slicing technique is VLANs. With VLANs, the administrator partitions the network by switch port and all traffic is mapped to a VLAN by input port or explicit tag. This coarse-grained type of network slicing complicates more interesting experiments such as IP mobility or wireless handover. Here, we demonstrate FlowVisor, a special purpose OpenFlow controller that allows multiple researchers to run experiments safely and independently on the same production OpenFlow network. To motivate FlowVisor’s flexibility, we demonstrate four network slices running in parallel: one slice for the production network and three slices running experimental code (Figure 1). Our demonstration runs on real network hardware deployed on our production network at Stanford and a wide-area test-bed with a mix of wired and wireless technologies.
---
paper_title: Delivering capacity for the mobile internet by stitching together networks

paper_content:

Despite of findings that only 5.2% of the spectrum from 30 MHz to 3 GHz is utilized, there is much talk of an impending spectrum crisis. This is no contradiction - spectrum is inefficiently utilized, with some part of the spectrum being heavily used while others barely used. In this paper, we explore a simple high-level approach to the problem: to enable user mobility across networks and exploit all the capacity available. By doing so, we can create a better mobile network by stitching together existing ones spanning multiple wireless technologies. We briefly outline our exploratory foray into radio agnostic handover and discuss the various challenges ahead.
---
paper_title: PhoneNet: a phone-to-phone network for group communication within an administrative domain

paper_content:

This paper proposes PhoneNet, an application framework to support direct group communication among phones without relay nodes. PhoneNet presents the familiar abstraction of a multi-user chat service to application writers. It performs two main functions: inviting participants to the chat room and routing data between participants directly without going through any intermediaries. Made possible by a generic chat room service embedded in the network itself, all application-specific code in PhoneNet applications runs on the phones themselves. Unlike the conventional server-client model, this design does not require scalable central servers that can handle all simultaneous interactions. As a first step, we have created a prototype of PhoneNet that works within an administrative domain. The multicast functionality among phones is implemented on top of a software-defined network (SDN). We have developed two applications using PhoneNet: teleconferencing and photo-sharing. Our experience suggests that it is easy to develop PhoneNet applications and PhoneNet appears to be effective in reducing network traffic.
---
paper_title: Towards programmable enterprise WLANS with Odin

paper_content:

We present Odin, an SDN framework to introduce programmability in enterprise wireless local area networks (WLANs). Enterprise WLANs need to support a wide range of services and functionalities. This includes authentication, authorization and accounting, policy, mobility and interference management, and load balancing. WLANs also exhibit unique challenges. In particular, access point (AP) association decisions are not made by the infrastructure, but by clients. In addition, the association state machine combined with the broadcast nature of the wireless medium requires keeping track of a large amount of state changes. To this end, Odin builds on a light virtual AP abstraction that greatly simplifies client management. Odin does not require any client side modifications and its design supports WPA2 Enterprise. With Odin, a network operator can implement enterprise WLAN services as network applications. A prototype implementation demonstrates Odin's feasibility.
---
paper_title: The Stanford OpenRoads deployment

paper_content:

We have built and deployed OpenRoads [11], a testbed that allows multiple network experiments to be conducted concurrently in a production network. For example, multiple routing protocols, mobility managers and network access controllers can run simultaneously in the same network. In this paper, we describe and discuss our deployment of the testbed at Stanford University. We focus on the challenges we faced deploying in a production network, and the tools we built to overcome these challenges. Our goal is to gain enough experience for other groups to deploy OpenRoads in their campus network.
---
paper_title: Blueprint for introducing innovation into wireless mobile networks

paper_content:

In the past couple of years we've seen quite a change in the wireless industry: Handsets have become mobile computers running user-contributed applications on (potentially) open operating systems. It seems we are on a path towards a more open ecosystem; one that has been previously closed and proprietary. The biggest winners are the users, who will have more choice among competing, innovative ideas. The same cannot be said for the wireless network infrastructure, which remains closed and (mostly) proprietary, and where innovation is bogged down by a glacial standards process. Yet as users, we are surrounded by abundant wireless capacity and multiple wireless networks (WiFi and cellular), with most of the capacity off-limits to us. It seems industry has little incentive to change, preferring to hold onto control as long as possible, keeping an inefficient and closed system in place. This paper is a "call to arms" to the research community to help move the network forward on a path to greater openness. We envision a world in which users can move freely between any wireless infrastructure, while providing payment to infrastructure owners, encouraging continued investment. We think the best path to get there is to separate the network service from the underlying physical infrastructure, and allow rapid innovation of network services, contributed by researchers, network operators, equipment vendors and third party developers. We propose to build and deploy an open - but backward compatible - wireless network infrastructure that can be easily deployed on college campuses worldwide. Through virtualization, we allow researchers to experiment with new network services directly in their production network.
---
paper_title: OpenRadio: a programmable wireless dataplane

paper_content:

We present OpenRadio, a novel design for a programmable wireless dataplane that provides modular and declarative programming interfaces across the entire wireless stack. Our key conceptual contribution is a principled refactoring of wireless protocols into processing and decision planes. The processing plane includes directed graphs of algorithmic actions (eg. 54Mbps OFDM WiFi or special encoding for video). The decision plane contains the logic which dictates which directed graph is used for a particular packet (eg. picking between data and video graphs). The decoupling provides a declarative interface to program the platform while hiding all underlying complexity of execution. An operator only expresses decision plane rules and corresponding processing plane action graphs to assemble a protocol. The scoped interface allows us to build a dataplane that arguably provides the right tradeoff between performance and flexibility. Our current system is capable of realizing modern wireless protocols (WiFi, LTE) on off-the-shelf DSP chips while providing flexibility to modify the PHY and MAC layers to implement protocol optimizations.
---
paper_title: OpenRoads: empowering research in mobile networks

paper_content:

We present OpenRoads, an open-source platform for innovation in mobile networks. OpenRoads enable researchers to innovate using their own production networks, through providing an wireless extension OpenFlow. Therefore, you can think of OpenRoads as "OpenFlow Wireless". The OpenRoads' architecture consists of three layers: flow, slicing and controller. These layers provide flexible control, virtualization and high-level abstraction. This allows researchers to implement wildly different algorithms and run them concurrently in one network. OpenRoads also incorporates multiple wireless technologies, specifically WiFi and WiMAX. We have deployed OpenRoads, and used it as our production network. Our goal here is for those to deploy OpenRoads and build their own experiments on it.
---
paper_title: OpenFlow control for cooperating AQM scheme

paper_content:

OpenFlow is defined as a unified control plane and architecture for packet and circuit switched networks. We deal with the congestion control problem in the multi-layer network, and propose a cooperative congestion control scheme for a domain with multiple AQM routers based on the OpenFlow architecture. This scheme operates three different cases in the domain, where the domain server share information with core router and edge router interactively. Moreover, we use the OpenFlow to control atomic behaviors for packet handing within each switching element, which could manipulate such behaviors from a control server, thus users can program their own network behaviors by injecting their own control programs into the server. The congestion control algorithm is simulated to ensure the convergence of the average rate and throughout capacity to its equilibrium state when there are many high-rate flows in multilayer network. Finally, we compared its performance of the dropping probability and the queue length queue length with respect to the single router control results.
---
paper_title: Virtual routers as a service: the RouteFlow approach leveraging software-defined networks

paper_content:

The networking equipment market is being transformed by the need for greater openness and flexibility, not only for research purposes but also for in-house innovation by the equipment owners. In contrast to networking gear following the model of computer mainframes, where closed software runs on proprietary hardware, the software-defined networking approach effectively decouples the data from the control plane via an open API (i.e., OpenFlow protocol) that allows the (remote) control of packet forwarding engines. Motivated by this scenario, we propose RouteFlow, a commodity routing architecture that combines the line-rate performance of commercial hardware with the flexibility of open-source routing stacks (remotely) running on general purpose computers. The outcome is a novel point in the design space of commodity routing solutions with far-reaching implications towards virtual routers and IP networks as a service. This paper documents the progress achieved in the design and prototype implementation of our work and outlines our research agenda that calls for a community-driven approach.
---
paper_title: QuagFlow: partnering Quagga with OpenFlow

paper_content:

Computing history has shown that open, multi-layer hardware and software stacks encourage innovation and bring costs down. Only recently this trend is meeting the networking world with the availability of entire open source networking stacks being closer than ever. Towards this goal, we are working on QuagFlow, a transparent interplay between the popular Quagga open source routing suite and the low level vendor-independent OpenFlow interface. QuagFlow is a distributed system implemented as a NOX controller application and a series of slave daemons running along the virtual machines hosting the Quagga routing instances.
---
paper_title: Scalable video streaming over OpenFlow networks: An optimization framework for QoS routing

paper_content:

OpenFlow is a clean-slate Future Internet architecture that decouples control and forwarding layers of routing, which has recently started being deployed throughout the world for research purposes. This paper presents an optimization framework for the OpenFlow controller in order to provide QoS support for scalable video streaming over an OpenFlow network. We pose and solve two optimization problems, where we route the base layer of SVC encoded video as a lossless-QoS flow, while the enhancement layers can be routed either as a lossy-QoS flow or as a best effort flow, respectively. The proposed approach differs from current QoS architectures since we provide dynamic rerouting capability possibly using non-shortest paths for lossless and lossy QoS flows. We show that dynamic rerouting of QoS flows achieves significant improvement on the video's overall PSNR under network congestion.
---
paper_title: Revisiting routing control platforms with the eyes and muscles of software-defined networking

paper_content:

Prior work on centralized Routing Control Platform (RCP) has shown many benefits in flexible routing, enhanced security, and ISP connectivity management tasks. In this paper, we discuss RCPs in the context of OpenFlow/SDN, describing potential use cases and identifying deployment challenges and advantages. We propose a controller-centric hybrid networking model and present the design of the RouteFlow Control Platform (RFCP) along the prototype implementation of an AS-wide abstract BGP routing service.
---
paper_title: Towards software-friendly networks

paper_content:

There has usually been a clean separation between networks and the applications that use them. Applications send packets over a simple socket API; the network delivers them. However, there are many occasions when applications can benefit from more direct interaction with the network: to observe more of the current network state and to obtain more control over the network behavior. This paper explores some of the potential benefits of closer interaction between applications and the network. Exploiting the emergence of so-called "software-defined networks" (SDN) built above network-wide control planes, we explore how to build a more "software-friendly network". We present results from a preliminary exploration that aims to provide network services to applications via an explicit communication channel.
---
paper_title: B4: experience with a globally-deployed software defined wan

paper_content:

We present the design, implementation, and evaluation of B4, a private WAN connecting Google's data centers across the planet. B4 has a number of unique characteristics: i) massive bandwidth requirements deployed to a modest number of sites, ii) elastic traffic demand that seeks to maximize average bandwidth, and iii) full control over the edge servers and network, which enables rate limiting and demand measurement at the edge. These characteristics led to a Software Defined Networking architecture using OpenFlow to control relatively simple switches built from merchant silicon. B4's centralized traffic engineering service drives links to near 100% utilization, while splitting application flows among multiple paths to balance capacity against application priority/demands. We describe experience with three years of B4 production deployment, lessons learned, and areas for future work.
---
paper_title: Modeling and performance evaluation of an OpenFlow architecture

paper_content:

The OpenFlow concept of flow-based forwarding and separation of the control plane from the data plane provides a new flexibility in network innovation. While initially used solely in the research domain, OpenFlow is now finding its way into commercial applications. However, this creates new challenges, as questions of OpenFlow scalability and performance have not yet been answered. This paper is a first step towards that goal. Based on measurements of switching times of current OpenFlow hardware, we derive a basic model for the forwarding speed and blocking probability of an OpenFlow switch combined with an OpenFlow controller and validate it using a simulation. This model can be used to estimate the packet sojourn time and the probability of lost packets in such a system and can give hints to developers and researchers on questions how an OpenFlow architecture will perform given certain parameters.
---
paper_title: Logically centralized?: state distribution trade-offs in software defined networks

paper_content:

Software Defined Networks (SDN) give network designers freedom to refactor the network control plane. One core benefit of SDN is that it enables the network control logic to be designed and operated on a global network view, as though it were a centralized application, rather than a distributed system - logically centralized. Regardless of this abstraction, control plane state and logic must inevitably be physically distributed to achieve responsiveness, reliability, and scalability goals. Consequently, we ask: "How does distributed SDN state impact the performance of a logically centralized control application?" Motivated by this question, we characterize the state exchange points in a distributed SDN control plane and identify two key state distribution trade-offs. We simulate these exchange points in the context of an existing SDN load balancer application. We evaluate the impact of inconsistent global network view on load balancer performance and compare different state management approaches. Our results suggest that SDN control state inconsistency significantly degrades performance of logically centralized control applications agnostic to the underlying state distribution.
---
paper_title: The controller placement problem

paper_content:

Network architectures such as Software-Defined Networks (SDNs) move the control logic off packet processing devices and onto external controllers. These network architectures with decoupled control planes open many unanswered questions regarding reliability, scalability, and performance when compared to more traditional purely distributed systems. This paper opens the investigation by focusing on two specific questions: given a topology, how many controllers are needed, and where should they go? To answer these questions, we examine fundamental limits to control plane propagation latency on an upcoming Internet2 production deployment, then expand our scope to over 100 publicly available WAN topologies. As expected, the answers depend on the topology. More surprisingly, one controller location is often sufficient to meet existing reaction-time requirements (though certainly not fault tolerance requirements).
---
paper_title: Experimental validation and performance evaluation of OpenFlow-based wavelength path control in transparent optical networks.

paper_content:

OpenFlow, as an open-source protocol for network virtualization, is also widely regarded as a promising control plane technique for heterogeneous networks. But the utilization of the OpenFlow protocol to control a wavelength switched optical network has not been investigated. In this paper, for the first time, we experimentally present a proof-of-concept demonstration of OpenFlow-based wavelength path control for lightpath provisioning in transparent optical networks. We propose two different approaches (sequential and delayed approaches) for lightpath setup and two different approaches (active and passive approaches) for lightpath release by using the OpenFlow protocol. The overall feasibility of these approaches is experimentally validated and the network performances are quantitatively evaluated. More importantly, all the proposed methodologies are demonstrated and evaluated on a real transparent optical network testbed with both OpenFlow-based control plane and data plane, which allows their feasibility and effectiveness to be verified, and valuable insights of the proposed solutions to be obtained for deploying into real OpenFlow controlled optical networks.
---
paper_title: OpenFlow Switching: Data Plane Performance

paper_content:

OpenFlow is an open standard that can be implemented in Ethernet switches, routers and wireless access points (AP). In the OpenFlow framework, packet forwarding (data plane) and routing decisions (control plane) run on different devices. OpenFlow switches are in charge of packet forwarding, whereas a controller set up switch forwarding table on a per-flow basis, to enable flow isolation and resource slicing. We focus on the data path and analyze the OpenFlow implementation in Linux based PCs. We compare OpenFlow switching, layer-2 Ethernet switching and layer-3 IP routing performance. Forwarding throughput and packet latency in underloaded and overloaded conditions are analyzed, with different traffic patterns. System scalability is analyzed using different forwarding table sizes, and fairness in resource distribution is measured.
---
paper_title: Hey, you darned counters!: get off my ASIC!

paper_content:

Software-Defined Networking (SDN) gains much of its value through the use of central controllers with global views of dynamic network state. To support a global view, SDN protocols, such as OpenFlow, expose several counters for each flow-table rule. These counters must be maintained by the data plane, which is typically implemented in hardware as an ASIC. ASIC-based counters are inflexible, and cannot easily be modified to compute novel metrics. These counters do not need to be on the ASIC. If the ASIC data plane has a fast connection to a general-purpose CPU with cost-effective memory, we can replace traditional counters with a stream of rule-match records, transmit this stream to the CPU, and then process the stream in the CPU. These software-defined counters allow far more flexible processing of counter-related information, and can reduce the ASIC area and complexity needed to support counters.
---
paper_title: HotSwap: correct and efficient controller upgrades for software-defined networks

paper_content:

Like any complex software, SDN programs must be updated periodically, whether to migrate to a new controller platform, repair bugs, or address performance issues. Nowadays, SDN operators typically perform such upgrades by stopping the old controller and starting the new one---an approach that wipes out all installed flow table entries and causes substantial disruption including losing packets, increasing latency, and even compromising correctness. This paper presents HotSwap, a system for upgrading SDN controllers in a disruption-free and correct manner. HotSwap is a hypervisor (sitting between the switches and the controller) that maintains a history of network events. To upgrade from an old controller to a new one, HotSwap bootstraps the new controller (by replaying the history) and monitors its output (to determine which parts of the network state may be reused with the new controller). To ensure good performance, HotSwap filters the history using queries specified by programmers. We describe our design and preliminary implementation of HotSwap, and present experimental results demonstrating its effectiveness for managing upgrades to third-party controller programs.
---
paper_title: Kandoo: a framework for efficient and scalable offloading of control applications

paper_content:

Limiting the overhead of frequent events on the control plane is essential for realizing a scalable Software-Defined Network. One way of limiting this overhead is to process frequent events in the data plane. This requires modifying switches and comes at the cost of visibility in the control plane. Taking an alternative route, we propose Kandoo, a framework for preserving scalability without changing switches. Kandoo has two layers of controllers: (i) the bottom layer is a group of controllers with no interconnection, and no knowledge of the network-wide state, and (ii) the top layer is a logically centralized controller that maintains the network-wide state. Controllers at the bottom layer run only local control applications (i.e., applications that can function using the state of a single switch) near datapaths. These controllers handle most of the frequent events and effectively shield the top layer. Kandoo's design enables network operators to replicate local controllers on demand and relieve the load on the top layer, which is the only potential bottleneck in terms of scalability. Our evaluations show that a network controlled by Kandoo has an order of magnitude lower control channel consumption compared to normal OpenFlow networks.
---
paper_title: The controller placement problem

paper_content:

Network architectures such as Software-Defined Networks (SDNs) move the control logic off packet processing devices and onto external controllers. These network architectures with decoupled control planes open many unanswered questions regarding reliability, scalability, and performance when compared to more traditional purely distributed systems. This paper opens the investigation by focusing on two specific questions: given a topology, how many controllers are needed, and where should they go? To answer these questions, we examine fundamental limits to control plane propagation latency on an upcoming Internet2 production deployment, then expand our scope to over 100 publicly available WAN topologies. As expected, the answers depend on the topology. More surprisingly, one controller location is often sufficient to meet existing reaction-time requirements (though certainly not fault tolerance requirements).
---
paper_title: Software defined networking: Meeting carrier grade requirements

paper_content:

Software Defined Networking is a networking paradigm which allows network operators to manage networking elements using software running on an external server. This is accomplished by a split in the architecture between the forwarding element and the control element. Two technologies which allow this split for packet networks are For CES and Openflow. We present energy efficiency and resilience aspects of carrier grade networks which can be met by Openflow. We implement flow restoration and run extensive experiments in an emulated carrier grade network. We show that Openflow can restore traffic quite fast, but its dependency on a centralized controller means that it will be hard to achieve 50 ms restoration in large networks serving many flows. In order to achieve 50 ms recovery, protection will be required in carrier grade networks.
---
paper_title: On the Flexibility of MPLS Applications over an OpenFlow-Enabled Network

paper_content:

In today's networks, a node usually has a static role that cannot be easily changed without an expensive upgrade. In MPLS architecture, despite the flexible forwarding data plane not tied to a single forwarding technology, each MPLS node has to be dedicated for a specific role depending on its position in the edge or the core of the MPLS network domain. This paper proposes an approach to address the flexibility of an MPLS node to play multiple roles for different MPLS domains built on top of an underlying OpenFlow-enabled physical network. The pipelined approach through tables introduced in the version 1.1 and later of the OpenFlow specification allows the change of the packet processing behavior by just updating the memory structures -- such as the TCAM and hash tables. It exploits the power of the OpenFlow rules-based paradigm to demonstrate the high level programmability to achieve the deossification of an MPLS infrastructure. In order to validate our proposal, we have implemented our approach over a 100Gbps switch box built on network processors and tested it with three applications to evaluate its flexibility. The results show that the local software to hardware update of a Label Switched Path (LSP) can be made in 2.2ms, in average, and the deployment of a Label Switched Router (LSR) application with 400 labels takes only 392.5ms.
---
paper_title: Source address validation solution with OpenFlow/NOX architecture

paper_content:

Current Internet is lack of validation on source IP address, resulting in many security threats. The future Internet can face the similar routing locator spoofing problem without careful design. The current in-progress source address validation standard, i.e., SAVI, is not of enough protection due to the solution space constraint. In this article, a mechanism named VAVE is proposed to improve the SAVI solutions. VAVE employs OpenFlow protocol, which provides the de facto standard network innovation interface, to solve source address validation problem with a global view. Significant improvements can be found from our evaluation results.
---
paper_title: Unifying Packet and Circuit Switched Networks

paper_content:

There have been many attempts to unify the control and management of circuit and packet switched networks, but none have taken hold. In this paper we propose a simple way to unify both types of network using OpenFlow. The basic idea is that a simple flow abstraction fits well with both types of network, provides a common paradigm for control, and makes it easy to insert new functionality into the network. OpenFlow provides a common API to the underlying hardware, and allows all of the routing, control and management to be defined in software outside the datapath.
---
paper_title: OMNI: OpenFlow MaNagement Infrastructure

paper_content:

Managing computer networks is challenging because of the numerous monitoring variables and the difficulty to autonomously configure network parameters. This paper presents the OpenFlow MaNagement Infrastructure (OMNI), which helps the administrator to control and manage OpenFlow networks by providing remote management based on a web interface. OMNI provides flow monitoring and dynamic flow configuration through a service-oriented architecture. OMNI also offers an Application Programming Interface (API) for collecting data and configuring the OpenFlow network. We propose a multi-agent system based on OMNI API that reduces packet loss rates. We evaluate both the OMNI management applications and the multi-agent system performance using a testbed. Our results show that the multi-agent system detects and reacts to a packet-loss condition in less than three monitoring intervals.
---
paper_title: QuagFlow: partnering Quagga with OpenFlow

paper_content:

Computing history has shown that open, multi-layer hardware and software stacks encourage innovation and bring costs down. Only recently this trend is meeting the networking world with the availability of entire open source networking stacks being closer than ever. Towards this goal, we are working on QuagFlow, a transparent interplay between the popular Quagga open source routing suite and the low level vendor-independent OpenFlow interface. QuagFlow is a distributed system implemented as a NOX controller application and a series of slave daemons running along the virtual machines hosting the Quagga routing instances.
---
paper_title: Ethane: taking control of the enterprise

paper_content:

This paper presents Ethane, a new network architecture for the enterprise. Ethane allows managers to define a single network-wide fine-grain policy, and then enforces it directly. Ethane couples extremely simple flow-based Ethernet switches with a centralized controller that manages the admittance and routing of flows. While radical, this design is backwards-compatible with existing hosts and switches. We have implemented Ethane in both hardware and software, supporting both wired and wireless hosts. Our operational Ethane network has supported over 300 hosts for the past four months in a large university network, and this deployment experience has significantly affected Ethane's design.
---
paper_title: OpenFlow MPLS and the open source label switched router

paper_content:

Multiprotocol Label Switching (MPLS) [3] is a protocol widely used in commercial operator networks to forward packets by matching link-specific labels in the packet header to outgoing links rather than through standard IP longest prefix matching. However, in existing networks, MPLS is implemented by full IP routers, since the MPLS control plane protocols such as LDP [8] utilize IP routing to set up the label switched paths, even though the MPLS data plane does not require IP routing. OpenFlow 1.0 is an interface for controlling a routing or switching box by inserting flow specifications into the box's flow table [1]. While OpenFlow 1.0 does not support MPLS1, MPLS label-based forwarding seems conceptually a good match with OpenFlow's flow-based routing paradigm. In this paper we describe the design and implementation of an experimental extension of OpenFlow 1.0 to support MPLS. The extension allows an OpenFlow switch without IP routing capability to forward MPLS on the data plane. We also describe the implementation of a prototype open source MPLS label switched router, based on the NetFPGA hardware platform [4], utilizing OpenFlow MPLS. The prototype is capable of forwarding data plane packets at line speed without IP forwarding, though IP forwarding is still used on the control plane. We provide some performance measurements comparing the prototype to software routers. The measurements indicate that the prototype is an appropriate tool for achieving line speed forwarding in testbeds and other experimental networks where flexibility is a key attribute, as a substitute for software routers.
---
paper_title: The controller placement problem

paper_content:

Network architectures such as Software-Defined Networks (SDNs) move the control logic off packet processing devices and onto external controllers. These network architectures with decoupled control planes open many unanswered questions regarding reliability, scalability, and performance when compared to more traditional purely distributed systems. This paper opens the investigation by focusing on two specific questions: given a topology, how many controllers are needed, and where should they go? To answer these questions, we examine fundamental limits to control plane propagation latency on an upcoming Internet2 production deployment, then expand our scope to over 100 publicly available WAN topologies. As expected, the answers depend on the topology. More surprisingly, one controller location is often sufficient to meet existing reaction-time requirements (though certainly not fault tolerance requirements).
---
paper_title: Openflow-based server load balancing gone wild

paper_content:

Today's data centers host online services on multiple servers, with a front-end load balancer directing each client request to a particular replica. Dedicated load balancers are expensive and quickly become a single point of failure and congestion. The OpenFlow standard enables an alternative approach where the commodity network switches divide traffic over the server replicas, based on packet-handling rules installed by a separate controller. However, the simple approach of installing a separate rule for each client connection (or "microflow") leads to a huge number of rules in the switches and a heavy load on the controller. We argue that the controller should exploit switch support for wildcard rules for a more scalable solution that directs large aggregates of client traffic to server replicas. We present algorithms that compute concise wildcard rules that achieve a target distribution of the traffic, and automatically adjust to changes in load-balancing policies without disrupting existing connections. We implement these algorithms on top of the NOX OpenFlow controller, evaluate their effectiveness, and propose several avenues for further research.
---
paper_title: Packet and circuit network convergence with OpenFlow

paper_content:

IP and Transport networks are controlled and operated independently today, leading to significant Capex and Opex inefficiencies for the providers. We discuss a unified approach with OpenFlow, and present a recent demonstration of a unified control plane for OpenFlow enabled IP/Ethernet and TDM switched networks.
---
paper_title: Application-aware aggregation and traffic engineering in a converged packet-circuit network

paper_content:

We demonstrate a converged OpenFlow enabled packet-circuit network, where circuit flow properties (guarantee d bandwidth, low latency, low jitter, bandwidth-on-demand, fast recovery) provide differential treatment to dynamically aggregated packet flows for voice, video and web traffic.
---
paper_title: MPLS with a simple OPEN control plane

paper_content:

We propose a new approach to MPLS that uses the standard MPLS data plane and an OpenFlow based simpler and extensible control plane. We demonstrate this approach using a prototype system for MPLS Traffic Engineering.
---
paper_title: Towards software-friendly networks

paper_content:

There has usually been a clean separation between networks and the applications that use them. Applications send packets over a simple socket API; the network delivers them. However, there are many occasions when applications can benefit from more direct interaction with the network: to observe more of the current network state and to obtain more control over the network behavior. This paper explores some of the potential benefits of closer interaction between applications and the network. Exploiting the emergence of so-called "software-defined networks" (SDN) built above network-wide control planes, we explore how to build a more "software-friendly network". We present results from a preliminary exploration that aims to provide network services to applications via an explicit communication channel.
---
paper_title: A network in a laptop: rapid prototyping for software-defined networks

paper_content:

Mininet is a system for rapidly prototyping large networks on the constrained resources of a single laptop. The lightweight approach of using OS-level virtualization features, including processes and network namespaces, allows it to scale to hundreds of nodes. Experiences with our initial implementation suggest that the ability to run, poke, and debug in real time represents a qualitative change in workflow. We share supporting case studies culled from over 100 users, at 18 institutions, who have developed Software-Defined Networks (SDN). Ultimately, we think the greatest value of Mininet will be supporting collaborative network research, by enabling self-contained SDN prototypes which anyone with a PC can download, run, evaluate, explore, tweak, and build upon.
---
paper_title: Enabling the future optical Internet with OpenFlow: A paradigm shift in providing intelligent optical network services

paper_content:

This paper proposes an optical networking paradigm suitable for future Internet services enabled by OpenFlow. The OpenFlow technology supports the programmability of network functions and protocols by separating the data plane and the control plane, which are currently vertically integrated in routers and switches. OpenFlow facilitates fundamental changes in the behaviour of networks and their associated protocols. This paper introduces an OpenFlow optical network architecture enabled by optical flow, optical flow switching elements and programmable OpenFlow controllers. The proposed solution allows intelligent, user controlled and programmable optical network service provisioning with the capability to operate any user defined network protocol and scenario.
---
paper_title: MPLS-TE and MPLS VPNS with openflow

paper_content:

We demonstrate MPLS Traffic Engineering (MPLS-TE) and MPLS-based Virtual Private Networks (MPLS VPNs) using OpenFlow [1] and NOX [6]. The demonstration is the outcome of an engineering experiment to answer the following questions: How hard is it to implement a complex control plane on top of a network controller such as NOX? Does the global vantage point in NOX make the implementation easier than the traditional method of implementing it on every switch, embedded in the data plane? We implemented every major feature of MPLS-TE and MPLS-VPN in just 2,000 lines of code, compared to much larger lines of code in the more traditional approach, such as Quagga-MPLS. Because NOX maintains a consistent, up-to-date topology map, the MPLS control plane features are quite simple to implement. And its simplicity makes it easy to extend: We have easily added several new features; something a network operator could do to customize their network to meet their customers' needs. ::: The demo consists of two parts: MPLS-TE services and then MPLS VPN driven by a GUI.
---

Title: Network Innovation using OpenFlow: A Survey

Section 1: INTRODUCTION
Description 1: Introduce the concept of Software Defined Networking (SDN) and OpenFlow, articulating the motivations and outlining the objectives of the paper.

Section 2: BACKGROUND OF PROGRAMMABLE NETWORKS
Description 2: Present an overview of early approaches to programmable networks and the transition to SDN, highlighting softnet, Active Networks, and the ForCES standard.

Section 3: OPENFLOW SPECIFICATION
Description 3: Detail the technical specifications of different versions of OpenFlow, discussing the architecture, components, operations, and how applications can be implemented.

Section 4: CAPABILITIES OF OPENFLOW
Description 4: Discuss the inherent capabilities of OpenFlow networks, including centralized control, software-based traffic analysis, dynamic rule updating, and flow abstraction, with practical examples.

Section 5: OPENFLOW-BASED APPLICATIONS
Description 5: Survey various applications of OpenFlow in networking, focusing on ease of configuration, network management, security, availability, network virtualization, and wide area and wireless network applications.

Section 6: OPENFLOW DEPLOYMENTS
Description 6: Highlight different real-world deployments of OpenFlow in campus networks, research testbeds, and large-scale industry deployments, with specific examples such as the GENI infrastructure.

Section 7: PERFORMANCE OF OPENFLOW-BASED NETWORKS
Description 7: Review studies that have evaluated the performance of OpenFlow-based networks, including measurements, modeling, and suggestions for improving performance.

Section 8: CHALLENGES OF OPENFLOW-BASED NETWORKS
Description 8: Identify and discuss the various challenges faced by OpenFlow-based networks, such as security, availability, scalability, reliability, expenditure, and compatibility.

Section 9: CONCLUSIONS AND FUTURE DIRECTIONS
Description 9: Summarize the findings of the paper and propose future research directions in the study and application of OpenFlow-based networks.

Section 10: ACKNOWLEDGMENT
Description 10: Acknowledge the contributions of individuals and organizations that supported the research or provided feedback on the manuscript.