Online Load Balancing for Network Functions Virtualization

TL;DR

This paper presents ORBIT, an online load balancing algorithm for NFV that optimizes network performance by dynamically distributing traffic across multiple paths, with proven performance guarantees and strong results on real datasets.

Contribution

The paper introduces ORBIT, a novel online load balancing algorithm for NFV that efficiently manages dynamic user demands with theoretical guarantees.

Findings

ORBIT effectively balances traffic without future demand knowledge.

It outperforms baseline methods under high-load conditions.

Theoretical analysis confirms near-optimal performance.

Abstract

Network Functions Virtualization (NFV) aims to support service providers to deploy various services in a more agile and cost-effective way. However, the softwarization and cloudification of network functions can result in severe congestion and low network performance. In this paper, we propose a solution to address this issue. We analyze and solve the online load balancing problem using multipath routing in NFV to optimize network performance in response to the dynamic changes of user demands. In particular, we first formulate the optimization problem of load balancing as a mixed integer linear program for achieving the optimal solution. We then develop the ORBIT algorithm that solves the online load balancing problem. The performance guarantee of ORBIT is analytically proved in comparison with the optimal offline solution. The experiment results on real-world datasets show that ORBIT performs very well for distributing traffic of each service demand across multipaths without knowledge of future demands, especially under high-load conditions.

Figures

Tables

Table 1. TABLE I: Summary of notations

Notation	Meaning
$V$	The set of NFVI nodes
$E$	The set of directed links on NFVI
$F$	The set of VNFs available on NFVI
$D$	The set of service demands
$n$	The number of NFVI nodes
$m$	The number of service demands
$C_{1,e}$	Bandwidth capacity of link $e\in E$
$C_{2,v}$	Computing capacity of node $v\in V$
$i_e$	The starting node of link $e\in E$
$j_e$	The terminating node of link $e\in E$
$h_d$	The traffic volume of demand $d\in D$
$s_d$	The source node of demand $d\in D$
$t_d$	The destination node of demand $d\in D$
$F_{di}$	The $i$th service function required by demand $d\in D$
$P_d$	The set of traffic flows of demand $d$
${\chi }_e$	The total traffic rate of all data flows going through link $e$
$w_e$	A non-negative integer variable that represents the metric of link $e$
$l_{vt}$	A non-negative integer variable that is the length of the shortest path from node $v$ to node $t$
$x_{epd}$	A non-negative continuous variable that represents the traffic on link $e$ of flow $p$ of demand $d$
$g_{vt}$	A non-negative continuous variable whose value is traffic assigned to outgoing links of node $v$ that belongs to the shortest paths from node $v$ to node $t$
$u_{et}$	A binary variable that equals to 1 if and only if link $e$ is on a shortest path to node $t$
$b_{epd}$	A binary variable that equals to 1 if and only if flow $p$ of demand $d$ uses link $e$
$k_{vdi}$	A parameter that equals to 1 if and only if node $v$ can provide the $i$th VNF of demand $d$
$r$	A non-negative continuous variable that is the maximum utilization over all links
$r_{vf}$	The computing resources required to process function $f$ with one unit of traffic rate at node $v$
w	A link metric vector of links on NFVI, $\text{w}=(w_e:e\in E)$
x	A traffic allocation vector for all demands, $\text{x}=(x_{epd}:e\in E,p\in P_d,d\in D)$

Equations

$${\sum }_{\left\{p,e:i_e=v\right\}}{x}_{epd}-{\sum }_{\left\{p,e:j_e=v\right\}}{x}_{epd}=0,$$

$$\begin{array}{r}\forall d,\forall v,v\ne s_d,v\ne t_d\end{array}$$

$${\sum }_{\left\{p,e:i_e=s_d\right\}}{x}_{epd}=h_d,\begin{array}{r}\forall d\end{array}$$

$${\sum }_{\left\{p,e:j_e=t_d\right\}}{x}_{epd}=h_d,\forall d$$

$${\sum }_{p,d}{x}_{epd}⩽r{C}_{1,e},\begin{array}{r}\forall e.\end{array}$$

$$0⩽g_{i_{e}t}-{\sum }_{\left\{p,d:t_d=t\right\}}{x}_{epd}⩽\left(1-u_{et}\right){\sum }_{\left\{d:t_d=t\right\}}{h}_d,$$

$$\begin{array}{r}\forall t,\forall e.\end{array}$$

$${\sum }_p{x}_{epd}⩽u_{e{t}_d}{h}_d,\begin{array}{r}\forall d,\forall e\end{array}$$

$$1-u_{e{t}_d}⩽l_{j_e{t}_d}+w_e-l_{i_e{t}_d}⩽\left(1-u_{e{t}_d}\right)M_z,\begin{array}{r}\forall d,\forall e\end{array}$$

$$w_e⩾1,\begin{array}{r}\forall e\end{array}.$$

$${\sum }_e{x}_{epd}\left(k_{i_{e}di}+k_{j_{e}di}\right)>0,\begin{array}{r}\forall d,\forall i,\forall p,h_d>0\end{array}$$

$${\sum }_e{x}_{epd}>0,\begin{array}{r}\forall d,\forall p,h_d>0\end{array}$$

$$0⩽x_{epd}⩽M_z{b}_{epd},\begin{array}{r}\forall d,\forall e,\forall p\end{array}$$

$$x_{epd}⩾{\sum }_{\left\{e^{\prime }:j_{e^{\prime }}=i_e\right\}}{x}_{e^{\prime }pd}-M_z\left(1-b_{epd}\right),\begin{array}{r}\forall d,\forall e,\forall p\end{array}$$

$$x_{epd}⩽{\sum }_{\left\{e^{\prime }:j_{e^{\prime }}=i_e\right\}}{x}_{e^{\prime }pd},\forall d,\forall e,\forall p$$

$${\sum }_{d,i}{R}_v(k_{vdi}{\sum }_{\left\{p,e:j_e=v\right\}}{x}_{epd},F_{di})⩽C_{2,v},\forall v$$

$$z_i\leftarrow z_i\left(1+1/{\pi }_i\epsilon \right)+1/\left({\pi }_i\left|Q(d)\right|\right)$$

$${\sum }_{i=1\dots \kappa }{\pi }_i{z}_i$$

$${\sum }_{i\in Q(d)}{z}_i⩾1,\forall d\in D$$

$$z_i⩾0,\forall 1⩽i⩽\kappa$$

$${\sum }_{d\in D}{\zeta }_d$$

$${\sum }_{d:i\in Q(d)}{\zeta }_d⩽{\pi }_i,\forall 1⩽i⩽\kappa$$

$${\zeta }_d⩾0,\forall d\in D$$

$$z_i⩾\frac{1}{\kappa }\left({\left(1+\frac{1}{{\pi }_i\epsilon }\right)}^{{\sum }_{d:i\in Q(d)}{\zeta }_d}-1\right).$$

$$z_{i,2}$$

$$=\frac{1}{\kappa }\left({\left(1+\frac{1}{{\pi }_i\epsilon }\right)}^{{\sum }_{d:i\in Q(d)\backslash \left\{k\right\}}{\zeta }_d}-1\right)$$

$$\times \left(1+\frac{1}{{\pi }_i\epsilon }\right)+\frac{1}{{\pi }_i\left|Q(d)\right|}.$$

$$z_{i,2}⩾\frac{1}{\kappa }\left({\left(1+\frac{1}{{\pi }_i\epsilon }\right)}^{{\sum }_{d:i\in Q(d)}{\zeta }_d}-1\right).$$

$$3⩾\frac{1}{\kappa }\left({\left(1+\frac{1}{{\pi }_i\epsilon }\right)}^{{\sum }_{d:i\in Q(d)}{\zeta }_d}-1\right).$$

$${\sum }_{d:i\in Q(d)}{\zeta }_d⩽\log \left(3\kappa +1\right)\left(1+{\pi }_i\epsilon \right)={\pi }_{i}O\left(\epsilon \log \kappa \right).$$

$$\Delta P_o$$

$$={\sum }_{i:q_i\in Q(d)}\left(\frac{z_i}{\epsilon }+\frac{1}{\left|Q(d)\right|}\right)$$

Full text

I Introduction

Communication networks have been growing rapidly with an increased growth of network-based services over the past decades. In such a context, network service providers have to reduce their operational costs and time-to-market for network services in order to adapt their business to on-demand customer needs. Responding to these objectives, Network Functions Virtualization (NFV) is a recent trend of network transformation that helps service providers offer new and multiple services in a more agile and cost-effective way. By building a virtualized infrastructure where network functions (e.g., Network Address Translation (NAT), Deep Packet Inspection, firewall) are softwarized and virtualized instead of embedded in specialized hardware devices (i.e., middlebox), NFV has the potential to revolutionize the entire telecommunication industry [1, 2].

Despite the potential of NFV, critical considerations in traffic engineering must be taken into account to maintain strict performance requirements of virtual network functions (VNF), alike in traditional networks [3]. In this context we tackle the value of using load balancing (LB) to support NFV deployment. Indeed, LB is an important approach to traffic engineering in the Internet as it splits the traffic among multiple paths in order to optimize link utilization, reduce congestion, and minimize delay of data flows in the network. However, to the best of our knowledge, there has been no attempt thus far to propose an effective solution for online load balancing using multipath routing in NFV.

A widely used load balancing technique is ECMP (Equal-cost Multipath). The principle of ECMP is that the total traffic going out from one network node will be divided equally over all the shortest paths to the same destination with the same cost. Many routing protocols like Open Shortest Path First (OSPF) and Intermediate System to Intermediate System (IS-IS) support ECMP [4, 5]. Constraints on the shortest path routing and equal load sharing makes the problem complex. It becomes even more difficult when considering the NFV characteristics such as the service function chaining (SFC) and the virtualization capacity at nodes and links of the NFV infrastructure (NFVI).

In this paper, we address an optimization problem of load balancing for NFV, which takes into account the fundamental features of NFV, constraints on the NFVI resource, and ECMP routing. The first main contribution of the paper is an analysis and modeling of the load balancing problem using ECMP for NFV. We formulate the optimization problem of load balancing across multiple paths in NFV as a Mixed Integer Linear Programming (MILP) model. The second important contribution is the ORBIT algorithm that provides an efficient solution for the online load balancing problem. The performance guarantee of ORBIT is analytically proved in comparison with the optimal offline solution.

We evaluated our load balancing solution using two real-world datasets. The results show that ORBIT can provide a solution that is close to optimal. Specially, our algorithm performs more efficiently in a large-scale NFVI under high traffic load conditions. Our solution can be deployed in a SDN network controller where the forwarding rules can be distributed to the forwarding plane of a network switch by using OpenFlow [6].

The rest of the paper is organized as follows. Section II reviews the related work. Section III describes the load balancing problem across multiple paths and formulates the optimization problem as a MILP model. Section IV describes our proposed algorithm for solving the online version of the problem and our theoretical analysis of the algorithm performance. Section V presents the performance evaluation of our solution. Section VI concludes the paper and highlights future work.

II Related Work

Many problems arising in the implementation of network functions virtualization have been considered such as the performance and architecture of NFV, and VNF management. The research team of Internet Research Task Force (IRTF) and European Telecommunications Standards Institute (ETSI) are both developing standards for NFV [1, 2]. Some research results about NFV are summarized in [3, 7]. More recent results about the performance of NFV are mentioned in [8, 9, 10, 11, 12, 13]. There are many studies about load balancing for IP network in the current Internet architecture. [14, 15, 16, 17]. However, so far, no research has been found that surveyed an optimal model and efficient online algorithms for load balancing across multiple paths for NFV.

Several papers were published to study the traffic engineering problem in NFV for better performance and efficient resource utilization [10, 11, 12, 13]. In [10], the authors provide the SDN controller’s design for load-balanced network resources usage. In their design, if a switch is considered overloaded, the orchestrator redirects the active data delivery paths to other switches. In [13], Leivadeas et al. propose a heuristic algorithm for dynamic traffic steering across single paths in SDN enabled data centers. Our work is different as it considers the problem of load balancing using multiple paths. A closely related study to ours is the one conducted by Zhang et al. [11]. However, the authors only consider issues of load balancing specific to multicast, and ignore several important features of NFV. The key difference of our work compared to previous studies on the traffic engineering problem in NFV is that we take into account ECMP routing and the fundamental features of NFV such as SFC and virtualization capacity at both NFVI nodes and links. These factors make the problem under our consideration practical but more complex. In our previous work [12], we propose an offline approximation algorithm for load balancing using multipath routing in NFV. In this paper, we study the optimization model and online algorithm for load balancing across multiple paths in NFV. In addition, we aim to provide the performance guarantee of the online algorithm in comparison with the optimal offline solution.

III Problem Formulation

Network Functions Virtualization is based on virtualization technologies such as those used in cloud computing. A NFV framework includes three components which are VNF, NFVI and NFV management system [2]. In the NFVI, the network functions can be deployed as software that can run in virtual machines on the standard multi-core microprocessor architecture $\times 86$ to handle the data flow. One service demand of NFV may require a network service including many VNFs, in which the VNFs can be processed in a given sequence (e.g., NAT is required to be processed after the firewall function). When processing a service demand, the NFV management system determines the location required to deploy a VNF based on resources available on NFVI. Unlike single-path routing schemes, load balancing strategies split traffic among several paths in order to avoid congestion. The NFV system supporting load balancing both selects the routing paths and splits traffic among them under constraints on NFVI resources and the requirement of the service demand. With the incorporation of the SFC feature of NFV, every data flow of the demand is required to go through a sequence of VNFs dynamically allocated on NFVI nodes according to the demand requirement. We aim to solve the optimization problem of load balancing using ECMP in order to minimize the maximum link utilization of data flows in NFV.

NFVI is modeled as a directed graph $G=(V,E)$, which consists of a set of nodes $V$ and directed links $E$. A node represents a commodity hardware device that can instantiate a VNF flexibly according to dynamic service demands. Let $C_{1,e}$ and $C_{2,v}$ denote respectively the bandwidth capacity of link $e\in E$ and the computing capacity of node $v\in V$. $F$ is a set of VNFs available on NFVI. We denote by $D$ a set of service demands. A service demand $d\in D$ is characterized by a source $s_{d}$, a destination $t_{d}$, demand volume $h_{d}$, and a service function chain $F_{d}\subset F$. Let $k_{vdi}$ be a parameter that equals to 1 if and only if node $v$ can provide the $i$th VNF of demand $d$. Throughout the paper, we will use $v$ and $t$ for a node, $e$ for a link, and $d$ for a demand unless stated otherwise.

We define $\text{w}=\left({{w_{e}}}:e\in E\right)$ to be a link metric vector of links on NFVI. According to service demands, a link metric vector, available system resources and ECMP routing, the system decides a flow allocation vector $\text{x}(\text{w})=\left(x_{epd}:e\in E,d\in D,p\in P_{d}\right)$ where $P_{d}$ is a set of flows for demand $d$, and $x_{epd}$ is the traffic rate on link $e$ of flow $p$ of demand $d$ when the system uses the link metric vector w. We denote by $i_{e}$ and $j_{e}$ the starting node and terminating node of link $e$, respectively.

Our objective is to find a link metric vector w and a flow allocation vector $\text{x}(\text{w})$ in order to minimize the maximum link utilization of data flows and satisfy all requirements of service demands under constraints on NFVI resources. $\text{x}(\text{w})$ is determined according to ECMP routing for each w.

We formulate the problem of load balancing using ECMP as a MILP model that allows us to obtain the optimal solution. For convenience, we summarize our notations in Table I.

The variables of our model are as follows:

• •

${w_{e}}$ is a non-negative integer variable that represents the metric of link $e$.

• •

${l_{vt}}$ is a non-negative integer variable that is the length of the shortest-path from $v$ to $t$ ($v\neq t$).

• •

$x_{epd}$ is a non-negative continuous variable that represents the traffic on link $e$ of flow $p$ associated with a demand $d$.

• •

$g_{vt}$ is a non-negative continuous variable whose value is traffic assigned to outgoing links of node $v$ that belongs to the shortest-paths from $v$ to $t$.

• •

$u_{et}$ is a binary variable that equals to 1 if and only if link $e$ is on a shortest-path to node $t$.

• •

${b_{epd}}$ is a binary variable that equals to 1 if and only if flow $p$ of demand $d$ uses link $e$.

Let $\chi_{e}$ packet per second denote the total traffic rate on link $e$, ${\chi_{e}}=\sum\nolimits_{d,p}{x_{epd}}.$ The link utilization on each link $e$ is $\chi_{e}\mathord{\left/{\vphantom{\chi_{e}C_{1,e}}}\right.\kern-1.2pt}{C_{1,e}}$. The maximum utilization over all links is represented by the dependent variable $r={\max_{e}}\left\{{\chi_{e}\mathord{\left/{\vphantom{{{y_{e}}}{{C_{1,e}}}}}\right.\kern-1.2pt}{C_{1,e}}}\right\}$.

We now present the constraints. The conditions of flow balance at one node are given by

[TABLE]

The capacity constraint on a link is

[TABLE]

The constraint on traffic splitting according to ECMP is given by

[TABLE]

Constraint (5) assures that if link $e$ belongs to one of the shortest-paths from node $i_{e}$ to node $t$ then its flow to node $t$ is equal to ${g_{i_{e}t}}$, a value common to all links outgoing from node $i_{e}$ and belonging to the shortest-paths to destination $t$.

We express the condition of the shortest path routing as follows:

[TABLE]

[TABLE]

where ${M_{z}}$ is the maximum link capacity.

Constraint (6) forces the zero flow to $t_{d}$ $({x_{epd}}=0)$ in the case when link $e$ is not on the shortest-path to $t_{d}$. Constraint (7) assures that if ${u_{et_{d}}}=1$, then link $e$ is on the shortest-path to $t_{d}$; if $u_{et_{d}}=0$, then link $e$ is not on the shortest-path to $t_{d}$.

The link weights need to be larger than or equal to 1. Thus,

[TABLE]

Constraints (9), (10), (11), (12) and (13) guarantee that any flow of demand $d$ must go through its VNFs.

[TABLE]

[TABLE]

[TABLE]

[TABLE]

[TABLE]

The total computing resource required to provide VNFs for all flows through node $v$ is limited by computing resource of node $v$. We represent this constraint on node capacity as follows:

[TABLE]

where ${R_{v}}\lparen x,f\rparen=x{r_{vf}}$, $\forall v\in V$, $\forall f\in F$. ${r_{vf}}$ is the amount of computing resources required to process function $f$ with one unit of traffic rate at node $v$.

As mentioned before, we aim at minimizing the maximum utilization over all links. The objective function is $U\lparen\text{w}\rparen=r$. Our MILP formulation of the load balancing problem, which allows us to obtain exact solutions, can be effectively solved for moderate network size by a MILP solver such as CPLEX [18]. However, it requires the entire service demands to be known. In the sequel we propose an online algorithm that provides a load balancing solution for each demand on the fly.

IV Online Solution

In this section, we present the algorithm ORBIT (Online algorithm foR load BalancIng in network funcTions virtualization) which is designed to effectively address the online case of the load balancing problem in NFV.

IV-A Algorithm Description

The basic idea of ORBIT is to regularly adjust a part of the traffic passing through a partition of NFVI. We divide NFVI into partitions in which the connection between distinct partitions is limited. By routing traffic through a partition, we restrict the possibility of using unnecessarily bottleneck link between partitions, thus improving network utilization and avoiding congestion. The detail of all steps is presented in Fig. 1.

In the preparation phase, we divide NFVI into $\kappa$ partitions with each partition including a maximum of $\epsilon n/\kappa$ nodes while minimizing the capacity of the edges between separate partitions, in which $\kappa$ and $\varepsilon$ are the algorithm parameters. Particularly, we find $\Lambda\lparen\kappa,\varepsilon\rparen=\left\{{{G_{i}}\lparen{V_{i}},{E_{i}}\rparen:i=1\ldots\kappa}\right\}$ by solving a $\left({\kappa,\varepsilon}\right)$ balanced partition problem. We evaluate the link metric vector used as an input of ORBIT by solving the MILP formulation using the set of service demands requested previously.

The main point of the ORBIT algorithm lies in the computation of traffic flows routed through a partition of NFVI according to the demand requirement and current situation of NFVI. Specifically, when a new demand arrives, we adjust traffic volume of a flow going through $G_{i}\in\Lambda\lparen\kappa,\varepsilon\rparen$ until the traffic requirement of demand $d$ is satisfied. The algorithm then distributes traffic of demand $d$ through $G_{i}$ according to ECMP. We denote by $\pi_{i}$ the sum of the bandwidth capacity of the edges in a minimum spanning tree of $G_{i}$. Let $q_{i}$ be a set of demands, in which demand $d$ is included in $q_{i}$, if and only if $G_{i}$ can provide all VNFs of $d$. The traffic volume of a flow going through $G_{i}$ depends on both the requirements of demand $d$ and the cost $\pi_{i}$ associated with $G_{i}$. In each adjustment, the ratio of demand bandwidth allocated to the flow through $G_{i}$ is computed as follows:

[TABLE]

where $Q\lparen d\rparen=\left\{{{q_{i}}:d\in{q_{i}}}\right\}$.

In summary, the ORBIT algorithm first divides NFVI into $\kappa$ partitions by solving a $\left({\kappa,\varepsilon}\right)$ balanced partition problem. It then computes the traffic volume of a demand routed through a partition according to formula (15). A traffic flow passing through a partition is routed according to ECMP. We will discuss the selection of the algorithm parameters in section V. In the following section, we analyze the performance of ORBIT for online load balancing of service demands across multiple paths.

IV-B Theoretical Analysis

In order to analyze the algorithm performance, we consider the following minimization problem as the primal program $\mathcal{P}$, which is given by

[TABLE]

The dual problem $\mathcal{D}$ of the primal problem $\mathcal{P}$ is as follows:

[TABLE]

In the online version of $\mathcal{P}$ (i.e., the online primal program), the constraints are given to the algorithm one-by-one. In the online version of $\mathcal{D}$ (i.e., the online dual program), a new variable $\zeta_{d}$ is introduced and the set of constraints in which $\zeta_{d}$ appears is also updated when a new demand $d$ arrives. The performance of an online solution is represented by the competitive ratio that is the ratio between the cost of the online solution and that of the optimal offline solution. Lemma 1 to 3 will give the foundation to derive the competitive ratio of ORBIT.

Lemma 1

The ORBIT algorithm produces a feasible solution for the online primal load balancing problem.

Proof:

Consider a constraint $\sum\nolimits_{i\in Q(d)}{{z_{i}}}\geqslant 1$ in $\mathcal{P}$. When demand $d$ arrives, ORBIT increases the values of the variables $z_{i}$ until the constraint is satisfied. Hence, the solution produced by ORBIT is feasible, which demonstrates the claim. ∎

Lemma 2 presents a feasible solution provided by ORBIT for the online version of $\mathcal{D}$. We add ${\zeta_{d}}\leftarrow{\zeta_{d}}+1$ between line 18 and 19 in the ORBIT algorithm in order to find a solution for $\mathcal{D}$.

Lemma 2

A feasible solution for the online dual load balancing problem is obtained by dividing the online dual solution which ORBIT produces by $c\varepsilon\log\kappa$ where $c$ is a constant. The cost of the feasible solution is $D_{f}=D_{o}/(c\varepsilon\log\kappa)$.

Proof:

We first prove by induction that, for $\forall d\in D$,

[TABLE]

Initially, $z_{i}=0$ and $\zeta_{d}=0$, so (21) is true. Let consider an iteration in which $\zeta_{k}$ increases by 1. We denote by $z_{i,1}$ and $z_{i,2}$ the values of $z_{i}$ before and after the increment, respectively. Using (15), we have

[TABLE]

Since $\left|{Q(d)}\right|\leqslant\kappa$, we find

[TABLE]

Thus, (21) is true for $\forall d\in D$.

Due to the fact that the algorithm never increases $z_{i}$ if $z_{i}\geqslant 1$, combining $\left|{{Q(d)}}\right|\geqslant 1$, $\pi_{i}\geqslant 1$ and (15), we have $z_{i}\leqslant 3$. From this inequality and (21), we find

[TABLE]

Using the fact that $\varepsilon\geqslant 1$, $\pi_{i}\geqslant 1$, simplifying (24), we obtain

[TABLE]

From (25), dividing the solution by $c\varepsilon\log\kappa$ where $c$ is a constant, we obtain a feasible solution for the online dual load balancing problem with the cost $D_{f}=D_{o}/(c\varepsilon\log\kappa)$, which proves the claim. ∎

Let $P_{o}$ and $D_{o}$ be the values of the objective function of the solutions that ORBIT produces for the online primal and dual programs, respectively. Let $\Delta P_{o}$ and $\Delta D_{o}$ be the changes of $P_{o}$ and $D_{o}$ in an iteration of ORBIT. Lemma 3 gives a comparison between $\Delta P_{o}$ and $\Delta D_{o}$.

Lemma 3

In each iteration of the ORBIT algorithm, the relationship between the online primal and dual solutions that ORBIT produces is given by $\Delta P_{o}\leqslant 2\Delta D_{o}$.

Proof:

From the cost function (16) of the primal program and the adjustment function (15), we have

[TABLE]

Since constraint (17) is infeasible when ORBIT updates the primal and dual solutions, we find $\Delta P_{o}\leqslant 2$. In addition, the change in the dual cost is 1. Thus, we obtain $\Delta P_{o}\leqslant 2\Delta D_{o}$, which proves the claim. ∎

We are almost ready to derive the competitive ratio of the ORBIT algorithm that is introduced in the following proposition.

Proposition 1

ORBIT produces an online load balancing solution which is $O\lparen\varepsilon\log\kappa\rparen$-competitive.

Proof:

First, by Lemma 1 the online solution produced by the ORBIT algorithm is feasible. From Lemma 3 and the fact that initially $P_{o}=D_{o}=0$, we find that the ORBIT algorithm produces online primal and dual solutions such that $P_{o}\leqslant 2D_{o}$. By Lemma 2, we get a feasible solution for the online dual program with value $D_{f}=D_{o}/(c\varepsilon\log\kappa)$ where $c$ is a constant. Therefore, we find $P_{o}\leqslant 2D_{f}(c\varepsilon\log\kappa)$. Using this inequality and the weak duality theorem, we obtain that the primal solution is at most $2c\varepsilon\log\kappa$ times the optimal primal solution, which demonstrates the proposition. ∎

V Evaluation

In this section, we describe the setting of our experiments using two real-world datasets. We then analyze the experimental results including the impact of the algorithm parameters and the evaluation of algorithm performance in comparison with the optimal and offline solutions.

In our experiments, we use two real-world datasets that contain the network topology and traffic matrices measured at different times. The first dataset is the Internet2 research network including a topology of 12 nodes, 30 links and traffic matrices with 130 demands [19]. The traffic traces are recorded for a duration of 30 minutes. The second dataset is the Geant dataset that contains a topology of 22 nodes and 72 links and traffic matrices with 250 demands. The traffic volume of demands in our experiments is a half of total traffic traces over four months in the Geant network. In our experiments, we consider four VNFs available on NFVI. The computing capacity, the resource requirements of a VNF, and the SFC of each demand are randomly generated. In the experiments, we solve the MILP formulation for 10 service demands to compute a weight system for ORBIT. In the preparation phase of ORBIT, we use a multilevel graph partitioning algorithm for dividing NFVI into $\kappa$ partitions [20].

We first evaluate the performance of ORBIT when varying the value of the algorithm parameters in order to gain insight into the parameter setting of ORBIT in practice. Fig. 2 shows the maximum link utilization and the demand acceptance ratio obtained by ORBIT for various $\varepsilon$ when $\kappa=2$ and $\kappa=3$ in the experiments using the two datasets. We observe that the best value of $\varepsilon$ for ORBIT is not affected by the number of partitions $\kappa$. Specifically, ORBIT obtains better results when $\varepsilon=3$ and $\varepsilon=1$ in the experiments using dataset Internet2 and Geant respectively. Thus, we use these values of $\varepsilon$ for other experiments.

Fig. 3 and 4 show the maximum link utilization and the demand acceptance ratio obtained by ORBIT for various $\kappa$ and the two datasets. We observe that ORBIT achieves better results when $\kappa$ increases until a threshold is reached, beyond which further increase in $\kappa$ degrades performance. Particularly, the algorithm obtains the best performance in both the maximum link utilization and the demand acceptance ratio when $\kappa=3$ in the experiment using dataset Internet2 and $\kappa=2$ in the experiment using dataset Geant. The reason is that ORBIT balances traffic over the partitions according to not only the number of partitions, but also the resource capacity of a partition. Under a high value of $\kappa$, ORBIT is likely prevented from distributing a flow through a small partition due to the lack of resource, resulting in worse performance. When we choose a different set of traffic demands in both datasets, the performance improvement also occurs at values of $\kappa$ between 2 and 3. It suggests that we can obtain an appropriate value of $\kappa$ for a specific NFVI by observing the algorithm behaviour in a time duration.

Second, we analyze the performance of the ORBIT algorithm in comparison with the optimal solution. We use the IBM ILOG CPLEX Optimizer to solve the MILP model in order to obtain the optimal results. Fig. 5 provides a comparison of the maximum link utilization obtained by ORBIT and the optimal solution. In both datasets, the results provided by ORBIT are close to the optimal solution. Specially, we observe that ORBIT obtains slightly better results in the experiments using the Geant dataset. This occurs because when NFVI is divided into several partitions, ORBIT can use both the shortest paths and many near-optimal paths.

Finally, in order to evaluate the performance of ORBIT in a large scenario we develop an offline solution based on a basic heuristic method called simulated annealing [21] for comparison purposes. As shown in Fig. 6 and 7, ORBIT outperforms the offline solution in term of both the maximum link utilization and demand acceptance ratio when the number of service demands is large. We argue that ORBIT is more efficient in this case due to the support of near-optimal paths for load balancing in a heavy loaded network.

The above results demonstrate that we have designed an efficient solution for online load balancing in NFV. ORBIT achieves good performance in terms of the link utilization and demand acceptance ratio in comparison with the optimal and offline solutions, especially when the network load is high.

VI Conclusion

We addressed the optimization problem of load balancing in NFV, which is important for guaranteeing the high performance requirements of a network function in a virtualized environment. We formulated the problem as a MILP model to compute the optimal solution. We developed the ORBIT algorithm that provides an efficient solution for online load balancing. As demonstrated through theoretical analyses, the performance of ORBIT is $O\lparen\varepsilon\log\kappa\rparen$-competitive where $\varepsilon$ and $\kappa$ are the algorithm parameters associated to graph partitioning on NFVI. Using two real-world datasets, we performed several experiments in which the result provided by ORBIT is close to the optimal solution. Importantly, the experiment results show that ORBIT works very well in comparison with an offline solution when the network load is high. This is obviously an important aspect for the practical deployment of our load balancing solution.

Although focusing on load balancing across multipaths according to ECMP, we believe the model and algorithm developed in this study can be exploited in the procedures of optimizing several performance metrics of other multipath routing schemes in NFV. Possible extensions of our results include an evaluation of the impact of ORBIT on congestion control when considering a delay guarantee in a demand, a more detailed analysis taking into account demand statistics of end-users in the network partitioning phase of ORBIT, or the capability of meeting a Service Level Agreement (SLA) when an infrastructure failure event occurs in NFV. It will be valuable to study also the performance impacts and economics of NFV in a mobile and multiple providers environment as in [22, 23].

Acknowledgment

This work was partially supported by project B2016-SPH-17 from the Vietnam Ministry of Education and Training.