Ieee communication surveys & tutorials, vol. 16, No. 4, Fourth quarter 2014

A. Language Abstractions

In SDN the control function consists of two parts, i.e., the

controller with the program and the set of rules implemented

on the routing/switching devices (Fig. 4). This has an impli-

cation of making the programmer not worry about the low-

level details in the switch hardware. The SDN programmers

can just write the specification that captures the intended for-

warding behavior of the network instead of writing programs

dealing with the low-level details such as the events and the

---

HU et al.: SURVEY ON SDN AND OPENFLOW: FROM CONCEPT TO IMPLEMENTATION

2187

forwarding rules of the network. This enables the interactions

between the controllers and switches. A compiler transforms

these specifications into code segments for both controllers

and switches. As an example, a SDN programming tool called

NetCore [69] allows descriptions of the network rules and

policies which cannot be implemented directly on the switches.

Another important fact about NetCore is that it has a clear

formal set of rules that provide a basis for reasoning about

program execution status.

Here, we introduce two important language abstractions in

SDN programming.

1) Network Query Abstractions: In SDNs each switch

stores counters for different forwarding rules. They are for

the counts of the total number of packets and data segments

processed using those rules. For traffic monitoring the con-

troller has the ability to check different counters associated with

different forwarding rules. This enables the programmers to

monitor the fine details of implementation on the switches. This

is a tedious job and makes the program complicated. Therefore,

an added level of abstraction will help the programmers. To sup-

port applications whose correct operation involves a monitoring

component, Frenetic [70] includes an embedded query lan-

guage that provides effective abstractions for reading network

state. This language is similar to SQL and includes segments

for selecting, filtering, splitting, merging and aggregating the

streams of packets. Another special feature of this language

is that it enables the queries to be composed with forwarding

policies. A compiler produces the control messages needed to

query and tabulate the counters on switches.

2) Consistent Update Abstractions: Since SDNs are event-

driven networks, the programs in SDNs need to update the data

forwarding policy from time to time because of the changes

in the network topology, failures in the communication links,

etc. An ideal solution is the automatic update of all the SDN

switches in one time; but in reality it is not easy to implement.

One good solution is to allow certain level of abstraction, and

then send these changes from one node to another. An example

is the per-packet consistency which ensures that each packet

just uses the same, latest policy (instead of a combination of

both the old and new policy). This preserves all features that

can be represented by individual packets and the paths they

take through the SDN. Those properties subsume important

structural invariants such as basic connectivity and free-of-loop,

and link access control policies. Per-flow consistency ensures

that a group of related packets are processed with the same flow

policy. Frenetic provides an ideal platform for exploring such

abstractions, as the compiler can be used to perform the tedious

bookkeeping for implementing network policy updates [70].