\documentclass[11pt,twoside]{article}\makeatletter

\IfFileExists{xcolor.sty}%
  {\RequirePackage{xcolor}}%
  {\RequirePackage{color}}
\usepackage{colortbl}
\usepackage{wrapfig}
\usepackage{ifxetex}
\ifxetex
  \usepackage{fontspec}
  \usepackage{xunicode}
  \catcode`⃥=\active \def⃥{\textbackslash}
  \catcode`❴=\active \def❴{\{}
  \catcode`❵=\active \def❵{\}}
  \def\textJapanese{\fontspec{Noto Sans CJK JP}}
  \def\textChinese{\fontspec{Noto Sans CJK SC}}
  \def\textKorean{\fontspec{Noto Sans CJK KR}}
  \setmonofont{DejaVu Sans Mono}
  
\else
  \IfFileExists{utf8x.def}%
   {\usepackage[utf8x]{inputenc}
      \PrerenderUnicode{–}
    }%
   {\usepackage[utf8]{inputenc}}
  \usepackage[english]{babel}
  \usepackage[T1]{fontenc}
  \usepackage{float}
  \usepackage[]{ucs}
  \uc@dclc{8421}{default}{\textbackslash }
  \uc@dclc{10100}{default}{\{}
  \uc@dclc{10101}{default}{\}}
  \uc@dclc{8491}{default}{\AA{}}
  \uc@dclc{8239}{default}{\,}
  \uc@dclc{20154}{default}{ }
  \uc@dclc{10148}{default}{>}
  \def\textschwa{\rotatebox{-90}{e}}
  \def\textJapanese{}
  \def\textChinese{}
  \IfFileExists{tipa.sty}{\usepackage{tipa}}{}
\fi
\def\exampleFont{\ttfamily\small}
\DeclareTextSymbol{\textpi}{OML}{25}
\usepackage{relsize}
\RequirePackage{array}
\def\@testpach{\@chclass
 \ifnum \@lastchclass=6 \@ne \@chnum \@ne \else
  \ifnum \@lastchclass=7 5 \else
   \ifnum \@lastchclass=8 \tw@ \else
    \ifnum \@lastchclass=9 \thr@@
   \else \z@
   \ifnum \@lastchclass = 10 \else
   \edef\@nextchar{\expandafter\string\@nextchar}%
   \@chnum
   \if \@nextchar c\z@ \else
    \if \@nextchar l\@ne \else
     \if \@nextchar r\tw@ \else
   \z@ \@chclass
   \if\@nextchar |\@ne \else
    \if \@nextchar !6 \else
     \if \@nextchar @7 \else
      \if \@nextchar (8 \else
       \if \@nextchar )9 \else
  10
  \@chnum
  \if \@nextchar m\thr@@\else
   \if \@nextchar p4 \else
    \if \@nextchar b5 \else
   \z@ \@chclass \z@ \@preamerr \z@ \fi \fi \fi \fi
   \fi \fi  \fi  \fi  \fi  \fi  \fi \fi \fi \fi \fi \fi}
\gdef\arraybackslash{\let\\=\@arraycr}
\def\@textsubscript#1{{\m@th\ensuremath{_{\mbox{\fontsize\sf@size\z@#1}}}}}
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\def\abbr{}
\def\corr{}
\def\expan{}
\def\gap{}
\def\orig{}
\def\reg{}
\def\ref{}
\def\sic{}
\def\persName{}\def\name{}
\def\placeName{}
\def\orgName{}
\def\textcal#1{{\fontspec{Lucida Calligraphy}#1}}
\def\textgothic#1{{\fontspec{Lucida Blackletter}#1}}
\def\textlarge#1{{\large #1}}
\def\textoverbar#1{\ensuremath{\overline{#1}}}
\def\textquoted#1{‘#1’}
\def\textsmall#1{{\small #1}}
\def\textsubscript#1{\@textsubscript{\selectfont#1}}
\def\textxi{\ensuremath{\xi}}
\def\titlem{\itshape}
\newenvironment{biblfree}{}{\ifvmode\par\fi }
\newenvironment{bibl}{}{}
\newenvironment{byline}{\vskip6pt\itshape\fontsize{16pt}{18pt}\selectfont}{\par }
\newenvironment{citbibl}{}{\ifvmode\par\fi }
\newenvironment{docAuthor}{\ifvmode\vskip4pt\fontsize{16pt}{18pt}\selectfont\fi\itshape}{\ifvmode\par\fi }
\newenvironment{docDate}{}{\ifvmode\par\fi }
\newenvironment{docImprint}{\vskip 6pt}{\ifvmode\par\fi }
\newenvironment{docTitle}{\vskip6pt\bfseries\fontsize{22pt}{25pt}\selectfont}{\par }
\newenvironment{msHead}{\vskip 6pt}{\par}
\newenvironment{msItem}{\vskip 6pt}{\par}
\newenvironment{rubric}{}{}
\newenvironment{titlePart}{}{\par }

\newcolumntype{L}[1]{){\raggedright\arraybackslash}p{#1}}
\newcolumntype{C}[1]{){\centering\arraybackslash}p{#1}}
\newcolumntype{R}[1]{){\raggedleft\arraybackslash}p{#1}}
\newcolumntype{P}[1]{){\arraybackslash}p{#1}}
\newcolumntype{B}[1]{){\arraybackslash}b{#1}}
\newcolumntype{M}[1]{){\arraybackslash}m{#1}}
\definecolor{label}{gray}{0.75}
\def\unusedattribute#1{\sout{\textcolor{label}{#1}}}
\DeclareRobustCommand*{\xref}{\hyper@normalise\xref@}
\def\xref@#1#2{\hyper@linkurl{#2}{#1}}
\begingroup
\catcode`\_=\active
\gdef_#1{\ensuremath{\sb{\mathrm{#1}}}}
\endgroup
\mathcode`\_=\string"8000
\catcode`\_=12\relax

\usepackage[a4paper,twoside,lmargin=1in,rmargin=1in,tmargin=1in,bmargin=1in,marginparwidth=0.75in]{geometry}
\usepackage{framed}

\definecolor{shadecolor}{gray}{0.95}
\usepackage{longtable}
\usepackage[normalem]{ulem}
\usepackage{fancyvrb}
\usepackage{fancyhdr}
\usepackage{graphicx}
\usepackage{marginnote}

\renewcommand{\@cite}[1]{#1}


\renewcommand*{\marginfont}{\itshape\footnotesize}

\def\Gin@extensions{.pdf,.png,.jpg,.mps,.tif}

  \pagestyle{fancy}

\usepackage[pdftitle={Past before Future: A Comprehensive Review on Software Defined Networks Road Map},
 pdfauthor={}]{hyperref}
\hyperbaseurl{}

	 \paperwidth210mm
	 \paperheight297mm
              
\def\@pnumwidth{1.55em}
\def\@tocrmarg {2.55em}
\def\@dotsep{4.5}
\setcounter{tocdepth}{3}
\clubpenalty=8000
\emergencystretch 3em
\hbadness=4000
\hyphenpenalty=400
\pretolerance=750
\tolerance=2000
\vbadness=4000
\widowpenalty=10000

\renewcommand\section{\@startsection {section}{1}{\z@}%
     {-1.75ex \@plus -0.5ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large\bfseries}}
\renewcommand\subsection{\@startsection{subsection}{2}{\z@}%
     {-1.75ex\@plus -0.5ex \@minus- .2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large}}
\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}%
     {-1.5ex\@plus -0.35ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\large}}
\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}%
     {-1ex \@plus-0.35ex \@minus -0.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\normalsize}}
\renewcommand\subparagraph{\@startsection{subparagraph}{5}{\parindent}%
     {1.5ex \@plus1ex \@minus .2ex}%
     {-1em}%
     {\reset@font\normalsize\bfseries}}


\def\l@section#1#2{\addpenalty{\@secpenalty} \addvspace{1.0em plus 1pt}
 \@tempdima 1.5em \begingroup
 \parindent \z@ \rightskip \@pnumwidth 
 \parfillskip -\@pnumwidth 
 \bfseries \leavevmode #1\hfil \hbox to\@pnumwidth{\hss #2}\par
 \endgroup}
\def\l@subsection{\@dottedtocline{2}{1.5em}{2.3em}}
\def\l@subsubsection{\@dottedtocline{3}{3.8em}{3.2em}}
\def\l@paragraph{\@dottedtocline{4}{7.0em}{4.1em}}
\def\l@subparagraph{\@dottedtocline{5}{10em}{5em}}
\@ifundefined{c@section}{\newcounter{section}}{}
\@ifundefined{c@chapter}{\newcounter{chapter}}{}
\newif\if@mainmatter 
\@mainmattertrue
\def\chaptername{Chapter}
\def\frontmatter{%
  \pagenumbering{roman}
  \def\thechapter{\@roman\c@chapter}
  \def\theHchapter{\roman{chapter}}
  \def\thesection{\@roman\c@section}
  \def\theHsection{\roman{section}}
  \def\@chapapp{}%
}
\def\mainmatter{%
  \cleardoublepage
  \def\thechapter{\@arabic\c@chapter}
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \pagenumbering{arabic}
  \setcounter{secnumdepth}{6}
  \def\@chapapp{\chaptername}%
  \def\theHchapter{\arabic{chapter}}
  \def\thesection{\@arabic\c@section}
  \def\theHsection{\arabic{section}}
}
\def\backmatter{%
  \cleardoublepage
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \setcounter{secnumdepth}{2}
  \def\@chapapp{\appendixname}%
  \def\thechapter{\@Alph\c@chapter}
  \def\theHchapter{\Alph{chapter}}
  \appendix
}
\newenvironment{bibitemlist}[1]{%
   \list{\@biblabel{\@arabic\c@enumiv}}%
       {\settowidth\labelwidth{\@biblabel{#1}}%
        \leftmargin\labelwidth
        \advance\leftmargin\labelsep
        \@openbib@code
        \usecounter{enumiv}%
        \let\p@enumiv\@empty
        \renewcommand\theenumiv{\@arabic\c@enumiv}%
	}%
  \sloppy
  \clubpenalty4000
  \@clubpenalty \clubpenalty
  \widowpenalty4000%
  \sfcode`\.\@m}%
  {\def\@noitemerr
    {\@latex@warning{Empty `bibitemlist' environment}}%
    \endlist}

\def\tableofcontents{\section*{\contentsname}\@starttoc{toc}}
\parskip0pt
\parindent1em
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\newenvironment{reflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemsep}{0pt}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\itshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{sansreflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\itemsep}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\upshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{specHead}[2]%
 {\vspace{20pt}\hrule\vspace{10pt}%
  \phantomsection\label{#1}\markright{#2}%

  \pdfbookmark[2]{#2}{#1}%
  \hspace{-0.75in}{\bfseries\fontsize{16pt}{18pt}\selectfont#2}%
  }{}
      \def\TheFullDate{2019-01-15 (revised: 15 January 2019)}
\def\TheID{\makeatother }
\def\TheDate{2019-01-15}
\title{Past before Future: A Comprehensive Review on Software Defined Networks Road Map}
\author{}\makeatletter 
\makeatletter
\newcommand*{\cleartoleftpage}{%
  \clearpage
    \if@twoside
    \ifodd\c@page
      \hbox{}\newpage
      \if@twocolumn
        \hbox{}\newpage
      \fi
    \fi
  \fi
}
\makeatother
\makeatletter
\thispagestyle{empty}
\markright{\@title}\markboth{\@title}{\@author}
\renewcommand\small{\@setfontsize\small{9pt}{11pt}\abovedisplayskip 8.5\p@ plus3\p@ minus4\p@
\belowdisplayskip \abovedisplayskip
\abovedisplayshortskip \z@ plus2\p@
\belowdisplayshortskip 4\p@ plus2\p@ minus2\p@
\def\@listi{\leftmargin\leftmargini
               \topsep 2\p@ plus1\p@ minus1\p@
               \parsep 2\p@ plus\p@ minus\p@
               \itemsep 1pt}
}
\makeatother
\fvset{frame=single,numberblanklines=false,xleftmargin=5mm,xrightmargin=5mm}
\fancyhf{} 
\setlength{\headheight}{14pt}
\fancyhead[LE]{\bfseries\leftmark} 
\fancyhead[RO]{\bfseries\rightmark} 
\fancyfoot[RO]{}
\fancyfoot[CO]{\thepage}
\fancyfoot[LO]{\TheID}
\fancyfoot[LE]{}
\fancyfoot[CE]{\thepage}
\fancyfoot[RE]{\TheID}
\hypersetup{citebordercolor=0.75 0.75 0.75,linkbordercolor=0.75 0.75 0.75,urlbordercolor=0.75 0.75 0.75,bookmarksnumbered=true}
\fancypagestyle{plain}{\fancyhead{}\renewcommand{\headrulewidth}{0pt}}

\date{}
\usepackage{authblk}

\providecommand{\keywords}[1]
{
\footnotesize
  \textbf{\textit{Index terms---}} #1
}

\usepackage{graphicx,xcolor}
\definecolor{GJBlue}{HTML}{273B81}
\definecolor{GJLightBlue}{HTML}{0A9DD9}
\definecolor{GJMediumGrey}{HTML}{6D6E70}
\definecolor{GJLightGrey}{HTML}{929497} 

\renewenvironment{abstract}{%
   \setlength{\parindent}{0pt}\raggedright
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
   \textcolor{GJBlue}{\large\bfseries\abstractname\space}
}{%   
   \vskip8pt
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
}

\usepackage[absolute,overlay]{textpos}

\makeatother 
      \usepackage{lineno}
      \linenumbers
      
\begin{document}

             \author[1]{Windhya  Rankothge}

\renewcommand\Authands{ and }

\date{\small \em Received: 8 December 2018 Accepted: 31 December 2018 Published: 15 January 2019}

\maketitle


\begin{abstract}
        


Software Defined Networking (SDN) is a paradigm that moves out the network switch?s control plane (routing protocols) from the switch and leaves only the data plane (user traffic) inside the switch. Since the control plane has been decoupled from hardware and given to a logically centralized software application called a controller; network devices become simple packet forwarding devices that can be programmed via open interfaces. The SDN?s concepts: decoupled control logic and programmable networks provide a range of benefits for management process and has gained significant attention from both academia and industry. Since the SDN field is growing very fast, it is an active research area. This review paper discusses the state of art in SDN, with a historic perspective of the field by describing the SDN paradigm, architecture and deployments in detail.

\end{abstract}


\keywords{software defined network (SDN), review.}

\begin{textblock*}{18cm}(1cm,1cm) % {block width} (coords) 
\textcolor{GJBlue}{\LARGE Global Journals \LaTeX\ JournalKaleidoscope\texttrademark}
\end{textblock*}

\begin{textblock*}{18cm}(1.4cm,1.5cm) % {block width} (coords) 
\textcolor{GJBlue}{\footnotesize \\ Artificial Intelligence formulated this projection for compatibility purposes from the original article published at Global Journals. However, this technology is currently in beta. \emph{Therefore, kindly ignore odd layouts, missed formulae, text, tables, or figures.}}
\end{textblock*}


\let\tabcellsep& 	 	 		 
\section[{Introduction}]{Introduction}\par
hree components of the network architecture are control plane, data plane, and management plane \hyperref[b0]{[1]}. The control plane carries control traffic (routing protocols) and is responsible for maintaining the routing tables. The management plane carries administrative traffic and is considered a subset of the control plane. The data plane bears the user traffic that the network exists to carry. It forwards the user traffic based upon information learned by the control plane. In a conventional network, all these three planes are implemented in the firmware of routers and switches.\par
Software Defined Networking (SDN) is a new paradigm that moves out the network switch's control plane from the switch and leaves only data plane inside the switch \hyperref[b1]{[2]}. Since the control plane is decoupled from hardware and given to a logically centralized software application called a controller, network devices become simple packet forwarding devices that can be programmed via open interfaces. The SDN's concepts: decoupled control logic and programmable networks provide a range of benefits for the network management process. They include centralized control, simplified algorithms, commoditizing network hardware, eliminating middle-boxes and enabling the design and deployment of third-party applications.\par
The promise of SDN has gained significant attention from both academia and industry. The Open Network Foundation (ONF) is an industrial driven organization, founded in the year 2011 by a group of network operators, service providers, and vendors to promote SDN and standardize the OpenFlow protocol  {\ref [3]}. Deutsche Telekom, Facebook, Google, Microsoft, Verizon and Yahoo are among the founders. Currently, ONF has around 95 members including several major vendors. The OpenFlow Network Research Center (ONRC) was created by the academia with a focus on SDN research  {\ref [4]}. Since the SDN field is growing very fast, it is a very active research area. This review paper discusses the state of art in SDN, with a historic perspective of the field by describing the SDN paradigm, architecture and deployments in detail. 
\section[{II.}]{II.} 
\section[{SDN History}]{SDN History}\par
The idea of programmable networks and decoupled control logic has a story of years. The history of SDN goes back to 1980s \hyperref[b3]{[5]}. This section provides an overview of four technologies which helped SDN to evolve. 
\section[{a) Central network control}]{a) Central network control}\par
In earlier days telephone networks were using in-band signaling where the data (voice) and the control signals are sent over the same channel. The resulting networks were always complex and insecure. In 1980s, AT\&T separated data and control planes of their telephone network and introduced the concept of "Network Control Point" (NCP) \hyperref[b5]{[6]}. The idea was to separate voice and control, and the control resided on NCP. NCP allowed operators to have a central networkwide vantage point and directly observe the networkwide behavior. Elimination of in-band signaling lead to independent evolution of infrastructure, data, and services where new services were able to be introduced to customers easily. So NCP was the origin of the SDN's concept: separating control and data plane, and to have centralized control over the network \hyperref[b3]{[5]}. 
\section[{b) Programmability in networks}]{b) Programmability in networks}\par
In the mid-1990s, DARPA research community introduced "Active Networks" with the idea of a network infrastructure that would be programmable for customized services \hyperref[b6]{[7]}. There were two main approaches: user programmable switches, with in-band data transfer and out-of-band management channels and capsules, which were program fragments that carried in user messages. Program fragments would be interpreted and executed by routers \hyperref[b7]{[8]}. A Cambridge project in the year 1998, Tempset developed programmable, virtualizable switches called switchlets \hyperref[b8]{[9]}. Switchware project of Penn, introduced a programmable switch and a scripting language to support switchlets \hyperref[b9]{[10]}. Smart Packets, research by BBN was focused on applying the active networks framework to network management process \hyperref[b10]{[11]}. The Open Signaling project of Columbia, introduced NetScript, a language to provide programmable processing of packet streams \hyperref[b11]{[12]}  \hyperref[b12]{[13]}. Pro-grammable switches accelerated the innovation of middle-boxes (firewalls and proxies) which are programmed to perform specific functions. Providing programming functions in networks and compose these functions together were the legacy of active networks for SDN \hyperref[b3]{[5]}. 
\section[{c) Network virtualization}]{c) Network virtualization}\par
Network virtualization is the representation of one or more logical network topologies on top of the same infrastructure. It separates the logical infrastructure from underlying physical infrastructure. There are many different instantiations such as Virtual LANs (VLANs), network testbeds and VMWare. In the Switchlets, the control framework has been separated from the switch and allowed virtualization of the switch \hyperref[b8]{[9]}. In the year 2006, VINI provided a Virtual Network Infrastructure to support different experiments on virtual topologies using a single infrastructure \hyperref[b13]{[14]}. VINI used the concept of separating control and data planes, and its control plane was a software routing protocol called XORP, which allowed to run routing protocols on virtual network topologies. VINI's data plane "Click" provided the appearance of the virtual network topologies to experimenters. In the year 2007, CABO, a network infrastructure, separated the infrastructure and services to allow service providers to operate independently \hyperref[b14]{[15]}. The concepts of separating services from infrastructure, using multiple con-trollers to control a single switch and exposing multiple logical switches on top of a single physical switch were the legacy of network virtualization for SDN \hyperref[b3]{[5]}. 
\section[{d) Control of packet switched networks}]{d) Control of packet switched networks}\par
With the above evolution of network technologies, the separation of control was needed for rapid innovation of networks. Since the control logic is tied to hardware, it was easier to modify the existing control logics of the telephone network. Having a separate control channel made it possible to have a separate software controller and could easily introduce new services to the telephone network. Software controllers also allowed operators to have a centralized network-wide vantage point and directly observe the network-wide behavior of the telephone network. With these motivations, packet switched networks also tried to separate the control plane from the data plane. There are four main ways that packet switched networks achieved separation of control: separate control channel, in-band protocols, customizing the hardware in the data plane and open Hardware \hyperref[b3]{[5]}.\par
The first approach of a separate control channel for packet switched network came from the Internet Engineering Task Force (IETF) with the protocol "FORCES" in the year 2003 \hyperref[b15]{[16]}. The FORCES redefined the network device's internal architecture by separating the control element (CE) from the forwarding elements (FE). The CE executes control and signaling functions and uses the ForCES protocol to instruct FEs on how to forward packets. The FEs forwards packets according to the instructions given by the CE. Each FE has a Logical Function Block in its data plane which enables the CE to control the FEs' configuration and used to process packets. The communication between FEs and CE are achieved by the FORCES protocol. The protocol works based on a master-slave model; FEs are slaves and CE is the master. Even though the FORCES architecture separated the control plane from the data plane, both the planes were kept in the same network device and was represented as a single entity. However, the FORCES required standardization, adoption and deployment of new hardware.\par
The second approach was to use existing protocols as control channels to send control messages to FEs, and it was called in-band protocols. With the Routing Control Platform (RCP) in the year 2004, each autonomous system in the network had a controller in the form of an RCP \hyperref[b16]{[17]}. An RCP computed the routes on behalf of routers and, it used existing routing protocols to communicate routes to routers. The limitation with this approach was, the control process was constrained by what the existing protocols can support.\par
Customizing the hardware in the data plane, supported a wide range of applications in the control plane. In the year 2007, Ethane presented a network architecture for enterprise networks, which used a centralized controller to manage policies and security in a network \hyperref[b17]{[18]}. Ethane directly enforced a single, network policy at an element called "Domain Controller." A Domain controller computes the flow table entries that should be installed in each of the enterprise switches based on access control policies defined at the Domain Controller. OpenWrt, NetFPGA, and Linux built custom switches to sup-port the Ethane protocol. However, they required new hardware deployments that support Ethane protocol.\par
The solution was the last approach, to use a method that can operate on existing routing protocols, and did not require customized hardware \hyperref[b18]{[19]}. It is called open hardware and in the year 2008, the OpenFlow project started with this concept \hyperref[b19]{[20]}  \hyperref[b20]{[21]}. OpenFlow took the capabilities of existing hardware and opened those capabilities, such that standard control protocols could control the behavior of that hardware. 
\section[{e) OpenFlow}]{e) OpenFlow}\par
The OpenFlow network has been deployed in academic campus networks initially \hyperref[b19]{[20]}  \hyperref[b20]{[21]} and today more than nine universities in the US have deployed OpenFlow networks  {\ref [22]}. OpenFlow has gained significant attention from both academia and industry as a strategy to increase the functionality of the network, but at the same time reducing costs and hardware complexity. The OpenFlow architecture consists of three modules: a Flow Table in each switch, a Secure Channel that connects the switch to a remote control process (called the controller) and the OpenFlow Protocol \hyperref[b19]{[20]} [21] as shown in Figure \hyperref[fig_0]{1}.\par
The forwarding device (OpenFlow enabled switch/router) has one or more flow tables. A flow table consists of flow entries, each of which determines how packets belonging to a flow will be processed and forwarded. Flow entries are stored according to their priorities. A flow table entry consists of three main fields [23] and shown in Figure \hyperref[fig_1]{2}.\par
? Match fields (information found in the packet header): used to match incoming packets ? Counters: used to collect statistics for the particular flow (number of received packets, number of bytes and duration of the flow) A set of instructions, or actions, to be applied upon a match; they dictate how to handle matching packets. The actions include dropping the packet, continuing the matching process on the next flow table, or for-ward the packet to the controller over the OpenFlow channel.   An OpenFlow enabled switch/router has the capability of forwarding packets according to the rules defined in the flow table. Figure \hyperref[fig_3]{3} shows a high-level description of how an OpenFlow enabled switch/router processes a packet. Internally, a switch uses Ternary Content Addressable Memory (TCAM) and Random Access Memory (RAM) to process each packet \hyperref[b21]{[24]}. When a packet arrives at the OpenFlow enabled switch/router, packet header fields are extracted and matched against the matching fields of the first flow table entries. If a matching entry is found, the switch applies the appropriate set of instructions associated with the matched flow entry. If a matching entry is not found, depends on the instructions defined by the tablemiss flow entry, the switch will take action. To handle table misses, every flow table must contain a table-miss entry which specifies a set of actions to be performed when no match is found for an incoming packet  {\ref [23]}. Figure \hyperref[fig_4]{4} shows a low-level description of how an OpenFlow switch processes a packet.   The metadata field acts as a register which can be used to pass information between the tables as the packet traverses through them. The Multi-Protocol Label Switching (MPLS) fields are included to support MPLS tagging. Since there are multiple flow tables available in the switch, the processing of a packet entering the switch is changed. The flow tables in the switch are linked together using a process called "pipeline processing." When the packet first enters the switch, it is sent to the first flow table to look for the flow entry to be matched. If there is a match, the packet gets processed there. If there is another flow table that the particular flow entry points to, the packet is then sent to that flow table. The process is repeated until a particular flow entry does not point to any other flow table. The flow entries in the flow tables can also point to the group table. The group table is specially designed to perform operations that are common across multiple flows. The OpenFlow 1.1.0 also replaced actions with instructions. In OpenFlow 1.0.0 an action could be to forward the packet or to drop it, as well as processing it normally as it would be in a regular switch. Instructions are more complex and they include modifying a packet, updating an action set or updating the metadata.\par
The OpenFlow 1.2.0 specification was released in De-cember 2011 and it included support to IPv6 addressing. Matching could be done using the IPv6 source and destination addresses. With OpenFlow 1.2.0 specifications, a switch could be connected to multiple controllers concurrently. The switch maintains connections with all the controllers. Controllers can communicate with each other. Having multiple controllers facilitated load balancing and faster recovery during a failure. The OpenFlow 1.3.0 specification was released in June 2012. It included features to (1) control the rate of packets through per flow meters, (2) have auxiliary connections between the switch and the controller and (3) add cookies to the packets sent from the switch to the controller. Table \hyperref[tab_0]{I} shows a summarization of OpenFlow specifications.  
\section[{SDN Architecture}]{SDN Architecture}\par
In SDN, the control plane is decoupled from the hard-ware data plane and given to a software application called a controller. The controller is the core of an SDN network and it lies between network devices and applications  {\ref [25] [26]}. This section gives a brief introduction to the SDN architecture. SDN architecture is shown in figure 6 and it includes: SDN Controllers, Southbound Interfaces, and Northbound Interfaces \hyperref[b22]{[25]}.  point to the network (network operating system) \hyperref[b24]{[27]}. While a computer operating system provides read and write access to various resources, a network operating system provides the ability to observe and control a network. The network operating system which is referred to as the controller here after, does not manage the network, but it provides a programmatic interface which can be used to implement applications to perform the actual management tasks. SDN controllers presents two possible behaviors: reactive and proactive \hyperref[b25]{[28]}.\par
When the controller behaves reactively, it listens to switches passively and configures routes on-demand. The first packet of each new flow, received by a switch (flow request) triggers the controller to insert flow entries in each switch of the network \hyperref[b25]{[28]}. Every new flow introduces a small delay because of the additional setup time. Also with the hard dependency of the controller, if a switch losses the connection to the controller, the switch will not be able to forward packets of new flows. When the controller behaves pro-actively, it prepopulates a flow table for each switch. So it has zero additional flow set-up time because the forwarding rules are already defined \hyperref[b25]{[28]}. With this approach, if the switch loss the connection with the controller, it will not disrupt traffic. However, the proactive approach requires the controller to know the traffic flows in advanced to configure the paths before it is used. Current controllers are implemented to facilitates both approaches. The Controller behaves reactively in the initial state of the network and, after getting to know the network it starts to behave pro-actively. 
\section[{b) Southbound Interfaces}]{b) Southbound Interfaces}\par
The southbound interfaces allow switches to communicate with the controller. The OpenFlow protocol is the most popular implementation of the southbound interface. OpenFlow 1.3.0 and above provide optional support for encrypted Transport Layer Security (TLS) communication and a certificate exchange between the switches and the controller for secure communication  {\ref [23]}. The OpenFlow protocol consists of three types of messages. 2) Asynchronous messages: Sent by the switch: The Packet-in messages are used to inform the controller about a packet that does not match an existing flow. The Flow Removed messages are used to inform the controller that a flow has been removed because of its time to live parameter or inactivity timer has expired. Finally, the Port status messages are used to inform the controller of a change in port status or that an error has occurred on the switch. 3) Symmetric messages: Sent by both the switch or the con-troller: The Hello messages exchanged between the controller and switch on startup, and the Echo messages are used to determine the latency of the controller-to-switch connection and to verify that the controller-to-switch connection is still operative. The Error messages are used to notify the other side of the connection of problems. Finally, the Experimenter messages are used to provide a path for future extensions to OpenFlow technology.\par
The Border Gateway Protocol (BGP), a wellknown core Internet routing protocol is used by Juniper Network's in their SDNs \hyperref[b26]{[29]}. The controller uses BGP as a control plane protocol and leverage NETCONF (an IETF network management protocol) as a management plane protocol to interact with physical routers, switches and networking services like firewalls. This approach enables SDN to exist in a multi vendor environment without requiring infrastructure upgrades. OpenFlow does not address the issue of the controller interoperability and requires physical changes to the network, so Juniper is introducing BGP to be the standard of the SDN. Extensible Messaging and Presence Protocol (XMPP) which was originally developed for instant messaging and online presence detection is also emerging as an alternative SDN protocol  {\ref [30]}. XMPP can be used by the controller to distribute control plane information to the server endpoints because XMPP manages information at all levels of abstraction down to the flow, not only to network devices. 
\section[{c) Northbound APIs}]{c) Northbound APIs}\par
The southbound interfaces allowed controllerswitches communication and provided basic operations to access the network system. But they could not retrieve complex information from the switches and therefore programming the network to perform high-level tasks (load balancing, implementing security policies) was difficult. Also, it was difficult to perform multiple independent tasks (routing, access control) concurrently using the south bound interfaces. So the northbound interface, a programming interface that allows applications to program the network with higher level abstraction \hyperref[b22]{[25]} [26] was introduced. Developers can use the northbound interface to extract information about the underlying network and to implement complex applications such as path computation, loop avoidance, routing, and security. Additionally, northbound interface can be used by controllers to communicate with each other to share resources and synchronize policies. The North-bound interface offers vendor in-dependability and ability to modify or customize control through popular programming languages. Unlike southbound interfaces, there is no currently accepted standard for northbound interfaces and they are more likely to be implemented depending on the application requirements.\par
IV. 
\section[{SDN Development Tools and Frameworks}]{SDN Development Tools and Frameworks}\par
The concept of decoupling control plane from the data plane allows SDN to facilitate network evolution and innovation by introducing new services and protocols easily. This section gives an overview of currently available tools and environments for developing services and protocols with SDN. 
\section[{a) SDN controller platforms}]{a) SDN controller platforms}\par
Many controller implementations are available for SDNs and a suitable controller can be selected by considering the programming language and performances of the controller \hyperref[b27]{[31]}  \hyperref[b28]{[32]} [33]. The popular controller platforms include ovs [23], NOX \hyperref[b24]{[27]},\par
POX \hyperref[b29]{[34]}, Beacon \hyperref[b27]{[31]}, Maestro \hyperref[b30]{[35]}, Trema [36] Ryu [37] and Floodlight  {\ref [38]}. Table \hyperref[tab_2]{II} shows a comparison of the SDN controller platforms according to their general details and Figure 7 (taken from \hyperref[b27]{[31]}) shows a comparison of the performances of SDN controller platforms.\par
The current standard for evaluating SDN controller performance is Cbench. The Cbench simulates OpenFlow switches and operates in either throughput or latency mode. In through-put mode, each of 64 emulated switches constantly sends as many Packet In messages as possible to the controller, ensuring that the controller always has messages to process. Evaluation tests have been run on Amazon's Elastic Computer Cloud using a Cluster Compute Eight Extra Large instance, containing 16 physical cores from 2 x Intel Xeon E5-2670 processors, 60.5GB of RAM, using a 64-bit Ubuntu 11.10 VM image. Figure 7 shows Cbench throughput mode results using controllers with a single thread. Beacon shows the highest throughput at 1.35 million responses per second, followed by NOX with 828,000, Maestro with 420,000, Beacon Queue with 206,000, Floodlight with 135,000, and Beacon Immediate with 118,000. Both Python-based controllers run significantly slower, POX serving 35,000 responses per second and Ryu with 20,000.  b) SDN software switch platforms With SDN, the switch architecture has become very simple, because it is left only with the data plane. It has reduced functions of switches and introduced concepts of software switch implementation and switch virtualization. The result was rapid innovations in software switch platforms. The software switch platforms can be used to replace the firmware of physical switches that do not support SDN. The popular software switch platforms include Open vSwitch [23], Pantou/OpenWRT [39] and ofsoftswitch13 \hyperref[b31]{[40]}. Table \hyperref[tab_3]{III} shows a comparison of the SDN software switch platforms. 
\section[{c) Native SDN switches}]{c) Native SDN switches}\par
As explained at the beginning of the paper, the promise of SDN has gained significant attention from many network de-vices vendors. One clear evidence of industry strong commitment to SDN is the availability of OpenFlow enabled commodity network hardware. Hewlett-Packard, Brocade, IBM, NEC, Pronto, Juniper, and Pica8 have introduced many OpenFlow enabled switch models. Table \hyperref[tab_4]{IV} shows a partial list of native SDN switches. 
\section[{d) SDN languages}]{d) SDN languages}\par
SDN programming languages are used for higher level abstraction of programming for network management. They consist of high-level abstractions for querying network state, defining forwarding policies and updating policies in a consistent way \hyperref[b32]{[41]}. SDN languages is an area of very active research and several languages have been proposed and are still under development. Table \hyperref[tab_5]{V} shows a classification of different SDN languages.\par
The FatTire \hyperref[b33]{[42]} allows programmers to declaratively specify sets of legal paths through the network and fault tolerance requirements for those paths. The FatTire compiler takes programs specified regarding paths and translates them to OpenFlow switch configurations. Since the backup paths are configured with those programs, responding to link failures can be done automatically without controller intervention.\par
The Nettle \hyperref[b34]{[43]} was originally designed for programming OpenFlow networks. Using the discrete nature of Functional Reactive Programming, Nettle can capture control messages to and from OpenFlow switches as streams of Nettle events. The Nettle model messages from switches with a data type SwitchMessage and commands to switches with a data type SwitchCommand. A Nettle program is a signal function (SF) having an input carrying switch messages from all switches in the network and output carrying switch commands to any switches in the network, SF (Event SwitchMessage) (Event SwitchCommand).\par
The Flow-based Management Language (FML) \hyperref[b35]{[44]} comes with high-level built-in policy operators that allow or deny certain flows flowing through a firewall or provide quality of service. If network forwarding policy falls into the space of policies that can be described by an FML program, the code for implementing the policy is easy. But adding new policy operators to the system requires coding outside the FML language. Moreover, a resulting policy decision applies equally to all packets within the same flow and it is not possible to move or redirect a flow as it is processed. So, even though FML provides network operators with a very useful set of SDN abstractions, the programming model, is inflexible.\par
The Procera \hyperref[b36]{[45]} is an extension to Nettle, which has been designed to incorporate events that originated from sources other than OpenFlow switches. It supports policies that react to conditions such as user authentications, time of day, bandwidth use and server load. Procera is expressive and extensible, so users can easily extend the language by adding new constructs. The input to the main Procera signal function is a world signal whose instantaneous values have the abstract World type. The output of a Procera program is a signal carrying flow constraint functions. A flow constraint function determines the constraints that are applied to a flow: allow or deny. The Frenetic language is embedded in Python and comprises two integrated sub-languages: a declarative network query language and a network policy management library. The results of such queries may be used for security monitoring and for decisions about the forwarding policy.\par
The Flog \hyperref[b37]{[46]} combines features of both FML and in Frenetic. From FML, Flog uses logic programming as the central paradigm for controlling SDNs. Logic programming fits the SDN domain because SDN programming is table driven collection and processing of network statistics. From Frenetic, Flog uses the concept that controller programs may be factored into three key components: a mechanism for querying network state, a mechanism for processing data learned from queries and a component for generating packet forwarding policies. Flog is designed as an event-driven and forward chaining logic programming language. Each time a networking event occurs, the logic program executes. It can have two effects: generates a packet forwarding policy that is compiled and deployed on switches and generates a state that is used to help the logic program to be executed when the next network event is processed.\par
The Pyretic system \hyperref[b38]{[47]} enables programmers to specify network policies, compose them together and execute them on abstract network topologies. The Pyretic's static policy lan-network), and policy combinators, which are used to mix primitive actions, predicates, and queries together to craft so-phisticated policies from simple components. The policies can be composed together in two ways: parallel and sequential. In parallel composition, multiple policies operate concurrently on separate copies of the same packets. In sequential composition, one module operates on the packets produced by another. 
\section[{e) SDN debugging tools}]{e) SDN debugging tools}\par
The emergence of SDN enables adding new network functionalities easily, at the risk of programming errors. Even though the centralized programming model has reduced the likelihood of bugs, the ultimate success of SDN depends on having effective ways to test applications in pursuit of avoiding bugs. There are many SDN debugging tools have been developed and they can be divided into four categories based on the layers they are working with. Table \hyperref[tab_5]{VI} shows a classification of different debugging tools according to the layers they are working with.\par
The NICE \hyperref[b39]{[48]} is an automated testing tool that can be used to identify bugs in OpenFlow programs though model checking and symbolic execution. It automatically generates streams of packets under possible events and tests unmodified controller programs. The programmer must supply the controller program and the specification of a topology with switches and hosts, to use with NICE. NICE can be instructed by the programmer to check for generic correctness properties (no forwarding loops or no black holes), and optionally application-specific correctness properties. NICE is developed to explores the space of possible system behaviors systematically and checks them against the desired correctness properties. As the output, NICE reports property violations with the traces to deterministically reproduce them.\par
Anteater \hyperref[b40]{[49]} is the first design and implementation of a data plane analysis system which can be used to find bugs in real networks. The system detects problems by analysing the contents of forwarding tables in routers, switches, firewalls and other networking equipment.  {\ref It}  The ndb \hyperref[b41]{[50]} is a prototype network debugger inspired by gdb (a popular debugger for software programs). It implements two primitives useful for debugging a SDN control plane: breakpoints and packet back-traces. A packet back-trace in ndb allows the user to define a packet breakpoint (an un-forwarded packet or a packet filter). Then it shows the sequence of for-warding actions seen by that packet leading to the breakpoint.\par
OFRewind \hyperref[b42]{[51]} allows SDN control plane traffic to be recorded at different granularities. Later they can be replayed to reproduce a specific scenario, giving the opportunity to localize and troubleshoot the events that caused the network anomaly. It records flow table state via a proxy and logs packet traces and aids debugging via scenario re-creation. The VeriFlow \hyperref[b43]{[52]} is a SDN debugging tool which finds faulty rules issued by SDN applications and prevents them from reaching the network and causing anomalous network behavior.\par
VeriFlow operates as a layer between the controller and the devices, and checks the validity of invariants as each rule is inserted. To ensure a real-time response, VeriFlow introduces new algorithms to search for potential violation of key network invariants: availability of a path to the destination, absence of routing loops, access control policies or isolation between virtual networks.\par
Other than the SDN debugging tools which were described earlier, there are two SDN troubleshooting simulators: STS (SDN Troubleshooting Simulator) \hyperref[b44]{[53]} and OpenSketch \hyperref[b45]{[54]}. STS \hyperref[b44]{[53]} is a SDN troubleshooting simulator which is written in python and depends on POX controller \hyperref[b29]{[34]}. It simulates the devices of the network to allow operators to easily generate test cases, examine the state of the network interactively and find the exact inputs that are responsible for triggering a given ment architecture, which separates the measurement data plane from the control plane. In the data plane, OpenSketch provides a simple three-stage pipeline (hashing, filtering, and counting). They can be implemented with commodity switch components and support many measurement tasks. In the control plane, OpenSketch provides a measurement library that automatically configures the pipeline and allocates resources for different measurement tasks. 
\section[{f) SDN emulation and simulation tools}]{f) SDN emulation and simulation tools}\par
The Mininet \hyperref[b46]{[55]}, the Emulab and the ns-3 [56] are popular emulation and simulation Tools used with SDN. Mininet \hyperref[b46]{[55]} is an emulation environment which creates a complete network of hosts, links, and switches on a single machine. It creates virtual networks using process-based virtualization and network namespaces (features available in Linux kernels). In Mininet, hosts are emulated as bash processes running in a network namespace. So any code that would run on a Linux server can be run within a Mininet "Host". The Mininet "Host" has its private network interface and can only see its own processes. Switches in Mininet are software- The Emulab \hyperref[b48]{[57]} is a network emulation testbed which includes a network facility and a software system. Emulab is widely used by computer science researchers in the fields of networking and distributed systems and it support OpenFlow. So currently it is used also used for SDN research works. The primary Emulab installation is 
\section[{g) SDN virtualization tools}]{g) SDN virtualization tools}\par
The OpenFlow has opened the control of a network for innovation, but only one network administrator can do experiments on the network at a time. If there is a way to divide, slice or replicate network resources, more than one network administrator can use them in parallel to do experiments. Actions in one slice or replication should not negatively affect other, even if they share the same underlying physical hardware. SDN Virtualization concepts have been introduced to achieve these goals.\par
The FlowVisor \hyperref[b49]{[58]} is a special purpose OpenFlow controller that allows multiple researchers to run experiments independently on the same production OpenFlow network. It uses a new approach to switch virtualization, in which the same hardware forwarding plane is shared among multiple logical networks, each with distinct forwarding logic. FlowVisor acts as a middle layer between the underlying physical hardware and the software that controls it. It is implemented as an OpenFlow proxy that intercepts messages between OpenFlow switches and OpenFlow controllers. The AutoSlice \hyperref[b50]{[59]} devel-ops a transparent virtualization layer (SDN hypervisor) which automates the deployment and operation of vSDN topologies. In contrast to FlowVisor, AutoSlice focuses on the scalability aspects of the hypervisor design. AutoSlice monitors flow level traffic statistics to optimize the resource utilization and to mitigate flow-table limitations. With the distributed hypervisor architecture, Autoslice can handle large numbers of flow table control messages from multiple tenants.\par
In a virtual machine environment, moving applications from one location to another without a disruption in service is called Live virtual machine (VM) migration. SDN applications can reside and rely on multiple VMs. So migrating individual SDN VMs, one by one, may disrupt the SDN applications. So the LIME \hyperref[b51]{[60]} design migrate an ensemble: the VMs, the network, and the management system to a different set of physical resources at the same time. LIME uses the SDN concept of separation between the controller and the data plane state in the switches. LIME clones the data plane state to a new set of switches, transparent to the application running on the controller. And then incrementally migrates the traffic sources.\par
The RouteFlow \hyperref[b52]{[61]} provides virtualized IP routing over OpenFlow capable hardware. It is composed with a OpenFlow Controller application, a server, and a virtual network environ-ment. The virtual network environment rebuild the connectivity of the physical infrastructure and runs IP routing engines. The routing engines generate the forwarding information base (FIB) according to the routing protocols configured. An ex-tension of RouteFlow \hyperref[b53]{[62]}, discusses incorporating RCPs \hyperref[b16]{[17]} in the context of OpenFlow and SDN. It proposes a controller centric networking model with a prototype implementation of an autonomous system-wide abstract BGP routing service.\par
V. 
\section[{Final Remarks}]{Final Remarks}\par
SDNs have emerged in the last decade as a very active research domain, gaining significant attention from both academia and industry. This survey discussed the state of art in SDN, with a historic perspective of the field by describing the SDN paradigm, architecture and deployments in detail.\par
We first introduced the concepts and definitions that enable a clear understanding of SDNs. The idea of programmable networks and decoupled control logic has been around for many years and the history of SDN goes back to the early 1980s. Central network control, programmability in networks, network virtualization and control of packet switched networks were the four main supporting technologies which helped SDN to evolve. The survey was extended by exploring the OpenFlow project and the standardized SDN architecture. Standard SDN three tier architecture includes: SDN controller, southbound APIs and northbound APIs. For a broader scope, the pa-per detailed the tools and frameworks associated with SDN development in the categories of SDN controller platforms, SDN software switch platforms, native SDN switches, SDN languages, SDN debugging tools, SDN emulation/simulation tools and SDN virtualization tools. Year 2 019 ( ) C\begin{figure}[htbp]
\noindent\textbf{1}\includegraphics[]{image-2.png}
\caption{\label{fig_0}Fig. 1 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{2}\includegraphics[]{image-3.png}
\caption{\label{fig_1}Fig. 2 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-4.png}
\caption{\label{fig_2}}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{3}\includegraphics[]{image-5.png}
\caption{\label{fig_3}Fig. 3 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{4}\includegraphics[]{image-6.png}
\caption{\label{fig_4}Fig. 4 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{5}\includegraphics[]{image-7.png}
\caption{\label{fig_5}Fig. 5 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-8.png}
\caption{\label{fig_6}}\end{figure}
   \begin{figure}[htbp]
\noindent\textbf{I} \par 
\begin{longtable}{P{0.4341991341991342\textwidth}P{0.19870129870129868\textwidth}P{0.055194805194805185\textwidth}P{0.08095238095238094\textwidth}P{0.08095238095238094\textwidth}}
Specification\tabcellsep \multicolumn{2}{l}{1.0.0 1.1.0}\tabcellsep 1.2.0\tabcellsep 1.3.0\\
Widely deployed\tabcellsep Yes\tabcellsep No\tabcellsep No\tabcellsep No\\
Flow tables\tabcellsep \multicolumn{4}{l}{One Multiple Multiple Multiple}\\
Group tables\tabcellsep No\tabcellsep Yes\tabcellsep Yes\tabcellsep Yes\\
MPLS matching\tabcellsep No\tabcellsep Yes\tabcellsep Yes\tabcellsep Yes\\
Group tables\tabcellsep No\tabcellsep Yes\tabcellsep Yes\tabcellsep Yes\\
IPV6 Support\tabcellsep No\tabcellsep No\tabcellsep Yes\tabcellsep Yes\\
Simultaneous communication\tabcellsep No\tabcellsep No\tabcellsep Yes\tabcellsep Yes\\
III.\tabcellsep \tabcellsep \tabcellsep \tabcellsep \end{longtable} \par
 
\caption{\label{tab_0}Table I :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{II} \par 
\begin{longtable}{P{0.06942231075697211\textwidth}P{0.06264940239043824\textwidth}P{0.07619521912350598\textwidth}P{0.11683266932270915\textwidth}P{0.05079681274900399\textwidth}P{0.05756972111553784\textwidth}P{0.41653386454183267\textwidth}}
Name\tabcellsep Language\tabcellsep License\tabcellsep Original authors\tabcellsep Can Extend\tabcellsep Currently active\tabcellsep Notes\\
Ovs\tabcellsep C\tabcellsep OpenFlow license\tabcellsep Stanford/ Nicira\tabcellsep No\tabcellsep No\tabcellsep A reference controller, act as a learning switch\\
NOX\tabcellsep C++\tabcellsep GPL\tabcellsep Nicira\tabcellsep Yes\tabcellsep Yes\tabcellsep Event-based\\
POX\tabcellsep Python\tabcellsep GPL\tabcellsep Nicira\tabcellsep Yes\tabcellsep Yes\tabcellsep Event-based\\
Beacon\tabcellsep Java\tabcellsep GPL\tabcellsep Stanford\tabcellsep Yes\tabcellsep Yes\tabcellsep Web Interface, Regression test framework, Event based and Multi-thread based\\
Maestro\tabcellsep Java\tabcellsep LGPL\tabcellsep Rice\tabcellsep Yes\tabcellsep No\tabcellsep Multi-thread based\\
Trema\tabcellsep Ruby, C\tabcellsep GPL\tabcellsep NEC\tabcellsep Yes\tabcellsep No\tabcellsep Emulator and Regression test framework\\
Floodlight\tabcellsep Java\tabcellsep Apache\tabcellsep Big switch\tabcellsep Yes\tabcellsep Yes\tabcellsep REST APIs, Supports multi-tenant clouds\end{longtable} \par
 
\caption{\label{tab_2}Table II :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{III} \par 
\begin{longtable}{P{0.14891472868217054\textwidth}P{0.009224806201550388\textwidth}P{0.04217054263565891\textwidth}P{0.5258139534883721\textwidth}P{0.12387596899224805\textwidth}}
Year 2 019\tabcellsep \tabcellsep \tabcellsep \tabcellsep Year 2 019\\
14\tabcellsep \tabcellsep \tabcellsep \tabcellsep 13\\
\tabcellsep \tabcellsep \tabcellsep \tabcellsep Volume XIX Issue I Version I\\
) ( C\tabcellsep \tabcellsep \tabcellsep \tabcellsep ( ) C\\
\multicolumn{2}{l}{Software switch Language OpenVSwitch C, Python}\tabcellsep OpenFlow Version V 1.0\tabcellsep Notes Implements a switch platform in a virtualized server environment. Supports standard Ethernet switching with VLANs and access control lists. Provides interfaces for managing configuration state and a method to remotely manipulate the forwarding\tabcellsep Global Journal of Computer Science and Technology\\
\tabcellsep \tabcellsep \tabcellsep path.\\
Pantou/\tabcellsep C\tabcellsep V 1.0\tabcellsep \\
OpenWRT\tabcellsep \tabcellsep \tabcellsep \\
ofsoftswitch13\tabcellsep C, C++\tabcellsep V 1.3\tabcellsep A user space software switch implementation. The code is based on the Ericsson's\\
\tabcellsep \tabcellsep \tabcellsep Traffic Lab 1.1 soft switch implementation.\\
© 2019 Global Journals\tabcellsep \tabcellsep \tabcellsep © 2019 Global Journals\end{longtable} \par
 
\caption{\label{tab_3}Table III :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{IV} \par 
\begin{longtable}{}
\end{longtable} \par
 
\caption{\label{tab_4}Table IV :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{V} \par 
\begin{longtable}{P{0.5822834645669291\textwidth}P{0.2533745781777278\textwidth}P{0.014341957255343082\textwidth}}
\multicolumn{2}{l}{Past before Future: A Comprehensive Review on Software Defined Networks Road Map}\tabcellsep \\
Switch Company\tabcellsep Series\tabcellsep \\
Cisco\tabcellsep Cisco cat6k, catalyst 3750,6500 series\tabcellsep \\
Juniper\tabcellsep Juniper MX-240,T-640\tabcellsep \\
HP\tabcellsep HP pro-curve 5400zl,8200zl,6200zl,3500zl,6600\tabcellsep \\
NEC\tabcellsep NEC IP8800\tabcellsep \\
Pronto\tabcellsep Pronto 3240, 3290\tabcellsep \\
Dell Toroki Ciena\tabcellsep Dell Z9000 and S4810 Toroki Light switch 4810 Ciena Core-director running firmware version 6.1.1\tabcellsep Year 2 019\\
Quanta\tabcellsep Quanta LB4G\tabcellsep \\
\multicolumn{2}{l}{Table VI: Classification of SDN debugging tools}\tabcellsep \\
\multicolumn{2}{l}{according to the layers they are working with}\tabcellsep \\
\tabcellsep \tabcellsep ( ) C\\
\multicolumn{2}{l}{(connectivity or consistency) that exist in the data plane.}\tabcellsep \\
\multicolumn{2}{l}{Violations of these invariants are considered as a bug in}\tabcellsep \\
\multicolumn{2}{l}{the network. Anteater translates the detected high-level}\tabcellsep \\
\multicolumn{2}{l}{network invariants into instances of boolean satisfiability}\tabcellsep \\
\multicolumn{2}{l}{problems (SAT). Then checks them against network}\tabcellsep \\
\multicolumn{2}{l}{state using an SAT solver. And finally, if violations have}\tabcellsep \\
\multicolumn{2}{l}{been found, it reports counter examples.}\tabcellsep \\
\tabcellsep © 2019 Global Journals\tabcellsep \end{longtable} \par
 
\caption{\label{tab_5}Table V :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{} \par 
\begin{longtable}{P{0.01690340909090909\textwidth}P{0.19921875\textwidth}P{0.159375\textwidth}P{0.1098721590909091\textwidth}P{0.16058238636363636\textwidth}P{0.20404829545454545\textwidth}}
\tabcellsep Language\tabcellsep Supports\tabcellsep Type\tabcellsep Based on\tabcellsep Used for\\
\tabcellsep FatTire\tabcellsep Only OpenFlow\tabcellsep -\tabcellsep Regular expressions\tabcellsep Fault tolerant programming\\
\tabcellsep Nettle\tabcellsep Only OpenFlow\tabcellsep Functional\tabcellsep Functional Reactive Program-\tabcellsep Load balancing programming\\
\tabcellsep \tabcellsep \tabcellsep \tabcellsep ming\tabcellsep \\
\tabcellsep FML\tabcellsep Only OpenFlow\tabcellsep Logical\tabcellsep datalog\tabcellsep Policy implementation programming\\
\tabcellsep Procera\tabcellsep Any type of hard-\tabcellsep Functional\tabcellsep Functional Reactive Program-\tabcellsep General programming\\
\tabcellsep \tabcellsep ware\tabcellsep \tabcellsep ming\tabcellsep \\
\tabcellsep Flog\tabcellsep Any type of hard-\tabcellsep Logical\tabcellsep datalog\tabcellsep General programming\\
Year 2 019\tabcellsep Frenetic\tabcellsep ware Any type of hard-ware\tabcellsep Logical\tabcellsep Query language\tabcellsep General programming\\
\tabcellsep Pyretic\tabcellsep Any type of hard-\tabcellsep Logical\tabcellsep Query language\tabcellsep General programming\\
\tabcellsep \tabcellsep ware\tabcellsep \tabcellsep \tabcellsep \\
\tabcellsep Layer\tabcellsep \tabcellsep Tools\tabcellsep \tabcellsep \\
\tabcellsep Application layer\tabcellsep \tabcellsep NICE\tabcellsep \tabcellsep \\
\tabcellsep Data Plane\tabcellsep \tabcellsep Anteater\tabcellsep \tabcellsep \\
\tabcellsep Control Plane\tabcellsep \tabcellsep ndb, OFrewind\tabcellsep \tabcellsep \\
)\tabcellsep \multicolumn{2}{l}{A new layer between Data Plane and Control Plane}\tabcellsep VeriFlow\tabcellsep \tabcellsep \\
( C\tabcellsep \tabcellsep \tabcellsep \tabcellsep \tabcellsep \\
\tabcellsep © 2019 Global Journals\tabcellsep \tabcellsep \tabcellsep \tabcellsep \end{longtable} \par
 
\caption{\label{tab_6}}\end{figure}
 			\footnote{( ) C © 2019 Global Journals Past before Future: A Comprehensive Review on Software Defined Networks Road Map} 			\footnote{© 2019 Global JournalsPast before Future: A Comprehensive Review on Software Defined Networks Road Map} 		 		\backmatter   			 
\subsection[{Acknowledgment}]{Acknowledgment}\par
I would like to thank Prof. Jorge Lobo, Prof. A. Russo, Dr. Frank Le, Dr. C. Makaya and Prof. H. Ramalhino, who collaborated in all my SDN related research work \hyperref[b54]{[63]}, \hyperref[b55]{[64]}, \hyperref[b56]{[65]}, \hyperref[b57]{[66]}, \hyperref[b58]{[67]}, [68].\par
run by the Flux Group, part of the School of Computing at the University of Utah. The ns-3 \hyperref[b47]{[56]} is a discrete event network simulator for internet systems. It is based on C++ and Python and widely used for research and educational use. Since ns-3 provides support for OpenFlow, it can be used to emulate SDNs. 			  			  				\begin{bibitemlist}{1}
\bibitem[Rothenberg and Nascimento]{b52}\label{b52} 	 		\textit{},  		 			C E Rothenberg 		,  		 			M R Nascimento 		.  		 	 	 (Revisiting routing) 
\bibitem[Ma et al.]{b58}\label{b58} 	 		\textit{A compre-hensive study on load balancers for vnf chains horizontal scaling},  		 			J Ma 		,  		 			W Rankothge 		,  		 			C Makaya 		,  		 			C Morales 		.  		 arXiv:1810.03238.  		 	 
\bibitem[Lantz et al. ()]{b45}\label{b45} 	 		‘A network in a laptop: rapid prototyping for software-defined networks’.  		 			B Lantz 		,  		 			B Heller 		,  		 			N Mckeown 		.  	 	 		\textit{ACM SIGCOMM Workshop on Hot Topics in Networks},  				2010.  	 
\bibitem[Canini and Venzano ()]{b38}\label{b38} 	 		‘A nice way to test openflow applications’.  		 			M Canini 		,  		 			D Venzano 		.  	 	 		\textit{USENIX conference on Networked Systems Design and Implementation},  				2012.  	 
\bibitem[Tennenhouse and Smith ()]{b6}\label{b6} 	 		‘A survey of active network research’.  		 			D L Tennenhouse 		,  		 			J M Smith 		.  	 	 		\textit{IEEE Communications Magazine}  		1997.  	 
\bibitem[
			D
		 ()]{b7}\label{b7} 	 		‘Active network vision and reality: lessons from a capsule-based system’.  		 			D 		.  	 	 		\textit{ACM Operating Systems Review}  		1999.  	 
\bibitem[Ma et al. ()]{b57}\label{b57} 	 		‘An overview of a load balancer architecture for vnf chains horizontal scaling’.  		 			J Ma 		,  		 			W Rankothge 		,  		 			C Makaya 		,  		 			C Morales 		,  		 			F Le 		,  		 			J Lobo 		.  	 	 		\textit{IEEE IFIP CNSM},  				2018.  	 
\bibitem[Wang and Tsou]{b18}\label{b18} 	 		\textit{Analysis of comparisons between openflow and forces draft-wang-forces-compareopenflowforces},  		 			H J S X Wang 		,  		 			Z Tsou 		,  		 			T 		,  		 			YX 		.  		 \url{http://tools.ietf.org/html/draft-wang-forces-compare-openflow-forces-01}  		 	 
\bibitem[Bozakov and Papadimitriou]{b49}\label{b49} 	 		‘Autoslice: automated and scalable slicing for software-defined networks’.  		 			Z Bozakov 		,  		 			P Papadimitriou 		.  	 	 		\textit{CoNEXT Student 12},  				 	 
\bibitem[Available]{b4}\label{b4} 	 		 \url{http://https://www.coursera.org/course/sdn}  		\textit{Available},  				 	 
\bibitem[Sherwood and Chan ()]{b48}\label{b48} 	 		‘Carving research slices out of your production networks with openflow’.  		 			R Sherwood 		,  		 			M Chan 		.  	 	 		\textit{ACM SIGCOMM}  		2008.  	 
\bibitem[Menga ()]{b0}\label{b0} 	 		\textit{Ccnp practical studies: Layer 3 switching},  		 			J Menga 		.  		 \url{http://www.ciscopress.com/articles/article.asp?p=102093}  		2003.  	 
\bibitem[Santhanam ()]{b21}\label{b21} 	 		\textit{Cisco support community: Cam vs tcam},  		 			T Santhanam 		.  		 \url{https://supportforums.cisco.com/docs/DOC-15833}  		2011.  	 
\bibitem[Fernandez]{b25}\label{b25} 	 		‘Comparing openflow controller paradigms scalability: Reactive and proactive’.  		 			F M Fernandez 		.  	 	 		\textit{AINA 2013},  				 	 
\bibitem[Monsanto and Reich ()]{b37}\label{b37} 	 		‘Composing software defined networks’.  		 			C Monsanto 		,  		 			J Reich 		.  	 	 		\textit{USENIX Conference on Networked Systems Design and Implementation},  				2013.  	 
\bibitem[Controller performance comparisons ()]{b28}\label{b28} 	 		\textit{Controller performance comparisons},  		 \url{http://www.noxrepo.org/pox/about-pox/}  		2011. 2012.  	 	 (About pox) 
\bibitem[Rankothge et al.]{b56}\label{b56} 	 		\textit{Data modelling for the eval-uation of virtualized network functions resource allocation algorithms},  		 			W Rankothge 		,  		 			F Le 		,  		 			J Lobo 		.  		 arXiv:1702.00369.  		 	 
\bibitem[Mai and Khurshid ()]{b39}\label{b39} 	 		‘Debugging the data plane with anteater’.  		 			H Mai 		,  		 			A Khurshid 		.  	 	 		\textit{ACM SIGCOMM},  				2011.  	 
\bibitem[Caesar and Caldwell ()]{b16}\label{b16} 	 		\textit{Design and implementation of a routing control platform},  		 			M Caesar 		,  		 			D Caldwell 		.  		2005.  	 
\bibitem[Emulab -network emulation testbed home ()]{b47}\label{b47} 	 		\textit{Emulab -network emulation testbed home},  		 \url{http://www.emulab.net/}  		2013.  	 
\bibitem[Casado ()]{b17}\label{b17} 	 		‘Ethane: Taking control of the enterprise’.  		 			M Casado 		,  		 			MJ F 		.  	 	 		\textit{Computer Communication Review (ACM SIGCOMM)}  		2007.  	 
\bibitem[Rankothge et al. ()]{b54}\label{b54} 	 		‘Experimental results on the use of genetic algorithms for scaling virtualized network functions’.  		 			W Rankothge 		,  		 			F Le 		,  		 			A Russo 		,  		 			J Lobo 		.  	 	 		\textit{IEEE SDN/NFV},  				2015.  	 
\bibitem[Reitblatt and Canini ()]{b32}\label{b32} 	 		\textit{Fattire: Declarative fault tolerance for software-defined networks},  		 			M Reitblatt 		,  		 			M Canini 		.  		2013.  	 
\bibitem[Johnson ()]{b26}\label{b26} 	 		\textit{feature/Border-Gateway-Protocol-as-a-hybrid-SDN-protocol 30},  		 			S Johnson 		.  		 \url{http://searchsdn.southbound-SDN-protocol}  		2012. 2012.  	 	 (The role for xmpp as a southbound sdn protocol) 
\bibitem[Doria and Salim ()]{b15}\label{b15} 	 		\textit{Forwarding and control element separation (forces) protocol specification},  		 			A Doria 		,  		 			J H Salim 		.  		 RFC 5810.  		2010.  	 
\bibitem[Feamster et al. ()]{b14}\label{b14} 	 		‘How to lease the internet in your spare time’.  		 			N Feamster 		,  		 			L Gao 		,  		 			J Rexford 		.  	 	 		\textit{ACM SIGCOMM},  				2007.  	 
\bibitem[Kim and Feamster ()]{b1}\label{b1} 	 		\textit{Improving network management with software defined networking},  		 			H Kim 		,  		 			N Feamster 		.  		2011.  	 	 (Open networking foundation) 
\bibitem[Bavier and Feamster ()]{b13}\label{b13} 	 		‘In vini veritas: Realistic and con-trolled network experimentation’.  		 			A Bavier 		,  		 			N Feamster 		.  	 	 		\textit{Computer Communication Review}  		2006.  	 
\bibitem[
			NF
		 ()]{b31}\label{b31} 	 		‘Languages for software-defined networks’.  		 			NF 		.  	 	 		\textit{IEEE Communications Magazine}  		2013.  	 
\bibitem[Keller and Arora ()]{b50}\label{b50} 	 		\textit{Live migration of an entire network and its hosts},  		 			E Keller 		,  		 			D Arora 		.  		2012.  	 	 (in HotNets-XI) 
\bibitem[Kaia et al. ()]{b36}\label{b36} 	 		‘Logic programming for software-defined networks: Flog’.  		 			N P Kaia 		,  		 			J Rexford 		,  		 			D Walker 		.  	 	 		\textit{ACM SIGPLAN Workshop on Cross-model Language Design and Implementation},  				2012.  	 
\bibitem[Cai and Cox ()]{b29}\label{b29} 	 		‘Maestro: A system for scalable openflow control’.  		 			Z Cai 		,  		 			A L Cox 		.  	 	 		\textit{Tech. Rep}  		2010.  	 
\bibitem[Voellmy and Hudak ()]{b33}\label{b33} 	 		‘Nettle: Functional reactive programming of openflow networks’.  		 			A Voellmy 		,  		 			P Hudak 		.  	 	 		\textit{International Conference on Practical aspects of declarative languages},  				2011.  	 
\bibitem[Henderson et al. ()]{b46}\label{b46} 	 		‘Network simulations with the ns-3 simulator’.  		 			T R Henderson 		,  		 			M Lacage 		,  		 			G F Riley 		.  	 	 		\textit{ACM SIGCOMM Workshop on Hot Topics in Networks},  				2008.  	 
\bibitem[Gude and Koponen ()]{b24}\label{b24} 	 		‘Nox: towards an operating system for networks’.  		 			N Gude 		,  		 			T Koponen 		.  	 	 		\textit{ACM SIGCOMM}  		2008.  	 
\bibitem[Wundsam and Levin ()]{b41}\label{b41} 	 		‘Of rewind: enabling record and re-play troubleshooting for networks’.  		 			A Wundsam 		,  		 			D Levin 		.  	 	 		\textit{USENIX conference on USENIX annual technical conference},  				2011.  	 
\bibitem[Erickson ; A. Tootoonchian and Gorbunov ()]{b27}\label{b27} 	 		\textit{On controller performance in softwaredefined networks},  		 			D Erickson ; A. Tootoonchian 		,  		 			S Gorbunov 		.  		2013. 2012.  	 	 (The beacon openflow controller. in Hot-ICE) 
\bibitem[Open networking research center (onrc) ()]{b2}\label{b2} 	 		 \url{http://onrc.net}  		\textit{Open networking research center (onrc)},  				2011.  	 
\bibitem[Campbell and Katzela ()]{b12}\label{b12} 	 		‘Open signaling for atm, internet and mobile networks’.  		 			A T Campbell 		,  		 			I Katzela 		.  	 	 		\textit{Computer Communication Review (ACM SIGCOMM)}  		1998.  	 
\bibitem[Limoncelli ()]{b20}\label{b20} 	 		‘Openflow: a radical new idea in networking’.  		 			T A Limoncelli 		.  		 \url{http://www.openflow.org/wp/current-deployments/23}  	 	 		\textit{Open Networking Foundation, Tech. Rep}  		2012. 2012. 2013. 22.  	 	 (ACM Queue -Performance) 
\bibitem[Mckeown and Anderson ()]{b19}\label{b19} 	 		‘Openflow: enabling innovation in campus networks’.  		 			N Mckeown 		,  		 			T Anderson 		.  	 	 		\textit{ACM SIGCOMM},  				2008.  	 
\bibitem[Rankothge and Le ()]{b55}\label{b55} 	 		‘Optimizing resources allocation for virtualized network functions in a cloud center using genetic algorithms’.  		 			W Rankothge 		,  		 			F Le 		.  	 	 		\textit{IEEE TNSM},  				2017.  	 
\bibitem[Hinrichs and Gude ()]{b34}\label{b34} 	 		‘Practical declarative network management’.  		 			T L Hinrichs 		,  		 			N S Gude 		.  	 	 		\textit{Proceedings of the 1st ACM Workshop on Research on enterprise networking},  				 (the 1st ACM Workshop on Research on enterprise networking)  		2009.  	 
\bibitem[Voellmy et al. ()]{b35}\label{b35} 	 		\textit{Procera: A language for high-level reactive network control},  		 			A Voellmy 		,  		 			H Kim 		,  		 			N Feamster 		.  		2012.  	 
\bibitem[Ryu : a component-based software-defined networking framework ()]{b30}\label{b30} 	 		\textit{Ryu : a component-based software-defined networking framework},  		 \url{http://www.openflow.org/wk/index.php/Open-Flow1.0forOpenWRT39}  		2012. 2012. 2012. 2011.  	 	 (Pantou: openflow 1.0 for openwrt. ofsoftswitch13," 2011. [Online) 
\bibitem[Feamster ()]{b3}\label{b3} 	 		\textit{Sdn course},  		 			N Feamster 		.  		2013.  	 
\bibitem[Sdn troubleshooting simulator (sts) ()]{b43}\label{b43} 	 		\textit{Sdn troubleshooting simulator (sts)},  		 \url{http://ucb-sts.github.com/sts/}  		2013.  	 
\bibitem[Schwartz and Jackson ()]{b10}\label{b10} 	 		‘Smart packets: applying active networks to network management’.  		 			B Schwartz 		,  		 			A W Jackson 		.  	 	 		\textit{ACM Transactions on Computer Systems}  		2000.  	 
\bibitem[Yu et al. ()]{b44}\label{b44} 	 		‘Software defined traffic measurement with opensketch’.  		 			M Yu 		,  		 			L Jose 		,  		 			R Miao 		.  	 	 		\textit{USENIX Symposium on Networked Systems Design and Implementation},  				2013.  	 
\bibitem[Shin et al.]{b22}\label{b22} 	 		\textit{Softwaredefined networking (sdn): A reference architecture and open apis},  		 			M.-K Shin 		,  		 			H.-J Kim 		,  		 			K.-H Nam 		.  		 ICTC 2012.  		 	 
\bibitem[Lawser ()]{b5}\label{b5} 	 		‘Stored program controlled network: Generic network plan’.  		 			J J Lawser 		,  		 			Lecronier 		.  	 	 		\textit{Bell System Technical Journal}  		1982.  	 
\bibitem[Smith and Farber ()]{b9}\label{b9} 	 		‘Switchware: Accelerating network evolution’.  		 			J M Smith 		,  		 			D J Farber 		.  	 	 		\textit{Tech. Rep}  		1996.  	 
\bibitem[Jonathan and David ()]{b23}\label{b23} 	 		‘The open sdn architecture -big switch networks’.  		 			M S Jonathan 		,  		 			J F David 		.  	 	 		\textit{Tech. Rep}  		2011.  	 
\bibitem[Van ()]{b8}\label{b8} 	 		\textit{The tempest: A practical framework for network programmability},  		 			J E Van 		.  		1998. IEEE Networks Magazine.  	 
\bibitem[Rankothge et al. ()]{b53}\label{b53} 	 		‘Towards making network function virtualization a cloud computing service’.  		 			W Rankothge 		,  		 			J Ma 		,  		 			F Le 		,  		 			A Russo 		,  		 			J Lobo 		.  	 	 		\textit{IEEE IM},  				2015.  	 
\bibitem[Yemini and Silva ()]{b11}\label{b11} 	 		‘Towards programmable networks’.  		 			Y Yemini 		,  		 			S D Silva 		.  	 	 		\textit{IEEE International Workshop on Distributed Systems: Operations and Management},  				1996.  	 
\bibitem[Khurshid and Zhou ()]{b42}\label{b42} 	 		\textit{Veriflow: verifying network-wide invariants in real time},  		 			A Khurshid 		,  		 			W Zhou 		.  		2011.  	 
\bibitem[Nascimento and Rothenberg ()]{b51}\label{b51} 	 		‘Virtual routers as a service: the routeflow approach leveraging software-defined networks’.  		 			M R Nascimento 		,  		 			C E Rothenberg 		.  	 	 		\textit{Future Internet Technologies},  				2011.  	 
\bibitem[Handigol and Heller ()]{b40}\label{b40} 	 		\textit{Where is the debugger for my software-defined network?},  		 			N Handigol 		,  		 			B Heller 		.  		2012.  	 	 (in HotSDN) 
\end{bibitemlist}
 			 		 	 
\end{document}
