Implementation and performance analysis of various VM placement strategies in CloudSim

Adapative heuristics for dynamic VM consolidation

For VM placement, the typical approach that is introduced by many real datacenters is based on the solutions of Bin packing problem. First Fit algorithm is one of the popular solutions which are used to consolidate VMs in these datacenters. In order to minimize the number of server and prepare computational resources Ajiro [4] implemented a load-balancing, least loaded algorithm and compared it with classical FFD (First Fit Decreasing) problem. Later in their work, they developed an improved version of FFD and LL algorithm, and evaluated them. They reported that for packing underutilized servers LL was more suitable but it produced poor performance on servers which were highly utilized.

Basmadjian et al. [5] presented different prediction models for power consumption in servers, storage devices and network equipments. For power saving they provided a three step model that consisted of optimization, reconfiguration and monitoring. The authors claimed that if the energy optimization policy could be guided by power consumption prediction models, then about 20 % energy consumption could be saved for typical single site private cloud data-centers.

Gebai el al. [6] studied the cause of task pre-emption across virtual machines. The authors used kernel tracing for latency problem. However, as the traces are from different virtual machines and generated from different time reference, a synchronization method is required. The authors proposed a trace synchronization method to merge the traces. Then the merged trace was explored further in a graphical interface to study the interactions among virtual machine CPUs. Finally, the interactions of threads among different systems were analyzed. This analysis could detect the execution flow centered on the threads and thus discover the cause for latency.

Dong et al. [7] proposed most-efficient-server-first (MESF) task-scheduling algorithm for cloud computing data center. They reduced the energy consumption by limiting the number of active servers and response time. They used integer programming for the optimization solution and showed a trade-off among active servers and response time. Their simulation results demonstrated that MESF could save 70 % energy consumption compared to random task scheduling scheme.

Panigrahy et al. [8] reordered the virtual machine request queue and proposed a geometric heuristics that run nearly as fast as FFD. Kangkang et al. [9] in their work emphasized on an approach based on the multiple multidimensional knapsack problem for VM placement instead of bin packing solution, where the main concern was to minimize the total job completion time of the input VM requests on the same physical machines through a reasonable VM placement schedule.

Khanna et al. [10] proposed a dynamically managed algorithm which is activated when a physical server becomes underloaded or overloaded. In the work, the authors reduced the violation of SLAs, minimized migration cost and number of physical server used, and optimized residual capacity. Jung et al. [11, 12] also tried to solve the dynamic VM consolidation problem while meeting SLA requirement where virtual machines were running on a multi-tier web application using live migration. Using gradient search and bin packing, a VM placement was done as a solution; however, this approach could only be applied to a single web application setup and therefore cannot be utilized for IaaS environment.

Speitkamp and Bichler [13, 14] used linear programming formulations for static and dynamic server consolidation problem by mapping virtual machines to certain physical servers which had unique attribute, and by limiting the number of VM migrations in physical machines. They proposed a LP-relaxation based heuristic to reduce the cost of solving the linear programming formulation. In another experiment, to minimize unnecessary migrations due to unpredictable workload, Tiago [15] proposed another LP formulation and heuristics to control VM migration prioritizing VMs with steady capacity which they named dynamic consolidation with migration control.

Beloglazov and Buyya [3] analyzed historical data of resource usage of VMs and proposed dynamic VM consolidation that can be split into four parts. First, they checked whether a host is overloaded. If it is, then decision is made to migrate some VMs from this particular host to another. Second, selection of VMs is done to decide the list of VMs that should be migrated from overloaded host. Third, checking is done to decide whether a host is underloaded and all VMs are needed to migrate to other hosts. Fourth, hosts have been selected to place the migrated VMs from overloaded and underloaded hosts. For VM placement optimization, they propose an algorithm which scans through the list of hosts and then tries to detect the hosts that are overloaded. If overloaded hosts are found then the algorithm tries to pick the VMs that are needed to be migrated from one host to another by applying any of the suitable VM selection policies. Once the list of VMs are created, the VM placement algorithm is executed to find a new placement for the migrated VMs. VM placement for underloaded host works in the similar fashion. After finding suitable host for all VMS from the underloaded host, the host is shut down or put in sleeping mode. The algorithm then returns the migration map which has the combined information of new VM placement which is needed to be migrated from both overloaded and underloaded hosts. They proposed a modified version of BFD (best fit decreasing) for VM placement solution.

In our work we also followed the heuristics that Beloglazov and Buyya [3] stated in their work for dynamic VM consolidation, but instead of their modified best fit decreasing algorithm for VM placement, we proposed our algorithms based on other bin packing solutions for VM placement with our custom modification.

The VM placement problem could be modeled as bin packing problem with variable bin sizes and prices. The physical nodes can be represented as the bin, VMs that have to be allocated could be viewed as the items, bin size can be seen as available CPU capacities and price can be seen as the power consumption by the nodes. Among many solution of bin packing problem Beloglazov and Buyya [3] proposed a modification of popular Best Fit Decreasing (BFD) algorithm that was shown to use bins, not more than 11/9.OPT + 1 (where OPT is the number of bins provided by the optimal solution) [3]. The modified BFD was named PABFD (power aware best fit decreasing) algorithm which first sorts the VMs according to their CPU utilization in decreasing order and then for each VM it checks all the hosts and find the suitable host where the increase of power consumption is minimum. At final steps, it allocates the VM to that host. The algorithm is given as Algorithm 1.

Proposed work

Now, if we follow carefully the above discussion, the first point could also be interpreted as the Worst Fit Decreasing technique. The reason for saying that is very trivial. Choosing host where the increase of power consumption is maximum is the exact opposite that BFD usually does. As we know WFD (worst fit decreasing) algorithm is the exact opposite algorithm of BFD. So at this point we are proposing a modified VM placement algorithm which we name MWFDVP (modified worst fit decreasing VM placement). The pseudo-code for the algorithm is presented in Algorithm 2.

Now let us turn into the second point, as we can see that it is slight modification over the first point, instead of choosing the host with minimum available power, it is choosing the host with second minimum available power; it can be interpreted as second worst fit technique or almost worst fit technique. AWF (almost worst fit) tries to fill the second largest gap first and does the rest just like worst fit decreasing [23]. So we propose another VM placement algorithm based of almost worst fit decreasing technique that we named SWFDVP (Second worst fit decreasing VM placement) whose pseudo code is given below as Algorithm 3.

The observation in point 3 can be modeled as First Fit Decreasing algorithm. We choose a host from the hostlist (starting from the very first position) and check whether the host is suitable for the VM. If the host is suitable then we pour the VM into that host and check for the next VM from the VMlist. If the host is not suitable than we move onto the next host from the hostlist. Considering this we propose a VM placement algorithm which we name as MFFDVP (modified first fit decreasing VM placement). As this algorithm is almost identical with our lastt algorithm, we skip describing its pseudo code and move toward the next point. Let us consider the point 4. Now we can see that it is a representation of modified first fit technique where hosts are decreasingly sorted with respected to their available power. So for this case, each VM will be first allocated to the host which has maximum available power, then after allocating the VM, the hostlist will be decreasingly sorted again (when the next VM is called), and in this manner it will continue allocating VMs until allocation for all the VMs from the VM migration list is done; when one host reaches close to its maximum power, the next host from the hostlist will be called. We named it FFDHDVP (first fit decreasing with decreasing host VM placement). The pseudo-code for the algorithm is presented in Algorithm 4.

In CloudSim 3.0, the Virtual Machines that needed to be migrated from one host to another are first sorted according to their CPU utilization in a decreasing order and then a suitable host for each VMs is found by using PABD algorithm. The most efficient way the optimization algorithm works by allocating as many VMs as it can on a single host so that it could reduce the utilization of host as well reduce the migration of VMs and SLA violations. In this work, instead of decreasingly sorting virtual machines list, we explored clustering technique that could form clusters of VMs based on its CPU utilization and currently allocated RAM. After making clusters we tried to find hosts for the VMs that came from highest density cluster, which means, we give highest priorities to the virtual machines that are the members of mostly dense cluster. In this way, a group of maximum number of VMs which are close to each other with respect to CPU utilization and current allocated RAM are subjected to be poured into host at first, then the VMs from a group of second dense cluster will be allowed to be poured on suitable hosts. Each cluster is basically a VM list and for VM placement highest dense clusters (the VM list with maximum number of VMs in it) will be considered to be hosted first. We will discuss about how we form the clusters, our choice of clustering algorithm and how we implement it below.

By the term clustering we mean grouping of objects in such a way that objects with identical attribute values reside together. There are many cluster models that include connectivity model, centroid based models, distribution models, density models, graph based models, etc. Among those models we choose to start working with centroid based model.

In the centroid based clustering, a central vector which may not necessarily be a member of the data set usually represents a cluster. The most popular centroid based clustering algorithm is k-means algorithm which is a prototype based ,partitioned clustering techniques that attempts to find a user specified number of clusters (k), which are represented by their centroid [24].

In this research, we introduced a new technique to find the number of clusters, i.e., k in this research. It is described below.

It is quite trivial to notice that if one host has a capacity of C _h and if the maximum allocated cpu capacity of a VM is C _v then the maximum number of VMs that could be allocated to a host is, MaxV = C _h /C _{v .} Following this we find the number of virtual machines in each cluster in such a way so that all the virtual machines in a cluster can be allocated to their suitable host as a group. Suppose we have a list of hosts H ₁ , H ₂ , H ₃ ……., H _n and a list of virtual machines like V₁, V₂,……., V_n. Now if we build a set of hosts according to their available CPU Million Instructions Per Second (MIPS) from the host list, we can get , H _(x) ^{available cpu mips}   = {H ₍₁₎ , H ₍₂₎ ,……,H _(n) } where x ϵ {1,……..,n}. Now we denote alpha as, α = max ({H _(x) ^{available cpu mips} : x ϵ (1,…, n) }) And beta as, β = min ({H _(x) ^{available cpu mips} : x ϵ (1,…,n) }). In the similar way if we build a set of Virtual machines according to their currently allocated mips from the virtual machine list , we can get V _(x) ^{current allocated cpu mips}   = {V ₍₁₎ , V ₍₂₎ ,……,V _(n) } where x ϵ {1,……..,n}. We denote gamma as, γ = max ({V _(x) ^{current allocated cpu mips} : x ϵ (1,…, n) }) and delta as , δ = min ({V _(x) ^{current allocated cpu mips} : x ϵ (1,…,n) }). Now, if we need to migrate the Virtual Machines to their suitable hosts from the host list, the maximum number of VMs that could be allocated into a host can be found by maxpoint = (α/ δ) and the minimum number of VMs in a cluster can be found by minpoint = (β / γ). So we compute the optimal number of cluster k as finding average of the maximum and minimum numbers of VMs set for each cluster. So k = (maxpoint + minpoint) / 2.

After we have found the value for k (optimal number of cluster) and the initial centroids we will repetitively build clusters by assigning Virtual Machines to its closest centroid based on the CPU utilization and currently allocated RAM by recounting the centroid of each clusters, until there is no alteration of centroids. After the completion of these steps we will start performing k-means algorithm which we named modified k-means algorithm (MK) which is represented in Algorithm 5.

After we get our desired clusters, we will start allocating VMs from the cluster which have maximum VMs on it. It will keep repeating to allocate VMs until all the VMs are allocated from higher dense cluster to lower dense clusters. We will try to implement the bin packing solutions to design our custom VM placement algorithms for placing the VMs into their suitable hosts. We considered using best fit, first fit, a modified version of first fit with decreasingly sorted host with respect to their available power, worst fit and almost worst fit algorithms to design our VM placement algorithms. As we have already seen that Beloglazov and Buyya in their work [3] implemented PABFD, so if we want to use it, we will need to make some tweaks on PABFD to make it work for our clustering approach. In PABFD, instead of sorting VMs in decreasing order, we will call our MK algorithm to make cluster of VMs and then we will rebuild the VM migration list based on the preference of VMs which came from highest dense cluster to lower dense clusters; this rebuilding operation will be done by a function that we named arrangeByHighDensityCluster which takes the returned cluster from MK and the VM list as parameters. In this way all the VMs from higher to lower dense clusters will be arranged in VM migration list and then we will follow the rest of the same methodology of PABFD algorithm. We are naming the tweaked version of PABFD as PABF_C.

Now, If we try to place each VM from the redesigned VM migration list(after clustering) on a host from hostlist, where the increase of power consumption is maximum, then VMs will occupy the hosts where available power would be minimum and turn on as much host as they can at the very beginning. The rate of turning on the host will eventually be reduced at each successive step. If we look carefully, we can see that, this scenario can be interpreted as the Worst Fit technique. So based on this, at this point we are proposing a modified VM placement algorithm which we name MWFVP_C (modified worst fit VM placement for clustering). The pseudo-code for the algorithm is presented in Algorithm 6.

In the similar manner we have designed SWFVP_C (second worst fit VM placement for clustering), MFFVP_C algorithm (modified first fit VM placement for clustering) and FFHDVP_C (first fit with decreasing host VM placement). Due to space limitation we do not provide the details of pseudo code here. We have integrated the entire proposed algorithm beside PABF_C to the CloudSim toolkit, and later we will verify whether these algorithms produce satisfactory results.

As our objective is to improve the quality of IaaS system model, we need to run our methods in simulation which can provide us IaaS environment. It would be beneficial for us if the environment could be represented by data centers consisting of specific number of physical server, where each server has multi-core architecture, adequate amount of RAM, bandwidth and storage. In general CPU performance is defined as Millions Instructions Per Second (MIPS) and instead of local disks the storage is defined as Network Attached storage (NAS) or Storage Area Network (SAN). We also need to make a power model to estimate the power consumption based on utilization of CPU. Now in order to design the power model we followed the steps of Beloglazov and Buyya’s work [3]. The authors reported that building precise analytical power model was quite difficult. Theredore, instead of using an analytical model of power consumption of a server they utilized real data on power consumption provided by the SPECpower benchmark result. Following their trail we selected the exact two server configuration that they choose to work with; HP ProLiant ML110 G4 (Intel Xeon 3040, 2 cores * 1860 MHz, 4 GB), and HP ProLiant ML110 G5 (Intel Xeon 3075, 2 cores * 2660 MHz, 4 GB). The power consumption data of HP ProLiant ML110 G4 server and HP ProLiant ML110 G5 was taken from the SPECpower benchmarks results from their website [https://www.spec.org/power_ssj2008/results/res2011q1/power_ssj2008-20110124-00338.html] [https://www.spec.org/power_ssj2008/results/res2011q1/power_ssj2008-20110124-00339.html].

We also used their metrics for calculating SLA violation, the first one was SLATH (SLA violation per active host) which is the percentage of time active host experiences 100 % utilization of cpu and the second one is PDM(performance degradation due to migrations).

The mathematical formula for SLATH is, \( \mathrm{SLATH}\kern0.5em =\kern0.5em \frac{1}{\mathrm{N}}\kern0.5em {\displaystyle {\sum}_{i=1}^N\frac{Tsi}{Tai}} \), where N = the number of hosts, Tsi = total time host i has experienced 100 % CPU utilization which led to SLA violation, Tai = total time of host i being active for serving virtual machines.

The mathematical formula for PDM is, \( PDM\kern0.5em =\kern0.5em \frac{1}{M}\kern0.5em {\displaystyle {\sum}_{j=1}^M\frac{Cdj}{Crj}} \), where M = number of Virtual Machines. Cdj = Estimate of performance degradation of VM j due to migrations. (By default it was set to 10 % of CPU utilization in MIPS during all migrations of VM j),Crj = total CPU capacity requested by VM j during its lifetime.

Performance evaluation

We ran simulation randomly among day wise PlanetLabs workload data for our proposed algorithms that have been discussed in earlier section. At first we ran the simulation according to the default mechanism of CloudSim. By default, VM migrationlist was decreasingly sorted with respect to CPU utilization and VMplacement algorithm was PABFD. We then used the decreasingly sorted VM migration but instead of PABFD we used our proposed MWFDVP, SWFDVP, MFFDVP, FFDHDVP algorithms for VM placement one at a time. We take into account the power consumption, SLA violation, SLA violation per active host, performance degradation due to migration and number of VM migration from the generated output to compare the performance of those algorithms.

The result for power consumption produced by our proposed algorithms is given in Fig. 1. From that figure we can see that for any chosen policy, CloudSim’s default PABFD resulted in higher power consumption followed by almost close results of SWFDVP and MFFDVP, then MWFDVP and the last is FFDHDVP. Therefore, all of our proposed VMplacement algorithms performed better than PABFD which is used as the default VM placement algorithm in CloudSim. The minimum power consumption is scored by both lrmmt 1.2 and lrrmmt 1.2 as a result of selecting FFDHDVP algorithm, which draw very good result compared to PABFD. Here the lrmmt means we use LR overload detection method and MMT as VM selection method where the threshold for LR is 1.2.

Now let us consider to the result of SLA violation which is given in Fig. 2. We could see that almost for all policies, MWFDVP, MFFDVP and SWFDVP resulted in higher SLA violation. PABFD and FFDHDVP managed to produce lower amount of SLA violation but for thrrc 0.8, thrmmt 0.8, thrmu 0.8 and thrrs 0.8, PABFD performed better results compared to others. Though PABFD was overall good performer, the lowest amount of SLA was scored by lrmmt 1.2 and lrrmmt 1.2 which used FFDHDVP as VM placement algorithm. So for lowest amount of SLA violation, again our proposed FFDHDVP produced better results compared to Cloudsims default PABFD algorithm.

In Fig. 3, we have shown the performance degradation due to VM migration for all of our proposed VM placement algorithms against PABFD. We can see from the figure that throughout the policies while using lrmmt 1.2 and lrrmmt 1.2, MWFDVP algorithm caused smallest amount of performance degradation, followed by FFDHDVP (the difference between them was 0.01 % which is very small), MFFDVP, SWFDVP and PABFD respectively.

Now we will discuss about the result of SLA violation time per active host generated by all the policies that include all our proposed algorithms and CloudSim’s by default PABFD algorithm. The result is given in Fig. 4. We can see from the figure that in 7.77 % of time active hosts experienced 100 % of CPU utilization while using iqrmc 1.5 policy and FFDHDVP algorithm. For VM placement both FFDHDVP and PABFD prodcuced good results but FFDHDVP got a slight edge over PABFD for causing smallest amount of SLA violation time per active host.

Now at last, we will examine the result of number of VM migrations for all VM placement algorithms. The result is given in Fig. 5, and we can see that lrmc 1.2 and lrrmc 1.2 scored minimum number of VM migration, when it is used with MWFDVP algorithm. After MWFDVP, MFFDVP scored second followed by FFDHDVP, SWFDVP and PABFD respectively.

After running simulations we can see from Fig. 6 that, for any chosen policy for VM placement, original PABFD with our clustered method that used PABFD (PABF_C) resulted in higher power consumption followed by almost close results of SWFVP_C and MFFVP_C, then MWFVP_C and last FFHDVP_C, so all of our proposed VM placement algorithms with clustering, performed better than PABFD which was enabled by default in CloudSim. The minimum power consumption is scored by both lrmmt 1.2 and lrrmmt 1.2 as a result of selecting FFHDVP_C algorithm, which produced very satisfactory results compared to PABFD and our other proposed algorithms in terms of power consumption.

Now if we move over to the result of SLA violation which is given in Fig. 7, we could see that, for all policies MWFVP_C, MFFVP_C and SWFVP_C resulted in higher SLA violation. PABF_C followed by FFHDVP_C managed to produce lower amount of SLA violation for thrrc 0.8, thrmmt 0.8, thrmu 0.8 and thrrs 0.8, PABF_C showed good results compared to others. Though PABF_C was overall good performer, the lowest amount of SLA was scored by lrmmt 1.2 and lrrmmt 1.2 which used FFHDVP_C. So for lowest amount of SLA violation, again our proposed FFHDVP_C produced satisfactory results compared to CloudSim’s by default PABFD and our other proposed algorithm.

Now, in Fig. 8, we have showed the output generated of performance degradation due to VM migration for all the policies of all our proposed algorithms. We can see from the picture that throughout the policies again lrmmt 1.2 and lrrmmt 1.2 caused smallest amount of performance degradation, this time MWFVP_C algorithm was the best performer followed by FFHDVP_C, MFFVP_C, SWFVP_C and last PABF_C.

Now we will discuss about the result of SLA violation time per active host, generated by all the policies which followed all our proposed algorithms and CloudSim’s by default PABFD algorithm. The result is given in Fig. 9 and what we can see from the picture is that for 7.38 % of time, active hosts experienced 100 % of CPU utilization using iqrmmt 1.5 as overload detection policy and FFHDVP_C algorithm as their VM placement algorithm. Both FFHDVP_C and PABF_C gave good results but FFHDVP_C got a slight edge over PABF_C for causing smallest amount of SLA violation time per active host.

Now at last, we will examine the result of number of VM migrations for all the policies that followed all the VM placement algorithms. The result is given in Fig. 10, and we can see lrrrs 1.2 scored minimum number of VM migration, when it used MWFVP_C algorithm for VM placement. For VM placement after MWFVP_C; MFFVP_C followed by FFHDVP_C, SWFVP_C and PABF_C scored good result.

Therefore, at the end of running all simulation, if we try to figure out which policy produced satisfactory results for a randomly chosen day, we can see that for power consumption, SLA violation and performance degradation due to host migration, both lrmmt 1.2 and lrrmmt 1.2 made very good results, compared with rest of the policies; for SLA violation time per active host iqrmmt 1.5 and for number of VM migration lrrrs 1.2 produced good results. If we consider to find the best policy considering all of them, we can see that being lagging behind in some of the cases (which is very negligible) lrmmt 1.2 and lrrmmt 1.2 gave us quite satisfactory results. For VM placement, in every cases all our proposed algorithms produced better result compared to the PABFD algorithm that was default VM placement techniquein CloudSim toolkit. However, among these algorithms, for power consumption, SLA violation and SLA violation time per active host FFHDVP_C, for performance degradation due to migration and number of VM migration MWFVP_C (having close contest with FFHDVP_C) showed strong results compared to other.

In the previous section, we individually showed results of our VM placement algorithms for both non-clustered and clustered approach with different VM selection and overload detection policies. On both cases we ran our simulation for one day data from ten days PlanetLab workload traces. We have seen that our proposed VM placement algorithms did very well compared to the PABFD algorithm in all perspectives, i.e., all performance metrics.

However, if we consider every VM placement, VM selection and overload detection techniques, the number of combinations is huge, i.e., 10 VM placement strategies (5 clustered and 5 non-clustered), 3 VM selection strategies and 5 overload detection strategies. If we want to consider all of them, 150 comparisons should be made which is huge and considerable amount of simulation time is required to report the findings. As we already found our best two VM Placement techniques as FFDHDVP and MWFDV, we consider them for further analysis. So, we took only FFDHDVP and MWFDVP for non-clustered, FFHDVP_C and MWFVP_C for Clustered VM placement algorithms and selected policies like lrrmmt 1.2, lrrmc 1.2, and iqrmc1.5. We skipped policies like lrmmt 1.2 and lrmc1.2 as they scored exactly the same as their robust versions.

The result of this descriptive statistic is discussed below. In the figures we used numbers to reflect policies name so that they can visibly fit into our graphs. We used #1, #2, and #3 to represent iqrmc 1.5, lrrmmt 1.2 and lrrmc 1.2 respectively. For example PABFD#1 means we used PABFD as our VM placement algorithm and iqrmc 1.5 as our VM selection and overload detection policy, i.e., iqr as overload detection with threshold 1.5, mc as maximum correlation VM selection policy.

By comparing our proposed VM placement algorithms against existing algorithm like PABFD it is found from Fig. 11 that, the power consumption is remarkably reduced in proposed FFDHDVP algorithm. Minimum energy consumption is 86.09 Kwh for lrrmmt 1.2 where the minimum of PABFD is 122.88 Kwh for the same policy; therefore we got 29.93 % reduction. Considering average values, FFDHDVP consumed 112.646 Kwh and PABFD consumed 161.87 Kwh on average for lrrmmt 1.2, resulting 24 % of energy saving.

From Fig. 12, we can see that SLA violation is significantly decreased when we used FFHDVP_C as VM placement algorithm and lrrmmt 1.2 as our policy. FFHDVP_C resulted 0.00087 %SLA violation in minimum compared to PABFD’s 0.00439 % which indicates 80 % reduction. If we consider average value, FFHDVP_C produced 0.001447 % SLA and PABFD incurred 0.004974 % on average, resulting 71 % reduction in SLA violation.

For performance degradation due to VM migration what we can see from Fig. 13, is that for lrrmmt1.2, MWFVP_C scored minimum PDM of 0.033296 % and PABFD scored 0.0734734 % resulting 54.68 % of improvement. If we count the average value MWFVP_C’s 0.041294 % PDM beat PABFD’s 0.07969383 % PDM by reduction of 48 %.

Figure 14 describes the result of SLA violation time per active host. We can see from the figure FFHDVP_C scored minimum SLATAH of 2.53 % for lrrmmt1.2 and PABFD scored 5.84 %, causing 56 % improvement. Counting average values we can see that both FFHDVP_C and PABFD caused 3.349 % and 6.213 % SLATAH for lrrmmt 1.2, resulting 46 % improvement over SLATAH.

Now at last we will move on to the results of number of VM migration. The result is given in Fig. 15 and we can see from the output that the minimum amount of VM migration for FFHDVP_C is 8449 and PABFD’s minimum is 16903 for lrrmc 1.5 policy, indicating 50 % less migration of VM. For average, FFHDVP_C’s 11890 VM migration outperformed PABFD’s 23931 VM migration causing 50 % improvements.

We could say that when lrrmmt 1.2 is chosen as VM selection and overload detection policy, for reducing power consumption FFDHDVP, for SLA violation, SLA violation time per active host and number of VM migration our clustered FFHDVP_C and, for performance degradation due to migration clustered MWFVP_C made outstanding results. So, we can say that all of our proposed algorithms outperformed PABFD algorithm that was the default VM placement algorithm given in CloudSim toolkit.

If the p-value is greater than 0.05, then we must accept the null hypothesis, otherwise we must reject the null hypothesis. From Table 3 we find that the p-value is significantly smaller than 0.05 for every performance metric. Therefore, we must reject the null hypothesis and we could conclude that there is significantly difference in performance found by the built in Power Aware Best Fit Decreasing (PABFD) in CloudSim and the best algorithm, FFHDVP_C that we develop and implement in this research. From the box plots, we could easily verify that our proposed algorithms perform significantly better than the built in PABFD VM placement algorithm