MASTER THESIS Performance Comparison Of the state of the art

MASTER  THESIS Performance Comparison Of the state of the art

Master's Programme in Computer Network Engineering, 60 credits

Performance Comparison Of the state of the art

Openflow Controllers

Ahmed Sonba, Hassan Abdalkreim

Computer Network Engineering, 15 credits

Halmstad 2014-09-01

Performance Comparison Of the state of the art

OpenFlow Controllers

Master Thesis in Computer Network Engineering

2014 December

Authors

:

Ahmed Sonba & Hassan Abdalkreim

Supervisor: Le-Nam Hoang

Examiner: Tony Larsson

__________________________________

School of Information Science, Computer and Electrical Engineering

Halmstad University

PO Box 823, SE-301 18 HALMSTAD

Sweden

ii

© Copyright Ahmed Sonba & Hassan Abdalkreim, 2014.

All rights reserved.

Master thesis report

ITE 1502

School of Information Science, Computer and Electrical

Engineering Halmstad University

iii

Acknowledgments

We would like to express our thanks and gratitude to our supervisor Le-Nam Hoang for his positive and supportive guidance. Also we would like to thank Professor Tony

Larsson the examiner for this thesis for his positive feedbacks during the process of this course.

Last but not least, we want to thank our families and friends for their support and encouragement.

Abstract

OpenFlow is a widely used protocol for software defined networks (SDNs) that presents a new paradigm in which the control plane is abstracted from the forwarding plane for the network devices. This approach differs from the conventional networking architecture, where both planes reside on the same networking device. In SDN approach centralized entities called “controllers” act like network operating systems run different applications that manage and control the network via well-defined APIs.

OpenFlow switch is the forwarding plane in SDN architecture that has tables of packethandling rules. Traffics passing the switch are compared against these rules and a match – action method is applied to the traffics. Depending on the rules installed by a controller application, an OpenFlow switch can act like a router, a switch, or a middle box without much caring about what kind of vendor to use in the network.

Data centers’ networking is one of the applications that showed successful integration with OpenFlow protocol by making the network more consistent to the rapidly expanding number of virtual machines. But with the growing traffic in the data centers, the need for high controllers’ performance increases. Therefore, in this thesis we presented a performance evaluation in both throughput and latency perspectives for the current well-known OpenFlow controllers: NOX, Beacon, Floodlight, Maestro,

OpenMul, and OpenIRIS. Controller benchmarking tool was implemented for incremental number of switches connected to the controller under test, and the results show that the OpenMul controller has the highest throughput, while OpenIRIS controller shows the lowest latency.

4

Contents

1 Introduction .................................................................................................................. 9

1.1

Motivation ..........................................................................................................................10

1.2

Previous Work .................................................................................................................10

1.3

Research questions ........................................................................................................10

1.4

Thesis structure ...............................................................................................................10

2 Software-Defined Networking ............................................................................. 11

2.1

Traditional network architectures ...........................................................................11

2.2

Traditional networks limitations..............................................................................12

2.3

The SDN architecture .....................................................................................................13

2.3.1

Benefits of SDN ...................................................................................................................... 13

2.3.2

SDN Applications .................................................................................................................. 15

2.4

Data centre networking and SDN ..............................................................................15

2.5

SDN for data center networks.....................................................................................17

2.6

Network virtualization and SDN ................................................................................18

2.7

Scalability in SDN ............................................................................................................20

2.8 Controller operational mode and scalability ............................................................21

3 OpenFlow ..................................................................................................................... 23

3.1

OpenFlow Architecture .................................................................................................23

3.2

OpenFlow enabled switch ............................................................................................24

3.2.1

Flow Tables ............................................................................................................................. 25

3.2.2

Matching flows ....................................................................................................................... 25

3.2.3

Actions taken on the flows ................................................................................................ 26

3.2.4

Counters ................................................................................................................................... 27

3.3

Flow types ..........................................................................................................................28

3.4

Packet forwarding mechanism ..................................................................................28

3.5

OpenFlow communication massages .......................................................................28

3.5.1

Controller-To-Switch Messages ...................................................................................... 29

3.5.2

Asynchronous Messages .................................................................................................... 30

3.5.3

Symmetric Messages ........................................................................................................... 30

3.6

Demonstration of the messages exchanged in OpenFlow network ..............30

3.6.1

Message establishment between a switch and a controller ................................ 31

3.6.2

Messages exchanged between two hosts .................................................................... 33

3.7

OpenFlow controller ......................................................................................................34

4 Methodology and Evaluation ................................................................................ 35

4.1

OpenFlow Controllers Evaluation .............................................................................35

4.2

Experiment Setup ............................................................................................................35

4.3

Benchmarking Methodology for OpenFlow Controller .....................................36

4.3.1

Flow setup throughput ....................................................................................................... 36

4.3.2

Flow setup latency................................................................................................................ 36

4.3.3

OpenFlow controller Benchmarking parameters ..............................................36

5

4.4

Cbench (Controller benchmark tool) .......................................................................36

4.4.1

Cbench Algorithm ................................................................................................................. 37

4.4.2

Cbench installation and running .................................................................................... 37

4.5

OpenFlow Controllers ...................................................................................................39

4.5.1

Beacon OpenFlow Controller ........................................................................................... 39

4.5.2

Floodlight Controller ........................................................................................................... 42

4.5.3

OpenMul Controller ............................................................................................................. 44

4.5.4

Open IRIS Controller............................................................................................................ 46

4.5.5

NOX Controller ....................................................................................................................... 48

4.5.6

Maestro Controller ............................................................................................................... 50

5 Conclusions and future work................................................................................ 53

5.1

Future work ......................................................................................................................54

Bibliography ...................................................................................................................... 55

6

List of Figures

Figure2.1: Traditional network architectures ......................................................................... 11

Figure 2.2: SDN architecture .................................................................................................. 14

Figure 2.3 Convectional data center networking [21]............................................................. 16

Figure 2.4: Fat tree topology ................................................................................................... 17

Figure 2.6: Network Virtualization and Server Virtualization [25] ...................................... 19

Figure 2.7: The organization scheme of distributed controller [27] ........................................ 20

Figure 3.1 : OpenFlow Network Architecture ........................................................................ 24

Figure 3.2: OpenFlow enabled switch OF v1.0 specification [34] .......................................... 25

Figure 3.3 Basic packet process mechanism for OpenFlow switch [36] .................................. 29

Figure 3.4 Network topology using Mininet ......................................................................... 31

Figure 3.5: Communication messages between OpenFlow switch and controller .................. 32

Figure 3.6: Wireshark capture for the connection establishment between the OF controller

and a switch ............................................................................................................................. 32

Figure 3.7: Ping process between h1 and h2 ........................................................................... 33

Figure 3.8: packets exchanged between h1 to h2 ..................................................................... 34

Figure 4.1: Experiment Setup ................................................................................................. 35

Figure 4.2: Cbench running in throughput mode ................................................................... 38

Figure 4.3: Cbench running in Latency mode ........................................................................ 38

Figure 4.4: Beacon Controller web interface ........................................................................... 40

Figure 4.5: Beacon Throughput .............................................................................................. 41

Figure 4.6: Beacon Latency ..................................................................................................... 41

Figure 4.7: Floodlight throughput ........................................................................................... 43

Figure 4.8: Floodlight Latency ................................................................................................ 43

Figure 4.9: OpenMuL throughput .......................................................................................... 45

Figure 4.10: OpenMuL Latency .............................................................................................. 45

Figure 4.11: OpenIRIS throughput......................................................................................... 47

Figure 4.12: OpenIRIS Latency .............................................................................................. 48

Figure 4.13: NOX Throughput ............................................................................................... 49

Figure 4.14: NOX Latency...................................................................................................... 50

Figure 4.15: Maestro Throughput ........................................................................................... 51

Figure 4.16: Maestro Latency ................................................................................................. 52

Figure 5.1: Controllers throughput comparison ..................................................................... 54

Figure 5.2: Controllers latency comparisons ........................................................................... 54

List of Tables

Table. 1: A flow table for OpenFlow v1.0 ................................................................................ 25

Table 2: List of virtual ports for the forwarding action ........................................................... 26

Table 3 : Required list of counters for use in statistics messages [34] .................................... 27

Table 4 : Cbench Running Options ......................................................................................... 38

7

8

Chapter 1

1 Introduction

Recently, Data centers have received significant attention as a very important infrastructure for its ability to store large amount of data and hosting large-scale service applications. Today large companies use data centers for their large scale computations and IT businesses.

Server virtualization and cloud computing are changing the way of using data centers.

Virtualization allows more efficient usage of IT resources with high levels of IT agility and control.

Cloud computing extends these benefits by allowing organizations to meet their IT requirements using flexible, on-demand, and rapidly scalable models that require neither ownership from their part nor provision of dedicated recourses.

Together, these technologies enable organizations to better meet organizational demands and provide greater agility for the data centers.

Despite of the rapid development of both tech Virtualization and Cloud computing, networking technologies still lack the consistency, because most current network technologies were not developed to consider Virtualization and Cloud computing.

Static topologies require manual intervention to deploy and migrate virtual machines

(VMs) that can make the networks to become a bottleneck in the future IT development.

A software-defined network (SDN) is a new networking paradigm that brings a lot of new capabilities and allows solving many hard problems of legacy networks. This approach is based on separating the network intelligence out of the packet switching device and putting it into a logically centralized controller. The controller is responsible for the forwarding decisions that are placed into the switches via standard protocols, like OpenFlow. The motivation of SDN is to perform a network operating system, where network tasks can be done without adding additional software for each of the switching elements, and allow for developing applications that control the switches by running it on top of a network operating system [1].

OpenFlow protocol [2] is introduced to unify the interface between the switching hardware and the remote controller in SDN paradigm. This protocol provides the controller a possibility to discover the OpenFlow-compliant switches, defines forwarding rules for the switching hardware, and collects statistics from the switching devices.

At the present there exists a number of controllers, where the most known controllers are surveyed on [3].

The OpenFlow standard was created at Stanford University and now it is maintained by the non-profit organization Open Networking Foundation [2] (ONF) that was founded in March 2011 by Deutsche Telekom, Facebook, Google, Microsoft, Verizon, and Yahoo. The goal of this organization is to promote and adopt new approaches in

SDN through open standards development.

9

1.1 Motivation

In data centers the need for high controller performance is crucial. Some of the controllers lack the performance for a large scale data centers, therefore it is very important to investigate the performance of the well-known open source controllers that are implemented now a days. Unlike closed source controllers that are represented as a distributed controller instances, open source controller represented as single controller instances and its performance can be an issue.

Two major parameters for OpenFlow controller benchmarking are: The average maximum number of flows setup per second that a controller is able to populate, and the time required for the controller to respond for requests from the OpenFlow switches. By such investigation, it is possible to know which controller has the highest throughput and lowest delay.

1.2 Previous Work

This thesis is based on the future work in [4], where an evaluation of NOX [5], Beacon

[6], and Maestro [7] controllers has been made. Other works [8], [9] have done performance evaluation as well for larger number of controllers, including Floodlight

[10], Ryu [11], OpenMul [12]. The results in these works have shown that Beacon controller has the highest throughput, and Mul controller has the lowest latency. A new controller architecture named "In Kernel" has been proposed in [13] to operate in the Kernel space instead of the user space for the Linux operating system and the results have shown a very high performance in terms of throughput and latency.

1.3 Research questions

The research questions of this master thesis are as follows:

What is SDN, OpenFlow architecture? And why is it needed instead of the traditional networking architecture in today’s modern datacenters?

How is the performance of the state-of-the-art OpenFlow controllers that are currently available?

1.4 Thesis structure

The structure of this thesis will be as follows: chapter 2 introduces background on SDN and its implementation in today’s networks. Chapter 3 describes the OpenFlow protocol architecture and how it works. Chapter 4 contains the methodology and the experiments on these controller platforms: NOX, Beacon, Maestro, Floodlight,

OpenMul, and OpenIRIS.

This thesis ends with a conclusion on which of the current available controllers represent the highest throughput and lowest delay, as well as possible future work.

10

Chapter 2

2 Software-Defined Networking

According to the official definition from the Open Networking Foundation "Software

Defined Networking (SDN) is an emerging network architecture where network control is decoupled from forwarding and is directly programmable. This migration of control, formerly tightly bound in individual network devices, into accessible computing devices enables the underlying infrastructure to be abstracted for applications and network services, which can treat the network as a logical or virtual entity." [15]

Another definition of SDN is the following: “The physical separation of the network control plane from the forwarding plane, and where a control plane controls several devices”. [16]

2.1 Traditional network architectures

Networks that we know today are isolated and separated physically to meet the needs of the industry, service providers, organizations and even end users, where we have both the control plane and the data forwarding plane on the same device as shown in

Figure2.1

Although such kind of network architecture has worked fine in the past, but with today virtualized world it will be challenging if not impossible for traditional network to meet the new virtual requirements. With today’s limited or flat budgets, enterprise

Information Technology departments are seeking to virtualize most of their servers.

Such process is challenging since the demand for both application and user mobility explodes.

Figure2.1: Traditional network architecture

11

2.2 Traditional networks limitations

While the existing traditional network architectures were not built in a way to meet today’s requirements for end-users, service providers and enterprises; some limitations of traditional network architecture are [15]:

Management Complexity:

Previous computer network technologies had always been built on a set of routing protocols that are engineered to connect hosts in a reliable manner over long distances with high speeds and different network designs. In order to meet the industry requirements such as high availability, security and extended connectivity, over the last decades, protocols have been designed in a lot of ways that lead to separation, where each protocol is to solve a specific kind of problems, without keeping in mind to benefit from abstractions. Such approach of design has led to one of the main problems that network administrators are facing nowadays, namely network management complexity. One example is that adding or removing a device on a network has become a burden for network administrators, where several parts of the network has to be reconfigured, such as: Access lists, VLANs quality of service policies, routing protocols and network topologies.

Beside the mentioned above, equipment vendor and software versions compatibility have to be considered before making any modification to the network. As a result, network administrators keep their network rather static, in order to avoid or minimize the service downtime that can be caused by any change. Such nature of static network design is limiting the dynamic nature of server virtualization, which in turn increases the number of hosts that needs connectivity.

Before the time virtualization service was introduced, a single server connects to selected clients. While nowadays thanks to the services that virtualization provides, it has become possible for the applications to be spread over several virtual machines that connect to each other. And in many cases VMs have to migrate to obtain balanced workloads; such functionality of virtualized platforms put a lot of challenges on the traditional networking that was not designed for such dynamic flow changes.

Difficulty to apply policies:

In order to maintain an enterprise network policy, network administrators would need to configure hundreds of routers switches and mechanisms. In virtualization, each time the IT adds a VM to the network, normally it takes up to hours if not days, where the network administrator needs to configure and adjust Access Lists (ACLs) across the whole network. With the kind of network complexity that we run today, it has become very difficult for network administrators to maintain a consistent setting for access privileges, quality of services and security.

Scalability issues:

Normally data centers have a high demand to grow rapidly, at the same time the network has to grow at the same speed. But in reality, networks have

12

become extremely complex due to the addition of hundreds if not thousands of routers, switches and even firewalls which are needed to be manageable and configurable. Network administrators have always relied heavily on bandwidth oversubscription in order to scale the enterprise networks, but with virtualization of data centers, traffic patterns have become highly dynamic which resulted in the difficultly in predicting the traffic patterns. Large operators, like Amazon, EBay and Facebook face even more extremely difficult scalability issues. Such large scaling networks are impossible to manually configure.

Equipment manufacture dependability:

Internet service providers and Datacenters always look forward to implementing new features and services to satisfy the changing industry requirements or end users demands. Normally, the ability to response is restricted by the equipment vender’s life cycles for the produced service and equipment, which in some cases can be about three years or even more. Also the absence of open standardized interfaces has resected the ability of network operators to customize the network to their required environments. Such mismatching between network capabilities and customer requirements has affected the industry badly.

2.3 The SDN architecture

As a response to the industry needs for an open standard [16]

Directly programmable: Network control is directly programmable because it

 is decoupled from forwarding functions.

Ease of traffic movement: Since the control is abstracted from forwarding functionality; this feature gives the administrators the ability of adjusting the network traffic flow dynamically to satisfy the changing requirements.

The main concept of SDN is rather simple. Normally routers, switches or any other network devices have two planes. The first plane is the forwarding plane renounceable of forwarding the data; therefore it is called the data or traffic-carrying plane. On the other hand we have the control plane, which is responsible of all the intelligence in the network and the decision making on where to route the traffic. The idea of SDN represented in Figure 2.2 is to decouple these two planes and to transform the traditional static network into a responsive, programmable, intelligent one that can be centralized controlled. This all can be done in logical manners that will response according to the traffic patterns, types or even emergencies.

2.3.1 Benefits of SDN

Software Defined Networking will change the way that network engineers and designers build and operate their networks to achieve business requirements. With the introducing of SDN, networks have become open standards, nonproprietary, and easy to program and manage. SDN will give enterprises and carriers more control of their networks, allow them to tailor and to optimize their networks to reduce the overall

13

cost of keeping the network. Some of the main SDN benefits can be summarized below

[17]:

Network management Simplicity:

With SDN the network can be viewed and managed as a single node which will transfer complicated default network management tasks to be abstracted in a rather easy to manage interfaces.

Fast service deployment:

New features and applications can be deployed in a fast manner within hours instead of many days.

Automated configuration:

Manually configuration tasks such as assigning VLAN and configuring QoS can be provisioned automatically.

Network Virtualization:

Since servers and storage virtualization has become deployed more than before networks can benefit from SDN to be virtualized as well.

Reducing the operational expense:

By befitting from the automation of network deployment, a change on the network has never been easier, as a result reducing the cost of the network operation.

Figure 2.2: SDN architecture

14

2.3.2 SDN Applications

Internet Research:

Since the internet is a life network and is constantly being used, it will be difficult to do any updates or tests for new ideas that might solve the issues or problems that current internet infrastructure faces. With SDN we have more control, since the controller part of the network and the data traffic is separated, or in other words separating the hardware part from software. Such separation allows for testing new ideas about future Internet architecture before implanting it in the live network. [18]

Load Balancing for Application Servers:

Load balancing is a necessary requirement for enterprise networks so it can provide high availability and scalability for the requests to a particular service.

Normally such functionality of balancing loads among several servers is implemented by a dedicated device that is implemented in the network.

Although with SDN an OpenFlow switch can deal with this functionality automatically and will distribute the traffic to different servers. But it does not scale well; therefore it is possible to write an application that works on top of the controller that can provide a scalable and efficient load-balancing application [19]. With such application the need for a dedicated middle in the network will be eliminated.

Data Centers Upgrading:

Data centers are an essential internal part of many large scale companies. For example, Google Facebook, Amazon and Yahoo have large numbers of data centers to accommodate the huge number of requests and response to them quickly. Such data centers are extremely expensive and complicated to maintain and run, SDN and OpenFlow allow companies to cut costs of setting up and configuring the datacenter, since data forwarding parts of the network can be managed from a central location [20].

2.4 Data centre networking and SDN

Data center is a facility that consist of servers (physical machines), storage, network devices (e.g. Routers, Switches. Middle boxes), power distributed systems, and cooling systems. Data center networking design has gone through a lot of changes; the conventional design for data center is the hierarchy design as show in Figure 2.3. In this design, Edge switches are located in the access layer that interconnects the servers with each other and to the aggregation l2/l3 switches. The aggregation switches locate in the aggregation layer (sometimes referred to as distribution layer) where it forwards traffic from the access layer to the core layer. The core layer provides secure connectivity between the aggregation switches and the core routers connected to the

Internet or a backbone network. This type of design has showed a number of drawbacks with regards to performance, forwarding, and virtualization demands.

15

Figure 2.3 Conventional data center networking [21]

Performance:

With the growing traffic demands, the need for high performance increases.

The conventional hierarchical architecture can be scaled but it limits the hostto-host capacity [21]. The switches are unable to let the hosts saturate the full bandwidth available by their network interfaces, because the topology does not allow multiple ways for hosts to reach one another. Therefore, the interfaces capacity for the switches in the higher layers in the topology limits the high rates for the hosts’ interfaces. As a result, the growing traffic of the data center can cause the overall throughput to be reduced. This problem can be solved by upgrading switches, routers, and links to support higher rates, but it increases the overall cost of the network.

Forwarding:

The forwarding scheme for the above topology consists of layer 3, layer 2 combinations, whereby IP addresses are assigned to hosts hierarchically based on their directly connected switches, and a routing protocol is employed among switches to find the best path between hosts. Unfortunately, layer 3 forwarding imposes administrative burden, since the process of adding new switch requires manual configuration. Improperly synchronization between system components, such as DHCP server and a configured subnet can lead to unreachable hosts and difficulties to diagnose errors [22].

Virtualization demands:

Host virtualization is very important in today’s datacenters, where a single physical server can run multiple virtual machine instances, each needs a specific MAC and IP address. With the flexibility of virtualization, it allows the entire VM to be migrated to different physical servers very quickly. The underlying network presents challenges in dealing with this flexibility. In layer

3 setting, the IP address of a virtual machine is set by its directly-connected switch subnet number, and when a VM migrates to another server, it is required to assign a new IP address based on the subnet number of the new next hop switch. That operation would bring a down time to the VM and brake to all of its open sessions while migrating.

16

Recommended solutions for the above described problems are the following: The performance problem can be solved by letting the switches in the higher layers of the data center network topology carry less traffic belong to the underlying hosts, in order to achieve higher rates for host-to-host connectivity without much upgrading. The forwarding problem can be solved by designing a data center as a large layer-two network to simplify the routing between hosts. Finally, updating the address mapping quickly can solve the VM migration problem when a VM migrates form one part of the data center to another.

2.5 SDN for data center networks

PortLand [22] is a network architecture based on fat tree topology [23] introduced to solve the problems in the current data center networking. A Fat tree architecture has multi-rooted tree topology, where the capacity increases towards the roots of the tree.

This topology design not only alleviates the bottlenecks toward the core but also provides inherit fault tolerance, because any sever in the edge of the data center has multiple routes to reach the core and other servers in the data center. Figure 2.4 illustrates the Fat tree topology.

The PortLand architecture introduces the concept of Pseudo-MAC address PMAC.

The PMAC has a format of pod.position.port.vmid, where pod is the pod number of an edge switch, position is its position in the pod, port is the port number of the switch that the end-host is connected to, and vmid is the ID of a VM located at the edge of the network [24]. The PMAC is hierarchically structured, where all servers in the same pod have the same prefix on their PMAC addresses. This stands in contrast to the conventional MAC address where it is completely flat. The hierarchy design of the

PMAC addresses allows the switches to forward the traffic towards the appropriate pod or region of the data center simply based on the structure of the PMAC address.

Core

Aggregation

Edge

Pod 0 Pod 1

Pod 2 Pod 3

Figure 2.4: Fat tree topology

17

Core

Fabric manager/

SDN controller(s)

Aggregation

Edge

Pod 0 Pod 1

Pod 2 Pod 3

Figure 2.5: SDN application in PortLand Data center architecture

Because each host in the data center has a custom PMAC address that depends on its location in the topology rather than on its physical interface, a logically centralized entity called the Fabric manager is used to maintain the network configuration information and the MAC-PMAC mapping. Similar to SDN controller, the fabric manager is the centralized brain that is used to achieve routing at layer 2, ARP resolution, multicast, and fault tolerance.

A software defined network controller can be installed in the PortLand network architecture as shown in Figure 2.6, since it has a centralized entity that manages the network. That can provide a logically centralized programmable environment for the datacenter.

The ease of VM migration in this topology is achieved by the new addressing schemes for the hosts, and the better routing between hosts is achieved because it is now based on layer 2 rather than layer 3 forwarding. The fat tree topology used in this architecture enables the high performance and availability, because hosts have more options in order to reach each other.

Beside of these benefits of the PortLand network architecture, there are several drawbacks. First, the multi rooted fat tree topology makes the PortLand difficult to be implemented to other used data center topologies. Second, the fabric manager is the centralized entity for network configuration, making it vulnerable to malicious attacks, and therefore the services might be unavailable.

2.6 Network virtualization and SDN

Until recently, virtualization in data centers has primarily focused on servers and storage, but the increasing of data and more access methods (mobile, tablets, desktops) anytime, anywhere have led to an urgent need for business requirements to increase agility. To better achieve this demand, the network is needed to be virtual as well, to achieve similar benefits that virtualization provided servers.

Network virtualization is a framework that decouples and isolates virtual networks from the underlying physical network hardware. Network virtualization concept is similar to server virtualization that isolates virtual machines from the underlying

18

physical server hardware. With network virtualization, virtual networks are isolated from the underlying physical network infrastructure as shown in Figure 2.7.

A virtualized network abstracted from physical hardware must still provide similar features and guarantees of a physical network, only with greater flexibility and agility than before, including more operational efficiency and hardware independence.

Conventionally, elements for network virtualization were presented in 802.1Q VLANs that allow isolation between LANs sharing the same physical link. Other approaches like IPsec/SSL VPNs, MPLS, virtual routers, and VRF have provided elements of network virtualization.

When employing one of the above network virtualization technologies, virtualizing affects some part of the network (a LAN segment, an L3 path, an L3 forwarding table, etc.) but not an entire network with all its properties. [26] For example, if VLANs is used to virtualize L2 segment, there will not be a virtualized counter that automatically updates, nor a virtual ACL that keeps working without concern of the new location for the VM.

Beside this limitation, in today’s data centers network the need for changes such as adding or removing VLANs, modifying firewall, ACL rules, takes weeks due to the complexity of the process of manual configuration and re-configuration for networking devices. While provisioning the compute and storage resources takes minutes.

Network virtualization is considered as a solution to close the gap between computing, storage virtualization and networking. The relationship between SDN and network virtualization is that SDN is a mechanism, and network virtualization is a concept, but SDN can be used to achieve network virtualization by abstracting the configuration parameters for the networking devices into logical centralized layer.

That layer can be represented as a network hypervisor, where all the network applications can sit on top of the hypervisor, and implement the needed logic for all the underlying network devices independently. With this approach, changes in network can be done in minutes, by implementing new network applications that address a certain demands in the network.

Figure 2.7: Network Virtualization and Server Virtualization [25]

19

2.7 Scalability in SDN

Despite of the numerous advantages of SDN, since SDN presents a centralized controller for the network, scalability has become an issue, which in turn influences the network performance. In Data centers the need for high controller performance is crucial. For example, assuming a small data center with 100K hosts and 32 hosts/rack, the maximum flow arrival rate can be up to 300M, and the average rate is between

1.5M and 10M per seconds [27]. By considering the current performance for the

OpenFlow controllers, with an average throughput at 2M per second, in order to manage the average rate incoming flow, 1-5 controllers are needed, but 150 ones for the maximum rate. In large scale data centers, the problem will be worse.

To solve this problem, one approach is to improve the controller itself, either by implementing more advanced multi-threaded optimizations or by developing new controllers that build in the kernel space and thereby eliminating the switching between the user and the kernel space that consumes additional time [13]. Another approach includes classifying the flows and events according to their duration and priority, where short duration flows can be handled by the switches, and longer duration flows can be sent to a controller. In this case the amount of processing load for a controller is reduced [28].

Beside the above methods of enhancing the controller performance, using distributed controllers teaming to act like a single logical centralized control plane can enhance the performance significantly, as illustrated in Figure 2.8. The network in this approach is divided into multiple segments that could be overlapped and controlled by a certain controller. The controller cluster is connected to a distributed data storage that provides all switches and applications’ information. Beside of the throughput scalability benefit in this approach, the reliability is also gained if a single controller crashes. Applications such as FlowVisor [29] , HyperFlow [30], Onix [31], are examples of the distributed controller’s architecture.

Distributed data storage

Controller cluster

Switches pool

Figure 2.8: The organization scheme of distributed controller [27]

20

2.8 Controller operational mode and scalability

The controllers in SDN architecture have two operational modes, reactive and proactive. In the reactive approach, packets of each new flow coming to switch are forwarded to the controller to decide how to manage the flow. This approach takes a considerable time while installing rules. The amount of latency can be affected by the resources of a controller, their performance, and the controller-switch distance.

In the proactive approach, rules are already installed in the switches; therefore the numbers of packets that send to the controller are reduced. In this approach the performance become better and therefore the scalability. Evaluation for both approaches has been done in [32], where a hybrid approach has been presented to gain the benefits of both reactive and proactive approaches. In this thesis we evaluated the number of controllers that runs in reactive mode, since it’s the standard mode in

OpenFlow controllers.

21

22

Chapter 3

3 OpenFlow

Reviewing the progress of networking technology lately, it has improved through large scale and innovative transformations at its speed, reliability and security. At physical layer networking devices have evolved providing high-capacity links, improving in terms of computational power and a variety of applications has emerged, offering tools to inspect operations easily. But the network in its structure has not seen much change from its early days.

In the existing infrastructure, tasks that make up the overall functionality of the network such as routing, switching or network access decisions are handled by network devices from various different vendors all running different firmware. This does not provide much space for novel research ideas such as new routing algorithms to be tested in wide-scale, real networks. Furthermore, any attempt for experimental ideas over the critical priority production network may end up with failure of the network at some point, which has led to the network infrastructure being static and inflexible, and has not attracted major innovations in this direction [33]

OpenFlow is an approach to tackle this problem. Because network operators can implement and control the features they want in software, rather than having to wait for a vendor to put it in plan in their proprietary products. Moreover, it also allows vendors to give researchers access to their equipment in a unified way without opening up their products, therefore researchers are able to conduct experiments with new protocols in a real-world network without affecting the production traffic.

OpenFlow uses flow-tables that are similar to the lookup tables in modern Ethernet switches and routers. These flow-tables can implement firewalls, NAT, QoS or to collect statistics for network management without concerning on which vendor it deals with. These flow-tables contain match/action rules that can be created and modified by a centralized controller. The controller offers a programmatic control of flows for network administrator to define a specific route from source to destination utilizing flow based processing of packets forwarding. It reduces power consumptions and network management costs by eliminating router’s packet processing as defining paths through a centralized controller.

3.1 OpenFlow Architecture

The OpenFlow network architecture consists of three basic concepts:

1. OpenFlow-compliant switches that compose the data plane.

2. The control plane consists of one or more OpenFlow controllers

3. A secure control channel connects the switches with the control plane.

The switches communicate with the hosts and with each other using the data path software can provide, and the controller communicates with the switches using the control path as shown in Figure 3.1.

23

Figure 3.1 : OpenFlow Network Architecture

The connection between the OpenFlow controller and the switch is secured using SSL or TLS cryptographic protocols, where the switch and the controller are mutually authenticated by exchanging certificates signed by both sides’ private key. Although this is a very powerful security algorithm, the controller may be vulnerable to denial of service (DoS) attack, or Man in the middle attack; therefore, appropriate security practices must be implemented to prevent such attacks.

3.2 OpenFlow enabled switch

An OpenFlow enabled switch is the basic forwarding device that forwards the packets according to its flow table, which is similar to traditional forwarding tables but not managed and maintained by the switch. It is connected to the controller via a secure channel on which OpenFlow messages are exchanged between the switch and the controller as shown in

Figure

3.2.

There are different versions of OpenFlow protocol specification available on

OpenFlow Switch Specification ONF but in the following sections, OpenFlow version

1.0 is explained because it is considered to be the fundamental of OpenFlow protocol.

24

Figure 3.2: OpenFlow enabled switch OF v1.0 specification [34]

Header fields Actions Counters

Table 1: A flow table for OpenFlow v1.0

3.2.1 Flow Tables

A switch in OpenFlow network has one (or more) flow table(s) that contains a set of entries, each of which consists of fields named match, action, and counters as showed in Table 1. All packets processed by the switch are compared against the flow table. If a packet header matches a flow entry, an action for that entry is performed on the packet (e.g., the action might be to forward a packet out a specified port). If no match is found, the packet is forwarded to the controller over the secure channel. The counters are reserved for collecting statistics about flows. They store the number of received packets and bytes, as well as the duration of the flow.

3.2.2 Matching flows

The header field in the flow table consists of different fields on which the incoming packets are compared to:

Incoming switch port

IEEE 802.3 Ethernet source and destination address

IEEE 802.3 Ethernet type

IEEE 802.1Q VLAN ID and priority

IP source and destination address

IP proto field

IP Type Of Service (TOS) bits

TCP/UDP source and destination ports

The incoming packets can be matched against various fields on every layer of the OSI model for a packet, ranging from the data link to the transport layer as well as on the

25

incoming switch port. In order to match all the header fields, the special value ANY can be used in the Flow table.

3.2.3 Actions taken on the flows

If an ingress packet matches one of the match fields in the flow table, an action should implied to that packet. Forwarding the packets action to each physical port must be supported by the OpenFlow switch. Additionally there are virtual ports defined by the OpenFlow standard as special targets that the packets can be forwarded to, as illustrated in

Table 2. These actions are “required” actions and “optional” actions. The required actions must be supported by all the switches in order to be OpenFlow-compliant and the optional actions which have proven to be useful actions but they are not necessarily supported in an OpenFlow compliant switch.

Virtual Port Description

ALL

Forward the packet to all ports except the received port

CONTROLLER Encapsulate the packet and send it to the controller

LOCAL

Send the packet to the local networking stack for the switch

TABLE

IN_PORT

Perform actions described in the flow table. Only for packet-out messages

Send the packet to the received port

Table 2.a: List of virtual ports for the “Required” forward action

Virtual Port

NORMAL

FLOOD

Description

Forward the packet using the traditional forwarding methods, i.e. traditional L2, VLAN, and L3 processing.

Send the packet along the minimum spanning tree, not including the incoming interface. Each port in the

OpenFlow enabled switch has a

NO_FLOOD-bit, which indicates that the port doesn’t belong to the minimum spanning tree. The packets that match that flow entry are forwarded to the ports that have a NO_FLOOD-bit.

Table 2.b List of virtual ports for the “Optional” forward action.

Table 2: List of virtual ports for the forwarding action

Beside the forwarding action, there are other actions in the flow table:

26

DROP: A required action indicated by an empty action list. All packets match an empty action list are dropped.

Enqueue: This optional action can be used to put packets in a queue which is associated with a port in order to provide Quality of service.

Modify-field: This optional action is employed to modify a specific header field for the incoming packet. The following modification can be made: o

Set VLAN ID and priority.

o

Strip VLAN header.

o

Modify Ethernet source and destination MAC address.

o

Modify IP source and destination.

o

Modify IP TOS bits o

Modify transport layer source and destination ports.

3.2.4 Counters

The OpenFlow standards enable the switch to expose statistics through counters. The counters consist of multiple variables per table, flow, port, queue, as illustrated in Table

3 below.

Counters Bits

Per Table

Active entries 32

Packet Lookup

Packet Matches

Per Flow

64

64

Received packets

Received Bytes

Duration (seconds)

Duration (nano seconds)

Per Port

Received packets

Transmitted packets

Received Bytes

Transmitted bytes

Receive Drops

Transmit Drops

64

64

64

64

64

64

64

64

32

32

Receive Errors

Transmit Errors

Receive Frame Alignment

Errors

Receive Overrun errors

Receive CRC Errors

Collisions

Per Queue

Transmit packets

64

64

64

64

64

64

64

Transmit bytes

Transmit overrun errors

64

64

Table 3: Required list of counters for use in statistics messages [34]

27

3.3 Flow types

Flows populated from the OpenFlow controller can be classified into types: micro flows and aggregated flows [35].

Microflows: This type of flow is useful when a small number of flows needs to be installed in the switch, e.g. campus network. The flow tables in this type contain one entry per flow and exact matching is needed to perform an action.

Aggregated: It is useful for big networks that require a large number of flow table entries, e.g. backbone networks. In this type one flow entry (Wildcarded) covers a large number of flows, each of which must belong to a specific category.

Each of the above types can be further classified into Reactive and Proactive flows.

Reactive: In this type the controller is idle until it receives the first packet from the OpenFlow switch. The controller parses the incoming packet and then inserts a new flow entry in the switch’s flow table. In this type each new flow entry needs a small additional setup time. If a connection between the controller and the switch fails, and the switch does not have the ability to forward the packet as a traditional switch, it will be unable to forward the packets to the hosts.

Proactive: In this type the controller pre-installs the flow entries into the switch’s flow table without the need to receive the first packet of the flow. It does not require additional time for flow setup and in case of link failure between the controller and the switch, the traffic will not be disrupted.

3.4 Packet forwarding mechanism

In OpenFlow network when a switch receives a packet, it parses the header field, and checks it against the rules in the flow table. If a match exists, an action in the flow table is considered. If several matches are found, packets are matched against a specific flow entry based on prioritization, i.e., the flow entry with the highest priority is selected.

Then the switch updates the counters of that flow table entry. Finally the switch forwards the packet out to a port. If the incoming packet didn’t match any flow entry in the flow table, the switch would forward the packet to the controller to calculate which logic must be implied to this packet and similar future packets. The process of packet forwarding mechanism can be illustrated in the flowchart Figure 3.3.

3.5 OpenFlow communication massages

There are three classes of communication exist in the OpenFlow protocol:

1. Controller-to-switch.

2. Asynchronous.

3. Symmetric.

28

Table entry found

Header field Counters Action

Incoming packet

Parsing the header field

Match against flow tables

No match found

Send the packet to the

Controller using

PACKET-IN message

Figure 3.3 Basic packet process mechanism for OpenFlow switch [36]

Perform action on packet

3.5.1 Controller-To-Switch Messages

Controller-to-switch messages are established by the controller and sent to the switch.

There are different types of these massages:

Features: These messages are request/reply mode, where the controller sends a features request message to the switch. The switch sends a features to reply that specifies the capabilities supported by the switch.

Configuration: This message enables the controller to set and query configuration parameters in the switch. The switch answers the query and sends the information needed to the controller.

Modify-State: It is used to add/delete or modify flows in the flow tables and to set switch port properties.

Read-State: These messages enable the controller to collect statistics from the switches flow-tables, ports and the individual flow entries.

Send-Packet: The controller uses these messages to send packets out of a specified port on the switch.

Barrier: These messages are request/reply mode, where the Barrier request is sent by the controller to ensure previous messages have been arrived. The switch sends a Barrier Reply upon successful execution of the messages.

29

3.5.2 Asynchronous Messages

These messages are initiated by the switch and send to the controller. There are four main asynchronous messages:

Packet-in: A packet-in message contains a packet to be sent to the controller.

Either because it does not have a match for any flow entry in the switch flow table or it matches an action that orders the switch to send it to the controller.

If the switch has the capabilities to buffer the packet, then it sends only a fraction of the header fields (by default 128 byte) and buffers the rest with a buffer ID to be used by the controller to donate the new flow entry with that buffered bytes.

Flow-Removed: Flow table entries are added with idle and hard timeout values by the controller’s flow-modification message. The idle timeout indicates a lack of activity for a flow, and the hard timeout indicates the lifetime of a flow. After the expiration of those values, the flows are automatically removed. Those events are announced to the controller by Flow-Removed messages.

Port-status: This message is send to the controller if a switch port changes their state, for example if they go down by a certain reason.

Error: If an error happened to a switch, the controller could be notified by this type of message.

3.5.3 Symmetric Messages

Symmetric messages are initialized by both the switch and the controller in either direction. According to the OpenFlow specification these messages are:

Hello: These messages are exchanged between the switch and the controller when the connection startup.

Echo: These messages are in request/reply form, where they can be sent by either a switch or a controller and must return an echo reply to indicate the latency, bandwidth, and/or liveness of a controller-switch connection.

Vendor: These messages enable certain vendor to create a custom message that enables the OpenFlow switches to offer additional functionality.

3.6 Demonstration of the messages exchanged in OpenFlow network

In order to demonstrate the messages explained above in real OpenFlow network, we used Mininet [37] network emulator to emulate two hosts connected to a switch and a controller, see Figure 3.4 below. For this demonstration, we first explain the Switch-

Controller connection establishment, then host-to-host communication through the

OpenFlow switch and controller.

30

Controller

C0

Port 6633

Loopback

127.0.0.1

S1-eth0

OpenFlow

Switch

S1

S1-eth1 h1-eth0

IP address 10.0.0.1

MAC address 00:00:00:00:00:01 h2-eth0

IP address 10.0.0.2

MAC address 00:00:00:00:00:02

Figure 3.4 Network topology using Mininet

3.6.1 Message establishment between a switch and a controller

When a switch connects to an OpenFlow network, it establishes a TCP handshake with the controller IP address (Loopback interface 127.0.0.1) and a default port of 6633.

Following that process, both sides start to exchange Hello messages that include the highest OpenFlow version number supported. After that, Feature request message is sent by the controller to see which ports are available in the switch, which in turn replies with Feature reply message that contains a list of ports, ports speed, and the supported tables and actions. Set config message is sent then by the controller to ask the switch to send flow expirations.

Finally, echo request, echo reply are sent frequently between the switch and the controller to exchange information related to the bandwidth, latency, and liveness of their connection. The figures below illustrate the sequence of processing and a

Wireshark capture for the packets, Figure 3.5.

31

OpenFlow

Controller

Hello Hello

Feature

request

Set Config

Feature

reply

Echo request

Echo

reply

OpenFlow Switch

Figure 3.5: Communication messages between OpenFlow switch and controller

Figure 3.6: Wireshark capture of the connection establishment between the OF controller and a switch

32

3.6.2 Messages exchanged between two hosts

To demonstrate how the host-to-host connection is performed in an OpenFlow network, we used the Ping tool to send ICMP packets from h1 to h2 and vice versa.

The process starts when h1 sends an ARP request to the switch, asking for h2 MAC address, the switch does not know how to deal with the packet, so it sends the packet as a PACKET-IN message to the controller. The controller answers with a PACKET-

OUT message that has an action instruct the switch to send the packet out to all ports except the incoming port (in our case just port 2) and wait for replying for that request.

When h2 replies for that request, the switch also sends that reply to the controller because it has no idea where to forward that packet. When the controller receives the

ARP reply, it sends FLOW-MOD message to install a new flow entry for the future

ARP replies from h2 that is distant to h1 to be forwarded directly by the switch without notifying the controller. The same process happens when h1 sends the ICMP request/reply, and when h2 sends an ARP request for resolving h1 MAC address and the consequence ARP reply. At the end, five new flow entries will be installed in the switch’s flow table by the OpenFlow controller as shown in Figure 3.7, Figure 3.8. h1

OpenFlow switch

OpenFlow

Controller h2

ARP request

PACKET-IN

PACKET-IN

ARP request

ARP reply

ARP reply

ICMP request

PACKET-IN

ICMP request

PACKET-IN

ICMP-reply

PACKET-IN

ARP request

ARP request

ARP reply

PACKET-IN

ARP reply

Figure 3.7: Ping process between h1 and h2

33

Figure 3.8: packets exchanged between h1 to h2

3.7 OpenFlow controller

The controller is the core, and the main part of the Network Operating System (NOS) in SDN networks. It is responsible for manipulating the switch’s flow table, and for communications between applications and network devices using OpenFlow protocol.

The controllers can be classified into two main categories [9]

1. Open source single instance controller.

2. Commercial closed source distribution controller.

The Open source controllers are available for research and development, therefore it is represented as a single controller instance with the ability to develop various APIs on their platform to perform certain tasks. There are many Open source OpenFlow controllers; the major distinction between them is the programming language they are written in.

Below is a list for Open source controller based on their programming language [3]

C: Trema [38] (also Ruby), and MUL [12]

C++: NOX [5] (also Python).

Java: Beacon [6], Floodlight [10], Open IRIS [14], Maestro [7], and OpenDaylight [39]

Python: POX [40], Pyretic [41], and RYU [11] .

Distributed controllers are able to operate and control the network through multiple controller instances. With such implementation, the benefits are having additional layers of abstraction for the control plane and fault tolerance. Some of the public examples for those controllers are: Onix [31], from Nicira Networks, IRIS [42], by

Research Team of ETRI, Big Network Controller from Big Switch Networks, and

Programmable Flow from NEC. Onix and IRIS controllers have the additional capability of scaling the performance by adding additional controllers in the controller cluster.

34

Chapter 4

4 Methodology and Evaluation

4.1 OpenFlow Controllers Evaluation

In this chapter we focus on the two main OpenFlow controllers performance parameters: throughput and latency. The evaluation will be performed on the learning switch application. The controllers that are examined during this experiment are

Beacon, OpenIRIS, OpenMul, Maestro, NOX and Floodlight, with the main goal in mind to explore which controller will give the highest throughput and the lowest latency.

4.2 Experiment Setup

The test environment was carried out on OpenFlow emulation software. In order to overcome the Ethernet interface speed limitations, both of the controllers and

Benchmarking tool were installed on the same host (Intel Core i7-3537U 2.00/3.10 GHz

CPU with two cores and 4 threads, 8GB DDR3 ram), [43] running (64-bit Ubuntu 14.04

LTS Linux OS). During the test we ran multiple parallel instances of both benchmarking tool (Cbench) and the controllers to utilize all the available resources.

In the Controller evaluation test, we connected different number of virtual switches and each switch had been connected to 100k unique MAC (Host) and consequently these hosts had been connected to the controller. As mentione-+d before, Cbench has been used to emulate these switches and hosts as illustrated in the Figure 4.1

Figure 4.1: Experiment Setup

35

For each controller, we ran the test with different number of the Switches (1, 8, 16, 32,

64, and 128) to investigate the impact on performance as increasing the number of virtual switches that will be connected to it. Moreover, each test was repeated three times and the final result was the average value for these tests. Each test consists of 14 loops each lasting 10 seconds. For controller warm-up purposes the first two loops' results will be ignored. Each test will emulate a 100k host connection or in other words a unique MAC address.

4.3 Benchmarking Methodology for OpenFlow Controller

Two types of testing will be conducted on the controllers; one will be for the flow setup throughput while the other test will be on the flow setup latency. These two main testing factors will be used to measure the performance of the controllers.

4.3.1 Flow setup throughput

In flow setup throughput mode, the emulated switches send as many PACKET_IN messages as possible to the controller, making sure that the controller always has messages to process. [9]

4.3.2 Flow setup latency

The flow setup latency test uses Cbench to emulate switches which send a single packet to the controller, waits for a reply, then repeat this process as quickly as possible. The total number of responses received from the controller at the end of the time period can be used to calculate the average time it took the controller to process each PACKET_IN initiated from the switches. [9]

4.3.3 OpenFlow controller Benchmarking parameters

For the benchmarking methodology of OpenFlow Controller the following parameters had been considered for the testing of both latency and the throughput:

Number of OpenFlow-enabled Switches: the number of OpenFlow switch that will establish a connection with the controller.

Number hosts (Flows): number of hosts that the controller will connect.

OpenFlow Version: protocol version that controller will use for connection setup, so far three version of OpenFlow protocol are 1.1, 1.2 and 1.3.

Test loops: the number of times the test needs to be repeated.

Test Duration: the duration of test iteration, expressed in seconds.

4.4 Cbench (Controller benchmark tool)

According to the Open Networking Foundation, Cbench can be defined as a

“(controller benchmarker) is a program for testing OpenFlow controllers by

36

generating packet-in events for new flows. Cbench emulates a bunch of switches which connect to a controller, send packet-in messages, and watch for flow-mods to get pushed down” [44]. With the current version of Cbench software two main benchmark tests on throughput and latency are available.

4.4.1 Cbench Algorithm

Cbench tool uses the below algorithm to perform tests for both throughput and latency.

Pretend to be n switches (n=16 is default)

Create n openflow sessions to the controller

if latency mode (default):

for each session:

1) send up a packet in

2) wait for a matching flow mod to come back

3) repeat

4) count how many times #1-3 happen per sec

else in throughput mode (i.e., with '-t'):

for each session:

while buffer not full:

queue packet_in's

count flow_mod's as they come back

4.4.2 Cbench installation and running

Installation instructions for the Cbench tools can be found in Chapter 2 of the oflops user manual [44] while the running options and description for each option can be found in Table 4 below

Option Description

-c/--controller <str> hostname of controller to connect to

Default value

("localhost")

-d/--debug

-h/--help enable debugging print this message

(off)

-l/--loops

-M/--macaddresses

-m/--ms-per test switch

<int> loops per test

<int> unique source MAC addresses per

(16)

(100000)

<int> test length in ms (1000)

-p/--port

-r/--ranged-test

-s/--switches

-t/--throughput

-D/--delay received (in ms)

<int> controller port test range of 1..$n switches

(6633)

(off)

<int> fake $n switches (16) test throughput instead of latency

-C/--cooldown <int> loops to be disregarded at test end

(cooldown)

<int> delay starting testing after features_reply is

(0)

(0)

37

-i/--connectdelay to the controller

-I/--connectgroup-size

<int> delay between groups of switches connecting

<int> number of switches in a connection delay

(in ms)

(1)

-L/--learn-dstmacs macs before send gratuitious ARP replies to learn destination

(on) testing

-o/--dpid-offset <int> switch DPID offset

Table 4: Cbench Running Options

During controllers evaluation tests the following parameters were used:

(1)

Throughput: The following command was used with the –t option for the throughput, see Figure 4.2. taskset -c 0-3 cbench -c localhost -p 6633 -m 10000 -l 14 -w 2

-M 100000 -i 50 -I 5 -s 64 –t

Latency: The following command was used, see Figure 4.3. taskset -c 0-3 cbench -c localhost -p 6633 -m 10000 -l 14 -w

2 -M 100000 -i 50 -I 5 -s 64

Figure 4.2: Cbench running in throughput mode

Figure 4.3: Cbench running in Latency mode

38

4.5 OpenFlow Controllers

The OpenFlow/SDN community has been witnessing the development of numerous controllers written in multiple programming languages such as C, C++, Java,

JavaScript, Ruby and Python. While there are many performance numbers and data published by the developers of these OpenFlow controllers, yet there has been no independent research performing evaluation comparisons using the same methodology and environment. In this part of the research we will work with the controller implementations that are much known for their high performance.

4.5.1 Beacon OpenFlow Controller

Beacon is an OpenFlow controller that is developed using Java programing language and since Java is known as cross-platform language or Write-once-run-anywhere

(WORA) so it can run on many platforms from multicore servers to Android enable phones. Some of the main key features that Beacon Controller has are [45]:

Stability: it has been in development for more than four years; since its development started in early 2010 also it has been used in several research projects and trial deployments.

Since Beacon is licensed under a combination of the GPL v2 license and the

Stanford University FOSS License Exception v1.0, it is considered as an Open source software.

Multithread is enabled so that it is considered as one of the fastest OpenFlow

Controllers.

Easy to install and run: it uses Java and Eclipse so it is rather simple to develop and debug of user applications.

Efficiency: Beacon code can be started/stopped/refreshed/installed at runtime for example it is possible to replace the running Learning Switch application without disconnecting any connected switches.

Beacon embeds the Jetty enterprise web server with a custom web based user interface framework, as shown below in Figure 4.4

Running and evaluating Beacon Controller

First the installation procedure for Beacon will be explained and then we will go through the prerequisites that will be required to run the controller. There are two procedures for running beacon controller; the first one involves running beacon code as a project in Eclipse workspace, which will require downloading openflowj in addition to beacon bundle itself. Running Beacon using Eclipse will require additional

CPU resources and our intention was to utilize all the available CPU resources for the running to the controller. Therefore it was necessary to use the second procedure, which includes the use of the binary package that could be run from the terminal directly and thus consuming fewer resources. During the test, the beacon version v1.0.4 was used and the following command is used to download the beacon file:

Git: git://gitosis.stanford.edu/beacon.git

39

Figure 4.4: Beacon Controller web interface

According to the OpenFlow benchmarking guidelines [45] Java version 6 series Oraclebased JRE/JDK is recommended for the benchmarking For Installing Oracle JDK the following commands: sudo apt-get install python-software-properties sudo add-apt-repository ppa:webupd8team/java sudo apt-get update

Then executing the following commands for Oracle JDK 6: sudo apt-get install oracle-java6-installer

After downloading and installing all required files and the Java JVM it is time to run the controller, but before that it is required to change the beacon/beacon.properties file

 threadCount parameter must be set to match the number of cores in the system, e.g. 4 cores in our system. controller.threadCount=4

During the latency benchmarking, the latency parameter has to be changed in the beacon.properties file as the following: controller.immediate=true

Also an Important beacon.ini parameter was setting

XX:+AggressiveOpts -Xmx3000M

40

As mentioned before, the system that was used during the experiment had two cores and 4 threads therefore it was necessary to use to the (taskset -c 0-3 ) to bind Beacon to specific processor cores when using Linux as in the command below to run the

Beacon Controller

/beacon 1.0.4/ sudo taskset -c 0-3 ./beacon -configuration configurationSwitch

As we can see from Figure 4.5, Beacon throughput represented in flows/sec showed that with one switch the throughput values were around 1.6 million flows/sec and then it increased to reach 1.7 million flows/sec. Finally it reached the maximum of around 2 million flows/sec with 64 and 128 switches.

Figure 4.6 represents latency test results for Beacon. That demonstrated relatively high latency (15 µs) when one switch was connected and then it went below 8 µs with 8 and

32 connected switches, as for 16 connected switches it showed around 9 µs. Finally it reached 8 µs for 64 and 128 connected switches.

Beacon Throughput

2500000

2000000

1500000

1000000

500000

0

1 8 16 32

Switches

64 128

Figure 4.5: Beacon Throughput

Beacon Latency

16

14

12

10

8

6

4

2

0

1 8 16 32

Number Of Switches

64 128

Figure 4.6: Beacon Latency

41

4.5.2 Floodlight Controller

The Floodlight open source SDN controller is written in Java language which makes it a cross-platform controller and it is considered as one of the enterprise class OpenFlow controllers. It provides the following main features:

Open source software under the Apache-licensing, which make it possible to be used for almost any purpose [10].

Standing on solid ground, since it is well supported by developers’ communities including Big Switch [46].

Floodlight is considered as a rather easy to use, build and run therefore it is a popular option for engineers starting to learn and test OpenFlow.

Being designed to scale to accommodate the growing number of OpenFlow enabled switches, routers, virtual switches, and wireless access points [10].

Running and evaluating Floodlight Controller

Since Floodlight is written in Java and thus runs within a JVM, we will need the following Prerequisites:

Ubuntu 10.04 or higher, in our system we used Linux Ubuntu 14.04 LTS.

JDK and Ant which can be installed by running the following command: sudo apt-get install build-essential default-jdk ant pythondev eclipse

After preparing all the prerequisites to run Floodlight it is time to download and run the controller by using the following commands:

Sudo git clone git://github.com/floodlight/floodlight.git cd floodlight sudo git checkout stable ant;

Running the controller to get the highest performance possible by using the following command: sudo taskset –c 0-3 java -jar target/floodlight.jar

After the installation and running of the controller we can run the Cbench tool for both

Throughput and latency using the same commands as with Beacon controller.

The results of flow rate measurement for the floodlight controller represented by

Figure 4.7 clearly demonstrate that the connection of one switch result a low (500,000 flows/sec) flow rate. However the values started to increase gradually when more switches were connected, reaching up to 1.2 million flows/sec with the connection of

8 switches. Further addition of switches led to a degradation in the flow rate which dropped to 1 million flows/sec when 16, 32, 64,128 switches were connected.

Measurement of latency for the floodlight controller showed that connecting one switch resulted in a high value as seen in Figure 4.8, while the connection of more switches (8, 10, 32 and 64) led to a decrease in latency which later dropped to 9 µs.

42

However, the latency increased again with the connection of 128 switches as demonstrated by the same figure.

Floodlight Throughput

1400000

1200000

1000000

800000

600000

400000

200000

0

1 8 16 32

Switches

64 128

Figure 4.7: Floodlight throughput

Floodlight Latency

25

10

5

0

20

15

1 8 16 32

Number of switches

64 128

Figure 4.8: Floodlight Latency

43

4.5.3 OpenMul Controller

Open Mul, is an OpenFlow (SDN) controller [12] written in C programing language which is known for its high performance and low CPU resources requirements. It has a modular application plugin interface which lets almost any language application use rather high performance services. Open Mul is an open source since it is under the

GPLv2 license, which encourages the developer communities to get involved in its development. Also it is most known for reliability, high performance and Modular

Application Hosting Capability.

Running and evaluating OpenMul Controller

From the installation instructions [47], first step was to download MuL code using

”git“ command to get the latest version git clone git://git.code.sf.net/p/mul/code mul-sf-code

Also the libwxgtk2.6-dev packages were necessary to get the MuL running, which can be downloaded by using the following command: sudo apt-get install flex bison libwxgtk2.6-dev buildessential expect g++-multilib tofrodos zlib1g-dev gawk libffidev

Then the utility script that comes with OpenMuL should be configured by using the following commands: cd mul-sf-code cd SCRIPTS

./configure_ext_libs

Finally the Configure and Make commands are issued as the following:

cd ../

./autogen.sh

./configure --with-glib=`pwd`/common-libs/3rd-party/glib-

2.32.0/ --with-libevent=`pwd`/common-libs/3rd-party/libevent-

2.0.21-stable/ make

./configure

Now OpenMuL is ready to be run by using the following commands cd mul-sf-code/mul sudo taskset –c 0-3 ./mul

With OpenMuL controller the layer two switches runs as an application on the top of the controller, therefor we will need be run it separately by issuing the following commands cd mul-sf-code/application/l2switch sudo taskset –c 0-3./mull2sw

44

The throughput results for the OpenFlow controller represented in Figure 4.9 show that the connection of one switch resulted in a low throughput (1.2 million flows/sec).

Then flow rate began to increase as more switches were connected reaching flow rate of 2.7 million flows/sec as connecting 8 switches. However, the connection of 16, 32,

64 and 128 switches led to a drop (2.6 million flows/sec) in flow throughput.

The latency values for the OpenMuL showed a relatively high latency when one switch was connected (12 µs) as shown in Figure 4.10. While connecting of more switches (8, 16, 32, 64 and 128 consequently) yielded low latency values which were around 10 µs.

Open Mul Throughput

3500000

3000000

2500000

2000000

1500000

1000000

500000

0

1 8 16 32

Number of switches

64

Figure 4.9: OpenMuL throughput

128

Open Mul Latency

14

12

10

8

6

4

2

0

1 8 16 32

Number of switches

64

Figure 4.10: OpenMuL Latency

128

45

4.5.4 Open IRIS Controller

Open IRIS is an open source version of IRIS OpenFlow controller [14]. Java language is used for its development with a vision that led to create an SDN controller platform with high scalability to accommodate carrier-grade networks. Moreover, it can provide high availability via transparent failover solution. Some of its main features are the following:

It supports different OpenFlow versions from 1.0.1 to 1.3.2.

Open IRIS is an open source controller where it uses Apache-2.0 license for its licensing policy.

It includes three sample controller implementations that are fully functional.

IRIS supports a multi-domain and recursive network abstraction based on

OpenFlow.

Running and evaluating Open IRIS Controller

According to the Developer of IRIS recommendations [48] the git Linux command should be used for the downloading for the OpenIRIS files, since it allows easy navigating between different versions of OpenIRIS as in the command below: git clone https://github.com/bjlee72/IRIS.git

After successfully execution, there are three controller instances included in the

OpenIRIS packages, which are:

Benchmarking.jar ”the instance that should be enabled for Benchmarking”

BasicOFController.jar

SimpleOFController.jar.

Finally, before starting the controller, the configuration file named

‘torpedo.Properties’ need to be modified according to the use of the controller. Since we are looking for benchmarking, we will need to enable it as shown in the below configuration: By opening the file, you can see following codes.

$ cd IRIS

$ cd Torpedo

$ vi torpedo.properties watcher-num = 3 storage-ip = 12x.xxx.xxx.xxx storage-port = 27017 storage-default-db = mydb storage-password = etri.sdn.controller.app.simple.SimpleOFController.instance-num

= 6 etri.sdn.controller.app.simple.SimpleOFController.role =

MASTER etri.sdn.controller.app.simple.SimpleOFController.run = false etri.sdn.controller.app.simple.Benchmarking.instance-num = 6 etri.sdn.controller.app.simple.Benchmarking.role = MASTER etri.sdn.controller.app.simple.Benchmarking.run = true

46

etri.sdn.controller.app.basic.BasicOFController.instance-num =

6 etri.sdn.controller.app.basic.BasicOFController.role = MASTER etri.sdn.controller.app.basic.BasicOFController.run = false

After the modification for the Torpedo properties file, it is time to run the controller by the following command: taskset -c 0-3 java -jar Torpedo.jar

One of the main issues that we faced during the running of the OpenIRIS controller was the high CPU utilization, but after contacting the Developers of the controllers, the issue was solved by fixing a bug that was causing this issue and releasing a new bundle v2.0.10.

The throughput for the Open IRIS controller demonstrates that the connection of one switch resulted in a throughput of around 1.15 million flows/sec. while the connection of more switches led to a gradual increase, reaching a maximal value of 2.3 million flows/sec when 16 switches were connected. However, the addition of more switches led to a decrease in throughput to 1.35 million flow/sec with the connection of 128 switches, as summarized by Figure 4.11.

As for the latency results for OpenIRIS tests, high latency (13 µs) is showed as one

Switch is connected and then it went lower as more switches (8, 16, 32, 64 and 128) was connected reaching around 5 µs as shown in the Figure 4.12.

OpenIRIS Throughput

2500000

2000000

1500000

1000000

500000

0

1 8 16 32

Number of switches

64

Figure 4.11: OpenIRIS throughput

128

47

OpenIRIS Latency

14

12

10

8

6

4

2

0

1 8 16 32

Number of switches

64

Figure 4.12: OpenIRIS Latency

128

4.5.5 NOX Controller

NOX [5] is an open source software OpenFlow controller that was written in C++ programming language. In the beginning it was developed at Nicira Networks along with OpenFlow. NOX was the first OpenFlow controller, and it was donated to the research community in 2008. Some of the main features are: providing support for C++

OpenFlow 1.0 API, as well as fast asynchronous IO. Finally some of its components are topology discovery, learning switch as well network-wide switch.

Running and evaluating NOX Controller

In order to run NOX controller, the following dependencies will be required, the following steps will be needed to install these dependencies [49]: cd /etc/apt/sources.list.d/ sudo wget http://openflowswitch.org/downloads/debian/nox.list sudo apt-get update sudo apt-get install nox-dependencies sudo apt-get install libtbb-dev sudo apt-get install libboost-serialization-dev libboost-alldev

After installing the required dependencies we will need to change the directory, that

NOX Controller source should be placed in by running the following commands: git clone git://github.com/noxrepo/nox cd nox

./boot.sh mkdir build cd build

../configure

48

make make install

Finally to starts NOX following commands will be needed: cd src

./nox_core -v -i ptcp:9933 switch

The throughput results for the NOX controller represented by Figure 4.13 clearly show that the throughput with one connected switch was low (below 600,000 flows/sec) when compared to the other tested controllers. However the flow rate was increased as more switches were connected: reaching the maximum of 1.1 million flows/sec) when 64 switches were connected. Further addition of more connected switches led to degradation in throughput resulting in only 90,000 flows/sec when the NOX controller connects to 128 switches. In other words, NOX controller faces scalability issues as more switches were connected.

The result of latency testing for NOX controller showed high latency values (23 µs) when one switch was connected as shown in Figure 4.14 .On the other hand, the introduction of more switches (8, 16, 32, 64 and 128 respectively) led to an insignificant decrease in latency which reached as low as 8 µs.

NOX Throughput

1400000

1200000

1000000

800000

600000

400000

200000

0

1 8 16 32

Switches

Figure 4.13: NOX Throughput

64 128

49

NOX Latency

25

20

15

10

5

0

1 8 16

Switches

32

Figure 4.14: NOX Latency

64 128

4.5.6 Maestro Controller

Maestro was developed at Rice University [7] and it is represented as "operating system" for orchestrating network control applications. It tries to provide a platform for achieving automatic and programmatic network control functions using modularized applications. Maestro is designed in a way that requires as little effort from programmers as possible to manage the parallelization. Instead, Maestro handles most of the tedious and complicated job of managing workload distribution and worker threads scheduling. Since Maestro platform and the components were developed in Java so it can provide high portability to various operating systems and architectures. Furthermore, it provides high scalability, since its multi-threaded implantation takes full advantage of multi-core processors systems. Finally, Maestro is an open source software and is licensed under LGPL v2.1.

Running and evaluating Maestro Controller

As mentioned before Maestro is based on Java, so it will be required to have a Java environment running on the system by issuing the following command: sudo apt-get update sudo apt-get install openjdk-6-jdk

Since, Maestro relies on Apache Ant to manage compilation of the code; it will be needed to be installed before running Maestro. This can be installed by running the following commands: sudo apt-get update sudo apt-get install ant

We will need to download the file for Maestro by issuing the following command

50

git clone http://maestroplatform.googlecode.com/files/Maestro-0.1.0 cd Maestro-0.1.0 ant ant Javadoc ant clean

So far we have all dependencies and files to run Maestro and since we are interested in throughput testing, the learning-switch functionality will be used in the Maestro working directory by typing:

JAVA_HOME/bin/java -cp build/ sys.Main conf/openflow.conf conf/learningswitch.dag 1

The throughput results for Maestro controller showed that the highest throughput

(1,670,000 flows/sec) was achieved when one switch was connected as shown in

Figure 4.15. The throughput started to gradually decrease as more switches were connected reaching (1,250,000 flow/sec) with the connection of 128 switches.

The highest latency among all tested controllers was seen with Maestro as shown in

Figure 4.16. This figure clearly shows that connection of one switch resulted in high latency (above 63 µs). The latency values started to drop with the connection of more switches to reach a value around 13 µs when 8 and 16 switches were connected.

Finally, the same figure also showed that the connection of 32, 64 and 128 switches led to further decrease in latency.

MaestroThroughput

1800000

1600000

1400000

1200000

1000000

800000

600000

400000

200000

0

1 8 16 32

Switches

Figure 4.15: Maestro Throughput

64 128

51

Maestro Latency

70

60

50

40

30

20

10

0

1 8 16

Switches

32

Figure 4.16: Maestro Latency

64 128

52

Chapter 5

5 Conclusions and future work

In this thesis, performance evaluation for different OpenFlow controllers running learning switch application has been made as well as analysis for SDN (Software defined networks) technology and OpenFlow protocol. In the beginning of the thesis, background study on SDN has been made to explore this new technology especially in Datacenters where it can be used to achieve the network virtualization concept that is similar to server virtualization in current Datacenter deployments. Then a study of

OpenFlow protocol has been presented to explore the architecture of OpenFlow protocol and OpenFlow controllers.

As illustrated in Figure 5.1, we conclude from the results of OpenFlow controller’s evaluation, that OpenMul shows the highest throughput, achieving nearly 2.7 million flows per second. Lowest throughput was showed by Floodlight and NOX controllers with approximately throughput of 900,000 flows/sec, while NOX throughput decreases severely on 128 switches, indicating that NOX controller is not suitable for large scale networks. The Beacon controller which had the highest throughput according to many pervious work [50] [9] [8], is overcome as compared to the new releases of OpenMuL and OpenIRIS controllers.

Although all tested controllers have multi-thread support, yet they showed deference in throughput scalability behaviors. The difference in throughput behavior for the controllers can be caused by two factors: the first one is algorithm that a controller uses to distribute the incoming messages between threads, and the second one is the mechanisms and libraries used for the interaction between the network and the controller [8]

Maestro controller showed different behavior than the other controllers. It has better results with the small number of switches, because Maestro controller uses roundrobin algorithm to distribute incoming packets, while other controllers dedicate available threads to certain switch connections.

Latency “The average flow setup latency” for the tested controllers has been performed with different numbers of connected switches to see how these controllers' response time can be effected as more workload was added, see Figure 5.2. The tests showed that OpenIRIS controller have the lowest latency value with approximately 5

µs per flow. While Maestro controller showed the highest latency among other controllers and it decreases by the increasing in the number of switches, due to the distribution algorithm for that controller.

The latency results are considered to be higher in real implementation, where in our test the communications between the switches and the controller are done through the loopback interface, where there is no delay while packets traversing the virtual ports as compared to the hardware ports.

53

30

20

10

0

70

60

50

40

Toltal Throughput

3000000

2500000

2000000

1500000

1000000

500000

0

1 8 16 32

Number of Switches

64 128

Figure 5.1: Controllers throughput comparison

Total Latency

1 8 16 32

Number of switches

64 128

Figure 5.2: Controllers latency comparisons

Beacon

OpenIRIS

OpenMUL

Floodlight

NOX

Maestro

Beacon

OpenIRIS

OpenMUL

Floodlight

NOX

Maestro

5.1 Future work

By looking to the future, performing another benchmarking test for the state-of-theart OpenFlow controllers is also useful. Beside the evaluation that is implemented in this thesis, scalability and reliability are two factors that are important to be considered when choosing an OpenFlow controller. Scalability benchmarking can test the maximum number of concurrent OpenFlow connections supported by a controller, and reliability test can characterize the behavior of the controller when a malicious

OpenFlow messages tries to compromise the OpenFlow controller.

54

Bibliography

[1] A. Lara, A. Kolasani and B. Ramamurthy, "Network innovation using openflow:

A survey." IEEE Communications Surveys & Tutorials, vol. 16, no. 1, pp. 493–512,

2013.

[2] Open Networking Foundation (2014,May.20). "Open networking foundation

specifications". [Online]. Available at: https://www.opennetworking.org/sdnresources/onf-specifications.

[3] M. Casado, (2014, June . 25)' "List of OpenFlow Software Projects". [Online].

Available at: https://yuba.stanford.edu/~casado/of-sw.html.

[4] G. R. De Tejada Muntaner, "Evaluation of OpenFlow Controllers," M.S. thesis

KTH, 2012

[5] N. Gude, T. Koponen, J. Pettit, B. Pfaff, M. Casado, N. McKeown and S. Shenker,

"NOX: towards an operating system for networks." ACM SIGCOMM Computer

Communication Review, 38(3), 105-110, 2008.

[6] D. Erickson, (2013, February. 4) Standford university "Beacon open flow

controller" [Online]. Available at: https://openflow.stanford.edu/display/Beacon.

[7] Z. Cai, A.L. Cox and T. S. Eugene Ng. "Maestro: A system for scalable openflow

control". Technical Report 10-11, Rice University, Dec. 2010.

[8] A. Shalimov, D. Zuikov, D. Zimarina, V. Pashkov and R. Smeliansky," Advanced study of SDN/OpenFlow controllers". In Proceedings of the 9th ACM Central &

Eastern European Software Engineering Conference in Russia, pp. 1, Oct. 2013.

[9] D. Erickson, "The beacon openflow controller". In Proceedings of the second ACM

SIGCOMM workshop on Hot topics in software defined networking, pp. 13-18, Aug.

2013.

[10] P. Lappas ( 2013, Decemember .7) "Floodlight documentation",[Online]. Available at: http://floodlight.openflowhub.org.

[11] K. Wan, ( 2013, Decemember .7) University Oregon "Ryu OpenFlow controller"

[Online]. Available at: http://osrg.github.io/ryu.

[12] D. Saikia (2014, June. 16) "Mul documentation", [Online]. Available at: http://sourceforge.net/p/mul/wiki/MuL%20Controller%20Background.

[13] P. Ivashchenko, A. Shalimov and R. Smeliansky(2014) "High performance in-

kernel SDN/OpenFlow controller" [Online]. Available at : https://www.usenix.org/sites/default/files/ons2014-poster-ivashchenko.pdf.

[14] B. Lee, S. H. Park, J. Shin and S. Yang, "IRIS: The Openflow-based Recursive

SDN controller". In 2014 16th International Conference on Advanced

Communication Technology (ICACT), pp. 1227-1231, Feb. 2014.

[15] Open Networking Foundation, "Software-defined networking: The new norm for networks." ONF White Paper, Apr. 2012.

55

[16] Open Networking Foundation (2014,May. 25 )"Software-Defined Networking

(SDN) Definition " [Online]. Available at: https://www.opennetworking.org/sdn-resources/sdn-definition.

[17] M. Nispel (January, 2013). “A Different Take on Software Defined Networks”.

Extreme Networks [Online]. Available at: http://www.extremenetworks.com/a-different-take-on-software-definednetworks.

[18] Y. Hu, W. Wendong, X. Gong, X. Que and C. Shiduan "Reliability-aware controller placement for Software-Defined Networks". In 2013 IFIP/IEEE

International Symposium on Integrated Network Management (IM 2013), pp. 672-675,

May 2013.

[19] R. Wang, D. Butnariu and J. Rexford (2011). "OpenFlow-based server load balancing gone wild". In Proceeding of the USENIX Conference on Hot Topics in

Management of Internet, Cloud, and Enterprise Networks and Services (Hot-ICE),

Boston, MA, USA, Mar. 2011.

[20] F. Hu, Q. Hao, and K. Bao. "A Survey on Software Defined Networking (SDN) and OpenFlow: From Concept to Implementation." IEEE Communications Surveys

& Tutorials, no. 99, pp. 1-1, May 2014.

[21] M. Al-Fares, A. Loukissas and A. Vahdat, "A scalable, commodity data center network architecture". In ACM SIGCOMM Computer Communication Review, vol.

38, no. 4, pp. 63-74, Aug. 2008.

[22] R. N. Mysore, A. Pamboris, N. Farrington, N. Huang, P. Miri, S. Radhakrishnan, and A.Vahdat, "Portland: a scalable fault-tolerant layer 2 data center network fabric". In ACM SIGCOMM Computer Communication Review, Vol. 39, No. 4, pp.

39-50, Aug. 2009.

[23] C. E. Leiserson, "Fat-trees: universal networks for hardware-efficient supercomputing.” IEEE Transactions on Computers, Vol:C-34), pp. 892-901, Oct.

1985.

[24] M. F. Bari, R. Boutaba, R. Esteves, L. Z. Granville, M. Podlesny, M. G. Rabbani, and M. F. Zhani, "Data center network virtualization: A survey". IEEE

Communications Surveys & Tutorials, , vol. 15, no. 2, pp. 909-928, 2013.

[25] B. Davie, "Open Networking Summit," (2013). [Online]. Available: http://www.opennetsummit.org/pdf/2013/presentations/bruce_davie.pdf.

[26] B. D avie and J. Gross (May, 2012). "network-virtualization" [Online]. Available: http://networkheresy.com/2012/05/31/network-virtualization/.

[27] A. Shalimov and R. Smeliansky. "On Bringing Software Engineering to

Computer Networks with Software Defined Networking." in Proceedings of the

Spring/Summer Young Researchers’ Colloquium on Software Engineering, no. 7, 2013.

[28] S. H. Yeganeh, A. Tootoonchian and Y. Ganjali. "On scalability of softwaredefined networking." IEEE Communications Magazine, vol. 51, no. 2, pp. 136-141,

2013.

[29] R. Sherwood, G. Gibb, K.-K. Yap, G. Appenzeller, M. Casado, N. McKeown, and

G. Parulkar. "Flowvisor: A network virtualization layer." OpenFlow Switch

Consortium, Tech. Rep., 2009.

56

[30] A. Tootoonchian and Y. Ganjali, "HyperFlow: A distributed control plane for

OpenFlow". In Proceedings of the 2010 internet network management conference on

Research on enterprise networking, pp. 3-3, 2010.

[31] T. Koponen, M. Casado, N. Gude, J. Stribling, L. Poutievski, M. Zhu, and S.

Shenker, Onix:" A Distributed Control Platform for Large-scale Production

Networks", In OSDI, vol. 10, pp. 1-6, 2010.

[32] M. P. Fernandez, "Comparing openflow controller paradigms scalability:

Reactive and proactive". In Advanced Information Networking and Applications

(AINA), 2013 IEEE 27th International Conference on , pp. 1009-1016, Mar. 2013.

[33] G. Kontesidou and Z. Kyriakos, "Open flow Virtual Networking: A Flow-Based

Network VirtualizationArchitecture." Royal Institute of Technology(KTH), 2009.

[34] B. Heller, "Openflow switch specification, version 1.0. 0." Wire. December (2009).

[35] Open networking summit, (2012. April) "SDN Tutorial for Engineers," open networking summit" [Online]. Available: http://www.opennetsummit.org/archives/apr12/heller-mon-intro.pdf.

[36] W. Braun and M. Menth, "Software-Defined Networking Using OpenFlow:

Protocols, Applications and Architectural Design Choices. Future Internet", vol.

6, no. 2, pp. 302-336, 2014.

[37] B. Lantz, B. Heller and N. McKeown,” A network in a laptop: rapid prototyping for software-defined networks". In Proceedings of the 9th ACM SIGCOMM

Workshop on Hot Topics in Networks, pp. 19, Oct. 2010.

[38] H. Shimonishi, Y. Chiba, Y. Takamiya, and K. Sugyo, "Trema: An Open Source

OpenFlow Controller Platform". GEC-11 Poster, 2011.

[39] R. R. Krishnan, V. Bhupatiraju, OpenDaylight Project Proposal “Dynamic Flow

Management” [Online]. Available: https://wiki.opendaylight.org/images/4/42/OpenDaylight-lb-prj-propv3.pdf

[40] J. Mccauley, (2014, May)"Pox: A python-based openflow controller." [Online].

Available at: http://www.noxrepo.org.

[41] C. Monsanto, J. Reich, N. Foster, J. Rexford, and D. Walker, "Composing

Software Defined Networks". In NSDI, pp. 1-13, Apr. 2013.

[42] B. Lee, S. H. Park, J. Shin, and S. Yang, "IRIS: The Openflow-based Recursive

SDN controller". In 2014 16th International Conference on Advanced Communication

Technology (ICACT), pp. 1227-1231, Feb. 2014.

[43] Intel Processors "Intel® Core™ i7-3537U Processor (4M Cache, up to 3.10 GHz)"

[Online]. Available at: http://ark.intel.com/sv/products/72054/Intel-Core-i7-

3537U-Processor-4M-Cache-up-to-3_10-GHz

[44] R. Sherwood, and K. K. Yap, (2010). "Cbench: an open-flow controller benchmarker".

[Online]. Available at: http://archive.openflow.org/wk/index.php/Oflops.

[45] D. Erickson, (2013, Jan.)."Open Flow Benchmarking Guidelines" [Online] Available at :https://openflow.stanford.edu/display/Beacon/Benchmarking.

[46] R. Sherwood, Big Switch Networks (2014, Jul.18) " Big Switch " [Online]

Available at : http://www.bigswitch.com.

57

[47] Open MuL SDN Controller "HOWTO manual" [Online] Available at : http://sourceforge.net/projects/mul/.

[48] B. P. Lee, S. H. Shin, J., and S. Yang, (2014, Jul.16) "Open IRIS installation and

running guide" [Online] Available at : https://github.com/bjlee72/IRIS/wiki/Download-%28English%29.

[49] NOX Controller (2014, Jul.1)"Installing NOX controller" [Online] Available at: http://mytestbed.net/projects/openflow/wiki/Installing_a_NOX_controller,

[50] Open Networking Foundation (2014, Jun. 8) "OpenFlow Controller

Performance Comparisons "[Online] Available at: http://archive.openflow.org/wk/index.php/Controller_Performance_Compa risons.

[51] Mehra., R, (2012, Jan.). "Designing and Building a Datacenter Network: An

Alternative Approach with OpenFlow". Sponsored by: NEC Corporation. [Online]

Available at: http://www.nec.com/en/global/prod/pflow/images_documents/Designing

_and_Building_a_Datacenter_Network.pdf

[52] Open Networking Foundation, (2014, Jun. 8) "OpenFlow switch specifications".

[Online] Available at https://www.opennetworking.org/sdn-resources/onfspecifications/openflow.

58

Ahmed Sonba

IT Network Specialist interested mainly in networks ,

Telecommunications, SDN and Linux.

I am a guy that is always seeking new challenges. Obtained bachelor degree in Software Engineering from Rafidain

University College in Baghdad.

Hassan Abdalkreim

Computer engineer interested mainly in networks and

linux. I'm a guy with endless passion to life. Obtained bachelor degree in Computer

Engineering and Information

Technology from University of

Technology in Baghdad.

PO Box 823, SE-301 18 Halmstad

Phone: +35 46 16 71 00

E-mail: [email protected]

www.hh.se

Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement

Table of contents