Delay guaranteed SFC placement with VNF parallelization in multidomain IoT networks

Abstract

As an emerging network technology, Network Function Virtualization (NFV) enables network functions decoupling from dedicated hardware by replacing traditional middleboxes with software implemented Virtual Network Functions (VNFs). In NFV-enabled Internet of Things (IoT) networks, each IoT service can be represented as an ordered sequence of VNFs, referred to as Service Function Chain (SFC). Through NFV, operating expenditure and capital expenditure can be significantly reduced, thereby achieving flexible provisioning of IoT services. However, with the arriving of 6G era, the network scale of IoTs continuously expands, and service requirements of IoT users become more diversified. Particularly, 6G enabled IoT services have stringent delay requirements. How to efficiently place the SFCs in multi-domain IoT networks to satisfy the specific delay requirements while guaranteeing quality of service becomes a serious challenge. To this end, in this paper, we investigate the problem of delay guaranteed SFC placement in multi-domain IoT networks. Specifically, by taking in account QoS requirements and VNF dependency relationships, we formulate the problem of delay guaranteed SFC placement in multi-domain IoT networks as a multi-objective optimization model to maximize service acceptance ratio and minimize operational cost, while satisfying the delay requirements of SFC requests. To solve the problem, we further design a Delay Guaranteed heuristic SFC Placement (DGSP) algorithm with VNF parallelization. In the proposed DGSP algorithm, the VNFs without dependency relationships are placed in parallel in an adaptive and cost efficient manner, and virtual link mapping is performed based on the shortest path algorithm. Finally, we conduct simulation experiments for performance evaluation, and simulation results demonstrate the proposed DGSP algorithm can get higher service acceptance ratio and lower operational cost than comparison algorithms.

Introduction

In traditional networks, various types of network functions can be realized based on middleboxes to satisfy various service requirements of different users. However, middleboxes heavily rely on the specific hardware, causing big Capital Expenditure (CAPEX) and Operational Expense (OPEX). Recently, Network Function Virtualization (NFV) has emerged as a promising network architecture to improve the flexibility and agility of service provisioning¹. Unlike middleboxes, network functions in NFV-enabled networks can be decoupled from specific hardware devices, and implemented as Virtual Network Functions (VNF) in the form of software. Benefiting from NFV, each network service can be constructed as a series of VNFs in a predefined sequence, called Service Function Chain (SFC)². To provide efficient services, all VNFs in the SFC should be deployed on common off-the-shelf servers which can satisfy the specific resource demands. At the same time, all virtual links in the SFC are required to map into the available physical links which can satisfy the specific bandwidth demands. This is known as the SFC placement problem. By leveraging SFC technique, network services can be achieved in dynamic and elastic method. It is vital for SFC placement strategy to guarantee network performance while satisfying Quality of Service (QoS) requirements of users.

Nowadays, with the coming of 6th Generation of mobile networks (6G) era, network scale of Internet of Things (IoT) grows rapidly, and meanwhile the service requirements of IoT users become more diversified³. To satisfy ever-increasing demands of users, service providers are envisioned to offer high quality and customized services in multi-domain IoT networks⁴. Different from single-domain IoT networks, multiple service providers and network operators collaborative to provide IoT network services in the multi-domain IoT network scenarios. The management strategies for different IoT domains are different so that the resource capacities and resource usage cost in various domains are also different. Multiple service providers and network operators in multi-domain IoT networks make SFC placement more complicated and challenging. When handling SFC placement, a SFC may be deployed across multiple IoT domains. As depicted in Fig. 1, one SFC which is composed of five VNFs may be deployed in the IoT single-domain network (represented by the red dashed arrow), or deployed in multiple IoT domain network (represented by the black dashed arrow). Compared with such case that a SFC is placed in the IoT single-domain network, the additional operational cost will become big and end-to-end delay of IoT service will be prolonged due to cross-domain deployment of SFC. Once the delay constraint of SFC request or operational cost constraint of service provisioning are violated, QoS requirements of IoT users cannot be satisfied. And accordingly, Quality of Experience (QoE) of IoT users may be affected significantly. Therefore, it is urgent to design an efficient SFC placement solution to save operational cost caused by SFC cross-domain placement while satisfying the delay requirements of SFC requests.

Figure 1

SFC placement in multi-domain IoT scenarios.

In recent years, a large number of research works have been concentrated on SFC placement optimization, in order to fulfill service requirements of a variety of users^5,6. Most existing researches focus on service cost saving, availability guarantee and delay optimization, by adopting heuristics based algorithms, machine learning based algorithms, or game based algorithms. However, few works try to jointly improve QoS and reduce operational cost while satisfying the delay constraints of SFC requests when placing the SFCs in multi-domain IoT networks. Therefore, it is desirable to design a novel SFC placement mechanism to reduce operational cost while guaranteeing the delay requirements of SFC requests.

In realistic IoT service applications, there exist certain dependency relationship constraints between different VNFs within the same SFC. For example, given a SFC $s: VF1 \sim VF2 \sim VF3 \sim VF4 \sim VF5$. We assume that VF2 depends on VF5. It means that data flow should be steered to traverse the instance of VNF VF5 before traversing the instance of VNF VF2. Therefore, VNFs VF2 and VF5 cannot be placed on the same server node when deploying the SFC s. In contrast, the other VNFs in the SFC s such as VF1 and VF3 can separately share the same server with VNF VF2 or VF5. In other words, some VNFs without dependency relationship constraints in the same SFC can be placed in parallel. In such case, the end-to-end delay will significantly decrease. Therefore, the VNF parallelization can be used to optimize the SFC placement in multi-domain IoT networks, thereby reducing end-to-end delay.

Inspired by this, in this paper, we focus on the problem of delay guaranteed SFC placement in multi-domain IoT networks with VNF parallelization. To improve QoE of IoT users, we take into account QoS requirements of SFC requests to establish a multi-objective optimization model for delay guaranteed SFC placement in multi-domain IoT networks, with the target of service acceptance ratio maximization and operational cost minimization. Then, we design a delay guaranteed heuristic SFC placement algorithm to reduce operational cost and improve service acceptance ratio, while guaranteeing the delay requirements of SFC requests. The main contributions of this paper are as follows.

• We establish a multi-objective optimization model for SFC placemen in multi-domain IoT networks, with the target of service acceptance ratio maximization and operational cost minimization, while guaranteeing the delay requirements of SFC requests.

• We develop a Delay Guaranteed heuristic SFC Placement (DGSP) algorithm to solve the above problem. In the proposed DGSP algorithm, the original SFC is reconstructed based on its VNF dependency relationships, and the VNFs without dependency constraints are placed in parallel. All VNFs in the same SFC are in priority placed in the same sub-IoT domains with small operational cost.

• We conduct extensive simulations to evaluate the performance of DGSP algorithm. Simulation results demonstrate the proposed DGSP algorithm outperforms benchmark algorithms terms of service acceptance ratio and operational cost.

The reminder of this paper is organized as follows. Section 2 presents the related works. We describe the system model and problem formulation in Section 3. Section 4 presents the detailed design of DGSP algorithm and the performance evaluations of the proposed DGSP algorithm is discussed in Section 5. We finally conclude this paper in Section 6.

Related works

Numerous research works have developed different optimization models and solutions for SFC placement in IoT scenarios by considering various optimization objectives in recent years.

Almurshed et al.⁷ designed an enhanced optimized greedy nominator heuristic SFC framework to optimize machine learning and artificial intelligence application placement in edge enabled IoTs. Liu et al.⁸ formulated the SFC dynamic orchestration problem as an Integer Linear Programming (ILP) model to minimize end-to-end delay, and devised a Lagrangian relaxation based heuristic SFC orchestration algorithm to solve it. Guo et al.⁹ formulated the user mobility and resource demand prediction based SFC reconfiguration problem as an ILP model to minimize end-to-end delay and SFC configuration cost, and devised a long short term memory network based SFC active reconfiguration algorithm to solve it. Xu et al.¹⁰ established a multiobjective SFC deployment model for cloud edge collaborative SFC mapping to balance the quality of industrial IoT services and resource consumption, and devised a deep Q-learning based online SFC deployment algorithm to solve it. Zhang et al.¹¹ designed a resource and QoE aware SFC placement algorithm for next-generation multi-domain IoT networks to minimize service cost comprised of resource consumption cost, cross-domain operation cost and penalty cost, by leveraging generative artificial intelligence technique. Zhu et al.¹² considered the competitive behaviors of users to formulate the resource allocation problem as a multiuser competition game model, and devised a multiagent reinforcement learning-based SFC deployment algorithm. Guo et al.¹³ designed a heterogeneous IoT network resource management model by integrating blockchain and SDN/NFV techniques, and devised an asynchronous advantage actor-critic based SFC orchestration algorithms to reduce SFC orchestration cost. Tsakanikas et al.¹⁴ designed an intelligent QoS monitoring model for next generation IoT to trigger SFC live migrations, thereby avoiding edge devices overload.

Xie et al.¹⁵ proposed a Graph Neural Network (GNN) and Deep Reinforcement Learning (DRL) based SFC deployment algorithm to realize VNF forwarding graph placement to reduce system cost. Thanh et al.¹⁶ designed a smart traffic monitoring IP camera system for edge cloud environments, and devised a resource and energy aware SFC algorithm for IoT applications to satisfy dynamic load and resource requirements of SFC requests. Li et al.¹⁷ formulated the radio aware SFC deployment problem in edge-enabled industrial IoT as a Markov Decision Process (MDP) model to reduce delay, and devised a natural gradient based actor critic SFC algorithm to address the radio resource dynamics problem. To detect anomalies in the SFC, Tang et al.¹⁸ designed a distributed knowledge distillation framework based time-series anomaly detection model to detect each status of VNF and perform anomaly detection on each link containing different VNFs. Chen et al.¹⁹ formulated the SFC selection and dynamic SFC orchestration problem to maximize total utility, and devised an average multistep double deep Q-network based distributed SFC orchestration algorithm to solve it. Huang et al.²⁰ considered the unique characteristics of industrial IoT services to formulate the delay constrained dynamic SFC orchestration problem as a MDP model, and devised a DRL based orchestration algorithm to solve it.

Table 1 Comparison between related work and our work.

Zeydan et al.²¹ designed a blockchain based network service orchestration architecture to achieve secure life cycle management of SFCs in a multi-cloud and multi-domain environment via a permissioned distributed ledger scheme. By combining SDN, NFV and deep learning, Zhang et al.²² designed an intelligent multi-domain SFC deployment architecture to achieve automatic SFC placement in multi-domain networks, based on real time network topology and resource status. To enhance service reliability of user requests, Liang et al.²³ designed a reliability augmentation algorithm for an admitted request with a SFC and reliability expectation requirements in mobile edge computing networks. Cai et al.²⁴ designed a privacy-preserving SFC deployment mechanism across multiple domains to protect resource and topology privacy. A deep Q-network based SFC deployment strategy is presented to protect domains privacy, and the learned strategies are distributed to intra-domain controllers to implement specific services. Zhang et al.²⁵ formulated the SFC embedding problem in space-division multiplexing elastic optical networks as an ILP optimization model, aiming to minimize the maximum index of utilized frequency slot, and designed a greedy SFC embedding algorithm solve it. Li et al.²⁶ established an ILP optimization model for the slice-based SFC embedding problem, with the aim to maximize flow acceptance ratio and minimize network resource cost. Two novel heuristic algorithms are devised to solve the problem. With sharing only a minimal amount of network domain information, Chen et al.²⁷ devised a distributed federated SFC framework to achieve the orchestration and maintenance of SFC in a distributed manner. He et al.²⁸ formulated the SFC mapping problem as an ILP optimization model with the target of the maximum link load factor minimization, and designed a novel SFC design and mapping joint optimization algorithm to solve it. By blending the merits of SDN and NFV, Zhang et al.²⁹ proposed a SFC based multi-domain service customization and deployment framework, to customize multi-domain network services based on users’ service preferences. Zhang et al.³⁰ designed a deep learning based VNF resource requirement prediction model by combining multitask regression layer and graph neural network, and presented a prediction-assisted Viterbi algorithm to solve the SFC placement problem. Although the above works focus on SFC placement optimization, delay guarantee of SFC requests is not considered.

To meet delay constraints of service requests, Wang et al.³¹ studied the parallelized SFC placement problem in data center networks taking into account availability guarantee and resource optimization. Three SFC placement strategies and a hybrid SFC placement algorithm are designed to reduce SFC delay and link resource consumption. Li et al.³² presented an availability-aware SFC provision algorithm, aiming to maximize the total number of service requests while satisfying reliability requirements of SFC requests. To minimize the average delay of service requests, an online service switching method is devised by jointly considering queuing delay, communication delay and switching delay. Cai et al.³³ presented a bin packing model based adaptive parallel SFC processing optimization mechanism to reduce delay and resource consumption. The proposed mechanism adjusts the SFC graph and further jointly optimizes SFC deployment and scheduling in a self-adaptive method. Varasteh et al.³⁴ formulated the power-aware and delay-constrained joint VNF placement and routing problem as an ILP optimization model, and designed a fast heuristic algorithm to solve it in an online manner. Yue et al.³⁵ formulated the resource optimization and delay guaranteed SFC placement problem as an ILP optimization model, with the aim to minimize resource consumption by considering resource overheads and shareability of VNF instances, and designed a two-phase SFC placement approach to solve it. Zheng et al.³⁶ formulated the parallelism-aware service function chaining and embedding problem to reduce processing delay of SFC, and designed a near-optimal maximum parallel block gain first optimization SFC deployment algorithm to solve it. To satisfy delay requirements, Sun et al.³⁷ formulated the SFC deployment problem as an ILP optimization model, aiming to minimize the total cost, and presented a heuristic SFC deployment algorithm to efficiently deploy the SFCs by using the hop-by-hop bandwidth allocation approach.

Considering fundamental resource overheads and the shareability of VNF instances, Yue et al.³⁸ proposed a throughput optimization and delay guarantee heuristic SFC placement algorithm to maximize the number of accepted SFC requests while guaranteeing the delay requirements of SFC requests. Pham et al.³⁹ formulated the SFC placement problem with delay guarantee as a mixed ILP model, and designed a reinforcement learning based traffic engineering solution to solve it. To guarantee delay requirements, by taking into account heterogeneity and capacity constraints of NFV nodes, Li et al.⁴⁰ formulated the resource-constrained multi-SFC embedding problem as an exact potential game model, and designed two iterative algorithms to get the best Nash equilibrium. Yaghoubpour et al.⁴¹ formulated the SFC deployment problem as a mixed-integer convex programming model to reduce end-to-end delay, and designed a two-level mapping algorithm to solve it. The functions of SFCs are mapped to VNF instances at the first level and VNF instances are deployed in the physical network at the second level. Wang et al.⁴² designed an online bandit learning based real-time SFC selection and deployment algorithm to provide popular services with the lowest latency by employing the greedy strategy based Prim-inspired method. Huang et al.⁴³ designed a federated reinforcement learning based scalable SFC orchestration framework to map the VNFs flexibly to reduce placement errors and improve resource utilization ratio. Toumi et al.⁴⁴ designed a DRL based multi-domain SFC placement algorithm to automatically construct the SFC placement policy by taking into account delay and cost constraints.

Li et al.⁴⁷ formulated the collaborative task offloading problem as a social welfare maximization model, and primal dual based online collaborative offloading algorithm to solve it. Cao et al.⁴⁸ formulated the multiuser computation offloading decision making problem as an exact potential game model, and machine learning based distributed computation offloading algorithm to solve it. While the cited works^47,48 provide effective solutions for network performance optimization in task offloading, our method addresses the delay guaranteed SFC placement problem by heuristic algorithm, to maximize service acceptance ratio and minimize operational cost. Compared with the other solutions such as online optimization and game theory, heuristic solutions can strike a balance between efficiency and solution quality by reducing search space and simplifying computational steps, making them particularly suitable for large-scale and high-complexity scenarios, particularly NP-hard problems. Therefore, heuristic solutions are suitable to solve the SFC placement in multi-domain IoT networks. Moreover, the above two research work focuses on task offloading based on online optimization, rather than SFC placement.

In addition, some solutions based on digital twin have been proposed to optimize network performance, such as⁴⁹ and⁵⁰. Digital twin can be used to address cross-domain network data privacy issues. Digital twin can achieve active optimization through real-time simulation and predictive decision-making, while VNFs focus more on the flexible deployment of functional modules. Digital twin and VNF techniques both support dynamic resource management, thereby improving network performance. Different from digital twin based optimization solutions, our work focuses on SFC placement in multi-domain IoT networks.

The aforementioned works put forward to a large number of SFC placement optimization solutions, in order to satisfy diversified service requirements of various service requests. However, as shown in Table 1, most of existing works neglect to jointly consider the dependency relationships among VNFs in the same SFC and QoS requirements for SFC placement optimization in multi-domain IoT networks. Different from above researches, in this work, we study the delay guaranteed SFC placement problem in multi-domain IoT networks, to maximize service acceptance ratio and minimize operational cost while guaranteeing the delay requirements of SFC requests.

System model and problem formulation

In this section, we introduce system model and problem formulation of delay guaranteed SFC placement in multi-domain IoT networks, In this work, we assume that multiple VNFs in different SFCs can share the same server nodes, and one VNF can be only placed on one server. The main notations used throughout this paper are listed in Table 2.

Table 2 Key Notations.

System model

Network model

We model the physical substrate multi-domain IoT network as an undirected graph $G=(V,E)$, where V denotes the set of IoT nodes, including switch nodes and server nodes, and E denotes the set of physical IoT links. As stated before, a multi-domain IoT network is comprised of several different sub-network IoT domains. Therefore, we model each sub-network IoT domain as an undirected graph $G'_i=(V'_i,E'_i)$, where $V'_i$ denotes the set of IoT nodes in i-th sub-network domain and $E'_i$ denotes the set of physical IoT links in i-th sub-network domain. To offer efficient IoT services, different types of VNF instances are instantiated by IoT server nodes with enough resource to process the traffic, and meanwhile data flow is forwarded by switch nodes. Each IoT server $v_s^{i,j}$ in sub-network domain $G'_i$ has a certain quantity of available resources, including but not limited, computing (i.e., CPU), memory and storage resources. We represent the resource of IoT server by $p^{i,j}$=($p_c^{i,j}$, $p_m^{i,j}$, $p_s^{i,j}$). Each physical IoT link has certain bandwidth resource denoted by $b_{m,n}^{i,j}$. The link delay between IoT nodes $v^{i,j}$ and $v^{m,n}$ is denoted as $d_{m,n}^{i,j}$. With respect to resource consumption of VNF instances, we define $s_c^{i,j}$, $s_m^{i,j}$, $s_s^{i,j}$ and $s_{m,n}^{i,j}$ to represent the unit usage cost of computing, memory, storage and bandwidth resources in i-th IoT sub-network domain, respectively.

SFC requests model

A service request needs to traverse a set of VNFs in the SFC in a predefined order. The set of SFC requests is represented as $R=(R_1,R_2,\cdots )$. The set of service required VNFs is denoted as $F=(F_1,F_2,\cdots )$. Each service instance of a VNF $F_i$ has certain resource requirement in terms of computing, memory and storage, denoted by $d_i=(d_c^i, d_m^i, d_s^i)$. We define $R_i=(R_i^{src}, R_i^{dst}, R_i^f, R_i^{vfd}, R_i^{dl},R_i^{bw})$ to represent one SFC request, where $R_i^{src}$ and $R_i^{dst}$ are source and destination nodes of service request, $R_i^f$ is the SFC of service request, $R_i^{vfd}$ is the set of dependency relationships between the VNFs in the SFC $R_i^f$, $R_i^{dl}$ is the delay requirement of requested service, $R_i^{bw}$ is the bandwidth requirement of requested service.

Problem formulation

Decision variables

To indicate the VNF placement location, we define a binary decision variable $x_{i,j}^{m,n}$ to represent whether the VNF $R_{i,j}^f$ is placed on IoT server node $v_s^{m,n}$ or not. If it is 1, VNF $R_{i,j}^f$ is placed on server node $v_s^{m,n}$, expressed as follows.

$$\begin{aligned} x_{i,j}^{m,n}=\left\{ \begin{aligned} 1&~~if~R_{i,j}^f~is~ placed~ on~ v_{s}^{m,n} \\ 0&~~otherwise \end{aligned} \right. \end{aligned}$$

(1)

There exist different types of VNFs in the real multi-domain IoT network scenarios. We define a binary decision variable $y_{i,j}^k$ to indicate the relationship between VNF type $F_k$ and the j-th VNF $R_{i,j}^f$ in the SFC $R_{i}^f$, expressed as follows.

$$\begin{aligned} y_{i,j}^k=\left\{ \begin{aligned} 1&~~ if~ R_{i,j}^f~belongs~ to~ F_k \\ 0&~~ otherwise \end{aligned} \right. \end{aligned}$$

(2)

On the other hand, for any SFC, there exist certain dependency constraints between its VNFs. Therefore, we define a binary decision variable $z_{i,j}^k=1$ to denote that VNF $R_{i,j}^f$ depends on VNF $R_{i,k}^f$ in the SFC $R_i^f$, expressed as follows.

$$\begin{aligned} z_{i,j}^{k}=\left\{ \begin{aligned} 1&~~ if ~R_{i,j}^{f} ~depends ~on~R_{i,k}^{f} \\ 0&~~otherwise \end{aligned} \right. \end{aligned}$$

(3)

To offer efficient IoT services, virtual links in the SFC needs to be mapped in the physical IoT links with abundant resource. Therefore, we define a binary decision variable $\varphi _{i,j,k}^{m,n,u,v}$ to identify the mapping relationship between virtual link and physical IoT link. If virtual link $l_{i,j,k}$ between VNF nodes $R_{i,j}^f$ and $R_{i,k}^f$ in the SFC $R_i^f$ is successfully mapped in the physical IoT link $e_{m,n}^{u,v}$, $\varphi _{i,j,k}^{m,n,u,v}=1$; otherwise, $\varphi _{i,j,k}^{m,n,u,v}=0$, expressed as follows.

$$\begin{aligned} \varphi _{i,j,k}^{m,n,u,v}=\left\{ \begin{aligned} 1&~~if~l_{i,j,k} ~ is ~ mapped ~ in ~e_{m,n}^{u,v} \\ 0&~~otherwise \end{aligned} \right. \end{aligned}$$

(4)

To indicate whether the SFC $R_i^f$ is successfully placed in the multi-domain IoT network or not, we define a binary decision variable $g_i$, expressed as follows.

$$\begin{aligned} g_i=\left\{ \begin{aligned} 1&~~if~R_i^f ~is~ sucessfully~ placed \\ 0&~~otherwise \end{aligned} \right. \end{aligned}$$

(5)

Similarly, we define a binary decision variable $\psi _{i,j,k}^{H,m,n,u,v}$ to indicate whether the virtual link $l_{i,j,k}$ is successfully mapped in the physical path $H_{m,n}^{u,v}$ or not, where source node is $v^{m,n}$ and destination node is $u^{u,v}$, expressed as follows.

$$\begin{aligned} \psi _{i,j,k}^{H,m,n,u,v}=\left\{ \begin{aligned} 1&~~if~l_{i,j,k}~is~mapped~in~H_{m,n}^{u,v} \\ 0&~~otherwise \end{aligned} \right. \end{aligned}$$

(6)

Moreover, we define $L_{m,n}^{u,v}=\{e_{p,q}^{s,t} \in H_{m,n}^{u,v} \}$ to represent the set of links belonging to a physical path $H_{m,n}^{u,v}$.

Objective functions

To satisfy QoS requirements and guarantee QoE of IoT users, more SFC requests are expected to accommodate multi-domain IoT networks. We define service acceptance ratio of service requests as follows.

$$\begin{aligned} \theta = \frac{{ {\textstyle \sum _{i}^{}g_i} }}{{|R|}} \end{aligned}$$

(7)

Where |R| is the total amount of SFC requests.

On the other hand, we expect to reduce the operational cost caused by SFC placement in multi-domain IoT networks. In this work, we assume that the operational cost is composed of resource consumption cost and SFC cross-domain placement cost. The operational cost of SFC placement in multi-domain IoT networks can be calculated as follows.

$$\begin{aligned} & \phi \mathrm{{ = }}\sum \nolimits _{{R_t},{g_i}} {\{ \varsigma \cdot {\theta _i} + \eta \cdot \delta (R_i^f)\} } \end{aligned}$$

(8)

$$\begin{aligned} & \theta _i =\sum \nolimits _{R_i^f} \{ x_{i,j}^k \cdot z_{i,j}^{m,n} \cdot (\frac{{d_c^k}}{{p_c^{m,n}}} \cdot s_c^{m,n} + \frac{{d_m^k}}{{p_m^{m,n}}} \cdot s_m^{m,n} + \frac{{d_s^k}}{{p_s^{m,n}}} \cdot s_s^{m,n}) \nonumber \\ & \quad + \varphi _{i,j,l}^{m,n,u,v} \cdot \psi _{i,j,l}^{H,m,n,u,v} \cdot H_{m,n}^{u,v} \cdot \frac{{R_i^{bw}}}{{b_{m,n}^{u,v}}} \cdot s_{m,n}^{u,v}\} \end{aligned}$$

(9)

Where $\varsigma$ and $\eta$ are the weight coefficients, $\theta _i$ is resource consumption cost caused by the placement of SFC $R_i^f$, $\delta (R_i^f )$ is the total amount of IoT domains occupied by the SFC $R_i^f$.

Optimization model

Our optimization objective is to maximize service acceptance ratio and minimize the operational cost. Therefore, we formulate the delay guaranteed SFC placement problem in multi-domain IoT networks as a multi-objective optimization model, expressed as follows.

$$\begin{aligned} & ~~~~~Max \, \theta \nonumber \\ & ~~~~~min \, \phi \nonumber \\ & s.t \end{aligned}$$

(10)

$$\begin{aligned} & C1:~~\sum {x_{i,j}^{u,v}} = 1,~~~~\forall u,v \end{aligned}$$

(11)

$$\begin{aligned} & C2:~~\sum {x_{i,j}^{u,v}\cdot y_{i,j}^k} \cdot d_c^k \le p_c^{u,v},~~~~\forall u,v \end{aligned}$$

(12)

$$\begin{aligned} & C3:~~\sum {x_{i,j}^{u,v} \cdot y_{i,j}^k} \cdot d_m^k \le p_m^{u,v},~~~~\forall u,v \end{aligned}$$

(13)

$$\begin{aligned} & C4:~~\sum {x_{i,j}^{u,v} \cdot x_{i,j}^k} \cdot d_s^k \le p_s^{u,v},~~~~\forall u,v \end{aligned}$$

(14)

$$\begin{aligned} & C5:~~ \sum {\varphi _{i,j,k}^{m,n,u,v}} \cdot R_i^{bw} \le b_{m,n}^{u,v},~~~~\forall m,n,u,v \end{aligned}$$

(15)

$$\begin{aligned} & C6:~~\sum {\psi _{i,j,k}^{H,m,n,u,v}} = 1,~~~~ \forall m,n,u,v \end{aligned}$$

(16)

$$\begin{aligned} & C7:~~\sum {\varphi _{i,j,k}^{m,n,u,v}} = 1,~~~~\forall m,n,u,v \end{aligned}$$

(17)

$$\begin{aligned} & C8:~~f_{i,j}^k - f_{i,k}^j = \left\{ \begin{matrix} 1 & ~~if~y_{i,j}^k=1\\ -1 & ~~if~y_{i,k}^j=1\\ 0 & ~~otherwise \end{matrix}\right. ~,~~~~\forall i,j,k \end{aligned}$$

(18)

$$\begin{aligned} & C9:~~\sum {\varphi _{i,j,k}^{m,n,u,v}} \cdot d_{m,n}^{u,v} \le R_i^{dl},~~~~ \forall i \end{aligned}$$

(19)

$$\begin{aligned} & C10:~~p_{i,j} - p_{j,i} = \left\{ \begin{matrix} 1 & ~~if~R_{i,j}^f=R_i^{src}\\ -1 & ~~if~R_{i,j}^f=R_i^{dst}\\ 0 & ~~otherwise \end{matrix}\right. ~,~~~~\forall i,j \end{aligned}$$

(20)

$$\begin{aligned} & C11:~~\sum x_{i,j}^{m,n}\cdot x_{i,k}^{u,v} \cdot \varphi _{i,j,k}^{m,n,u,v} \cdot \psi _{i,j,k}^{H,m,n,u,v}=1,~~~~\forall i,j,k \end{aligned}$$

(21)

Constraint C1 ensures that each VNF can only be placed on one IoT server node. Constraints C2 $\sim$ C4 guarantee that the total computing, memory and storage resources allocated for VNFs being placed on the IoT server node cannot exceed overall resource capacity of that IoT server node. Constraints C6 and C7 indicate that one virtual link should be mapped in only one physical IoT link and one physical path respectively. Constraint C8 ensures that if the VNF $R_{i,k}^f$ being placed on IoT server node $v_s^{u,v}$ depends on VNF $R_{i,j}^f$ being placed on IoT server node $v_s^{m,n}$, data flow must be steered to traverse from IoT server nodes $v_{s}^{m,n}$ to $v_{s}^{u,v}$. Constraint C9 guarantees that the delay requirement of SFC request should be satisfied. Constraint C10 ensures the sequencing constraints of VNFs in a SFC. Constraint C11 ensures the constraint on VNF placement and available paths for connecting the corresponding VNFs.

In addition, these binary decision variables $x_{i,j}^{m,n}$, $y_{i,j}^k$, $z_{i,j}^{k}$, $\varphi _{i,j,k}^{m,n,u,v}$, $\psi _{i,j,k}^{H,m,n,u,v}$, and $g_i$ should obey the 0-1 integer constraints

DGSP algorithm

In order to solve the above problem, we devise a delay guaranteed heuristic SFC placement algorithm. In this section, we first introduce the detailed design of DGSP algorithm and then discuss its algorithm complexity.

Algorithm design

Algorithm 1 presents the main workflow of the proposed DGSP algorithm. The proposed DGSP algorithm takes a multi-domain IoT network G and a set of SFC requests R as the input, and finally outputs the optimal SFC placement solution P and SFC placement flag (i.e., an indicator to identify SFC placement successes or fails) flg. In the proposed DGSP algorithm, we reconstruct the original SFC for each requested service by leveraging the VNF dependency relationship constrains. In the SFC reconstruction process, for each SFC, its all VNFs are categorized into two different sets based on their dependency relationships. More specifically, the VNFs without dependency relationship constraints can be placed on the same IoT servers in parallel. The VNFs in the same SFC are in priority placed in the same IoT sub-network domains with least resource consumption cost as possible. The main workflow of the proposed DGSP algorithm is described as follows.

At the beginning of DGSP algorithm , We first reconstruct the SFCs by leveraging the dependency relationship constraints between the VNFs, in order to efficiently reduce end-to-end delay of SFC, illustrated in Lines 2-4. For each service request, all VNFs in the SFC are categorized into two sets based on the VNF dependency relationship constraints, i.e., dependent-VNF set and nondependent-VNF set. In order to facilitate the understanding, we give a simple example. It is assumed that one SFC $f_1$ is composed of five different VNFs, denoted as: $VF1-VF2-VF3-VF4-VF5$ and $VF2 \rightarrow VF5$. $VF2 \rightarrow VF5$ represents virtual network function VF2 depends on virtual network function VF5. Based on the dependency relationships, all the VNFs in the SFC $f_1$ are divided into two sets, i.e., $g_d=(VF2,VF5)$ and $g_{nd}=(VF1,VF3,VNF4)$. The VNFs in the nondependent-VNF set $g_{nd}$ can be placed on the same IoT server nodes which can satisfy the resource demands. However, the VNFs in dependent-VNF set cannot be placed on the same IoT server nodes in parallel due to VNF dependency relationship constraints. After completing the VNF category, the original SFC is reconstructed as a set of different VNF groups. The length of reconstructed SFC can be calculated as the sum of the total number of VNFs in the dependent-VNF set and 1. With respect to SFC $f_1$, its reconstructed SFC $f'_1$ can be represented as $(VF2) \rightarrow (VF5)-(VF1, VF3, VF4)$. The length of SFC $f_1$ is 5, but the length of SFC $f'_1$ is 3. The specific procedure of SFC reconstruction algorithm (i.e., SFCRC algorithm) is illustrated in Algorithm 2.

After completing the SFC reconstruction, we begin the SFC paralleled placement process. To reduce end-to-end delay of SFC, the VNFs without dependency relationship constraints can be placed on the same IoT server nodes in parallel, and the VNFs in the nondependent-VNF set can be placed on the same servers with the dependent-VNFs. For example, for SFC $f_1$, VNFs VF1 and VNF2 can be placed on the same IoT server node in parallel, and VNFs VF1 and VNF3 can also be placed on the same IoT server node in parallel. To further reduce operational cost, all the VNFs in the same SFC are prioritized for placement within the same IoT sub-network domain and on the IoT server nodes with small resource usage cost. For example, when placing the SFC $f_1$, We prioritize placing five VNFs in a IoT sub-network domain. The detailed process of SFC placement is described as follows.

Before the SFC placement, we sort all the IoT sub-network domains by resource capacity in descending order. Next, we process the placement of first VNF. We select the appropriate IoT server, which can satisfy resource requirement of that VNF and has the smallest resource usage cost, from the first IoT sub-network domain. If none of IoT servers in the first IoT sub-network domain can meet resource requirement of first VNF, we search the appropriate IoT server in the subsequent IoT sub-network domain. If all IoT servers in the entire multi-domain IoT network cannot meet the resource requirement, the placement of that SFC fails. In other words, the SFC request will be rejected by the multi-domain IoT network system, due to resource limitation. In such case, we will continue to process the placement of subsequent SFC.

Algorithm 1

DGSP Algorithm

If the first VNF is successfully placed in the multi-domain IoT network, we will process the placement of remaining VNFs in the SFC. For each subsequent VNF in the SFC, we first check whether it belongs to dependent-VNF or not. Based on its dependency relationship constraints, we adopt different placement strategies. If the VNF has certain dependency relationship constraint on the front VNF, we place it on the other IoT server with enough resources and the least resource usage cost in the same IoT sub-network domain as the front VNF. Once there are no appropriate IoT servers within this IoT sub-network domain that satisfy the resource requirements of that VNF, we will select the other appropriate IoT servers from the nearest IoT sub-network domain. If no IoT servers that can satisfy the resource requirements can be found in the multi-domain IoT network, the SFC fails to placement, and then we continue to process next SFC request. On the other hand, if the VNF has no dependency relationship constraints on the front VNF, it is prioritized to place on the IoT server where its front VNF is placed, with smallest resource usage cost while having abundant resources.

Upon determining the placement location of all VNFs in the SFC, the shortest path method based on Dijkstra algorithm is employed to perform virtual link mapping between VNF nodes. In such a way, the end-to-end of SFC requests can be improved and the operational cost can be further reduced. The detailed process of virtual link mapping is as follows. Specifically, for the first VNF $R^f_{i,1}$ in the SFC $R_i^f$, based on the bandwidth demand $R_i^{bw}$, we determine the shortest path $h_i^1$ between IoT node $R^{src}_i$ (i.e., source node of SFC) and IoT node $v_s^{m.n}$ where VNF $R^f_{i,1}$ is placed. Then, we determine whether the first VNF and the second VNF are deployed on the same IoT server. If yes, we continue to judge whether the second VNF and the third VNF are deployed on the same IoT server. We repeat the above process until the destination node of that SFC. Otherwise, based on the bandwidth demand, we will search for the shortest path $h_i^j$ between IoT servers where adjacent VNFs are deployed. In the end, we will get the complete routing path pof that SFC. That is. $p=\bigcup h_i^j$. Finally, we judge whether the mapping path p satisfies the delay constraint $R_i^{dl}$ of that SFC. If the delay constraint is violated, the SFC request will be rejected. In other words, the placement of that SFC fails. Otherwise, it means that the placement of that SFC succeeds.

Algorithm 2

SFCRC Algorithm

To accommodate more SFC requests and further save operational cost, we adjust the VNF placement after SFC paralleled placement process is finished. Algorithm 3 illustrates the main workflow of VNF placement adjustment process. VNFPA algorithm takes the placement locations Pl of SFCs as the input, and finally outputs the adjusted placement locations $Pl'$ of SFCs. Specifically, we first count the resource utilization and workload of each IoT server, illustrated in Lines 1-4. Then, all the IoT servers are first sorted by their resource utilization in descending order, and then by their workload in ascending order respectively. As illustrated in Lines 9-11, we determine the VNFs being placed on the IoT server with the smallest workload, and replace them on IoT servers with the smallest resource utilization and resource usage cost within the same IoT sub-network domain.

Algorithm 3

VNFPA Algorithm

In order to facilitate the proposed DGSP algorithm, as depicted in Fig. 2, we give a simple example. Given a SFC $sf:~~vf1-vf2-vf3-vf4$, we assume that source node is $v^{1,1}$, destination node is $v^{3,3}$ and $vf1\rightarrow vf3$. We first reconstruct that SFC based on the VNF dependency relationships. The reconstructed SFC can be represented as $\{vf1\}\rightarrow \{vf3\}-\{vf2,vf4\}$. Next, we sort all IoT sub-network domains by resource capacity in descending order. It is assumed that the sorted IoT domains are $dm_1$, $dm_2$ and $dm_3$ respectively. We first place the VNFs vf1 and vf3, and then place the VNFs vf2 and vf4. For the VNF vf1, we search an appropriate IoT server from IoT domain $dm_1$ to deploy it. If none of IoT servers in IoT domain $dm_1$ can satisfy the resource demand of VNF vf1, we search an appropriate IoT server from IoT domain $dm_2$ or $dm_3$ respectively. If all IoT servers in three IoT domains cannot satisfy the resource demand, the placement of SFC sf fails. We assume that VNF vf1 is placed on IoT server $v^{1,2}$. For the VNF vf3, we repeat the above process to select the appropriate IoT server. Note that VNFs vf1 and vf3 cannot be placed on the same IoT server due to the VNF dependency relationship constraint. We assume that VNF vf3 is placed on IoT server $v^{2,2}$.

Figure 2

An illustrative example.

For the VNF vf2, we first judge whether IoT server $v^{1,2}$ can satisfy its resource demand. If yes, we place the VNF vf2 on IoT server $v^{1,2}$. Otherwise, we search the other appropriate IoT server to place it. We assume that VNFs vf2 and vf4 are placed on IoT server $v^{1,2}$. After completing the VNF placement, we will determine the SFC routing path. By leveraging Dijkstra algorithm, based on the bandwidth demand of SFC sf, we determine the shortest paths from source node to IoT server $v^{1,2}$, from IoT server $v^{1,2}$ to IoT server $v^{2,2}$, and from IoT server $v^{2,2}$ to destination node respectively. We assume that the SFC routing path is $h=v^{1,1} \rightarrow v^{1,2} \rightarrow v^{2,2} \rightarrow v^{3,1} \rightarrow v^{3,3}$. In order to further reduce operational cost and end-to-end delay, we can execute VNFPA algorithm to adjust the VNF placement.

Algorithm complexity

In order to analyze the algorithm performance of DGSP algorithm, it is assumed that the total number of SFC requests is |R|, the maximum length of SFC is |f|, the total amount of IoT sub-network domains is |G|. The maximum amount of IoT servers in each IoT sub-network domain is $|G_i|$. Therefore, the time complexity of SFC reconstruction process in Algorithm 2 can be calculated as $O(|f|^2)$. The SFC paralleled placement process requires $O(|G|^2+|f|(|G_i|\cdot |G|+|V|^2))$ time overheads. The time complexity of SFC placement adjustment process in Algorithm 3 can be calculated as $O((|G_i|\cdot |G|)^2 )$. Therefore, the overall time complexity of DGSP algorithm is $O(|R|\cdot ((|f|^2 )+(|G|^2+|f|\cdot (|G_i|\cdot |G|+|V|^2 ))+((|G_i|\cdot |G|)^2 )))$.

Performance evaluations

In this section, we conduct the simulation experiments for performance evaluations, and then analyze the simulation results.

Simulation setup

We conduct the simulation experiments in a computer with 2.80 GHz Intel Core(TM) i7-1165G7, and 32GB RAM, and implement the program based on MATLAB 2014a platform.

In simulation experiments, we select CERNET2 and Interoute from network topology zoo⁴⁵ as test topology cases. CERNET2 network consists of 20 physical nodes and 22 physical links, and Interoute network is composed of 110 physical nodes and 148 physical links. In order to simulate the real multi-domain IoT network, we randomly divide CERNET2 and Interoute networks into four and ten IoT sub-network domains. To make the simulation scenarios more generic, similar to⁴⁶, we use ’unit’ to measure the resource capacity, resource requirement and resource usage cost. The probability of each node in CERNET2 and Interoute networks being selected as the IoT server is 0.5. The parameter settings in both network scenarios are listed in Table 3.

Table 3 Parameter settings in network scenarios.

Regarding with SFC requests, source and destination nodes of each SFC are generated randomly. Table 4 shows the details of SFC request settings. The weight coefficients $\varsigma$ and $\eta$ are set as 1 and 1 respectively.

Table 4 Settings of SFC requests.

To comprehensively evaluate the performance of the proposed DGSP algorithm, the improved multi-level delay guaranteed SFC mapping algorithm (IMDG)²⁶, the improved heuristic SFC deployment algorithm (IHSD)²⁰ and the improved SFC random placement algorithm with delay guarantee (IRDP)⁴⁶ are selected as comparison algorithm, as follows.

• IMDG: The network functions are first mapped to the VNF instances by leveraging the instance sharing potential, and then the instances are deployed in the multi-domain IoT network with delay guarantee.

• IHSD: The breadth-first-search method is used to find all physical IoT nodes that can host the VNFs with delay guarantee.

• IRDP: The SFC is randomly placed in the multi-domain IoT network while satisfying delay requirement of SFC requests, and the routing path is calculated based on Dijkstra algorithm.

Moreover, three performance indicators, including service acceptance ratio, operational cost and time overhead, are selected as performance evaluation indicators in simulation experiments.

Simulation results

Comparison between heuristic solution and optimal solution

We first compare the heuristic solution obtained by the proposed DGSP algorithm with the optimal solution, as depicted in Fig. 3. We conduct the simulation experiments based on CERNET2 network where the length of SFC is 3 and the number of SFCs is varied from 5 to 25. From Fig. 3, we can observe that the proposed DGSP algorithm can obtain the near optimal solution.

Figure 3

Comparison between obtained solution and optimal solution.

Service acceptance ratio

Figure 4 depicts service acceptance ratio comparison results of four SFC placement algorithms in both network scenarios under different lengths of SFC. In simulation experiments, the length of SFC is ranged from 3 to 6, and the total number of SFC requests is 400. From Fig. 4, it can be observed that the proposed DGSP algorithm can obtain higher service acceptance ratio than the other three SFC placement algorithms. This is because compared with IMDG, IHSD and IRDP algorithms, the proposed DGSP algorithm attempts to accommodate more service requests by executing VNF paralleled placement and SFC placement adjustment. Moreover, it can be also observed that as the length of SFC increases, service acceptance ratio gradually becomes low. This is because the increase of SFC length results in big resource consumption on IoT server resource and IoT link bandwidth resource. And accordingly, more SFC requests are rejected due to resource capacity limitation.

Figure 4

Service acceptance ratio under different lengths of SFCs.

Figure 5

Service acceptance ratio under different numbers of SFCs.

Figure 5 depicts the impact of the varied SFC length on service acceptance ratio under different network scenarios. It can be observed from Fig. 5 that the proposed DGSP algorithm obtains the highest service acceptance ratio in both network scenarios among four SFC placement algorithms. On the other hand, we can observe that as the number of service requests increases, more SFCs are successfully deployed in the multi-domain IoT networks. Due to the limitation of overall resource capacity, the resource competition faced by the SFCs becomes more intense. As a result, the service acceptance ratio of four SFC placement algorithms gradually decreases with the increase of the number of SFC requests.

Operational cost

Figure 6 depicts the effect of the length of SFC on the operational cost performance of different SFC placement algorithms in both network scenarios. From Fig. 6, it can be observed that the proposed DGSP algorithm brings smaller operational cost than IMDG, IHSD and IRDP algorithms. Different from the three comparison algorithms, the proposed DGSP algorithm places the VNFs in the same SFC in the same IoT sub-network domain as possible, and meanwhile adjusts the deployment of VNFs being placed on the IoT servers with high resource utilization. In such way, the operational cost caused by the SFC placement can be significantly reduced. On the other hand, it can be also observed that as the length of SFC increases, the overall operational cost of four SFC placement algorithms gradually becomes small. This is because the increase in the length of SFC results in generating more VNFs. More SFCs are rejected due to resource competition.

Figure 6

Operational cost under different lengths of SFCs.

Figure 7

Operational cost under different numbers of SFCs.

Figure 7 depict the operational cost of four SFC placement algorithms in both network scenarios with respect to the number of requested SFCs. We can observe that the operational cost and the number of requested SFCs are approximately positively correlated. This is because as the number of requested SFCs increases, more SFCs are deployed successfully in the multi-domain IoT networks. Accordingly, more resource are consumed and the number of IoT sub-network domains occupied by the deployed SFCs also becomes big.

Time overhead

Figure 8 depicts time overhead of four SFC placement algorithms in both network scenarios by varying the length of SFC. From Fig. 8, it can be observed that the proposed DGSP algorithm gets the biggest time overhead among four SFC placement algorithms. This is because compared with the other three SFC placement algorithms, the proposed DGSP algorithm consists of SFC reconstruction process, SFC paralleled placement process, and SFC placement adjustment process. Compared with benchmark algorithms, the SFC placement process in DGSP algorithm is more complex. As a result, DGSP algorithm needs to take more time to complete the SFC placement in multi-domain IoT networks.

Figure 8

Time overhead under different lengths of SFCs.

Figure 9

Time overhead under different numbers of SFCs.

Figure 9 depicts the effects of the number of requested SFCs on time overhead of four SFC placement algorithms. It can observed from Fig. 9 that the time overhead of SFC placement algorithms and the number of requested SFCs are approximately positively correlated. As the number of requested SFCs increases, more service requests are generated. The SFC placement algorithms need to take more time to deploy the SFCs in multi-domain IoT networks. On the other hand, it can be also observed that compared with CERNET2 network, the time overhead of four SFC placement algorithms in Interoute network is higher. The reasons are explained as follows. The total number of IoT server nodes and physical IoT links in CERNET2 network is less than that in Interoute network. When we deploy one SFC in the multi-domain IoT network, the SFC placement algorithms need to take more time to select the optimal IoT server nodes and physical IoT links in Interoute network than in CERNET2 network.

Conclusions

In this paper, we investigate the problem of delay guaranteed SFC placement optimization in multi-domain IoT networks. We formulate the problem of delay guaranteed SFC placement in multi-domain IoT networks as a multi-objective optimization model, with the target of service acceptance ratio maximization and operational cost minimization, while satisfying delay requirements of SFC requests. To solve it, we design DGSP, an efficient delay guaranteed SFC placement algorithm, to reconstruct the SFC and optimize the SFC placement, by taking into account VNF dependency relationship and SFC placement adjustment. In future works, we will attempt to apply artificial intelligence techniques to intelligently obtain the real-time and dynamic service requirements for dynamic SFC placement optimization in multi-domain IoT networks, in order to enhance the QoE of users. Moreover, we will attempt to build a real multi domain IoT network for performance testing.