Virtual Network Embedding Algorithms Based on Best-Fit Subgraph Detection

One of the main objectives of cloud computing providers is increasing the revenue of their cloud datacenters by accommodating virtual network requests as many as possible. However, arrival and departure of virtual network requests fragment physical network's resources and reduce the possibility of accepting more virtual network requests. To increase the number of virtual network requests accommodated by fragmented physical networks, we propose two virtual network embedding algorithms, which coarsen virtual networks using Heavy Edge Matching (HEM) technique and embed coarsened virtual networks on best-fit sub-substrate networks. The performance of the proposed algorithms are evaluated and compared with existing algorithms using extensive simulations, which show that the proposed algorithms increase the acceptance ratio and the revenue.


Introduction
Network virtualization is one of the most important features of the cloud computing, which allows creation of multiple virtual networks (VNs) on a single substrate network (SN) (Fajjari et al, 2013).In cloud computing, virtual network requests (VNRs) arrive dynamically over time with different topologies, resource requirements, and lifetime.Cloud providers accommodate VNRs by mapping each virtual node to a substrate node and each virtual link to a substrate path, such that a set of previously defined mapping constraints (e.g.topology constraints, link bandwidth, CPU capacity) is satisfied (Lischka & Karl, 2009).At the end of the VNR's lifetime, allocated SN's resources are released.
However, mapping virtual networks' resources to substrate network's resources is known to be nondeterministic polynomial-time hard (NP-hard) (Chowdhury et al, 2009;Chowdhury et al, 2012).This problem is usually referred to as the Virtual Network Embedding (VNE) problem (Till Beck et al, 2013).In the last few years, many studies have proposed several algorithms for efficient and effective VNE (Lischka & Karl, 2009;Chowdhury et al, 2009;Chowdhury et al, 2012;Cheng et al, 2011;Zhang et al, 2013;Cheng et al, 2012).Effective VNE increases the utilization of the SN's resources and increases the revenues of the cloud computing datacenters.However, the process of allocating and releasing SN's resources fragments SN's resources (Fischer et al, 2013).SN's resources are considered fragmented if there are two or more sub-substrate networks connected by substrate paths with available bandwidths less than the minimum required VNR's bandwidth or substrate paths with lengths greater than the maximum allowed hops.
Reactive algorithms just act when a VNR is rejected, and try to re-embed one or more VNRs to increase the acceptance ratio.Some of the current researches consider load balance of the SN's resources to avoid SN's resources fragmentation (Cheng et al, 2012;Sun et al, 2013).However, considering load balance of the SN's resources during embedding VNRs with small resources may cause rejecting VNRs with large resources in the future.
In this paper, we propose two VNE algorithms to improve the acceptability of fragmented substrate networks.The proposed algorithms increase the possibility of accepting future VNRs by embedding VNRs on best-fit sub-substrate networks.The proposed algorithms are one stage (embed virtual nodes and virtual links at the same stage to allow coordination between them), online (deal with VNRs that arrive over time and do not require VNRs to be previously known), and backtracking algorithms.
Both algorithms exploit the virtualization feature of the cloud computing to embed more than one virtual node from the same VN on the same substrate node, which minimizes the cost of embedding VNRs by eliminating the cost of embedding virtual links between those virtual nodes.Additionally, the second algorithm coarsens VNs using Heavy Edge Matching (HEM) technique to minimize its size and to minimize the total required bandwidth before embedding them on best-fit sub-substrate networks.
The performance of the proposed algorithms have been evaluated using extensive simulations, which show that the proposed algorithms increase the long-term average revenue and the acceptance ratio compared to some of the existing embedding algorithms.
The rest of this paper is organized as follows.In Section 2, we discuss the related work on VNE problem.Section 3 presents the VN embedding model and problem formulation.Section 4 describes the proposed algorithms.Section 5 evaluates the proposed VN embedding algorithms using extensive simulations.Finally, in Section 6 we conclude this paper.

Related Work
Many researches have been done for efficient VN embedding.Zhu and Ammar (Zhu & Ammar, 2006) proposed two VN embedding algorithms.The first algorithm is static VNE algorithm, where allocated substrate resources are fixed throughout the VN lifetime.Heuristics and adaptive optimization strategies are used to improve the performance of the proposed algorithm.The second algorithm reconfigures the embedded VNs to increase the utilization of the underlying substrate resources.However, the proposed algorithms deal only with offline embedding problem (all VNRs are previously known).On the other hand, in cloud computing data centers, VNE problem is online problem, where new VNRs arrive over time.Lischka and Karl (Lischka & Karl, 2009) presented online backtracking VNE algorithm.The proposed algorithm is one stage VNE algorithm (maps nodes and links during the same stage) and maps VN to a sub-physical network that is similar to the topology of the VN and achieves previously defined constraints (e.g.CPU capacity, link bandwidth).Nodes are mapped to substrate nodes sequentially after sorting it in descending order based on its required CPU.The proposed algorithm tries to map virtual links to substrate paths with minimal hops by incrementally increasing the maximum hop limit.However, the computational complexity is high due to multiple operations of the proposed algorithm.Di et al. (Di et al, 2010) improved performance and complexity of the proposed algorithm in (Lischka & Karl, 2009) by considering link mapping cost during the process of sorting nodes and choosing the maximal hop limit.Nogueira et al. (Nogueira et al, 2011) proposed heuristic-based VN embedding algorithm to deal with the heterogeneity of VNs and SN, in both links and nodes.The proposed algorithm is one stage VNE algorithm.
Cheng et al. (Cheng et al, 2011) proposed two online virtual network-embedding algorithms called RWMaxMatch and RW-BFS.Both of them rank nodes using topology-aware node ranking technique to reflect the topological structure of the VNs and the SN.RWMaxMatch algorithm is two stage embedding algorithm, which performs node mappings and link mappings at two different stages without coordination between them.However, mapping nodes without considering its relation to the link mapping might result in neighboring virtual nodes being widely separated in the SN, which leads to high consumption of the underlying SN's resources and reduces the acceptance ratio of the proposed algorithm.To avoid this problem, they proposed RW-BFS algorithm.RW-BFS algorithm is a backtracking one stage embedding algorithm, which embeds nodes and links at the same stage.
To improve the coordination between nodes mapping stage and links mapping stage, Chowdhury et al. (Chowdhury et al, 2009;Chowdhury et al, 2012) formulated the VNE problem as a mixed integer program (MIP), which is NP-hard.To obtain polynomial-time solvable algorithms, they relaxed the integer program to linear program, and proposed two VNE algorithms: D-ViNE (deterministic VNE algorithm) and R-ViNE (randomized VNE algorithm).
Zhang et al. (Zhang et al, 2013) proposed two VN embedding models: an integer linear programming model and a mixed integer programming model.To solve these models, the authors proposed VN embedding algorithm based on particle swarm optimization.The time complexity of the link mapping stage is reduced by using shortest path algorithm and greedy k-shortest paths algorithm.Some of existing works proposed VN embedding algorithms to embed VNRs in distributed cloud computing environments (Samuel et al, 2013;Houidi et al, 2008a;Xin et al, 2011;Lv et al, 2010).Houidi et al. (Houidi et al, 2011) proposed exact and heuristics VN embedding algorithms, which split virtual network requests using max-flow min-cut algorithms and linear programming techniques.Leivadeas et al. (Leivadeas et al, 2013) proposed VN embedding algorithm based on linear programming.The proposed algorithm partitions VNRs using partitioning approach based on Iterated Local Search.Houidi et al. (Houidi et al, 2008b) proposed distributed VN embedding algorithm, which is performed by agent-based substrate nodes.The authors proposed VN embedding protocol to allow communication between the agent-based substrate nodes.However, the proposed algorithm assumes that all VNRs are previously known.

Substrate network (SN):
We model the substrate network as a weighted undirected graph = ( , ), where is the set of substrate nodes and is the set of substrate links.Each substrate node ∈ is weighted by the CPU capacity, and each substrate link ∈ is weighted by the bandwidth capacity. Figure 1 (b) shows a simple SN example, where the available CPU resources are represented by numbers in rectangles and the available bandwidths are represented by numbers over the links.

Virtual network (VN): virtual network
is modeled as a weighted undirected graph = , , where is the set of virtual nodes and is the set of virtual links.Virtual nodes and virtual links are weighted by the required CPU and bandwidth, respectively.Figure 1 (a) shows an example of VN with required CPU and bandwidth.Virtual Network Embedding Cost: as in (Cheng et al, 2011;Zhang et al, 2013;Fischer et al, 2013), the cost of embedding at time is defined as the sum of all allocated substrate CPU and substrate bandwidth to at time .) is the length of the substrate path that the virtual link is mapped to.

Virtual network requests (VNR):
Objectives: the main objectives are to increase the revenue and decrease the cost of embedding virtual networks in the long run.To evaluate the achievement of these objectives, we use the following metrics: -The long-term average revenue, which is defined by Where =∥ ∥, and is the total time.
-The VNR acceptance ratio, which is defined by Where is the set of all accepted virtual network requests.
-The long term R/Cost ratio, which is defined by

The Proposed Algorithms
We proposed two VNE algorithms to increase the acceptance ratio for fragmented SNs and minimize the remapping process.In the next sub-sections, we describe the motivation behind the proposed algorithms and describe the details of the proposed algorithms.

Motivation
For each VNR, we may have different VNE solutions.For example, table 1 shows some VNE solutions to embed VN in figure 2 From this example, we conclude that increasing the possibility to accept more future VN requests does not only depend on the mapping cost.This conclusion motivates us to propose VNE algorithms for selecting VNE solutions that increase the possibility to accept as many VNRs as possible.Even if the selected solutions maybe increase the embedding cost, the revenue is increased by accommodating more VNRs.

BFSN VNE Algorithm
The inputs to BFSN algorithm are: (1) : the virtual network to be embed, (2) G : the substrate network to embed on, (3) Max_hops: the maximum allowed substrate path length, and (4) Max_backtrack: the upper bound of nodes re-mapping operation.The outputs of BFSN algorithm is a map M(G ).
Figure 3 shows the steps of BFSN algorithm.The algorithm constructs breadth-first searching tree of .The root node of the constructed tree is the virtual node with the largest resources (sum of CPU and BW).Nodes in each level in the created breadth-first searching tree are sorted in descending order based on their resources.
The set of candidate sub-substrate networks = | = , , ⊆ , ⊆ is built, where N is a set of all substrate nodes in G with available CPU ≥ minimum required CPU (the minimum CPU in G ), and P is the set of all loop free substrate paths in G with available BW ≥ minimum required BW and with length less than or equal a pre-specified maximum path length.
Candidate sub-substrate networks are specified by visiting substrate nodes in N sequentially and creating a breadth-first searching tree from a substrate node if it has not been included in any sub-substrate network yet.Substrate node is added to the sub-substrate network if it has not been included in any sub-substrate network, and has been connected with previously added substrate node through a substrate path in P .G is reduced by removing sub-substrate networks that do not have enough resources to embed .All remaining sub-substrate networks in are sorted in ascending order based on their total available resources.
The BFSN algorithm embeds VN on a sub-SN using Embed() function, which is described in figure 6.In the Embed() function, candidate substrate node list for each virtual node is built by collecting all substrate nodes that have available CPU capacity at least as large as the virtual node CPU and have a loop free substrate path to each substrate node contains one of the previously mapped neighbors.Each substrate path should satisfy the constraint of the maximum substrate length, and have available bandwidth greater than or equal the bandwidth of the virtual link between the virtual node and its previously mapped neighbor.
Candidate substrate nodes for each virtual node are collected by creating a breadth-first search tree from each substrate node contains one of the previously mapped neighbors, and finding the common substrate nodes between the created trees.In the constructed trees, substrate nodes should satisfy the CPU constraints for virtual node, and substrate paths should satisfy the connectivity constraints to connect the virtual node with its neighbors.By this way, all candidate substrate nodes in the list satisfy all constraints (CPU and connectivity constraints).
Substrate nodes in the candidate substrate node list are sorted in ascending order according to the total cost of embedding virtual links from the virtual node to all previously embedded neighbors.If the virtual node is a root node, the candidate substrate node list is a set of all substrate nodes that have enough resources to embed the virtual node.The candidate substrate nodes for the root are sorted in descending order according to the total available resources.
Virtual node is sequentially mapped to substrate nodes in its candidate substrate node list.If there is no appropriate substrate node in its candidate substrate node list, we backtrack to the previously mapped node, re-map it to the next candidate substrate node, and continue to the next node.Mappings of the virtual node and its virtual links are added to ( ) by using the function Add() in line 3.In line 6, Delete() function is used to perform the backtracking process.
Algorithm 1 The Details of the BFSN VNE algorithm 1: Build breadth-first searching tree of from virtual node with largest resources.
2: Sort all nodes in each level in the created breadth-first tree in descending order according to their required resources.2 (c), we construct a breadth-first searching tree from the virtual node b, which is the virtual node with largest resources.Virtual nodes in each level are sorted in descending order based on their resources as in figure 3. Figure 4 shows candidate sub-substrate networks that are specified, and sorted in ascending order based on its total available resources.Numbers in triangles represent numbers of hops for links.Figure 5 shows the embedding steps of the VN in figure 2 (a) on the first candidate sub-SN, which is the candidate sub-SN in figure 4 (a).
The candidate substrate nodes list for the root node b is built as , , .root node b is mapped to the substrate node G as shown in figure 5(b).The next virtual node in the breadth first search tree in figure 3 is the virtual node a.The set of candidate substrate nodes for the virtual node a is specified as , , , which is sorted in ascending order based on the cost of mapping the virtual node a to each of them.G substrate node is included because the proposed algorithm allows substrate nodes to include more than one virtual node from the same VN. Figure 5(c) shows the SN after mapping the virtual node a to the substrate node G. Finally, the virtual node c is mapped to the substrate node F, which is the only substrate node that can satisfy the connectivity constraints to the substrate node G (the total required bandwidth is 50).

BFSN-HEM VNE Algorithm
Allowing substrate nodes to contain more than one virtual node from the same VN coarsens the VN.For example, the VN in figure 2 (a) is coarsened as shown in figure 6. Coarsening VNs reduces the embedding cost by eliminating the cost of embedding virtual links between virtual nodes on the same substrate node.However, VNs coarsening performed by BFSN algorithm is not the optimal coarsening solution.For this reason, we proposed BFSN-HEM algorithm, which coarsens VNs using Heavy Edge Matching (HEM) technique to minimize its sizes and to minimize the edge-cut before embedding them.The Details of the Coarsening() function are shown in algorithm 3.
Coarsening() function sorts all links in descending order based on their bandwidth.The incident nodes of each link is merged if the total CPU less than or equal the maximum allowed CPU.After each coarsening step, VN is updated to a new coarsened virtual network with merged nodes and links.In the BFSN-HEM algorithm, coarsened virtual nodes are mapped as in BFSN algorithm.Coarsened virtual links are mapped by mapping its virtual links independently.

Performance Evaluation
The proposed VN embedding algorithms are evaluated by comparing its performance with some of existing algorithms.First, we implemented four algorithms: BFSN, BFSN-HEM, RW-MaxMatch (Cheng et al, 2012), and RW-BFS (Cheng et al, 2011).Second, we generated SN topology and 3000 VN topologies to be used as inputs to the implemented algorithms.Finally, we compared the results from the implemented algorithms.In the following sub-sections, we describe the evaluation environment settings and discuss the results of the simulations.

Evaluation Environment Settings
In our evaluation, the substrate network topology is configured to have 200 nodes with 1000 links.Substrate network is generated using Waxman generator.Bandwidths of the substrate links are real numbers uniformly distributed between 50 and 100 with average 75.We have selected two server configurations: HP ProLiant ML110 G4 (Intel Xeon 3040, 2 cores X 1860 MHz, 4 GB), and HP ProLiant ML110 G5 (Intel Xeon 3075, 2 cores X 2660 MHz, 4 GB).Each substrate node is randomly assigned one of these server configurations.For all algorithms, we set the maximum allowed hops (Max_hops) to 2, and the upper bound of remapping process (Max_backtrack) to 3n, where n is the number of nodes in each VNR.We set the value of in Coarsening() function (Algorithm 3) to the maximum available CPU in the sub-substrate network.Note that the BFSN-HEM algorithm does not guarantee that there are enough substrate nodes with available CPU equal to the to embed coarsened virtual nodes if all virtual nodes are coarsened to nodes with CPU equal to , but our experiments have shown that it works very well.This is because, practically most of coarsened virtual nodes have CPU less than .

Evaluation Results
Three metrics have been used to evaluate the performance of the proposed algorithms: the long-term average revenue, which is defined by Equation ( 1), the VNR acceptance ratio, which is defined by Equation ( 2), and the long-term R/Cost ratio, which is defined by Equation (3). Figure 7 shows the simulation results using the VNR acceptance ratio to compare the different VNE algorithms.It can be seen that algorithms that embed VNs on best-fit sub-SNs increase the acceptance ratio compared with other algorithms.For example, at time unit 30000, in figure 7, the VNR acceptance ratio for the RW-BFS and RW-MaxMatch are 20 and 16 percent, while the VNR acceptance ratio for the BFSN and BFSN_HEM are 59 and 65 percent.Figure 7 also shows that the BFSN-HEM algorithm that coarsens VNs using Heavy Edge Matching technique has better VNR acceptance ratio than the BFSN algorithm.In other words, the proposed algorithms can embed more VNs on the same SN at the same time.Consequently, the proposed algorithms increase the long-term average revenue compared with other algorithms, as shown in figure 8.For example, at time unit 30000, the average revenue for the RW-BFS and RW-MaxMatch are 72 and 33, while the average revenue for the BFSN and BFSN_HEM are 290 and 336.
From figures 7 and 8, we can observe that the proposed algorithms enhanced the acceptance ratio around 40 percent while they tripled the long-term average revenue compared with other algorithms.This is because RW-BFS and RW-MaxMatch algorithms lead to SN's resource fragmentation.Thus, it may accept VNRs with small size and reject VNRs with large size.By accepting VNRs with large size, the average revenue of the BFSN and BFSN_HEM algorithms grows faster than the average revenue of the RW-BFS and RW-MaxMatch algorithms.
In addition to the higher revenue, the proposed algorithms are faster than other algorithms, because the proposed algorithms deal only with sub-SNs instead of the whole SN. Figure 9 depicts the long-term Revenue/Cost ratio for different VN embedding algorithms.As shown in figure 9, the long-term Revenue/Cost ratio of BFSN and BFSN-HEM are nearly the same, but the proposed algorithms perform slightly better than other algorithms.We believe that the reason behind this is the small value for the maximum allowed hops (Max_hops), which allows only embedding VNs if there are solutions with small cost.

Conclusion
In this paper, we proposed two virtual network embedding algorithms, which embed virtual networks on best-fit sub-substrate networks.Sub-substrate networks are specified by eliminating substrate links and substrate nodes that do not satisfy the connectivity and the CPU constraints.Virtualization technology is exploited to consolidated more than one virtual node from the same virtual network to one substrate node.Virtual networks are coarsened using Heavy Edge Matching (HEM) technique to minimize the cost of embedding virtual links.
Our evaluation results show that the proposed algorithms improve the acceptance ratio and the revenue.Finally, we conclude that embedding virtual networks on best-fit sub-substrate networks allows substrate networks to accommodate more virtual networks.Additionally, coarsening virtual networks to coarsened virtual networks with minimal coarsened virtual links minimizes the embedding cost.For the future work, we plan to investigate other coarsening techniques to find the best coursing technique, which increases the acceptance ratio and the revenue while decreasing the embedding cost.

Figure 2 .
Figure 2. Example of VNs and SN

Figure 5 .
Figure 5. Embedding VN in figure 2 (a) on the candidate sub-substrate network in figure 4 (a)

Figure 7 .
Figure 7.The VNR acceptance ratio comparison Virtual network topologies are generated using Waxman generator with average connectivity 50%.Number of Example of VN coarsening virtual nodes in each VN is variant from 2 to 20.Each virtual node is randomly assigned one of the following CPU: 2500 MIPS, 2000 MIPS, 1000 MIPS, and 500 MIPS, which are correspond to the CPU of Amazon EC2 instance types.Bandwidths of the virtual links are real numbers uniformly distributed between 1 and 50.VN's arrival times are generated randomly with arrival rate 10 VNs per 100 time units.The lifetimes of the VNRs are generated randomly between 300 and 700 time units with average 500 time units.3000 VN topologies are generated and stored in brite format.For each algorithm, we run the simulation for 30000 time units with the previously generated VNRs.The generated SN topology, generated VNRs topologies, and outputs are available online at (Note 1).