Performances of OpenFlow-Based Software- Defined Networks: An overview <s> INTRODUCTION <s> 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? <s> BIB001 </s> Performances of OpenFlow-Based Software- Defined Networks: An overview <s> INTRODUCTION <s> Network architectures in which the control plane is decoupled from the data plane have been growing in popularity. Among the main arguments for this approach is that it provides a more structured software environment for developing network-wide abstractions while potentially simplifying the data plane. As has been adopted elsewhere [11], we refer to this split architecture as Software-Defined Networking (SDN). While it has been argued that SDN is suitable for some deployment environments (such as homes [17, 13], data centers [1], and the enterprise [5]), delegating control to a remote system has raised a number of questions on control-plane scaling implications of such an approach. Two of the most often voiced concerns are: (a) how fast can the controller respond to data path requests?; and (b) how many data path requests can it handle per second? There are some references to the performance of SDN systems in the literature [16, 5, 3]. For example, an oft-cited study shows that a popular network controller (NOX) handles around 30k flow initiation events1 per second while maintaining a sub-10ms flow install time [14]. Unfortunately, recent measurements of some deployment environments suggests that these numbers are far from sufficient. For example, Kandula et al. [9] found that a 1500-server cluster has a median flow arrival rate of 100k flows per second. Also, Benson et al. [2] show that a network with 100 switches can have spikes of 10M flows arrivals per second in the worst case. In addition, the 10ms flow setup delay of an SDN controller would add a 10% delay to the majority of flows (short-lived) in such a network. This disconnect between relatively poor controller performance and high network demands has motivated a <s> BIB002 </s> Performances of OpenFlow-Based Software- Defined Networks: An overview <s> INTRODUCTION <s> 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, which can be situated very far from a networking point of view from the switches its manages, sets up switch forwarding tables on a per-flow basis. The connection between a switch and its Controller is thus of primary importance for the performances of the network. In this paper, we study the impact of the latency between an OpenFlow switch and its Controller. We show that UDP and TCP have different effects depending on the available bandwidth on the control link. Bandwidth arbitrates how many flows the Controller can process, as well as the loss rate if the system is under heavy load, while latency drives the overall behavior of the network, that is the time to reach its full capacity. Finally, we propose solutions to mitigate the phenomenons we outline. <s> BIB003 </s> Performances of OpenFlow-Based Software- Defined Networks: An overview <s> INTRODUCTION <s> This paper presents an independent comprehensive analysis of the efficiency indexes of popular open source SDN/OpenFlow controllers (NOX, POX, Beacon, Floodlight, MuL, Maestro, Ryu). The analysed indexes include performance, scalability, reliability, and security. For testing purposes we developed the new framework called hcprobe. The test bed and the methodology we used are discussed in detail so that everyone could reproduce our experiments. The result of the evaluation show that modern SDN/OpenFlow controllers are not ready to be used in production and have to be improved in order to increase all above mentioned characteristics. <s> BIB004 </s> Performances of OpenFlow-Based Software- Defined Networks: An overview <s> INTRODUCTION <s> The idea of programmable networks has recently re-gained considerable momentum due to the emergence of the Software-Defined Networking (SDN) paradigm. SDN, often referred to as a "radical new idea in networking", promises to dramatically simplify network management and enable innovation through network programmability. This paper surveys the state-of-the-art in programmable networks with an emphasis on SDN. We provide a historic perspective of programmable networks from early ideas to recent developments. Then we present the SDN architecture and the OpenFlow standard in particular, discuss current alternatives for implementation and testing of SDN-based protocols and services, examine current and future SDN applications, and explore promising research directions based on the SDN paradigm. <s> BIB005 </s> Performances of OpenFlow-Based Software- Defined Networks: An overview <s> INTRODUCTION <s> OpenFlow is currently the most commonly deployed Software Defined Networking (SDN) technology. SDN consists of decoupling the control and data planes of a network. A software-based controller is responsible for managing the forwarding information of one or more switches; the hardware only handles the forwarding of traffic according to the rules set by the controller. OpenFlow is an SDN technology proposed to standardize the way that a controller communicates with network devices in an SDN architecture. It was proposed to enable researchers to test new ideas in a production environment. OpenFlow provides a specification to migrate the control logic from a switch into the controller. It also defines a protocol for the communication between the controller and the switches. As discussed in this survey paper, OpenFlow-based architectures have specific capabilities that can be exploited by researchers to experiment with new ideas and test novel applications. These capabilities include software-based traffic analysis, centralized control, dynamic updating of forwarding rules and flow abstraction. OpenFlow-based applications have been proposed to ease the configuration of a network, to simplify network management and to add security features, to virtualize networks and data centers and to deploy mobile systems. These applications run on top of networking operating systems such as Nox, Beacon, Maestro, Floodlight, Trema or Node.Flow. Larger scale OpenFlow infrastructures have been deployed to allow the research community to run experiments and test their applications in more realistic scenarios. Also, studies have measured the performance of OpenFlow networks through modelling and experimentation. We describe the challenges facing the large scale deployment of OpenFlow-based networks and we discuss future research directions of this technology. <s> BIB006 </s> Performances of OpenFlow-Based Software- Defined Networks: An overview <s> INTRODUCTION <s> Emerging mega-trends (e.g., mobile, social, cloud, and big data) in information and communication technologies (ICT) are commanding new challenges to future Internet, for which ubiquitous accessibility, high bandwidth, and dynamic management are crucial. However, traditional approaches based on manual configuration of proprietary devices are cumbersome and error-prone, and they cannot fully utilize the capability of physical network infrastructure. Recently, software-defined networking (SDN) has been touted as one of the most promising solutions for future Internet. SDN is characterized by its two distinguished features, including decoupling the control plane from the data plane and providing programmability for network application development. As a result, SDN is positioned to provide more efficient configuration, better performance, and higher flexibility to accommodate innovative network designs. This paper surveys latest developments in this active research area of SDN. We first present a generally accepted definition for SDN with the aforementioned two characteristic features and potential benefits of SDN. We then dwell on its three-layer architecture, including an infrastructure layer, a control layer, and an application layer, and substantiate each layer with existing research efforts and its related research areas. We follow that with an overview of the de facto SDN implementation (i.e., OpenFlow). Finally, we conclude this survey paper with some suggested open research challenges. <s> BIB007
Software-Defined Networking (SDN) is a new concept of network architecture that has emerged in last years. Contrary to traditional architectures where the control plane and the data plane coexist in network devices such as routers and switches, this concept basically consists to move the control plane outside network devices and leaves only the data plane inside. The control plane is supported by a software application called: "Controller". Network devices become simple packet forwarding devices that can be programmed through rules that are set by the controller. In SDN, communication between the control plane (the controller or controllers) and the data plane (networking devices) is mainly established today by the OpenFlow protocol. After the proposal of the SDN concept and the implementation of OpenFlow by researchers from Stanford University towards 2008, SDN has aroused great interest and it becomes an important topic for research, development, and standardization in the networking area. This is due, on the one hand to the limitations of current network architectures to meet the requirements of new IT trends such as cloud computing, virtualization, Internet of things and the explosion of mobile devices and on the other hand, to the potential and the various benefits, which Software-Defined Networks may offer. In fact, the coupling between the control plane and the data plane in network elements prevents quick and easy deployment of new network functionalities and services because they must be implemented directly in infrastructure. However, this depends on the production cycles of manufacturers which may be very long. Thus, traditional networks are relatively static and lack flexibility to adapt to the dynamic nature of traffic, applications, cloud and virtual environments. The interest of SDN is the ability to program network devices in a unified and centralized way through software applications. This gives a large flexibility to administrators to dynamically control, manage, secure and optimize their network resources. Moreover, the ability to program the network by operators, enterprises and users will accelerate innovation in networks. The introduction of new network services will be done at software development speed without need to wait for new hardware products from manufacturers. The SDN approach certainly has several advantages, as explained above. However, some questions and issues have occurred with this approach. In fact, the first propositions and deployments of SDN networks use a single centralized controller. This poses the problem of having a single point of failure, a concern about the performance of the controller and its capacity to handle a large amount of flow requests and by consequence the ability to scale when the network size grows. The first Openflow controller has been NOX, it has a flow install time less than 10 ms and can handles up to 30000 flow requests per second BIB001 . Many other Openflow controllers were developed after with considerably better performance like Floodlight  , OpenDayLight  . In this article we provide an overview of the progress that has been made regarding the performance of the controller and techniques that have enabled this progress. On the other hand, to avoid the problem of a single point of failure and address the scalability issue, control planes with multiple controllers have been proposed. But this generates new questions and issues such as: the number of needed controllers, the placement of controllers and the communication between controllers. In this context, we can distinguish two main propositions of control plane designs: logically centralized and logically distributed control planes. Both propositions have their advantages and disadvantages. Later in this paper, we present these propositions and discuss their advantages and disadvantages. Since the emergence of Software Defined Networking concept, a lot of works have investigated this topic in the networking area. Several recent papers BIB005 , BIB007 ,  , and BIB006 provide interesting surveys about SDN and the performed works. These papers present the different contributions that have helped to promote programmable networks before SDN. They explain in details the concept, the motivations and the architecture of SDN. They give all information about the Openflow implementation and its different releases. They present and discuss the current deployments and challenges and also the future directions for SDN. Our goal in this paper is different, we aim to give to the reader especially interested in the performances of SDN networks, an overview of the main studies and enhancement propositions that have been made in the literature regarding the performances of SDN networks. In fact, on the one hand, the survey papers mentioned above cover all aspects of SDN networks and do not focus on the performance issues and the improvement solutions. The information on performance is embedded in a large amount of information and details about SDN. On the other hand, some articles are exclusively devoted to performances but they are specific to a controller or a performance aspect. For instance, the paper BIB002 is dedicated to performances of the NOX-MT controller, the paper BIB003 analyses the impact of the latency between an openflow switch and its controller, moreover, authors BIB004 compare the throughput of different controller, and shows the impact of multi-threading on their performances. The paper is organized as following: the first section describes briefly the concept of SDN and OpenFlow protocol. The second section is devoted to the performances of OpenFlow switches. The third section treats the performances of Openflow controllers. The fourth section surveys the emerging propositions based on multiple controllers. Section V describes the various techniques that have been used to evaluate the performances of OpenFlow networks. The last section is dedicated to a conclusion and some ideas for future works.