1 Introduction
2 Impact of network load on VNF performance
3 A formal model for dynamic VNF provisioning
Symbol | Formal specification | Definition |
---|---|---|
Superscripts and subscripts | ||
P | Physical infrastructure entity | |
S | SFC entity | |
Sets and set objects | ||
\(p \in \mathcal {P}\)
|
\(p = \left (N^{P}, L^{P}, E^{P}\right)\)
| Physical infrastructure instance, composed of nodes and links |
i∈NP | NP={i | i is a N-PoP} | Network points of presence (N-PoPs) in the physical infrastructure |
(i,j)∈LP |
\(L^{P} = \left \{(i,j)\,\vert \, i,j \in N^{P}\right \}\)
| Unidirectional links connecting pairs of N-PoPs i and j |
〈i, r〉∈EP |
\(E^{P} = \{\langle i, r \rangle \,\vert \, i \in N^{P} \land r \in \mathbb {N}^{*}\}\)
| Identifier r of the actual location of N-PoP i |
\(m \in \mathcal {F}\)
|
\(\mathcal {F} = \{m\,\vert \,m\,\text {is a function type}\,\} \)
| Types of virtual network functions available |
\(j \in \mathcal {U}_{m}\)
|
\(\mathcal {U}_{m} = \{j\,\vert \,j\,\text {is an instance of}\, m \in \mathcal {F}\,\}\)
| Instances of virtual network function m available |
\(\mathcal {Q}\)
| Set of Service function chaining (SFC) requests to be deployed | |
\(q \in \mathcal {Q}\)
|
\(q = \left (N^{S}_{q}, L^{S}_{q}, E^{S}_{q}\right)\)
| A single SFC request, composed of VNFs and their chainings |
\(i \in N^{S}_{q}\)
| NS={i | i is a VNF instance or endpoint} | SFC nodes (either a network function instance or an endpoint) |
\((i,j) \in L^{S}_{q}\)
|
\(L^{S}_{q} = \left \{(i,j)\,\vert \, i,j \in N^{S}\right \}\)
| Unidirectional links connecting SFC nodes |
\(\langle i, r \rangle \in E_{q}^{S}\)
|
\(E^{S}_{q} = \{\langle i, r \rangle \,\vert \, i \in N^{S} \land r \in \mathbb {N}^{*}\}\)
| Required physical location r of SFC endpoint i |
\(H^{S}_{q}\)
| Distinct forwarding paths (subgraphs) contained in a given SFC q | |
\(H^{H}_{q,i} \in H^{S}_{q}\)
|
\(H^{H}_{q,i} = \left (N^{H}_{q,i}, L^{H}_{q,i}\right)\)
| A possible subgraph (with two endpoints only) of SFC q |
\(N^{H}_{q,i}\)
|
\(N^{H}_{q,i} \subseteq N^{S}_{q}\)
| VNFs that compose the SFC subgraph \(H^{H}_{q,i}\) |
\(L^{H}_{q,i}\)
|
\(L^{H}_{q,i} \subseteq L^{S}_{q}\)
| Links that compose the SFC subgraph \(H^{H}_{q,i}\) |
\(y^{\prime }_{i,m,j}\)
| Denotes whether there was a previous VNF placement | |
\(\delta ^{\prime }_{i,q,j}\)
| Denotes whether there was a previous assignment of flow to VNF | |
\(\lambda ^{\prime }_{i,j,q,k,l}\)
| Denotes whether there was a previous flow chaining | |
Parameters | ||
ϕ
|
\(\phi \in \mathbb {R}_{+}, \phi \geq 0\)
| Percentage of capacity of VNFs that can be violated. |
α, β, and γ | Weight factors of the ILP model. | |
\(C^{P}_{i} \in \mathbb {R}_{+}\)
| Computing power capacity of N-PoP i | |
\(B^{P}_{i,j} \in \mathbb {R}_{+}\)
| One-way link bandwidth between N-PoPs i and j | |
\(D^{P}_{i,j} \in \mathbb {R}_{+}\)
| One-way link delay between N-PoPs i and j | |
\(C^{S}_{q,i} \in \mathbb {R}_{+}\)
| Computing power required for network function i of SFC q | |
\(B^{S}_{q,i,j} \in \mathbb {R}_{+}\)
| One-way link bandwidth required between nodes i and j of SFC q | |
\(D^{S}_{q} \in \mathbb {R}_{+}\)
| Maximum tolerable end-to-end delay of SFC q | |
Functions | ||
\(f^{type}_{m}\)
|
\(f^{type} : N^{P} \cup N^{S} \rightarrow \mathcal {F}\)
| Type of some given virtual network function (VNF) |
\(f^{cpu}_{m,j}\)
|
\(f^{cpu} : (\mathcal {F} \times \mathcal {U}_{m}) \rightarrow \mathbb {R}_{+}\)
| Computing power associated to instance j of VNF type m |
\(f^{delay}_{m}\)
|
\(f^{delay} : \mathcal {F} \rightarrow \mathbb {R}_{+}\)
| Processing delay associated to VNF type m |
Variables | ||
yi,m,j∈Y |
\(Y = \{\,y_{i,m,j}\,,\,\forall \,i \in N^{P}, m \in \mathcal {F}, j \in \mathcal {U}_{m}\,\}\)
| VNF placement |
δi,q,j∈Δ |
\(\Delta = \left \{\,\delta _{i,q,j}\,,\,\forall \,i \in N^{P}, q \in \mathcal {Q}, j \in N_{q}^{S}\,\right \}\)
| Assignment of required network functions/endpoints |
λi,j,q,k,l∈Λ |
\(\Lambda = \left \{\,\lambda _{i,j,q,k,l}\,,\,\forall \,(i,j) \in L^{P}, q \in \mathcal {Q}, (k,l) \in L_{q}^{S}\,\right \}\)
| Chaining allocation |
\(\overline {y}_{i,m,j} \in \overline {Y}\)
|
\(\overline {Y} = \{\,\overline {y}_{i,m,j}\,,\,\forall \,i \in N^{P}, m \in \mathcal {F}, j \in \mathcal {U}_{m}\,\}\)
| Denotes whether an VNF placement changes |
\(\overline {\delta }_{i,q,j} \in \overline {\Delta }\)
|
\(\overline {\Delta } = \left \{\,\overline {\delta }_{i,q,j}\,,\,\forall \,i \in N^{P}, q \in \mathcal {Q}, j \in N_{q}^{S}\,\right \}\)
| Denotes whether an assignment of flow to VNF changes |
\(\overline {\lambda }_{i,j,q,k,l} \in \overline {\Lambda }\)
|
\(\overline {\Lambda } = \left \{\,\overline {\lambda }_{i,j,q,k,l}\,,\,\forall \,(i,j) \in L^{P}, q \in \mathcal {Q}, (k,l) \in L_{q}^{S}\,\right \}\)
| Denotes whether a flow chaining changes |
3.1 Model notation and description
3.2 Model formulation
4 Adaptive VNF placement and chaining with NFV-PEAR
4.1 Optimization layer
4.2 Deployment layer
4.3 NFV-PEAR application programming interface
Class | Description |
---|---|
class SFC(sfc_id, edges_list, dict):
def deploy_sfc()
def deploy_nf(nfunction, pop)
def enable_nf(nfunction)
def deploy_flow()
def enable_flow()
| A class to materialize Service Function Chaining (SFC) documents. Each instance of this class must have an id, an array with flow steering specifications, and a dictionary that contains mapping information of network functions (NFs) into Network Points-of-Presence (N-PoPs). The class contains methods to deploy the SFC as a whole, and also to deploy and enable NFs individually, and deploy and enable flow steering between NFs (and between NFs and endpoints). The deploy_sfc() method deploys an SFC. Internally, it calls deploy_nf() , deploy_flow() , enable_nf() , and enable_flow() methods. The deploy_nf() method creates and returns an NF instance, receiving as parameter an NF image and an N-PoP instance. Finally, deploy_flow() deploys all flows of an SFC. |
class NfData(nfunction, npop, enabled) : def enable() def disable() | A class to maintain NF operation data. Each NfData object points to an instance of NFunction and N-PoP. It also has a flag indicating if the NF is in operation, and methods to enable/disable its operation. |
class NFunction(nf_id, type):
| A class to represent NF instances. Each NFunction instance must have the identification number of the NF, and a string representing the NF type (ex: “Load Balancer”). The class constructor receives as input a network function id and type. |
class NPop(npop_id, location):
def add_deploy(deploymentFunction)
def is_deployed()
| A class to represent N-PoP instances. The class constructor receives as input an N-PoP id and the location of the switch to which the N-PoP belongs. |
h1
to h3
, and also in the backward direction, i.e., from h3
to h1
. Each link belonging to a chain is a list of 3-tuple edges (u,v,d)
with a source node u
, a destination node v
, and a dictionary d
. The dictionary contains {src_ip:x, dst_ip:y, npop: Bool}
(with a Boolean flag indicating if either source or destination is connected to an N-PoP. This list represents the paths (source -> destination, destination -> source)
of an SFC.
deploy_sfc()
deploys the SFC into the infrastructure.5 Prototypical implementation
5.1 Optimization layer
5.2 Deployment layer
5.3 Infrastructure
ifconfig
. An example of a topology can be seen in Fig. 5. Links are described by means of one pair node-interface for origin and another one for destination (separated by colon), in which “node” can be a switch or end host. From the topology description, Ryu starts its execution and connects to all switches on the network. It also starts the REST server, waiting for the requests from upper layer modules.
sar
, available in the GNU/Linux sysstat
package. sar
shows textual info about CPU, memory and I/O data, among others. That textual info is passed on to a python parser and then to the Metric Collector module. We chose this architectural deployment as is requires no changes to other modules in case one wishes to replace sar
.