Technical Sessions

In this paper we present a new Openflow based architecture to manage flows across a multi entrance SDN network in a consistent way, thus improving in several aspects on previous works [4, 5]. Our contributions are in three levels. At the first level we use OpenFlow features in a sophisticated way to implement a range classification scheme which to the best of our knowledge is more space efficient (only 3 entries per range) than previous known classifiers. In the second contribution we show how to update ranges across multiple switches in an atomic manner - allows to update the set of ranges and their associated actions while packets are classified and the network is changing. Finally, using the two schemes above, we present an architecture suitable for several applications such as load-balancing, and NFV, to manage multi-entrance consistency - keeping Per Flow consistency even when the flow changes the entrance point to our network.

Standardized data-path provision as achieved by OpenFlow enables the integration of network elements from different vendors in the same forwarding plane, with these elements being managed by the same logically centralized control plane. However, there is no clear abstraction that enables the integration of control planes from different vendors into a single virtually centralized controller. Yet, today's software-dened network (SDN) control planes are highly homogeneous and require networks (or slices thereof) to be controlled by the same controller platform. Hence to deploy a new service in a network, an operator needs to acquire and integrate new implementation modules into the existing controller platform. Though some earlier work has considered increasing the flexibility of controllers by allowing dynamic addition and removal of services, all integrated services need to obey specific constraints of the integrating platform

The usage of accurate time to schedule updates in software defined networks was recently proposed in [1]; time can be a powerful tool for applying network updates in a relatively simple manner and with a very brief period of inconsistency during the update. In the current paper we introduce the flow-swapping scenario, which demonstrates the necessity of time-based updates. We show that while traditional update approaches result in temporary packet loss, the time-based approach allows a smooth reconfiguration procedure. We introduce the lossless flow allocation problem, and formally show that given the online nature of resource allocation in SDN, scenarios that require simultaneous changes at multiple switches are bound to occur, with clock-based near-simultaneous scheduling offering an advantageous solution.

Adoption of Software Defined Networking (SDN) remains largely confined to data center networks, where network architects frequently have the luxury of designing and deploying within a tightly controlled greenfield environment. In comparison, adoption of SDN technologies within existing ISP and enterprise networks depends on the network operator’s ability to evaluate SDN’s impact and define a transition plan with confidence. Unfortunately, existing tools for emulating SDN networks do not support the evaluation of interactions with components found in today’s networks, such as intradomain routing policies and interdomain interactions with other autonomous systems. Within this work, we explain how our testbed provides network operators with comprehensive, 1:1 emulation of an existing network, which can then be used to experiment with SDN and evaluate its impact. We believe that our testbed will provide operators with a better understanding of how SDN fits into their existing networks, thus making SDN technologies more accessible to the broader community.

Modern networks operate at a speed and scale that make it impossible for human operators to manually respond to transient problems, e.g., congestion induced by workload dynamics. Even reacting to issues in seconds can cause significant disruption, so network operators overprovision their networks to minimize the likelihood of problems.

Software-defined networking (SDN) introduces the possibility of building autonomous, self-tuning networks that constantly monitor network conditions and react rapidly to problems. Previous work has demonstrated that new routes can be installed by an SDN controller in tens of milliseconds, but state-of-the-art network measurement systems take hundreds of milliseconds or more to collect a view of current network conditions. To support future autonomous SDNs, a much lower latency network monitoring mechanism is necessary, especially as we move from 1 Gb to 10 Gb and 40 Gb links, which require 10x and 40x faster measurement to detect flows of the same size. We believe that networks need to, and can, adapt to network dynamics at timescales closer to milliseconds or less.

Software defined network (SDN) eases the task of programming and managing computer networks. The conceptually centralized nature of the control plane provides a holistic view of the network, thereby making it feasible to verify SDN’s functionalities. Verification of SDN is gaining attention in the last few years. There are two main challenges of SDN: (1) SDNs are often programmed in general-purpose programming languages (e.g. Java, Python), which makes it tedious and error-prone to apply formal methods over controller applications; (2) the sheer scale of modern networks makes state explosion problem an insurmountable challenge for model checking. Model checking techniques combined with limiting the expressiveness of the programming language have demonstrated as an effective approach to verifying basic properties. However, due to the highly dynamic nature of SDN, verification of more complex security properties is still challenging.

To address the above challenges, we propose a unified framework for programming and verification of SDNs. Our framework relies on the use of a declarative language, Network Datalog (NDLog), which provides compact encoding of SDN functionalities and serves as a basis for formal analysis. As a preliminary step, we demonstrate that NDLog can encode basic openflow applications succinctly, and preserve well-formed logical structure. Based on the semantics of NDLog, we develop a sound program logic for verifying invariant properties of NDLog program. The approach of static analysis avoids the state explosion problem. Also, properties of the system can be verified in a compositional manner by dividing them into smaller invariants of different components. Compared to existing proposals such as Frenetic, NDLog has a tighter connection to first-order logic and therefore makes the verification tasks easier.

To cope with the exponential traffic growth, increasingly diverse trafficc mix including voice, video, machine-to-machine (M2M), and the spectrum shortage, wireless networks have to get densely deployed and dynamically adapt to meet the distinct requirements of diverse traffic classes. However, current network architectures are ill-equipped to support a dense and dynamic wireless infrastructure. First, since it will be impossible to obtain regularly placed cell sites for an infrastructure with higher density, basestations will be deployed wherever possible in a chaotic fashion. However, a chaotic and dense wireless deployment will be very complex to manage, since it will experience highly variable loads and unpredictable inter-cell interference among other things. Further since spectrum is limited, very likely all the basestations will be operating on the same frequency (referred to as frequency reuse factor of one). This leads to a tremendous amount of inter-cell interference, and that becomes the limiting factor for network capacity. Second, a dense infrastructure is very expensive to deploy and operate. Current deployments are unaffordable except to the largest operators, so a deployment with significantly higher density will likely be enormously expensive even for the largest operators, preventing smaller operators from expanding and offering consumers the choices they need.

In software-defined networks (SDN), the separation of the control and data-plane moves the concurrency control from the data-plane to a separate, now logically centralized controller program. As a result, despite its intention to simplify programming, the separation forces the programmer to deal with a spectrum of concurrent events (e.g. execution of controller programs, in-flight packets), a task that is notoriously challenging and error-prone. It is not even clear what concurrency problems the programmer shall account for. Although early stage works propose specific correctness conditions and point solutions, a comprehensive study is still lacking.

Most existing work focuses on the concurrency problem we call atomicity, which concerns one single network-wide update transaction. We use network-wide transaction (or transaction) to refer to a logical network operation that consists of potentially multiple switch-level updates. An atomicity failure scenario is shown in the figure (the red transaction spanning over switches 1; 2; 4) when in-flight packets during the transaction are processed by a mixture of switches with rules before or after the transaction. In addition to atomicity, we identify concurrency problems arising from multiple transactions, which we call the consistency and isolation. To the best of our knowledge, they are not addressed in existing works. Section 3 will connect atomicity, consistency, and isolation to the well-studied ACID transactional semantics in databases literature.

Software-Defined Networking (SDN) promises to significantly improve network manageability by enabling direct, and centralized control over the network forwarding state via a well-defined Application Programming Interface (API). Fulfilling this promise though is a challenge for network operators as it often requires heavy modifications to their current network architecture, including: i) equipment upgrades, as the vast majority of the installed base of network equipments (e.g., routers) do not support SDN protocols; ii) new management, monitoring and provisioning systems; but also iii) the need for operators training as managing and debugging a SDN network requires essentially completely different skill sets.

In this short paper, we present a lightweight SDN solution that does not require any new network equipment, nor SDNspecific protocols. While it is less expressive than OpenFlow-based SDN, our solution is powerful enough to fulfill complex traffic engineering requirements (e.g., traffic steering through middleboxes, load-balancing) that are hardly achieved in traditional, configuration-based, networks. Moreover, by minimizing SDN inertial factors and simplifying the management interface exposed to network operators, our lightweight SDN model can provide significant incentives to bootstrap the transition towards SDN.

SDN needs to program heterogeneous forwarding elements (FE) with different forwarding architectures. Ideally, OpenFlow should provide a uniform interface to allow platform-independent programming and platform-specific compiling. In this paper we discuss an SDN programming framework which is suitable for flexible and protocol-oblivious forwarding plane. Specifically, we describe three different forwarding plane programming approaches and their tradeoffs. We show how an OpenFlow instruction set can support different programming styles which map to different forwarding chip architectures. We also show how applications can be compiled into NP-based FEs and compare it with the interpreter-mode implementation.

Network state is always in flux. Due to traffic engineering, topology changes, policy updates, VM migrations, etc., today’s networks undergo a variety of large updates that concurrently affect many switches. Transitioning between network states can be a source of instability, leading to outages, disruptions and security vulnerabilities. Consistent network updates introduces a mechanism that guarantees to preserve well defined behaviors when transitioning between states. However, a major problem for this technique is the update performance, that is, the time it takes to install a network state update onto the data-plane—the current generation of OpenFlow switches can install flows with rate as low as 40 rules/second. Even moderate-sized updates can take several seconds, during which operators are in the dark about how badly links could be congested. Therefore it is desirable to complete updates quickly. However, we note that the lowest bound of the total time to complete the update is determined by the switch that is last to complete.

Applying the concept of SDN to WiFi networks is challenging, since wireless networks feature many peculiarities and knobs that often do not exist in wired networks: obviously, WiFi communicates over a shared medium, with all its implications, e.g., higher packet loss and hidden or exposed terminals. Moreover, wireless links can be operated in a number of different regimes, e.g., transmission rate and power settings can be adjusted, RTS/CTS mechanisms can be used.

Indeed, due to the non-stationary characteristic of the wireless channel, permanently adjusting settings such as transmission rate and power is crucial for the performance of WiFi networks and brings significant benefits in the service quality, e.g., through reducing the packet loss probability. Today’s rate and power control is mainly done on the WiFi device itself. But it is rarely optimized to the application-layer demands and their diverse traffic requirements, e.g., their individual sensitivity to packet loss or jitter. Therefore, if SDN for wireless can provide mechanisms to control the WiFi-specific transmission settings on a per-slice, per-client, and per-flow level, traffic and application-aware optimizations are feasible.

Software Defined Networking (SDN) breaks the barrier of Internet innovation and has attracted tremendous attentions from both industrial and academic communities. Although OpenFlow is the de factor SDN protocol nowadays, which defines the interface between the data plane switches and the control plane controllers, there are emerging SDN proposals. Even for OpenFlow itself, it keeps evolving. As a result, a flexible SDN data plane switch, which is capable to upgrade the processing logic, is highly desired for the research and innovation purpose.

This paper presents the vision of the Control Exchange Point (CXP) architectural model. The model is motivated by the inflexibility and ossification of today’s inter-domain routing system, which renders critical QoS-constrained end-to-end (e2e) network services difficult or simply impossible to provide. CXPs operate on slices of ISP networks and are built on basic Software Defined Networking (SDN) principles, such as the clean decoupling of the routing control plane from the data plane and the consequent logical centralization of control. The main goal of the architectural model is to provide e2e services with QoS constraints across domains. This is achieved through defining a new type of business relationship between ISPs, which advertise partial paths (so-called pathlets) with specific properties, and the orchestrating role of the CXPs, which dynamically stitch them together and provision e2e QoS. Revenue from value-added services flows from the clients of the CXP to the ISPs participating in the service. The novelty of the approach is the combination of SDN programmability and dynamic path stitching techniques for inter-domain routing, which extends the value proposition of SDN over multiple domains. We first describe the challenges related to e2e service provision with the current inter-domain routing and peering model, and then continue with the benefits of our approach. Subsequently, we describe the CXP model in detail and report on an initial feasibility analysis.