|
B. Methods to Enhance Controller’s Performance
We can make OpenFlow network more scalable by designing
a multi-level controller architecture. With carefully deployed
controllers, we can avoid throughput bottleneck in real net-
works. For example, in [81] authors have measured the flow
rate in a HP ProCurve (model # 5406zl) switch, which is
over 250 flows per second. In the meantime, in [82] authors
reported that for a data center with over 1000 servers, it could
face a flow arrival rate of 100 k flows/second, and in [83]
they reported a peak rate of 10 M flows per second for an
100-switch network. The above example shows that current
switches cannot handle the application flow rate demands.
Therefore, we need to invent an efficient protocol which can
minimize the switch-to-controller communications.
The data plane should be made simple. Currently OpenFlow
assigns routing tasks to the central controller for flow setup.
And the low-level switches have to communicate with the
controller very frequently in order to obtain the instructions on
how to handle incoming packets. This strategy can consume
the controller’s processing power and also congest switch-
controller links. Eventually they cause a serious bottleneck in
terms of the scalability of OpenFlow.
However, recent measurements of some deployment environ-
ments suggest that these numbers are far from sufficient. This
causes relatively poor controller performance and high network
demands to address perceived architectural inefficiencies. But
there has been no in-depth study on the performance of a
traditional SDN controller. Most results were gathered from
systems that were not optimized for throughput performance.
To underscore this point, researchers were able to improve the
performance of NOX, an open source controller for OpenFlow
networks, by more than 30 times in throughput [84].
In most SDN designs the central controller(s) can perform
all the programming tasks. This model certainly brings the
scalability issue to the control plane. A better control plane
should be able to make the packet handling rate scalable with
the number of CPUs. It is better to always have the network
status in packet level available to the controllers. Study from
Tootoonchian et al. [84] implements a Glasgow Haskell Com-
piler (GHC) based runtime system. It can allocate/deallocate
memory units, schedule different event handlers, and reduce
the interrupts or system calls in order to decrease the runtime
system load. They have showed the possibility of using a single
controller to communicate with 5000 switches, and achieving
the flow rate of up to 14 M per second! The switch-controller
communication delay is less than 10 ms in the worst case.
In [79] a partition/aggregate scheme is used to handle TCP
congestion issue.
C. Advanced Controller Design
Here, we introduce an advanced method for high-speed
control functions in control plane. In [140], a mechanism called
Control-Message Quenching (CMQ) is proposed to reduce the
flow setup delay and improve the SDN throughput among
switches/routers. There are huge number of flows that need to
be handled by the controllers. The inability of OpenFlow to pro-
cess so many flows’ policy management is due to the inefficient
design of control-data plane interfaces. Especially, there exist
frequent switch-controller communications: the switches have
to consult the controller frequently for instructions on how to
handle new incoming packets.
The basic idea of CMQ is to ask any switch to send only
one packet-in message during each RTT (round-trip-time), for
each source-destination pair, upon multiple flow table misses.
Thus we do not need to bother the controllers each time we
receive the packets with the same source/destination. Each
switch should maintain a dynamically updated table with all
learned, unique source-destination pairs. For each incoming
packet that cannot find its source-destination pair, i.e., table-
miss occurs, the switch will insert such a new pair into the table,
and query the controller. Such a pair table will be maintained
periodically in case the network topology changes, which can
detected by the control plane.
2190
IEEE COMMUNICATION SURVEYS & TUTORIALS, VOL. 16, NO. 4, FOURTH QUARTER 2014
A problem with existing SDN controller is that the SDN
flow tables typically cannot scale well when there are more
than 1000 entries [141]. This is mainly because the tables often
include wildcards, and thus need ternary content-addressable
memory (TCAM), as well as complex, slow data structures. In
[141] a scheme called Palette, can decompose a large SDN table
into small ones and distribute them to the whole SDN without
damaging the policy semantics. It can also reduce the table size
by sharing resources among different flows. The graph-theory
based on model is used to distribute the small tables to proper
switches.
There could exist multiple controllers in the SDN. In [142]
a load balancing strategy called BalanceFlow, is proposed to
achieve controller load balancing. Through cross-controller
communications, a controller is selected as super-controller,
which can tune the flow requests received by each controller
without introducing much delay. Note that each controller
should publish its load information periodically to allow super-
controller to partition the loads properly.
IV. N
ETWORK
V
IRTUALIZATION
Do'stlaringiz bilan baham: | 
