In Software-Defined Networking (SDN), the typical switch-controller cycle, from generating a network event notification at the controller until the flow rules are installed at the switches, is not an instantaneous activity. Our measurement results show that this has serious implications on the performance of flow setup procedure, specifically for larger networks: we observe that, even with software switches, the flow setup latency for networks of around 500 switches is in order of 50 milliseconds, with 99th percentile exhibiting 10 times higher latencies. To reduce both the latency and the variance of the flow setup, we propose path aggregation strategies, which turn the network into a set of pre-configured pipes that connect any pair of nodes. Our approach radically simplifies the flow setup procedure by minimizing the set of switches to be updated for new userinitiated flows to a constant number. We implement our solution in our testbed and study its performance through measurements. The results show that, in similar settings, it reduces the median and 99-percentile latencies to 5.9ms and 7ms, respectively, significantly improving the performance, especially in the tail.

Virtual network embedding is considered an important problem to solve in order to make infrastructure virtualization economically reasonable. The most efficient algorithms proposed so far define link and node mappings as optimal solutions of Integer Programming (IP) problems. They exhibit reasonably good performance only for small problem instance sizes, including few tens of nodes and links per physical substrate, few nodes and links per virtual request and a dozen of virtual requests to handle in parallel. However, we find these instances too small to be of any practical use. To address this scalability issue, we propose VNetMapper, an algorithm to solve the virtual network embedding problem based on an integer program formulation with appropriately selected objective function, variables and the set of constraints tuned to give an optimal performance. We show through simulations that VNetMapper can quickly, within seconds, solve large problem instances, involving physical substrates with hundreds of nodes and thousands of links and batches of hundreds of virtual network requests. By identifying exact properties that make VNetMapper so fast and scalable, we present guidelines for designing scalable integer programs.

Simulators are a commonly used tool in peer-to-peer systems research. However, they may not be able to capture all the details of a system operating in a live network deployment. Transitioning from simulation to the actual system implementation is a non-trivial and time-consuming task, a problem that we propose to solve in this paper. We present ProtoPeer, a peer-to-peer systems prototyping toolkit that allows for switching between the event-driven simulation and live network deployment without changing any of the application code. ProtoPeer exports a set of APIs for message passing, message queuing, timer operations as well as overlay routing and managing the overlay neighbors. Users can plug in their own custom implementations of most of the parts of ProtoPeer including custom network models for simulation and custom message passing over transports other than the default TCP/UDP.

Current solutions to evolve mobility management in Mobile Core Networks (MCN) based on SDN have showed the gain in flexibility and how to reduce control signaling. However, these works neglect the problems of describing the design choices of SDN Mobility Management Applications (MMA) and identifying where and what are the critical processing latency contributors for such design. Our paper addresses these problems. We study the internal mechanisms and interactions of MMA and controller, to determine the contributors to the overall processing latency. We implemented two MMA solutions (based on reactive and proactive designs) as modules of Floodlight, and we run experiments using Mininet and OpenFlow. The proactive MMA design can guarantee that the overall processing latency in the 95th percentile can be kept near the median value, given available CPU capacity at the SDN controller. One key lesson learned with our study is that only optimizing control signaling of MMA is not enough to provide better overall processing latency.

Telco operators started to apply the SDN technologies also in the design of Mobile Core Networks (MCNs). In this change towards SDNized Mobile Core Network, it is crucial to understand how conventional interfaces among different mobile network entities should evolve. The issues derived from this change have not been tackled by current research approaches. This paper presents the first initiative to close this research gap. We tackle the key problem of how to identify which mobile SDN applications (APPs) should be invoked once a PACKET_IN (the OpenFlow message that transport information from the data plane to the control plane) is received at the control level. We propose data structures, a model, and detailed examples of three important PACKET_IN context interpretation for MCNs. Initial experiments, based on Floodlight controller and Mininet emulation environment were carried out. The results indicate that it is feasible to use our proposed approach to dispatch PACKET_INs to the right SDN APP. The delay introduced due to invocation of such mechanism to interpret the context of the PACKET_IN and activate the appropriate mobile SDN APPs is only in the order of microseconds. Our proposal can be used to simplify current Mobile Core Network interface design by exploiting the SDN mechanisms. We believe, this work helps to pave the way towards fully SDNized Mobile Core Networks.