A multi-objective algorithm for virtual machine placement in cloud environments using a hybrid of particle swarm optimization and flower pollination optimization

Modeling placement time

This subsection derives a mathematical expression for the placement time T_j of a VM v_j. The placement time T_j is measured from the instant at which v_j is requested to the expected instant at which v_j is to be placed onto a specified PM p_i. From this definition, T_j consists of two components.

1. The search time S_j is the time required by v_j to find all the available PMs x_k ∈X that fulfill its requirements, where |X| = N. Hence, the value of S_j can be written as (8)${\displaystyle S_j=\sum _{k=1}^N{x}_k\left(\right.T\left(\right.\frac{c_j^{{}^{\prime }}}{c_k}+\frac{m_j^{{}^{\prime }}}{m_k}\left)\right.+{\delta }_k\left)\right.,}$ where T is the time required to find appropriate PMs on which to place the requested VMs, and δ_k is the search time factor representing the time delay for each VM cycle.

2. The expected waiting time E[W_j] of v_j in the cloud DC consists of the VM queuing time and the VM service time. Let the arrival process of a given VM at the cloud DC be a Poisson process with arrival rate λ. Let the service time of a VM be exponentially distributed with expectation $\frac{1}{\mu }$. We assume that the DC has an infinite queue for the hosting of all arrived VMs on N PMs. From this physical description, the system dynamics (i.e., arrival, service, and departure) can be modeled as the well-known multi-server queuing system M/M/N, where λ < μ is the steady state condition. The expected waiting time E[W_j] of M/M/N can be written as (White, 2012) (9)${\displaystyle E\left[W_j\right]=\frac{\mu \left(\right.\frac{\lambda }{\mu }{\left)\right.}^N{p}_0}{\left(N-1\right)!{\left(N\mu -\lambda \right)}^2}+\frac{1}{\mu },}$ where p₀ is the probability of an empty queue and is given by (10)${\displaystyle p_0=\left[\right.\sum _{n=0}^{N-1}\frac{{\left(\frac{\lambda }{\mu }\right)}^n}{n}+\frac{{\left(\frac{\lambda }{\mu }\right)}^n}{N!\left(1-\frac{\lambda }{N\mu }\right)}{\left]\right.}^{-1}.}$

Using Equations Eqs. (8) and (9), the placement time t_j of v_j is given as (11)${\displaystyle t_j=S_j+E\left[W_j\right].}$ The total placement time T_j can be calculated as follows: (12)${\displaystyle T_j=\sum _{i=0}^N{e}_{ij}{t}_j.}$ Finally, the total placement time T for all VMs can be calculated using Eq. (12): (13)${\displaystyle T=\sum _{j=0}^M{T}_j.}$

Modeling power consumption

Jin et al. (2020) accurately modeled power consumption linearly as a function of the resource utilization of the PMs in the cloud DC. In this model, power consumption is based only on CPU utilization. Additionally, unused PMs are deactivated to save power. Hence, power consumption can be computed for each PM p_i ∈ P as follows. Let $u_i^{max}$ and $u_i^{idle}$ be the power consumption of PM p_i at maximum CPU utilization and idle state, respectively. The power consumption PU_i of the PM p_i due to the VM v_j is given as (14)${\displaystyle P{U}_i=u_i^{idle}+\left(\right.u_i^{max}-u_i^{idle}\left)\right.\frac{e_{ij}{c}_j^{{}^{\prime }}}{c_i}.}$ The power consumption $P{U}_i^{{}^{\prime }}$ of the PM p_i due to all VMs is given using Equation (6) as (15)${\displaystyle P{U}_i^{{}^{\prime }}=u_i^{idle}+\left(\right.u_i^{max}-u_i^{idle}\left)\right.U_i^{cpu}.}$ From Eqs. (14) and (15), the total power consumption PU of all PMs in a DC can be computed as follows: (16)${\displaystyle PU=\sum _{i=0}^N{x}_i\times P{U}_i^{{}^{\prime }}.}$

Modeling resource wastage

The residual resources offered by each physical machine may vary according to the VMP strategy. To maximize the utilization of multiple resources such as CPU and RAM, the resource wastage W_i of the PM p_i can be calculated as follows: (17)${\displaystyle W_i=\frac{\left|\right.r_i^{cpu}-r_i^{ram}\left|\right.}{U_i^{cpu}+U_i^{ram}}+\varepsilon ,}$ where $r_i^{cpu}$ and $r_i^{ram}$ represent the normalized residual CPU and memory resources; the values of $U_i^{cpu}$ and $U_i^{ram}$ are given in Eqs. (6) and (7); and ɛ = 0.001, a small positive real number (Gupta & Amgoth, 2016). This model and its corresponding objective are included to make best use of the resources of all PMs and achieve balance between multiple residual resources. The total resource wastage W of all PMs in a DC is given by (18)${\displaystyle W=\sum _{i=1}^N{x}_i\frac{\left|\right.\left(\right.U_i^{cpu}-\sum _{j=1}^M{e}_{i,j}{c}_j^{{}^{\prime }}\left)\right.-\left(\right.U_i^{ram}-\sum _{j=1}^M{e}_{i,j}{m}_j^{{}^{\prime }}\left)\right.\left|\right.+\varepsilon }{\sum _{j=1}^M{e}_{i,j}{c}_j^{{}^{\prime }}+\sum _{j=1}^M{e}_{i,j}{m}_j^{{}^{\prime }}}.}$ Finally, the placement problem can be formulated: (19)${\displaystyle MinimizeT.}$ (20)${\displaystyle MinimizePU.}$ (21)${\displaystyle MinimizeW.}$ Subject to the constraints (22)${\displaystyle \sum _{i=1}^N{e}_{i,j}=1,\forall j=1,2,\dots ,M,}$ (23)${\displaystyle \sum _{j=1}^M{e}_{i,j}{c}_j^{{}^{\prime }}<c_i,\forall i=1,2,\dots ,N,}$ (24)${\displaystyle \sum _{j=1}^M{e}_{i,j}{m}_j^{{}^{\prime }}<m_i,\forall i=1,2,\dots ,M,}$ and (25)${\displaystyle x_i,e_{i,j}\in \left\{0,1\right\},\forall i=1,2,\dots ,N,j=1,2,\dots ,M.}$ From Eq. (22), each VM can be placed only on a single PM. Equations (23) and (24) stipulate that the summation of CPU and RAM respectively of all VMs hosted on a given PM must not surpass that PMs CPU and RAM capacity. Finally, Eq. (25) formalizes the domains of the variables M and N. Hence, there are M^N possible solutions for the placement problem.

Particle encoding

Each particle represents a candidate solution for the placement of a set of VM requests on a set of PMs. The placement matrix 𝕄, defined in Eq. (1), is used to initiate the particles. In this manner, each created particle represents one of the M^N possible solutions to the placement problem.

For example, consider two different particles created from 𝕄 in the initial swarm as shown in Fig. 2. Each particle is created in a two-dimensional scheme that uses one-to-many maps between each PM and its hosted VMs within the particle.

Particle evaluation

The optimal solution for placement is obtained through successive iterations of swarm regeneration. A new swarm is generated whenever the position and velocity of the particles are updated. The equations for particle position and velocity as implemented in the standard PSO and PSOLF algorithms are as follows. Using PSO, the velocity of each particle is updated as (27)${\displaystyle V_i\left(t+1\right)=\omega \times V_i\left(t\right)+{\rho }_1\times c_1\times \left(P_{lbest}-P_i\left(t\right)\right)+{\rho }_2\times c_2\times \left(P_{gbest}-P_i\left(t\right)\right),}$ where i is the particle number within the swarm, ω is the inertia weight which determines the impact of the previous velocity on the current velocity, V_i(t) is the current particle velocity, V_i(t + 1) is the new particle velocity, P_i(t) is the current position of the particle within the swarm, C₁ and C₂ are learning factors of the particle and swarm, and ρ₁ and ρ₂ are uniformly distributed random variables between 0 and 1. Using PSO, the position of each particle is updated as (28)${\displaystyle P_i\left(t+1\right)=P_i\left(t\right)+V_i\left(t+1\right),}$ where P_i(t + 1) is the new position of the particle within the search space, and P_i(t) is the current position. Standard PSO has a defect known as premature convergence that pushes the particles to converge too early and become trapped within local optima (Nakisa et al., 2014). To overcome this problem, Lévy flight can be combined with PSO to produce PSOLF. This reduces early particle convergence by updating velocities in a manner that causes the particles to take a long step towards the optimal solution (Haklı& Uğuz, 2014). When using Lévy flight, the particle positions and velocities are updated as follows. Using PSOLF, the velocity of each particle is updated as (Jensi & Jiji, 2016) (29)${\displaystyle V_i\left(t+1\right)=\omega \times L\times V_i\left(t\right)+{\rho }_1\times c_1\times \left(P_{lbest}-P_i\left(t\right)\right)+{\rho }_2\times c_2\times \left(P_{gbest}-P_i\left(t\right)\right),}$ where L is a step size emulating the large distance. This can be calculated using Lévy flight: (30)${\displaystyle L\left(s,a\right)\sim \frac{\lambda \times \Gamma \left(\lambda \right)\times sin\frac{\left(\pi \lambda \right)}{2}}{\pi },}$ where Γ(λ) is the gamma function with index λ, a = 1 is a control parameter of the distribution, and S is a large step which is given by (31)${\displaystyle S=\frac{U}{|V{|}^{\left(\lambda -1\right)}}.}$ The parameters U and V are drawn from a Gaussian normal distribution and are given by (32)${\displaystyle U\sim N\left(0,{\sigma }_u^2\right),V\sim N\left(0,{\sigma }_v^2\right),}$ where (33)${\displaystyle {\sigma }_u={\left[\frac{\Gamma \left(1+\lambda \right)}{\lambda \Gamma \left(\frac{\left(1+\lambda \right)}{2}\right)}\times \frac{sin\left(\frac{\pi \lambda }{2}\right)}{2^{\frac{\left(\lambda -1\right)}{2}}}\right]}^{\frac{1}{\lambda }}.}$ The size of each step is calculated using Jensi & Jiji (2016) (34)${\displaystyle stepsize=0.01\ast S.}$ Using PSOLF, the position of each particle is updated as (35)${\displaystyle P_i\left(t+1\right)=V_i\left(t+1\right).}$

The PSOLF-based VMP algorithm stages

Before describing the proposed PSOLF-based VMP algorithm, there are some preparatory PSO principles that should be clarified and described. In the search space, each particle has position P_i and velocity V_i. Both should be computed at each iteration of the swarm evaluation. In addition, each particle has a key criterion known as the local best solution P_l−best. During each iteration, P_l−best is updated with the particles computed position value if the computed value is less than P_l−best. The swarm itself has an analogous criterion known as the global best solution P_g−best. Generally, the global best solution is given by the minimum value of the local best solution among all particles.

The proposed algorithm consists of three principal operations: swarm initialization, swarm evaluation, and termination.

• Swarm initialization. The swarm is initialized by generating a particle vector P from the placement matrix 𝕄. All initiated particles are restricted by the constraints in Eqs. (22)–(25). The number of particles in the swarm is N_swarm. For each particle, the initial position and velocity are generated randomly based on the particles index within the vector P. The position of each particle is set to its corresponding local best solution P_l−best. The minimum value of P_l−best among all particles is assigned to the global best P_g−best of the swarm. In addition, the required PSO parameters are defined, including the learning factors c₁, c₂, inertia weight coefficient ω, and the random variables ρ₁, ρ₂ ∈ [0,1]. Moreover, the random function rand() is defined to generate random numbers between [0,1], and the maximum number of iterations is set to Max_iter. Finally, the fitness function of all particles is computed using Eq. (26) to obtain the local fitness of each particle.

• Swarm evaluation. During each iteration, the particle velocities and positions are updated by either PSO or PSOLF. The choice between algorithms is dependent upon the value generated by rand(). If the value of rand() is less than 0.5, the particle velocities and positions are updated as in Eqs. (29) and (35). Else, the particle velocities and positions are updated as in Eqs. (27) and (28). Subsequently, the fitness values associated with the updated particle position P_u and the position P_l−best are compared. If the fitness value of P_u is less than the fitness value of P_l−best, then P_l−best is set to P_u. Furthermore, if the fitness value of P_l−best is less than the fitness value of the global best position P_g−best, then P_g−best is set to P_l−best.

• Swarm termination. Swarm evaluation continues iteratively until the maximum number of iterations Max_iter is reached. Following the final iteration, the particle corresponding to P_g−best is selected to represent the optimal fitness value for the VMP solution.

The pseudo-code for the PSOLF algorithm is presented below.

Pollen encoding

Each pollen grain encodes a possible VMP solution. The placement matrix 𝕄 can be used to initialize the pollen as in the case of the particle swarm. An example of the pollen initialization is shown in Fig. 3. Each pollen grain is created in a two-dimensional scheme that uses one-to-many maps between each PM and its hosted VMs within the pollen grain.

Pollen evaluation

The two principal steps of the FPO algorithm are represented by two pollination methods: global pollination and local pollination. The method used is selected based on a switching probability value β. The optimal placement solution is obtained through a series of iterations. During each iteration a random number between [0,1] is generated. This number is compared with the switch probability β. If the random number is less than β, global pollination will be used and updated using the Lévy distribution. Else, local pollination is used. When using global pollination, the pollen vectors are updated as (36)${\displaystyle S_i^{\left(t+1\right)}=S_i^t+L\times \left(S_i^t-g_{best}^{\ast }\right),}$ where $S_i^t$ is the ith pollen vector (solution) at iteration t, $g_{best}^{\ast }$ is the global best solution at the current iteration, and L is the pollination strength and is calculated in the same manner as the step size using Eqs. (30)–(34). When using local pollination, the pollen vectors are updated as (37)${\displaystyle S_i^{\left(t+1\right)}=S_i^t+\varepsilon \left[S_{r1}^t-S_{r2}^t\right],}$ where $S_{r1}^t$ and $S_{r2}^t$ are a random selection of pollen grains (solutions) for local pollination.

The FPO-based VMP algorithm stages

The FPO algorithm consists of three principal operations: pollen initialization, population evaluation, and termination.

• Pollen initialization. To initialize the pollen, the placement matrix 𝕄 is used to generate all possible placement solutions S_i. All solutions must obey the placement constraints in Eqs. (22)–(25). Each solution S_i is assigned randomly to a pollen grain. In addition, the fitness function for each pollen grain is computed using Eq. (26). The minimum fitness value among the pollen is selected as $g_{best}^{\ast }$. Furthermore, the population size is set to N_pop, and the maximum number of iterations is set to N_iter. Finally, the switching probability is defined as β ∈ [0,1].

• Population evaluation. During each iteration a random number ∈ [0,1] is generated and compared with the switching probability β. If the random number is less than β then global pollination and Eq. (36) are used. Else, local pollination and Eq. (37) are used. Subsequently, the results of the new solutions S_u are evaluated using the pre-computed fitness functions. If the fitness value of the new solution is less than the fitness value of $g_{best}^{\ast }$, then $g_{best}^{\ast }$ is set to the new solution.

• Termination. Population evaluation continues iteratively until the maximum number of iterations N_iter is reached. Following the final iteration, $g_{best}^{\ast }$ is selected as the optimal VMP solution.

The pseudo-code for the FPO algorithm is presented below.