Placement and Allocation of VNF Nodes Under Budget and Capacity Constraints Revisited

Abstract

Network function virtualization (NFV) enables cost reduction and optimized service deployment. By means of virtualization, network functions which used to be executed on specialized hardware are being replaced with software called Virtual Network Functions (VNFs) that can run on commodity hardware. These VNFs are applied to data flows passing through network nodes with VNFs hosted on them. To fully realize the benefits of NFV, each flow must be fully processed on VNF nodes. Given the budget constraints, only a finite number of nodes can be selected to host VNFs, and these nodes also have limited capacity to process the flows passing through them. In this paper, we consider the problem of VNF node placement and capacity allocation in a network graph $G=(V,E)$, i.e., selecting the best subset of VNF nodes and optimally distributing their bandwidth to maximize the total volume of fully processed traffic flows F. We propose a simpler algorithm for solving this problem than the previously proposed version, representing it as an integer linear programming problem with an approximation ratio of ${\displaystyle \frac{1}{2}}(1-1/e)$, and time complexity $O(|V{|}^{2.5}·|F{|}^{2.5}·L)$, where L is the number of bits of input data.

1. Introduction

Network function virtualization (NFV) is currently very important. It allows organizations to reduce costs and optimize service deployment. With virtualization, network functions that were previously executed on specialized hardware are replaced with software called virtual network functions (VNFs), which can be run on standard hardware. This allows network functions (such as load balancers, firewalls, gateways, and routers) to be applied to data flows passing through network nodes hosting virtual network functions. These network nodes are called VNF nodes. To fully realize the benefits of network function virtualization, each flow must be fully processed on these VNF nodes [1,2].

Network function virtualization is also effective in providing flexible management in cloud computing environments while reducing costs, as proprietary hardware middleboxes (MBs) can now be exposed as virtual network functions (VNFs) and run as lightweight containers on commodity hardware. To ensure the performance and security of user applications, cloud operators create service function chains (SFCs) (or data center policies). In this case, virtual machine (VM) application traffic must flow through a sequence of VNFs [3,4].

Typically, due to budget constraints, only a limited number of nodes can be selected to host VNFs. Furthermore, each node normally has limited capacity, which must be used to handle the multiple flows passing through it. Given these constraints, it is necessary to select a subset of nodes to host VNFs and determine a capacity allocation that maximizes the volume of traffic passing through them.

In this paper, we consider the VNF node placement and capacity assignment (VPCA) problem proposed by Sallam and Ji [5], i.e., selecting the best subset of VNF nodes and optimally allocating their capacity to maximize the total volume of fully processed traffic flows. Unlike [5] that used algorithmic graph optimization techniques, we propose a simpler algorithm for solving this problem, representing it as an integer linear programming problem with two integer variables—VNF node placement and flow selection. We also prove that the approximation ratio of this algorithm is ${\displaystyle \frac{1}{2}}(1-{\displaystyle \frac{1}{e}})$, and its time complexity is $O(|V{|}^{2.5}·|F{|}^{2.5}·L)$ where L is the number of bits of input data. The major contribution of this paper is the new algorithmic solution that beats the previous algorithm in [5] for the cases when $\left|F\right|=o(|V|)$. This situation happens, for example, in CDN deployments that often involve a large number of edge caches (nodes) but only a few high-level streams (flows) that connect to central content sources for popular media, resulting in fewer active-flow, high-traffic streams than physical edge devices.

This paper is structured as follows. In Section 2, we briefly review the related previous work. In Section 3, we describe the model and definition of the VPCA-ILP problem, and in Section 4, we propose an algorithm for solving it. Next, in Section 5 and Section 6, we present a theoretical analysis of this algorithm, evaluating its accuracy and complexity. Simulation results and discussion are demonstrated in Section 7. Finally, we conclude the paper.

2. Related Work

Much work has been carried out to study the NFV placement problem. This is typically considered in terms of VNF instances, i.e., where and how many instances of each network function should be placed and distributed [3,6,7,8]. Nevertheless, these studies pursue different goals. The problem of satisfying the demand of all flows with minimal cost (e.g., in terms of the number of instances) is considered in ref. [9]. The authors of ref. [10] assume that each flow should transmit a chain of network functions, rather than a single function along a given route. The same problem, but for online networks (flows come and go online), is considered in ref. [11]. In ref. [12], the joint problem of localizing and routing a VNF service chain is considered with the goal of minimizing the total cost of communication and computing resources. In ref. [13], a dynamic version of this problem is considered (the goal is to ensure network stability with minimal resource expenditure). See some related results in Zhao et al. [14] and Coromberque [15].

Unlike most previous works, which ignore either budget or capacity constraints, the authors of ref. [5] consider both constraints and formulate a joint VNF node and resource allocation problem (VPCA problem). The authors of ref. [5] formulated the VPCA problem with budget and capacity constraints and showed that the capacity allocation and capacity allocation subproblems were NP-hard. They developed two algorithms for solving the problem with approximation ratios of ${\displaystyle \frac{1}{2}}(1-{\displaystyle \frac{1}{e}})$ and ${\displaystyle \frac{1}{3}}(1-{\displaystyle \frac{1}{e}})$ and time complexity of $O(V^5)+O(F^2{V}^2)$ and $O(V^5)+O(FV)$, respectively.

3. Model and Formulation of the Problem

In the paper by Sallam and Ji [5], the authors consider the problem of traffic flow optimization in a network graph. They propose a joint VNF node placement and flow capacity allocation problem (VPCA) in the network graph, the goal of which is to select the best subset of VNF nodes and optimally allocate their capacities to maximize the total volume of fully processed traffic for the flow.

For this purpose, the network is represented as a network graph $G=(V,E)$, where V is the set of nodes and E is the set of edges connecting nodes in G. A node is a VNF node if it can support a VNF. Since the budget for deploying VNFs in networks is typically limited, it is possible to select only a subset of nodes $U\subseteq V$ to be VNF nodes.

There is a set of flows F in the network. The flow traffic rate for $f\in F$, denoted by ${\lambda }_f$, can be partitioned and processed across multiple VNF nodes. The portion of flow f allocated to a particular node v is denoted by ${\lambda }_f^v$. The problem statement stipulates that the traffic of flow f will be sent along a predetermined path, and the set of nodes on this path is denoted by $V_f$, while $F_U$ is used to denote the set of all flows that have at least one (or more) VNF nodes (nodes of set U) on their path, i.e., $F_U=\{f\in F|V_f\cap U\ne ⌀\}$. For convenience, the set of VNF nodes of a flow f is denoted by $U_f$, that is, $U_f=V_f\cap U$. The set of all flows passing through node v is denoted by $F_v$ ($F_v=\{f\in F|v\in V_f\}$).

A flow is considered processed if the VNF nodes through which it passes have sufficient capacity to handle its entire rate, that is, ${\sum }_{v\in U_f}{\lambda }_f^v\ge {\lambda }_f.$ The problem also assumes that the highest traffic rate of any flow does not exceed the lowest capacity of any node. Furthermore, each VNF node v has a limited capacity, denoted $c_v$, and its own cost for converting node v into a VNF node, denoted $b_v$. The total cost of the VNF nodes must not exceed the total budget B: ${\sum }_{v\in U}{b}_v\le B$.

Example 1.

In Figure 1, given graph $G=(V,E)$ with set of flows $\mathcal{F}=\{f_1,f_2,f_3,f_4\}$, where $F=4=\left|\mathcal{F}\right|$:

Separate flows are given by $f_1=(A,C,E,M,N),f_2=(A,B,L),f_3=(B,J,C,E),f_4=(D,C,E,M),$ where the set of nodes in separate flow is ${\mathcal{V}}_{f_1}=\{A,C,E,M,N\},{\mathcal{V}}_{f_2}=\{A,B,L\},{\mathcal{V}}_{f_3}=\{B,J,C,E\},{\mathcal{V}}_{f_4}=\{D,C,E,M\}$.

Traffic rates are given as ${\lambda }_{f_1}=15,{\lambda }_{f_2}=20,{\lambda }_{f_3}=25,{\lambda }_{f_4}=15.$ The set of VNF nodes is given by $\mathcal{U}=\{A,D,M,N\}\subset V$. The set of all flows whose path has one or more nodes in $\mathcal{U}$ is ${\mathcal{F}}_{\mathcal{U}}=\{f_1,f_2,f_4\}$.

Flows are considered to be processed if

$$\left\{\begin{array}{c}{\lambda }_{f_1}^A+{\lambda }_{f_1}^M+{\lambda }_{f_1}^N\ge 15,\hfill \\ {\lambda }_{f_2}^A\ge 20,\hfill \\ {\lambda }_{f_4}^D+{\lambda }_{f_4}^M\ge 15.\hfill \end{array}\right.$$

Total processed traffic is

$$J_1(\mathcal{U},\lambda )=\sum _{{\lambda }_{f_1}^A+{\lambda }_{f_1}^M+{\lambda }_{f_1}^N\ge 15}15+\sum _{{\lambda }_{f_2}^A\ge 20}20+\sum _{{\lambda }_{f_4}^D+{\lambda }_{f_4}^M\ge 15}15.$$

The limited capacity of every VNF-node v is $c_v=10$. This means that

$$\left\{\begin{array}{c}v=A\Rightarrow {\lambda }_{f_1}^A+{\lambda }_{f_2}^A+{\lambda }_{f_4}^A\le 10,\hfill \\ v=D\Rightarrow {\lambda }_{f_1}^D+{\lambda }_{f_2}^D+{\lambda }_{f_4}^D\le 10,\hfill \\ v=M\Rightarrow {\lambda }_{f_1}^M+{\lambda }_{f_2}^M+{\lambda }_{f_4}^M\le 10,\hfill \\ v=N\Rightarrow {\lambda }_{f_1}^N+{\lambda }_{f_2}^N+{\lambda }_{f_4}^N\le 10.\hfill \end{array}\right.$$

and for every $i\in \{1,2,3,4\}$ and for every $v\in V\setminus \{A,D,M,N\}$, the following equality holds: ${\lambda }_{f_i}^v=0$. After that, consider budget constraint $B=20$ and costs of making nodes to be VNF as $b_A=4$, $b_B=5$, $b_C=2$, $b_D=10$, $b_E=30$, $b_J=1$, $b_K=10$, $b_L=3$, $b_M=3$, $b_N=3$. The following budget constraints should be satisfied: $b_A+b_D+b_M+b_N=20\le 20$.

Given the above constraints of the VPCA problem, we formulate it as integer linear programming problem VPCA-ILP as follows.

Let us introduce integer binary variables. Let $x_f\in \{0,1\}$ be the flow processing variable, where for each flow $f\in F$$x_f=1$ if flow f is fully processed (all its traffic is processed on VNF nodes), and $x_f=0$, otherwise; $y_v\in \{0,1\}$ is the node placement variable, where for each node $v\in V$ $y_v=1$ if node v is selected to host the VNF (becomes a VNF node, i.e., $v\in U$), and $y_v=0$, otherwise. The traffic distribution variables ${\lambda }_f^v\ge 0$ for each flow $f\in F$ and each node $v\in U$ (reflecting the portion of flow f ’s traffic assigned to processing on VNF node v) are continuous.

• Objective function:

Maximize the total volume of fully processed traffic:

$$\mathrm{maximize}J=\sum _{f\in F}{\lambda }_f·x_f.$$

(∗)

• Constraints:

• 1. Binary node placement variable (whether node v becomes a VNF node or not):

  $$y_v\in \{0,1\},\forall v\in V.$$

  (1)

• 2. Budget constraint:

  $$\sum _{v\in V}{b}_v·y_v\le B.$$

  (2)

According to constraints (1) and (2), the set $\{v|y_v=1\}=U$ is the set of graph vertices where VNF nodes are located.

• 3. Binary variable of the flow state (whether to take flow f into consideration or not):

  $$x_f\in \{0,1\},\forall f\in F.$$

  (3)
• 4. Minimum traffic assignment constraint:

  $$\sum _{v\in U_f}{\lambda }_f^v\ge {\lambda }_f·x_f,\forall f\in F.$$

  (4)
• 5. Maximum traffic assignment constraint:

  $$\sum _{v\in U_f}{\lambda }_f^v\le {\lambda }_f,\forall f\in F.$$

  (5)

Constraints (3)–(5) mean that if $x_f=1$, then all traffic of the flow must be processed, i.e., ${\sum }_{v\in U_f}{\lambda }_f^v={\lambda }_f$, and if $x_f=0$, then the traffic can be partially processed, i.e., ${\sum }_{v\in U_f}{\lambda }_f^v<{\lambda }_f$. However, in any case, the assigned traffic should not exceed the total volume of the flow requirement, ${\sum }_{v\in U_f}{\lambda }_f^v\le {\lambda }_f$, namely

$$x_f=\{\begin{array}{cc}1,& \sum _{v\in U_f}{\lambda }_f^v={\lambda }_f\\ 0,& \sum _{v\in U_f}{\lambda }_f^v<{\lambda }_f.\end{array}$$

• 6. Node capacity constraints:

  $$\sum _{f\in F_v}{\lambda }_f^v\le c_v·y_v,\forall v\in V.$$

  (6)
• 7. Non-negativity of traffic assignment:

  $${\lambda }_f^v\ge 0,\forall v\in V_f,\forall f\in F.$$

  (7)

4. Algorithm for Solving the VPCA-ILP Problem

Intuitively, we first allow fractional solution of flows. It means that initially we solve the variant of the problem when we can satisfy not necessarily entire flows but possibly only some fraction of each. After this step, we carefully choose the flows that we can entirely satisfy. Formally, to solve this problem, we propose Algorithm 1. It consists of the following steps:

We will now explain each stage separately.

In Stage I, we solve an LP-relaxed linear programming problem in which $y_v\in [0,1]$ for each $v\in V$, $x_f\in [0,1]$ for each $f\in F$, and the remaining variables and constraints remain unchanged. We obtain the optimal solution to this relaxed problem. Let us denote the optimal values of the fractional variables ${y_v}^{\ast }$, ${x_f}^{\ast }$ and ${{\lambda }_f^v}^{\ast }$, and also $J^{\ast }$ is the optimal value of the LP-relaxation objective function, $U^{\ast }$ is the set of VNF nodes selected by the solver for the optimal value of the relaxed problem, and $F^{\ast }$ is the set of flows selected by the solver for the optimal value of the relaxed problem.

Then. it is necessary to round the continuous (non-integer) variables ${y_v}^{\ast }$ and ${x_f}^{\ast }$ to binary (0 or 1); budget and resource constraints remain the same. We first round ${y_v}^{\ast }$ separately, forming a set of VNF nodes. Then, depending on this set, we round ${x_f}^{\ast }$, selecting flows and distributing their traffic.

In Stage II, we round ${y_v}^{\ast }$ as follows. For each $v\in U^{\ast }$, we calculate the value ${\rho }_v={\displaystyle \frac{c_v}{b_v}}$, which expresses the “utility” (efficiency) of node v (step line 4 of the algorithm). Then, we sort the nodes $v\in U^{\ast }$ (the nodes selected by the solver as a result of LP relaxation) in non-increasing order of ${\rho }_v$. This yields an ordered set of nodes ${U^{\ast }}_{\mathrm{order}}=\{v_1,\dots ,v_{|U^{\ast }|}\}$ (step line 6 of the algorithm). Then, initially setting $U=⌀$ and the used budget $B_{\mathrm{used}}=0$ (line 7 of the algorithm), we select nodes into the set of VNF nodes (for an integer solution) $U=\{v|y_v=1\}$ using the following steps.

First, we form the candidate set $U^{\prime }=\{v|{y_v}^{\prime }=1\}$. Having initialized $U^{\prime }\leftarrow ⌀$, we add one node $v_i$ at a time to $U^{\prime }$ (in order to decrease ${\rho }_{v_i}$), each time checking the sum for compliance with the budget constraint ${\sum }_{v\in V}{b}_v·y_v\le B$, namely, for each iteration $i\in \{1,\dots ,|U^{\ast }|\}$, if $B_{\mathrm{used}}+b_{v_i}\le B$, then we set ${y_{v_i}}^{\prime }=1$; otherwise, we set ${y_{v_i}}^{\prime }=0$. We stop adding to $U^{\prime }$ after checking all nodes (step lines 8–17 of the algorithm).

Having thus formed the set $U^{\prime }=\{v|{y_v}^{\prime }=1\}$, we determine its total throughput ${\sum }_{v\in U^{\prime }}{c}_v$ (lines 19–21 of the algorithm) and compare it with the maximum throughput ${max}_{v\in U^{\ast }}{c}_v$ among all nodes $v\in U^{\ast }$:

-

If ${\sum }_{v\in U^{\prime }}{c}_v\ge {max}_{v\in U^{\ast }}{c}_v$, then we select the candidate set $U^{\prime }$ as the desired set of VNF nodes U, assigning $y_{v_i}=1$ to all nodes in this set and $y_{v_i}=0$ to the remaining nodes (lines 28–30 of the algorithm);

-

If ${\sum }_{v\in U^{\prime }}{c}_v<{max}_{v\in U^{\ast }}{c}_v$, then we select this node for the set of VNF nodes U, assigning $y_v=1$ to it and $y_v=0$ to the remaining nodes (lines 31–37 of the algorithm).

Having rounded ${y_v}^{\ast }$ in this way, we form the set $U=\{v|y_v=1\}$, which is the set of graph vertices in which VNF nodes are located.

In Stage III, to round off the ${x_f}^{\ast }$ variables, we perform the following steps. We define $F^{\ast }(U)=\{f\in F^{\ast }|U_f\ne ⌀\}$: this is the set of flows selected by the solver as a result of LP relaxation (i.e., processed both fully and partially), each of which passes through at least one VNF node from those selected in Stage II). We sort these flows $f\in F^{\ast }$ in non-increasing order of ${\lambda }_f$. We obtain an ordered set of flows $F^{\ast }{(U)}_{\mathrm{order}}=\{f_1,\dots .f_{|F^{\ast }(U)|}\}$(lines 38–39 of the algorithm). Then, we set all $x_f=0$, all assignments ${\lambda }_f^v=0$, remember the current node capacities ${c_v}^{\prime }\leftarrow c_v$ (lines 40–48 of the algorithm), and begin adding flows one by one as follows.

For each flow $f\in F^{\ast }{(U)}_{\mathrm{order}}$, we check whether we can completely place the flow f (that is, distribute its ${\lambda }_f$) among the nodes $v\in U_f$ without violating capacity constraints, i.e., in the general case, ${\sum }_{v\in U_f}{c_v}^{\prime }\ge {\lambda }_f$. If this is true, we set $x_f=1$ (lines 50–51 of the algorithm) and distribute ${\lambda }_f$ among nodes $v\in U_f$, normalizing their ${\lambda }_f^v$ proportionally to ${c_v}^{\prime }$ so that the total is exactly ${\lambda }_f$, that is, ${\sum }_{v\in U_f}{\lambda }_f^v={\lambda }_f$ (lines 52–53 of the algorithm); after the assignment, we reduce the cardinalities of the nodes ${c_v}^{\prime }\leftarrow {c_v}^{\prime }-{\lambda }_f^v$ (line 54 of the algorithm). If the flow cannot be completely accommodated (${\sum }_{v\in U_f}{c_v}^{\prime }<{\lambda }_f$), then we leave $x_f=0$ (lines 56–59 of the algorithm).

After iterating over all flows $f\in F^{\ast }{(U)}_{\mathrm{order}}$, we obtain an integer solution, that is, the set of flows $F(U)=\{f|x_f=1\}$, for each of which ${\sum }_{v\in U_f}{\lambda }_f^v={\lambda }_f$.

5. Accuracy Evaluation of Algorithm

Algorithm 1 first selects nodes for VNF placement, then distributes flows to these nodes within the resulting set of VNF nodes for processing. Therefore, we will split the accuracy evaluation of Algorithm 1 into two stages: we will consider the approximation during VNF node selection and flow distribution separately.

• Approximation Evaluation for VNF Node Selection

Sorting nodes $v\in U^{\ast }$ (selected by the solver in LP relaxation) in non-increasing order of ${\rho }_v$ obtained in LP relaxation (line 6 of Algorithm 1) yields an ordered set of nodes ${U^{\ast }}_{\mathrm{order}}=\{v_1,\dots ,v_{|U^{\ast }|}\}$. Moreover, ${\rho }_{v_i}$ maximizes the “efficiency” of a node,

$${\rho }_{v_i}={\displaystyle \frac{c_{v_i}}{b_{v_i}}}.$$

(8)

Algorithm 1 Algorithm for solution of VPCA-ILP problem.

Stage  I   1: Set variables $y_v,x_f\in [0,1]$ as continuous   2: Solve the LP → obtain ${y_v}^{\ast },{x_v}^{\ast },{{\lambda }_f^v}^{\ast }$, optimum $J^{\ast },$         $U^{\ast }\leftarrow \{v|{y_v}^{\ast }>0\},$         $F^{\ast }\leftarrow \{f|{x_f}^{\ast }>0\}.$ Stage  II   3: for every node $v\in U^{\ast }$ do   4:       ${\rho }_v={\displaystyle \frac{c_v}{b_v}}$   5: end for   6: Sort $U^{\ast }$ in non-ascending order ${\rho }_v\to$ list ${U^{\ast }}_{\mathrm{order}}=\{v_1,\dots ,v_{|U^{\ast }|}\}$   7: $U\leftarrow ⌀,B_{\mathrm{used}}\leftarrow 0$   8: $U^{\prime }\leftarrow ⌀$   9: for every node $v\in {U^{\ast }}_{\mathrm{order}}$ do 10:       if $B_{\mathrm{used}}+b_v\le B$ then 11:             ${y_v}^{\prime }\leftarrow 1$ 12:             $U^{\prime }\leftarrow U^{\prime }\cup \{v\}$ 13:             $B_{\mathrm{used}}\leftarrow B_{\mathrm{used}}+b_v$ 14:       else 15:             ${y_v}^{\prime }\leftarrow 0$ 16:       end if 17: end for 18: $c_{\mathrm{sum}}\leftarrow 0,c_{\max }\leftarrow 0$ 19: for every node $v\in U^{\prime }$ do 20:       $c_{\mathrm{sum}}\leftarrow c_{\mathrm{sum}}+c_v$ 21: end for 22: for every node $v\in U^{\ast }$ do 23:       if $c_v>c_{\max }$ then 24:              $c_{\max }\leftarrow c_v$ 25:              $v_{\max }\leftarrow v$ 26:       end if 27: end for 28: if $c_{\mathrm{sum}}\ge c_{\max }$ then 29:       $U\leftarrow U^{\prime }$ 30:       $y_v\leftarrow {y_v}^{\prime }$ 31: else 32:        $U\leftarrow \{v_{\max }\}$ 33:        $y_{v_{\max }}\leftarrow 1$ 34:       for every node $v\in U^{\ast }\setminus \{v_{\max }\}$ do 35:             $y_v\leftarrow 0$ 36:       end for 37: end if Stage  III 38: $F^{\ast }(U)\leftarrow \{f\in F^{\ast }|U_f\ne ⌀\}$ 39: Sort $F^{\ast }(U)$ in non-ascending order ${\lambda }_f\to$ list $F^{\ast }{(U)}_{\mathrm{order}}$ 40: for every flow $f\in F^{\ast }{(U)}_{\mathrm{order}}$ do 41:       $x_f\leftarrow 0$ 42:       for every node $v\in U$ do 43:             ${\lambda }_f^v\leftarrow 0$ 44:       end for 45: end for 46: for every node $v\in U$ do 47:       ${c_v}^{\prime }\leftarrow c_v$ 48: end for 49: for every flow $f\in F^{\ast }{(U)}_{\mathrm{order}}$ do 50:       if ${\sum }_{v\in U_f}{c_v}^{\prime }\ge {\lambda }_f$ then 51:             $x_f\leftarrow 1$ 52:             for every node $v\in U_f$ do 53:                   ${\lambda }_f^v\leftarrow {\displaystyle \frac{{c_v}^{\prime }·{\lambda }_f}{{\sum }_{v\in U_f}{c_v}^{\prime }}}$ 54:                   ${c_v}^{\prime }\leftarrow {c_v}^{\prime }-{\lambda }_f^v$ 55:             end for 56:       else 57:             $x_f\leftarrow 0$ 58:             for every node $v\in U_f$ do 59:                   ${\lambda }_f^v\leftarrow 0$ 60:             end for 61:       end if 62: end for

Obviously, the deployment cost of each VNF node $b_{v_i}$ does not exceed B, since nodes with a cost greater than B do not belong to any feasible solution.

Khuller et al. [16] considered the maximum coverage problem with a budget and proved an approximation for their algorithm to solve the problem. We apply a similar approach to evaluating the approximation of our algorithm when solving the VPCA-ILP problem at the stage of finding a set of nodes for hosting VNFs while preserving the budget constraint.

To further prove the approximation, we denote the set of VNF nodes U found by the algorithm as $U_{ALG}$, and the set of VNF nodes in the optimal solution as $U_{OPT}$. To determine the approximation coefficient in Stage II of the algorithm, we need to determine how close the set $U_{ALG}$ is to $U_{OPT}$ in terms of their total throughput (since the throughput $c_{v_i}$ is a weight characteristic of node $v_i$).

We denote the total throughput of the VNF nodes selected by the algorithm as ${\sum }_{v_j\in U_{ALG}}{c}_{v_j}=c(U_{ALG})$, and the total throughput of the set of VNF nodes of the optimal solution as ${\sum }_{v_j\in U_{OPT}}{c}_{v_j}=c(U_{OPT}).$ Similarly, the cost of deploying the VNF nodes selected by the algorithm is denoted by $b(U_{ALG})$, and the cost of deploying the optimal set of VNF nodes is denoted by $b(U_{OPT})$. The major idea is to show that the total throughput of the VNF nodes selected by our solution at each step is bounded by the total throughput of the VNF nodes selected by the optimal solution multiplied by some constant close to 1.

Let l be the number of nodes added to the set $U_{ALG}$ during the first r iterations performed by the algorithm in selecting nodes, until the first node from $U_{OPT}$ is considered but not added to $U_{ALG}$ because its addition would violate the budget B. Without loss of generality, we can renumber these nodes so that $v_i$ is the $i^{\mathrm{th}}$ node added to $U_{ALG},i=1,\dots ,l,$ and $v_{l+1}$ is the first node from $U_{OPT}$ considered by the algorithm but not added to $U_{ALG}$.

Let $U_{ALG}^i={\bigcup }_{j=1}^i\{v_j\}$ for $i=1,\dots ,l+1$, and let i be the index of the iteration in which node $v_i$ was considered.

Lemma 1.

After each $i^{th}$ iteration, $i=1,\dots ,l+1$, the following holds:

$$c_{v_i}\ge {\displaystyle \frac{b_{v_i}}{B}}·(c(U_{OPT})-c(U_{ALG}^{i-1})).$$

(9)

Proof. 

Obviously,

$$c(U_{OPT})-c(U_{ALG}^{i-1})\le c(U_{OPT}\setminus U_{ALG}^{i-1}).$$

(10)

Since all nodes v are sorted in non-increasing order of ${\rho }_v$ (i.e., they maximize ${\displaystyle \frac{c_v}{b_v}}$), among the nodes of the set $U_{OPT}\setminus U_{ALG}^{i-1}$, the $i^{\mathrm{th}}$ node has the largest value, ${\rho }_v={\displaystyle \frac{c_v}{b_v}}$, which means its value ${\rho }_v$ is no less than the average value for this set of nodes:

$${\rho }_{v_i}\ge {\rho }_{v_{\mathrm{avg}}}.$$

(11)

The average value ${\rho }_{v_{\mathrm{avg}}}$ over the nodes of this set will satisfy

$${\displaystyle \frac{{\sum }_{v\in U_{OPT}\setminus U_{ALG}^{i-1}}{c}_v}{{\sum }_{v\in U_{OPT}\setminus U_{ALG}^{i-1}}{b}_v}}={\displaystyle \frac{c(U_{OPT}\setminus U_{ALG}^{i-1})}{b(U_{OPT}\setminus U_{ALG}^{i-1})}}.$$

The denominator of this fraction is less than B (less than the entire budget), so

$${\displaystyle \frac{c(U_{OPT}\setminus U_{ALG}^{i-1})}{b(U_{OPT}\setminus U_{ALG}^{i-1})}}\ge {\displaystyle \frac{c(U_{OPT}\setminus U_{ALG}^{i-1})}{B}};$$

that is,

$${\rho }_{v_{\mathrm{avg}}}\ge {\displaystyle \frac{c(U_{OPT}\setminus U_{ALG}^{i-1})}{B}}.$$

(12)

Thus, from (11) and (12),

$${\rho }_{v_i}={\displaystyle \frac{c_{v_i}}{b_{v_i}}}\ge {\displaystyle \frac{c(U_{OPT}\setminus U_{ALG}^{i-1})}{B}};$$

hence,

$$c(U_{OPT}\setminus U_{ALG}^{i-1})\le B·{\displaystyle \frac{c_{v_i}}{b_{v_i}}}.$$

(13)

Therefore, from (10) and (13), we obtain

$$c(U_{OPT})-c(U_{ALG}^{i-1})\le B·{\displaystyle \frac{c_{v_i}}{b_{v_i}}}.$$

Multiplying both sides by ${\displaystyle \frac{b_{v_i}}{B}}$, we obtain the required inequality (9). □

Lemma 2.

After each $i^{th}$ iteration, $i=1,\dots ,l+1$, the following holds:

$$c(U_{ALG}^i)\ge [1-{\displaystyle \prod _{k=1}^i}(1-{\displaystyle \frac{b_{v_k}}{B}})]·c(U_{OPT}).$$

Proof. 

We prove the lemma by induction on the number of iterations in which nodes $v_i$ are considered, $i=1,\dots ,l+1.$

For $i=1$ (the induction base), $c(U_{ALG}^i)=c_{v_1}$; i.e., we need to prove that

$$c_{v_1}\ge {\displaystyle \frac{b_{v_1}}{B}}·c(U_{OPT}).$$

This follows from the fact that the ratio is maximal for all nodes (the nodes are sorted by ${\rho }_v$), and the cost of the optimum is bounded by B (i.e.,

$${\displaystyle \frac{c_{v_1}}{b_{v_1}}}\ge {\displaystyle \frac{c(U_{OPT})}{B}}).$$

Suppose that the assertion of the lemma holds for iterations $1,\dots ,i-1$ (the induction hypothesis). We will show that it also holds for iteration i:

$$c(U_{ALG}^i)=c(U_{ALG}^{i-1})+c_{v_i}$$

$$\stackrel{(9)}{\ge }c(U_{ALG}^{i-1})+{\displaystyle \frac{b_{v_i}}{B}}·(c(U_{OPT})-c(U_{ALG}^{i-1}))$$

$$=(1-{\displaystyle \frac{b_{v_i}}{B}})·c(U_{ALG}^{i-1})+{\displaystyle \frac{b_{v_i}}{B}}·c(U_{OPT})$$

$$\ge (1-{\displaystyle \frac{b_{v_i}}{B}})·[1-{\displaystyle \prod _{k=1}^{i-1}}(1-{\displaystyle \frac{b_{v_k}}{B}})]·c(U_{OPT})+{\displaystyle \frac{b_{v_i}}{B}}·c(U_{OPT})$$

$$=[1-{\displaystyle \prod _{k=1}^i}(1-{\displaystyle \frac{b_{v_k}}{B}})]·(c(U_{OPT})).$$

In the proof above, the first inequality follows from Lemma 1, and the second inequality follows from the induction hypothesis. □

Next, we apply the property that for $a_1,\dots ,a_n\in {\mathbb{R}}^{+}$ such that ${\sum }_{i=1}^n{a}_i=\alpha A$, the function $(1-{\prod }_{i=1}^n(1-{\displaystyle \frac{a_i}{A}}))$ attains its minimum $1-{(1-{\displaystyle \frac{\alpha }{n}})}^n$, when $a_1=a_2=\cdots =a_n={\displaystyle \frac{\alpha A}{n}}$, for $A,\alpha >0$ [16]. Here, substituting $b_{v_k}$ for $a_i$, ${\sum }_{k=1}^{l+1}{b}_{v_k}$ for $A,l+1$ for n, and 1 for $\alpha$, we obtain that

$$[1-{\displaystyle \prod _{k=1}^{l+1}}(1-{\displaystyle \frac{b_{v_k}}{B}})]\ge [1-{(1-{\displaystyle \frac{1}{l+1}})}^{l+1}].$$

(14)

Let $b(U_{ALG}^i)$ denote the total cost of the VNF nodes selected by the algorithm after iteration $l+1$. Using the fact that adding $v_{l+1}$ to $b(U_{ALG}^i)$ violates the budget B, i.e.,

$${\displaystyle \sum _{k=1}^{l+1}}{b}_{v_k}={\displaystyle \sum _{k=1}^l}{b}_{v_k}+b_{l+1}>B,$$

(15)

and applying Lemma 2 to iteration $l+1$, we obtain

$$c(U_{ALG}^{l+1})\ge [1-{\displaystyle \prod _{k=1}^{l+1}}(1-{\displaystyle \frac{b_{v_k}}{B}})]·c(U_{OPT})$$

$$\stackrel{(15)}{\ge }[1-{\displaystyle \prod _{k=1}^{l+1}}(1-{\displaystyle \frac{b_{v_k}}{{\sum }_{k=1}^{l+1}{b}_{v_k}}})]·c(U_{OPT})$$

$$\stackrel{(14)}{\ge }[1-{(1-{\displaystyle \frac{1}{l+1}})}^{l+1}]·c(U_{OPT})$$

$$\ge (1-{\displaystyle \frac{1}{e}})·c(U_{OPT}).$$

As a result, we obtain

$$c(U_{ALG}^{l+1})=c(U_{ALG}^l)+c_{v_{l+1}}\ge (1-{\displaystyle \frac{1}{e}})·c(U_{OPT}).$$

(16)

Now, we consider the following individual cases.

• (A) If $U^{\ast }$ contains a node $v^{\prime }$ with capacity $c_{v^{\prime }}>{\displaystyle \frac{1}{2}}·c(U_{OPT})$, then this node will be considered by the algorithm as one of the nodes in the final solution, with a value of $c(U_{ALG})\ge {\displaystyle \frac{1}{2}}c(U_{OPT})$.

This will occur either at the stage of greedy selection of nodes for the candidate set of VNF nodes $U^{\prime }$ (lines 9–17 of the algorithm) or at the stage of comparison with the node with the maximum capacity (lines 28–37 of the algorithm). There can only be one such node with $c_{v^{\prime }}>{\displaystyle \frac{1}{2}}c(U_{OPT})$ (more than one such node will exceed $c(U_{OPT}))$. If this node is chosen greedily, $U_{ALG}$ may contain other nodes, but $c(U_{ALG})$ will not be less than the capacity of this node $c_{v^{\prime }}>{\displaystyle \frac{1}{2}}c(U_{OPT}).$

• (B) Now assume that no node in $U^{\ast }$ has capacity greater than ${\displaystyle \frac{1}{2}}c(U_{OPT})$.

Note that if

(B-1) $b(U_{ALG})<{\displaystyle \frac{1}{2}}·B,$ then for any $v\in U_{ALG},b_v>B$ (otherwise, it could be added to $U_{ALG}$), so, in this case, $U_{OPT}\setminus U_{ALG}$ contains at most one node (more than one with $b_v>{\displaystyle \frac{1}{2}}B$ will not fit in B).

Since, by our assumption (B), all nodes have $c_v<{\displaystyle \frac{1}{2}}·c(U_{OPT})$, it follows that $c(U_{OPT}\cap U_{ALG})>c(U_{OPT})$, and thus $c(U_{ALG})>{\displaystyle \frac{1}{2}}c(U_{OPT}).$

Finally, if

(B-2)

$$b(U_{ALG})>{\displaystyle \frac{1}{2}}·B,$$

(17)

then, by Lemma 2,

$$c(U_{ALG}^l)\ge [1-{\displaystyle \prod _{k=1}^l}(1-{\displaystyle \frac{b_{v_k}}{B}})]·c(U_{OPT})$$

$$\stackrel{(17)}{\ge }c(U_{ALG}^l)\ge [1-{\displaystyle \prod _{k=1}^l}(1-{\displaystyle \frac{b_{v_k}}{2·{\sum }_{k=1}^l{b}_{v_k}}})]·c(U_{OPT})$$

$$\stackrel{(14)}{\ge }[1-{(1-{\displaystyle \frac{1}{2l}})}^l]·c(U_{OPT})$$

$$\ge (1-{\displaystyle \frac{1}{\sqrt{e}}})·c(U_{OPT}).$$

We have shown that in certain cases, such as the presence of a node with a throughput greater than ${\displaystyle \frac{1}{2}}c(U_{OPT})$, as well as in the case where the algorithm selects VNF nodes whose cost is less than half of the allocated budget, the approximation coefficient of the first stage of Algorithm 1 (Stage II—formation of the set of VNF nodes) is ${\displaystyle \frac{1}{2}}$. In other cases, the coefficient is $(1-{\displaystyle \frac{1}{\sqrt{e}}})$.

However, we will further prove that, provided that the algorithm selects three or more VNF nodes ($l\ge 3$), this approximation coefficient can be improved.

Claim 1.

When solving the VPCA-ILP problem for VNF node placement (Stage II of Algorithm 1), provided that there are at least three nodes, the approximation ratio $(1-{\displaystyle \frac{1}{e}})$ is achieved, i.e.,

$$c(U_{ALG})\ge (1-{\displaystyle \frac{1}{e}})c(U_{OPT}).$$

(18)

Proof. 

Let $U_{ALG}^k$ be the set of the first k nodes in the order they are selected for the set U. Assume that without loss of generality that $|U_{OPT}|>k$, since otherwise $U_{ALG}=U_{OPT}$.

Therefore, based on the above, we will continue the proof for cases where $l\ge 3$ and $k\ge 3.$

Consider the $k^{\mathrm{th}}$ iteration of Stage II of Algorithm 1, which considers the subset $U_{ALG}^k$. Let $U_{\mathrm{add}}$ denote the set of nodes added to $U_{ALG}^k$ by the algorithm until $U_{ALG}$ is obtained; that is, let $U_{ALG}=U_{ALG}^k\cup U_{\mathrm{add}}.$

Obviously,

$$c(U_{ALG})=c(U_{ALG}^k)+c(U_{\mathrm{add}}).$$

(19)

The completion of $U_{ALG}^k$ in $U_{ALG}$ can be considered a separate part of Stage II of Algorithm 1, similar to the one considered earlier.

Let $l^{\prime }$ be the number of nodes added to $U_{\mathrm{add}}$ in $r^{\prime }$ iterations performed by the algorithm during the completion of the subset $U_{ALG}^k$ in $U_{ALG}$, until the first node from $U_{OPT}\setminus U_{ALG}^k$ is considered but not added to $U_{\mathrm{add}}$ because its addition violates the budget B$(l^{\prime }=l-k)$. Let $v_{i^{\prime }}$ be the ${i^{\prime }}^{\mathrm{th}}$ node added to $U_{\mathrm{add}}$, $i^{\prime }=1,\dots ,l^{\prime }$, and let $v_{l^{\prime }+1}$ be the first node from $U_{OPT}\setminus U_{ALG}^k$ that is considered but not added to $U_{\mathrm{add}}$. Applying inequality (16) to $U_{\mathrm{add}}$ instead of $U_{ALG}^l$, to $v_{l^{\prime }+1}$ instead of $v_{l+1}$, and, respectively, to $U_{OPT}\setminus U_{ALG}^k$ instead of $U_{OPT}$, we obtain

$$c(U_{\mathrm{add}})+c_{v_{l^{\prime }+1}}\ge (1-{\displaystyle \frac{1}{e}})·c(U_{OPT}\setminus U_{ALG}^k).$$

(20)

Note that when the nodes are sorted, the capacity of each of the nodes covered by $U_{ALG}^k$ is at least $c_{v_{l^{\prime }+1}}$. Therefore,

$$c_{v_{l^{\prime }+1}}\le {\displaystyle \frac{1}{k}}·c(U_{ALG}^k).$$

(21)

Now we get

$$c(U_{ALG})\stackrel{(19)}{=}c(U_{ALG}^k)+c(U_{\mathrm{add}})$$

$$\stackrel{(20)}{\ge }c(U_{ALG}^k)+(1-{\displaystyle \frac{1}{e}})·c(U_{OPT}\setminus U_{ALG}^k)-c_{v_{l^{\prime }+1}}$$

$$\stackrel{(21)}{\ge }c(U_{ALG}^k)+(1-{\displaystyle \frac{1}{e}})·c(U_{OPT}\setminus U_{ALG}^k)-{\displaystyle \frac{1}{k}}·c(U_{ALG}^k)$$

$$=(1-{\displaystyle \frac{1}{k}})·c(U_{ALG}^k)+(1-{\displaystyle \frac{1}{e}})·c(U_{OPT}\setminus U_{ALG}^k).$$

Because for $k\ge 3$

$$(1-{\displaystyle \frac{1}{k}})>(1-{\displaystyle \frac{1}{e}}),$$

(22)

and also

$$c(U_{ALG}^k)+c(U_{OPT}\setminus U_{ALG}^k)=c(U_{OPT}),$$

(23)

then as a result we get

$$c(U_{ALG})\stackrel{(22,23)}{\ge }(1-{\displaystyle \frac{1}{e}})·c(U_{OPT}).$$

Thus, claim 1 is proven. □

• Approximation Estimation for Flow Allocation

Stage III of Algorithm 1 accepts a flow f if and only if the available bandwidth at nodes $U_f$ is sufficient to handle its entire rate ${\lambda }_f$. These accepted flows constitute the set $F(U_{ALG})=\{f|x_f=1\}$. The total bandwidth of the VNF nodes along the path of flow f, i.e., ${\sum }_{v\in U_f}{c}_v$, is denoted by $c(U_f)$. For further evaluation, we introduce the following definitions that are critical for approximation analysis evaluation of our proposed solution.

Definition 1.

An $\mathit{“}\mathit{isolated}\mathit{”}\mathit{flow}$ (denoted as $f_{sep}$) is a flow that does not share any VNF nodes with other flows.

That is, it is isolated from other flows, its nodes are not connected to the nodes of other flows; it can be processed on one VNF node or on several VNF nodes, but it does not share VNF nodes with other flows, meaning no other flows pass through these VNF nodes.

Definition 2.

An $\mathit{“}\mathit{isolated}\mathit{”}\mathit{VNF}\mathit{node}$ (denoted as $v_{sep}$) is a VNF node that is not connected by flows to other VNF nodes.

That is, this node is isolated from other nodes, one or more flows pass through it and are processed by it, and these flows do not have other VNF nodes, being processed only by this node.

In the process of solving the problem, the flows considered by the algorithm can be of four types:

(A)

Non-“isolated” flows that pass through non-“isolated” nodes (each of these flows is processed on more than one VNF node, and more than one flow selected by the algorithm passes through each of these VNF nodes);

(B)

Isolated flow $f_{sep}$, pass through isolated VNF node $v_{sep}$ (the flow passes only through one node, through which no other flows pass);

(C)

Several non-“isolated” flows pass through an “isolated” node $v_{sep}$ (the flows are not “isolated”, since they are connected to each other by this common isolated VNF node, and each of these flows passes only through this one common “isolated” VNF node $v_{sep}$ and has no other VNF nodes; thus, node $v_{sep}$ is “isolated” because it is not connected by flows with other nodes (Def. 2));

(D)

“Isolated” flow $f_{sep}$ passes through several non-“isolated” VNF nodes (in this case, the flow is “isolated” because it does not share VNF nodes with other flows (Def. 1) but passes through several VNF nodes that are not “isolated” because they are connected by this common flow $f_{sep}$).

It should be emphasized that the list of these four cases ((A)–(D)) is exhaustive, since no flow can simultaneously pass through “isolated” and non-“isolated” VNF nodes (since when a flow passes through more than one VNF node, each of these VNF nodes is no longer “isolated”); similarly, none VNF node cannot simultaneously service “isolated” and non-“isolated” flows (since if multiple flows pass through a VNF node, then all these flows are no longer “isolated”).

For all flows specified in case (A), i.e., those that are not “isolated” and do not pass through “isolated” VNF nodes, we prove the following lemma.

Lemma 3.

For any flow f completely processed as a result of Algorithm 1, provided that it is NOT an “isolated” flow $f_{sep}$ or a flow passing through an “isolated” node $v_{sep}$, its distributed traffic is at least half the total capacity of its VNF nodes, i.e.,

$${\lambda }_f\ge {\displaystyle \frac{1}{2}}c(U_f).$$

(24)

Proof. 

According to Algorithm 1, the traffic of a processed flow must not exceed the total residual capacity of its VNF nodes; i.e., there is

$${\lambda }_f=\sum _{v\in U_f}{\lambda }_f^v\le \sum _{v\in U_f}{c_v}^{\prime }.$$

Consider the moment when the algorithm rejects the first flow $f_r$, since it does not have enough of the total remaining capacity of its VNF nodes. By this point, the total free capacity of all nodes in this flow $v\in U_f$ is less than ${\lambda }_{f_r}$, that is,

$${\lambda }_{f_r}>\sum _{v\in U_{f_r}}{c_v}^{\prime }.$$

Moreover, the residual capacity of each of these nodes ${c_v}^{\prime }$ is its initial capacity minus the portion already used by other flows processed by this node previously:

$${c_v}^{\prime }=c_v-\sum _{f\in F_v}{\lambda }_f^v.$$

Thus,

$${\lambda }_{f_r}>\sum _{v\in U_{f_r}}(c_v-\sum _{f\in F_V}{\lambda }_f^v)=\sum _{v\in U_{f_r}}{c}_v-\sum _{v\in U_{f_r}}\sum _{f\in F_V}{\lambda }_f^v.$$

(25)

Here, ${\sum }_{v\in U_{f_r}}{\sum }_{f\in F_V}{\lambda }_f^v$ represents the sum of the traffic portions of the flows allocated to the VNF nodes of flow $f_r$ before it was considered by the algorithm and rejected due to a lack of ${\sum }_{v\in U_{f_r}}{c_v}^{\prime }$. Since flow $f_r$ is the first to be rejected by the algorithm, all flows prior to it were fully allocated (processed).

Let us assume, by contradiction, that not all of these processed flows (those not “isolated” and not passing through “isolated” nodes), considered before flow $f_r$, used at least half of the total throughput of their VNF nodes for traffic distribution; i.e., among them there are fully allocated flows for which ${\lambda }_f<c(U_f)$. In this case, since the algorithm distributes the traffic of flows ${\lambda }_f$ among their VNF nodes proportionally to their residual capacity ${c_v}^{\prime }$, the fractions ${\lambda }_f^v$ of the traffic of such flows allocated to the VNF nodes of flow $f_r$ before it was considered and rejected must also use less than half of their capacity, meaning that

$$\sum _{v\in U_{f_r}}\sum _{f\in F_V}{\lambda }_f^v<{\displaystyle \frac{1}{2}}\sum _{v\in U_{f_r}}{c}_v,$$

and, therefore (from (25)), we have

$${\lambda }_{f_r}>{\displaystyle \frac{1}{2}}\sum _{v\in U_f}{c}_v.$$

However, this assumes that ${\lambda }_f$ of the fully processed flows considered earlier by the algorithm is less than ${\lambda }_{f_r}$ of the first flow rejected by the algorithm. This contradicts our algorithm, which requires considering flows in order from the largest ${\lambda }_f$ to the smallest. The proof follows. □

Claim 2.

When solving the VPCA-ILP in the part of flow traffic distribution (Stage III of Algorithm 1), the approximation ratio ${\displaystyle \frac{1}{2}}$ is achieved; that is, for the optimal solution ${(x_f^{\ast })}_{f\in F(U_{ALG})}$ of the LP-relaxed linear programming problem with continuous variables in the part of flows $f\in F(U_{ALG})$ (passing through at least one VNF node), Algorithm 1 returns the solution ${(x_f)}_{f\in F(U_{ALG})}$ of the integer problem in the part of flows $f\in F(U_{ALG})$, such that

$$\sum _{f\in F(U_{ALG})}{\lambda }_f·x_f\ge {\displaystyle \frac{1}{2}}\sum _{f\in F(U_{ALG})}{\lambda }_f·{x_f}^{\ast }.$$

(26)

Proof. 

By Lemma 3, the distributed traffic of each flow that is not an “isolated” flow $f_{sep}$ or a flow passing through an “isolated” node $v_{sep}$ (case (A)), completely processed as a result of Algorithm 1, is at least half the total throughput of its VNF nodes, i.e., ${\lambda }_f\ge {\sum }_{v\in U_f}{c}_v$. Summing over all flows $f\in F(U_{ALG})\setminus F_{sep}\setminus F(V_{sep})\setminus F_{sep}(V_{sep})$, that are not “isolated” or passing through an “isolated” node, we find that the total traffic across all nodes of these flows is no less than half of their total capacity:

$$\sum _{f\in F(U_{ALG})\setminus F_{sep}\setminus F(V_{sep})\setminus F_{sep}(V_{sep})}{\lambda }_f\ge {\displaystyle \frac{1}{2}}\sum _{v\in (U_{ALG}\setminus V_{sep}\setminus U_{f_{sep}})}{c}_v.$$

Here,

$V_{sep}$ is the set of “isolated” VNF nodes $v_{sep}$;

$F(V_{sep})$ is the set of non-“isolated” flows received by the algorithm that pass through them;

$F_{sep}$ is the set of “isolated” flows $f_{sep}$ recieved by the algorithm;

$F_{sep}(V_{sep})$ is the set of “isolated” flows $f_{sep}$ received by the algorithm that pass through “isolated” VNF nodes $v_{sep}$;

$U_{f_{sep}}$ is the set of VNF nodes of “isolated” flows $f_{sep}$.

Consequently, the total traffic of flows already accepted by the algorithm (for which $x_f=1$) that are not “isolated” and do not pass through “isolated” nodes

$$\sum _{f\in F(U_{ALG})\setminus F_{sep}\setminus F(V_{sep})\setminus F_{sep}(V_{sep})}{\lambda }_f·x_f$$

is not less than half of their total capacity, and this capacity is not less than the total fractional traffic of the same flows in the optimal solution of the LP-relaxed problem

$$\sum _{f\in F(U_{ALG})\setminus F_{sep}\setminus F(V_{sep})\setminus F_{sep}(V_{sep})}{\lambda }_f·{x_f}^{\ast }$$

(since the capacities $c_v$ were not exceeded in LP). That is why

$$\sum _{f\in F(U_{ALG})\setminus F_{sep}\setminus F(V_{sep})\setminus F_{sep}(V_{sep})}{\lambda }_f·x_f\ge {\displaystyle \frac{1}{2}}·\sum _{f\in F(U_{ALG})\setminus F_{sep}\setminus F(V_{sep})\setminus F_{sep}(V_{sep})}{\lambda }_f·{x_f}^{\ast }.$$

(27)

Thus, inequality (27) proves Claim 2 for case (A) flows.

• Let us consider the remaining cases separately.
  (B) The “isolated” flows $f_{sep}$ accepted by the algorithm pass only through the “isolated” VNF nodes $v_{sep}$.

In this case, two subcases are possible:

(B-1) If ${\lambda }_{f_{sep}}>c_v$, then such a flow is definitely rejected by the algorithm $(x_f=0)$.

(B-2) If ${\lambda }_{f_{sep}}\le c_v$, then in this case ${\lambda }_f<{\displaystyle \frac{1}{2}}c(U_f)$ is indeed possible (a contradiction to Lemma 3) if the traffic of this flow ${\lambda }_f<{\displaystyle \frac{1}{2}}{c}_v$ of its single VNF node. Thus, under this condition, all these flows will be unambiguously definitely accepted by the algorithm $(x_f=1)$ with their full traffic (since the capacity of their single node will be sufficient for all of them); that is, for all flows of case (B), the approximation ratio of this stage of the algorithm will be equal to 1. That is,

$$\sum _{f\in F_{sep}(V_{sep})}{\lambda }_f·x_f=\sum _{f\in F_{sep}(V_{sep})}{\lambda }_f·{x_f}^{\ast }.$$

(28)

• (C) If non-“isolated” flows share a common “isolated” VNF node, that is, each of these flows passes only through this one common “isolated” node $v_{sep}$ and has no other VNF nodes, then this case also has two subcases:

(C-1) If ${\sum }_{f\in F_v}{\lambda }_f\le c_v$, then these flows will all be definitely accepted by the algorithm $(x_f=1)$, since the capacity of this node $v_{sep}$ is sufficient to process all of these flows passing through it. Therefore, for these flows, the approximation ratio is 1 and Formula (28) is valid.

(C-2) If ${\sum }_{f\in F_v}{\lambda }_f>c_v$, then when the algorithm rejects the first such flow $f_r$ because it lacks the remaining capacity of its single VNF node, that is,

$${\lambda }_{f_r}>{c_v}^{\prime }=c_v-\sum _{f\in F_v}{\lambda }_f^v.$$

Thus, similar to the proof of Lemma 3, the total traffic of distributed flows passing through the “isolated” node $v_{sep}$ is greater than half of its capacity

$$\sum _{f\in F_v}{\lambda }_f\ge {\displaystyle \frac{1}{2}}{c}_v,$$

and therefore, the approximation coefficient for such flows is ${\displaystyle \frac{1}{2}}$; that is, Formula (27) is valid for them, and the total approximation ratio for all flows passing through “isolated” nodes (case (C) for both subcases) is not less than ${\displaystyle \frac{1}{2}}$. It means that

$$\sum _{f\in F(V_{sep})}{\lambda }_f·x_f\ge \sum _{f\in F(V_{sep})}{\lambda }_f·{x_f}^{\ast }.$$

(29)

• (D) If an “isolated” flow (which does not share VNF nodes with other flows) passes through several non-“isolated” VNF nodes (connected by this flow), then for its VNF nodes ${c_v}^{\prime }=c_v$, and two subcases are also possible:

(D-1) If ${\lambda }_{f_{sep}}\le {\sum }_{v\in U_{f_{sep}}}{c}_v$, that is, if the total capacity of its VNF nodes is not less than its speed, then it can definitely be completely allocated (i.e., it must be selected by the algorithm, $x_f=1)$, and in this case, the approximation ratio of these flows is also equal to 1; that is, Formula (28) is valid.

(D-2) If ${\lambda }_{f_{sep}}>{\sum }_{v\in U_{f_{sep}}}{c}_v$, then such a flow is definitely rejected by the algorithm $(x_f=0)$.

Thus, for all flows in case (D), the overall approximation ratio is 1; that is,

$$\sum _{f\in F_{sep}}{\lambda }_f·x_f=\sum _{f\in F_{sep}}{\lambda }_f·{x_f}^{\ast }.$$

(30)

Thus, to take into account all types of flows (cases (A)–(D)), it suffices to add (27) + (28) + (29) + (30) to obtain the required inequality (24). Claim 2 is proven. □

Theorem 1.

Algorithm 1 is a ${\displaystyle \frac{1}{2}}(1-{\displaystyle \frac{1}{e}})$-approximation algorithm for the VPCA-ILP problem.

Proof. 

By the assumptions of the VPCA-ILP problem, the objective function is

$$J=\sum _{f\in F}{\lambda }_f·x_f.$$

We denote the optimal value of the objective function of the VPCA-ILP problem by $J_{OPT}$, and the value of the objective function found by Algorithm 1 by $J_{ALG}.$

The optimal value of the objective function of the LP-relaxed linear programming problem with continuous variables was previously denoted by

$$J^{\ast }=\sum _{f\in F}{\lambda }_f·{x_f}^{\ast }.$$

(31)

The VPCA-ILP problem is a maximization problem; therefore,

$$J^{\ast }\ge J_{OPT}.$$

(32)

Given that the set $U_{ALG}=\{v|y_v=1\}$

$$c(U_{ALG})=\sum _{v\in U_{ALG}}{c}_v=\sum _{f\in F(U_{ALG})}(\sum _{v\in U_f}{c}_v)=\sum _{f\in F(U_{ALG})}(\sum _{v\in U_f}{c}_v·y_v)\stackrel{(6)}{\ge }$$

$$\sum _{f\in F(U_{ALG})}(\sum _{v\in U_f}{\lambda }_f^v)\stackrel{(4)}{=}\sum _{f\in F(U_{ALG})}{\lambda }_f·x_f\stackrel{(26)}{\ge }{\displaystyle \frac{1}{2}}\sum _{f\in F(U_{ALG})}{\lambda }_f·{x_f}^{\ast }.$$

(33)

Similarly,

$$c(U_{OPT})\ge {\displaystyle \frac{1}{2}}·\sum _{f\in F(U_{OPT})}{\lambda }_f·{x_f}^{\ast }.$$

(34)

Then from (18), (33) and (34), it follows

$${\displaystyle \frac{1}{2}}·\sum _{f\in F(U_{ALG})}{\lambda }_f·{x_f}^{\ast }\ge {\displaystyle \frac{1}{2}}·(1-{\displaystyle \frac{1}{e}})\sum _{f\in F(U_{OPT})}{\lambda }_f·{x_f}^{\ast }.$$

(35)

Thus, using (26), (31), (32), and (35), we obtain

$$J_{ALG}=\sum _{f\in F(U_{ALG})}{\lambda }_f·x_f\stackrel{(26)}{\ge }{\displaystyle \frac{1}{2}}·\sum _{f\in F(U_{ALG})}{\lambda }_f·{x_f}^{\ast }\stackrel{(35)}{\ge }$$

$${\displaystyle \frac{1}{2}}·(1-{\displaystyle \frac{1}{e}})\sum _{f\in F(U_{OPT})}{\lambda }_f·{x_f}^{\ast }\stackrel{(31)}{=}{\displaystyle \frac{1}{2}}·(1-{\displaystyle \frac{1}{e}})J^{\ast }\stackrel{(32)}{\ge }{\displaystyle \frac{1}{2}}·(1-{\displaystyle \frac{1}{e}})J_{OPT},$$

which is what was required. □

6. Complexity Evaluation of Algorithm

To estimate the complexity of this algorithm, let us consider it in terms of individual computational blocks.

1.

Stage I—LP Relaxation Solution

In the problem after relaxation, we have the following variables: $y_v\in [0,1],\mathrm{for}v\in V;x_f\in [0,1]\mathrm{for}f\in F;{\lambda }_f^v\ge 0,\mathrm{for}v\in V,f\in F.$

There are many algorithms for solving linear programming problems with varying complexity. In particular, Vaidya [17] developed an algorithm for solving linear programming problems that requires $O(m^{1.5}nL)$ arithmetic operations and is sufficient to perform each operation with $O(L)$ bit precision, where m is the number of constraints and n is the number of variables. The parameter L here can be roughly considered as the number of bits of input data. Thus, in our problem, the complexity of this block of the algorithm is

$$O(m^{1.5}nL)={O((\left|V\right|·\left|F\right|)}^{1.5}·(|V|·|F|·L)=$$

$$O(|V{|}^{2.5}·|F{|}^{2.5}·L).$$

2.

Stage II—rounding $y_v^{\ast }$ (VNF node placement).

2.1.

Sorting nodes in descending order ${\rho }_v={\displaystyle \frac{c_v}{b_v}}$: complexity of order $O(|V|log|V|).$

2.2.

Sequentially adding nodes and checking the budget constraint ${\sum }_{i=1}^k{b}_{v_i}\le B:$

-

We traverse the ordered list (in the worst case, up to $\left|V\right|$ nodes);

-

The sum is cumulative (to avoid recalculating each time), so each check step is $O(1)$;

-

The entire cycle is $O(|V|).$

Total: the rounding step of $y_v^{\ast }$ adds up to

$$O(|V|log|V|)+O(|V|)=O(|V|log|V|).$$

3.

Stage III—rounding $x_f^{\ast }$ (flow selection and distribution).

3.1.

Sorting flows $f\in F_U$ in descending order of ${\lambda }_f:$

-

In the worst case; $|F_U|\le |F|,$

-

Sorting complexity is $O(|F|log|F|).$

3.2.

Step-by-step flow addition:

-

For each flow $f_k$ (there are $\le \left|F\right|$), we check cumulatively whether we can “place” ${\lambda }_{f_k}$ into available nodes $v\in V_f\cap U;$

-

In the worst case, $|V_f|\le |V|$, i.e., each flow can be connected to any node (if we consider a very rough estimate);

-

Checking ${\sum }_{v\in V_f\cap U}{c_v}^{\prime }\ge {\lambda }_{f_k}$ takes $O(|V_f|)$, then distributing ${\lambda }_{f_k}$ (setting ${\lambda }_{f_k}^v$) also takes $O(|V_f|)$, since we need to iterate through all suitable nodes;

-

The total computation time for one thread is about $O(|V|)$; for all threads, it is $O(|V|·|F|).$

Total computation time: rounding $x_f^{\ast }$ takes

$$O(|F|log|F|+|V|·|F|).$$

4.

Overall Complexity

Combining all blocks, we get

-

LP solution: $O(|V{|}^{2.5}·|F{|}^{2.5}·L)$;

-

$y_v^{\ast }$ rounding: $O(|V|log|V|)$;

-

$x_f^{\ast }$ rounding: $O(|F|log|F|+|V|·|F|).$

Thus, the asymptotically overall complexity is $O(|V{|}^{2.5}·|F{|}^{2.5}·L).$

7. Simulation Results and Discussion

We have evaluated our (Algorithm 1) and RP-MCA [5] algorithms and performed a comparative evaluation between them. In order to do this, we considered three types of topologies of different sizes as shown in Figure 2: appropriate $k-$ ary fat tree (3-level tree with k ports on each switch), Erdos-Rényi network (we chose probability of 1/2 for existing edge between arbitrary pair of nodes in generated graph) and Barabási-Albert network (the starting graph was a triangle graph with three nodes). The results are shown below. Simulations have been conducted on the Windows 11 operating system with a 12th Gen Intel(R) Core(TM) i7-1255U 1.70 GHz processor. The simulations have been implemented in Python 3.14. We considered different size networks of varying size between 50 and 1000 nodes with the number of flows between 50 and 200. The flows were generated as random paths in the corresponding network with the rate varying in the range [20, 500]. We also considered that the case of uniform costs (valued 25 and total budget of 1000) and capacities (valued 10) versus heterogeneous case costs range is [15, 300], capacity range is [5, 100]), and total budget range [1000, 10,000]. As can be seen below, Algorithm 1 (solid) consistently outperforms RP-MCA (dashed) in our obtained traces. The performance gap and its scaling with V vary for different scenarios. Algorithm 1 will tend to outperform RP-MCA on instances where greedy, deterministic exploitation of concentrated coverage or large indivisible gains is advantageous and where the randomness or fractional rounding in RP-MCA tends to lose value. The most significant advantage of our algorithm was achieved for the case of fat-tree topology. When costs vary widely and some nodes are extremely cost-efficient (large capacity relative to cost and covering useful flows), a greedy algorithm that ranks by marginal processed flows per unit cost will quickly pick those and obtain near-optimal integral solutions. Randomized schemes that spread budget may not concentrate on the cheapest high-value nodes and can underperform in expectation.

We can characterize natural sufficient conditions under which the Algorithm 1—type approach is provably close to optimal, and when that bound is tight. If we can view the problem as selecting nodes U under cost budget B so that the set (or total rate) of processed flows is a monotone submodular function of U, then the standard greedy algorithm that at each step picks the node with largest marginal gain per unit cost achieves a $(1-1/e)$—approximation to the optimum for the budgeted case (this is the classical result for budgeted maximum coverage). There are known worst-case instances for budgeted coverage where no polynomial-time algorithm can beat $(1-1/e)$ unless P = NP; so our algorithm guarantee is essentially is tight in that abstraction. If node capacities $c_v$ are large relative to demand so capacity constraints rarely bind (or the algorithm’s local allocations never exceed capacities), then the problem reduces to budgeted coverage and our solution is near-optimal.

8. Conclusions

In this paper, we have considered the problem of VNF node placement and bandwidth allocation in a network graph, i.e., selecting the best subset of VNF nodes and optimally distributing their bandwidth to maximize the total volume of fully processed traffic flows.

Unlike previous approaches, we have introduced a simpler algorithm for solving this problem, representing it as an integer linear programming problem (VPCA-ILP) with two integer variables—VNF node placement and flow selection. This algorithm consists of several stages: solving an LP-relaxed linear programming problem to obtain optimal fractional values for the variables, followed by rounding these fractional variables, resulting in a set of VNF nodes, and then using this set, distributing the capacity of these VNF nodes among the flows they process. We have also proven that with an approximation ratio of ${\displaystyle \frac{1}{2}}·(1-{\displaystyle \frac{1}{e}})$, the time complexity of this algorithm is ${\displaystyle \frac{1}{2}}(1-{\displaystyle \frac{1}{e}})$, and its complexity is $O(|V{|}^{2.5}·|F{|}^{2.5}·L)$ which is the case for $\left|F\right|=o(|V|)$, which is a better result than in [5]. Notice that fixed routing paths and static traffic assumptions as described in our problem impose strict restrictions on the shape of our solution. If we are interested in making the system more dynamic, additional algorithmic and optimization techniques must be involved. Several recent intelligent methods may be considered as well, as described in [18,19]. Also it would be interesting to obtain better approximation solutions to the original problem.