Performances of OpenFlow-Based Software- Defined Networks: An overview <s> B. Logically Centralized Control Plane <s> OpenFlow assumes a logically centralized controller, which ideally can be physically distributed. However, current deployments rely on a single controller which has major drawbacks including lack of scalability. We present HyperFlow, a distributed event-based control plane for OpenFlow. HyperFlow is logically centralized but physically distributed: it provides scalability while keeping the benefits of network control centralization. By passively synchronizing network-wide views of OpenFlow controllers, HyperFlow localizes decision making to individual controllers, thus minimizing the control plane response time to data plane requests. HyperFlow is resilient to network partitioning and component failures. It also enables interconnecting independently managed OpenFlow networks, an essential feature missing in current OpenFlow deployments. We have implemented HyperFlow as an application for NOX. Our implementation requires minimal changes to NOX, and allows reuse of existing NOX applications with minor modifications. Our preliminary evaluation shows that, assuming sufficient control bandwidth, to bound the window of inconsistency among controllers by a factor of the delay between the farthest controllers, the network changes must occur at a rate lower than 1000 events per second across the network. <s> BIB001 </s> Performances of OpenFlow-Based Software- Defined Networks: An overview <s> B. Logically Centralized Control Plane <s> Computer networks lack a general control paradigm, as traditional networks do not provide any network-wide management abstractions. As a result, each new function (such as routing) must provide its own state distribution, element discovery, and failure recovery mechanisms. We believe this lack of a common control platform has significantly hindered the development of flexible, reliable and feature-rich network control planes. ::: ::: To address this, we present Onix, a platform on top of which a network control plane can be implemented as a distributed system. Control planes written within Onix operate on a global view of the network, and use basic state distribution primitives provided by the platform. Thus Onix provides a general API for control plane implementations, while allowing them to make their own trade-offs among consistency, durability, and scalability. <s> BIB002 </s> Performances of OpenFlow-Based Software- Defined Networks: An overview <s> B. Logically Centralized Control Plane <s> Limiting the overhead of frequent events on the control plane is essential for realizing a scalable Software-Defined Network. One way of limiting this overhead is to process frequent events in the data plane. This requires modifying switches and comes at the cost of visibility in the control plane. Taking an alternative route, we propose Kandoo, a framework for preserving scalability without changing switches. Kandoo has two layers of controllers: (i) the bottom layer is a group of controllers with no interconnection, and no knowledge of the network-wide state, and (ii) the top layer is a logically centralized controller that maintains the network-wide state. Controllers at the bottom layer run only local control applications (i.e., applications that can function using the state of a single switch) near datapaths. These controllers handle most of the frequent events and effectively shield the top layer. Kandoo's design enables network operators to replicate local controllers on demand and relieve the load on the top layer, which is the only potential bottleneck in terms of scalability. Our evaluations show that a network controlled by Kandoo has an order of magnitude lower control channel consumption compared to normal OpenFlow networks. <s> BIB003
This kind of solutions is focused on improving the performance of SDN networks by sharing the charge between controllers. Each controller must synchronize all information about its portion of the network. We can benefit from these solutions in data centers where the controller instances share a huge amount of information to ensure fine-grained network wide consistency. The first attempt that suggests using a physically distributed control-plane is Hyperflow BIB001 . In this project, all controllers synchronize their network wide view using a distributed file system. To facilitate cross-controller communication, they employ the Publish/Subscriber messaging communication. As a result, Hyperflow can handle more flow events while keeping the flow setup latency minimal. With the same concept, Onix BIB002 provides a distributed system which runs on a cluster. It's responsible for control logic programmatic access to the network, moreover it distributes network state to other instances within the cluster, the Onix team designs four components in a network that is controlled by Onix, physical infrastructure (switch and router), connectivity infrastructure (control channel), Onix and Control logic. Similarly, KANDOO BIB003 introduces a hierarchical distribution controller based on two layers of controlplane, the bottom layer contains a group of local controllers that manage local applications with no knowledge of network wide state, and a centralized root controller builds the top layer, its role is to determine the desired network behavior and to run non-local applications. As a result they reduce the number of events that are received at the control plane of the network. All these solutions are physically distributed but logically centralized, they propose a different architecture and layer of a SDN network, though they offer a simplified central view of the network and decrease the look-up overhead by enabling communication with local controllers. However, there are not adapted to large networks with several Autonomous Systems (AS), and they require extensive traffic between controllers to keep a network-wide view.