Using Heavy Clique Base Coarsening to Enhance Virtual Network Embedding

Network virtualization allows cloud infrastructure providers to accommodate multiple virtual networks on a single physical network. However, mapping multiple virtual network resources to physical network components, called virtual network embedding (VNE), is known to be non-deterministic polynomial-time hard (NP-hard). Effective virtual network embedding increases the revenue by increasing the number of accepted virtual networks. In this paper, we propose virtual network embedding algorithm, which improves virtual network embedding by coarsening virtual networks. Heavy Clique matching technique is used to coarsen virtual networks. Then, the coarsened virtual networks are enhanced by using a refined Kernighan-Lin algorithm. The performance of the proposed algorithm is evaluated and compared with existing algorithms using extensive simulations, which show that the proposed algorithm improves virtual network embedding by increasing the acceptance ratio and the revenue.


INTRODUCTION
In cloud computing data centers, virtualization is employed to accommodate multiple virtual networks (VNs) on a single substrate network (SN), and multiple virtual servers on a single physical server [1]. Consolidating multiple virtual servers from the same virtual network to a single physical server coarsens virtual network down to a few physical servers. Coarsening VN reduces the cost of embedding by eliminating the cost of embedding virtual links between virtual nodes on the same substrate node. Although, effective VN coarsening can improve the utilization of SN's resources and increase the acceptance ratio of VNs and the revenue of infrastructure providers, most of current virtual network embedding algorithms do not take into account VN coarsening [2,3,4,5,6,7].
In this paper, we propose virtual network embedding algorithm, which coarsens virtual networks using Heavy Clique matching technique. Then, the coarsened virtual networks are enhanced by using a refined Kernighan-Lin algorithm. The performance of the proposed algorithm is evaluated and compared with existing algorithms using extensive simulations, which show that the proposed algorithm improves virtual network embedding by increasing the acceptance ratio and the revenue.
The rest of this paper is organized as follows. Section 2 gives a short overview of related work. Section 3 presents the VN embedding model and problem formulation. Section 4 describes the proposed algorithm. Section 5 evaluates the proposed VN embedding algorithm. Finally, we conclude in section 6.

II. RELATED WORK
In the last few years, many algorithms have been proposed for efficient VNE. VN embedding problem is NP-hard, and finding optimal solution can only be found for small problem instances [8]. Therefore, several heuristic algorithms have been proposed to find a good solution [5,6,7,9]. Some algorithms have been proposed to find exact VNE solutions to be used as optimal bound for the heuristic based VNE solutions [4,10]. Zhu and Ammar [11] proposed two VN embedding algorithms. In the first algorithm, allocated substrate resources are fixed throughout the VN lifetime. The performance of the first algorithm is improved by using heuristics and adaptive optimization. In the second algorithm, allocated substrate resources are reconfigured to increase the utilization of the underlying substrate resources. However, the proposed algorithms deal only with VNRs that are previously known and do not deal with VNRs that dynamically arrive over time.
In [12], Lischka and Karl proposed online VNE algorithm, which maps nodes and links during the same stage. The proposed algorithm 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). During nodes mapping process, virtual nodes are sorted in descending order based on its required CPU and mapped sequentially to substrate nodes without allowing coexisting multiple virtual nodes from the same VN on one substrate node. To minimize the mapping cost, virtual links are mapped to substrate paths with minimal hops by incrementally increasing the maximum hop limit. However, the computational complexity of the proposed algorithm is high due to multiple operations. In [13], Di et al. improved performance and complexity of the proposed algorithm in [12] by considering the cost of mapping links during the process of www.ijacsa.thesai.org sorting virtual nodes and choosing the maximal hop limit. Fischer et al. [3] modified the algorithm proposed in [12] to consider energy efficiency during nodes and links mapping. Fischer et al. allowed mapping several virtual nodes of the same virtual network to the same substrate node. Although, they take into account the energy efficiency during consolidating virtual nodes, they did not consider the mapping cost.
In [10], Cheng et al. proposed two-stage VN embedding algorithm, called RW-MaxMatch, which ranks nodes using topology-aware node ranking technique to reflect the topological structure of the VNs and the SN. However, RW-MaxMatch algorithm maps nodes without considering its relation to the link mapping, which leads to high consumption of the underlying SN's resources. This is due to mapping neighboring virtual nodes widely separated in the SN.
In [10], Cheng et al. improved the coordination between nodes and links mapping in the RW-MaxMatch algorithm by proposing RW-BFS algorithm. RW-BFS algorithm is a backtracking one-stage VN embedding algorithm, which maps nodes and links at the same stage. In [14,15], Zhang et al. proposed two VN embedding models: an integer linear programming model and a mixed integer-programming model. To solve these models, Zhang et al. proposed an enhanced version of the MaxMatch algorithm, called RW-PSO algorithm, based on particle swarm optimization. RW-PSO algorithm reduces the time complexity of the link mapping stage by using shortest path algorithm and greedy k-shortest paths algorithm.
To improve the coordination between nodes mapping stage and links mapping stage, Chowdhury et al. [16,17] 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). Nogueira et al. [18] 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.
Some of existing works proposed VN embedding algorithms to embed VNRs in distributed cloud computing environments [19,20,21,22]. Houidi et al. [23] 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. [24] proposed VN embedding algorithm based on linear programming.
The proposed algorithm partitions VNRs using partitioning approach based on Iterated Local Search. Houidi et al. [25] 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 deals only with the offline VN embedding problem.

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. Fig. 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. Fig. 1  Virtual Network Embedding Revenue: as in [8,10,14], the revenue of embedding at time is defined as the sum of all required substrate CPU and substrate bandwidth by at time .
Where ( ) is the required CPU for the virtual node , ( ) is the required bandwidth for the virtual link , and ( ) if is in its lifetime and substrate resources are allocated to it, otherwise ( ) . www.ijacsa.thesai.org Virtual Network Embedding Cost: as in [8,10,14], the cost of embedding at time is defined as the sum of all allocated substrate CPU and substrate bandwidth to at time .
Where ( ( )) is the length of the substrate path that the virtual link is mapped to.
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 IV. THE PROPOSED ALGORITHM In this section, we describe the motivation behind the proposed algorithm and describe the details of the proposed algorithm, which is called HCM-VNE algorithm.

A. Motivation
VN embedding cost (defined by equation 1) depends on allocated substrate CPU and allocated substrate bandwidth. VN embedding cost can be reduced by minimizing these resources. However, minimizing allocated substrate CPU may violate service level agreement and reduce the quality of the service provided to the customers. Allocated substrate bandwidth can be reduced by increasing the number of virtual links between virtual nodes that are mapped to the same substrate node. VN embedding cost is reduced by eliminating the cost of embedding such virtual links. However, finding VN embedding solution with maximum number of eliminated virtual links is not easy task. For example, to map VN in Fig.  2(a) to SN in Fig. 2(b), Fig. 2 shows the mapping solution with the maximum number of eliminated virtual links among other solutions. This solution can be reached by finding sub-VNs that are close to be clique and map each sub-VN to one substrate node. This example motivates us to propose HCM-VNE algorithm, which coarsens VNs using heavy clique matching technique before mapping it.

B. The HCM-VNE algorithm
Algorithm 1 shows the steps of the proposed HCM-VNE algorithm. In line 1, , which is the upper bound of the coarsened node CPU, is set to the maximum available CPU in SN. In line 2, the upper bound of the total coarsened node bandwidth, , is set to the maximum available bandwidth in SN. VNs are coarsened using () function and coarsened VNs are optimized using () function.

() function and
() function will be described later on. The HCM-VNE algorithm constructs breadth-first searching tree for the graph of the coarsened VN. The root node of the constructed tree is the coarsened 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. Finally, in line 8, the HCM-VNE algorithm embeds coarsened VN on SN using Embed() function.

C. Coarsening() function
Virtual networks are coarsened using heavy clique matching technique. A clique in undirected graph is a fully connected subgraph. The cost of embedding VNs is reduced by embedding each sub-VN that is close to clique on one substrate node.
To determine how close sub-VN ( ) is to a clique, we define link density ( ) as ( ) ‖ ‖ (‖ ‖(‖ ‖ )) If the sub-VN is clique (or fully connected), the number of edges is equal to (‖ ‖(‖ ‖ )) and the link density ( ) goes to one.
( ) is small if the sub-VN is far from being clique.
Algorithm 2 shows the details of the Coarsening() function. Coarsening process is iterative and starts with an initial coarsening graph ( ) , which is created and initialized by creating coarsened node for each virtual node and coarsened link for each virtual link. Each coarsened node can be considered as a sub-VN ( ) , where (at this time each contains only one virtual node), and , such that each virtual link connects two virtual nodes in . Each coarsened link between two coarsened nodes is a set of virtual links connect virtual nodes in these coarsened nodes. Each virtual node exists in exactly one coarsened node, and each virtual link exists in exactly one coarsened node or one coarsened link. For example, VN in Fig. 2(a) can be coarsened as in Fig. 3.  Fig. 2(a) The graph of the coarsened VN in Fig. 3 is In Coarsening() function, coarsened nodes are visited in a sequential way, and each unmatched coarsened node is matched with its unmatched neighbor such that the new coarsened node created by combining and achieves the CPU and BW constraints and its is the largest among all possible coarsened nodes created by combining with other unmatched neighbors. If such neighbor exists, we add coarsened node with its neighbor to the matching list At the end of each iteration, coarser graph is updated by combining each pair in to a new coarsened node. If is empty the Coarsening() function terminates.

D. Optimize() function
Coarsening() function coarsens VN in Fig. 2(a) as in Fig. 3. However, Coarsening() function combines coarsened nodes only based on link density and does not consider the required bandwidth for each virtual link, which sometimes increases the cost of VN embedding. For example, if the virtual link (a, d) in Fig. 3 has bandwidth equal to 50, coarser VN can be improved by moving the virtual node a from the coarsened node to the coarsened node . Fig. 4 shows the optimized coarsened VN.
To optimize coarsened VN, we used a refined Kernighan-Lin (KL) algorithm. In 1970, Kernighan-Lin (KL) algorithm was proposed by Kernighan and Lin for graph partitioning problem. Kernighan-Lin (KL) algorithm partitions graph into two parts with equal sizes and with minimal number of cutting edges. It starts with an initial bipartition of the graph and searches for two subsets of vertices from each part of the graph, such that they have the same number of vertices and swapping them improves the cost of the partition. Kernighan-Lin algorithm swaps the selected subsets and repeats the entire process until no such subsets found [26]. However, standard Kernighan-Lin algorithm deals only with typical graph partitioning problem, so it is not directly applicable to optimize coarsened VNs, which may be partitioned to more than two partitions with different sizes.  Fig. 3 To optimize coarsened VN, we redefined Kernighan-Lin (KL) algorithm as shown in algorithm 4. Optimize() function starts with the partition performed by the Coarsening() function and moves boundary virtual nodes between coarsened nodes to improve edge-cut, such that this movement does not violate the CPU and BW constraints. Virtual node is called boundary node, if it is connected to virtual nodes outside its coarsened node. For example, in Fig. 3, virtual node a is a boundary virtual node for the coarsened node , because it has virtual link to the virtual node d, which is not in the coarsened node .
If moving the selected boundary virtual node to the target coarsened node violates the CPU or BW constraints, we try to find one or more boundary nodes in the target coarsened node to be swapped with the selected boundary virtual node. If no such boundary virtual nodes found, we postpone this movement and recheck it again in the next iteration. The whole process is repeated until no movements are performed.

E. Embed() function
The Embed() function embeds coarsened VN on SN as described in algorithm 4. In the Embed() function, candidate substrate node list for each coarsened virtual node is built by collecting all substrate nodes that have available CPU capacity at least as large as the coarsened 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 path length, and have available bandwidth greater than or equal the bandwidth of the coarsened virtual link between the coarsened virtual node and its previously mapped neighbor.
Candidate substrate nodes for each coarsened 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 coarsened virtual node, and substrate paths should satisfy the connectivity constraints to connect the coarsened virtual node with its neighbors. By this way, all candidate substrate nodes in the candidate www.ijacsa.thesai.org substrate node 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 coarsened virtual links from the coarsened virtual node to all previously embedded neighbors. If the coarsened 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 coarsened virtual node. The candidate substrate nodes for the root are sorted in descending order according to the total available resources.
Coarsened 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. In line 3, mappings of the coarsened virtual node and its coarsened virtual links are added to ( ) by using the function Add(). To map coarsened node to substrate node , the function Add() adds maps from each virtual node in to the substrate node . All virtual links in the coarsened node are mapped to substrate paths with length zero from the substrate node to itself. For each coarsened link from to one of the previously mapped coarsened nodes, the function Add() adds maps for all virtual links in these coarsened links. Virtual links are mapped to shortest loop free substrate paths, which are specified by breadth-first search manner. In line 6, Delete() function is used to perform the backtracking process.

V. PERFORMANCE EVALUATION
We evaluated the proposed HCM-VNE algorithm by comparing its performance with some of existing algorithms.
First, we implemented three algorithms: HCM-VNE, RW-MaxMatch [15], and RW-BFS [10]. 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.

A. 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.
Virtual network topologies are generated using Waxman generator with average connectivity 50%. Number of 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 1 . 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.

B. 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 (2), the VNR acceptance ratio, which is defined by Equation (3), and the long-term R/Cost ratio, which is defined by Equation (4). Fig. 5 shows the simulation results using the VNR acceptance ratio to compare the different VNE algorithms. It can be seen that the proposed algorithm that coarsened VNs using heavy clique matching increases the acceptance ratio compared with other algorithms. For example, at time unit 30000, in Fig. 5, the VNR acceptance ratio for the RW-BFS and RW-MaxMatch are 20 and 16 percent, while the VNR acceptance ratio for the HCM-VNE is 53 percent. In other words, the proposed algorithm can embed more VNs on the same SN at the same time. Consequently, the proposed algorithm increases the long-term average revenue compared with other algorithms, as shown in figure 6. www.ijacsa.thesai.org 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 HCM-VNE is 240. As shown in Fig. 7, the long-term Revenue/Cost ratio of all algorithms are nearly the same, but the proposed algorithm performs slightly better than other algorithms.

VI. CONCLUTION
In this paper, we proposed virtual network embedding algorithm, which coarsens virtual networks using heavy clique matching and optimizes the coarser virtual networks by applying a refined Kernighan-Lin (KL) algorithm. The proposed algorithm coarsens sub-virtual networks that are close to clique and embeds each sub-virtual network to substrate node. The cost of embedding virtual networks is reduced by eliminating the cost of embedding virtual links between virtual nodes on the same substrate node. Performance of the proposed algorithm has been evaluated and compared with some of the existing algorithms using extensive simulations. Extensive simulation experiments show that the proposed algorithm increases the acceptance ratio and the revenue. For the future work, we plan to investigate other coarsening techniques (e.g. Random Matching and Light Edge Matching) to find the best coursing technique, which increases the acceptance ratio and the revenue while decreasing the embedding cost.