Enhanced active VM load balancing algorithm using fuzzy logic and K-means clustering

Abstract

With the rapid development of data and IT technology, cloud computing is gaining more and more attention, and many users are attracted to this paradigm because of the reduction in cost and the dynamic allocation of resources. Load balancing is one of the main challenges in cloud computing system. It redistributes workloads across computing nodes within cloud to minimize computation time, and to improve the use of resources. This paper proposes an enhanced ‘Active VM load balancing algorithm’ based on fuzzy logic and k-means clustering to reduce the data center transfer cost, the total virtual machine cost, the data center processing time and the response time. The proposed method is realized using Java and CloudAnalyst Simulator. Besides, we have compared the proposed algorithm with other task scheduling approaches such as Round Robin algorithm, Throttled algorithm, Equally Spread Current Execution Load algorithm, Ant Colony Optimization (ACO) and Particle Swarm Optimization (PSO). As a result, the proposed algorithm performs better in terms of service rate and response time.

Keywords

Load balancing fuzzy logic clustering k-means

1. Introduction

Cloud computing is being widely adopted as one of the most popular paradigms appeared in the last years, in both industrial and academic worlds [51]. The main idea of cloud computing is to provide related services according to users demands through the sharing of hardware resources and software programs [31]. Cloud computing architecture can be divided into three categories, which are Platform-as-a-Service (PaaS), Software-as-a-Service (SaaS) and Infrastructure-as-a-Service (IaaS). These help resources management and end-user to get their requirement application [66]. On the platform as a service level, a software layer is provided to create high level services. This platform helps users to design, develop, evaluate, and host applications on the cloud level [18]. In SaaS, the software application is offered to the end users without any customization [65]. Infrastructure-as-a-Service allows users to use IT resources remotely on a “pay-as-you-go” basis [45]. Cloud computing can be classified into four models such as Public, Private, Hybrid and Community. In the private cloud, the cloud infrastructure can be used solely by an Individual or a Single Organization. It can be handled by the Person/Member of the Organization to which it belongs [57]. Public cloud is an open network that is available on the Internet and managed by a third-party cloud service provider [48]. Hybrid cloud is a combination of two or more distinct models (private, community or public) that remain unique entities [33]. Cloud computing meets numerous challenges at increasing number of users because the demand of resources sharing and usage are increased rapidly. Therefore, load balancing between resources is an important challenge [23]. Load balancing distributes a workload across multiple entities, which can achieve optimal utilization, maximize throughput, minimize response time, and avoid overload [43].

Fuzzy logic, which may be viewed as an extension of classical logical systems, provides an effective conceptual framework for dealing with the problem of knowledge representation in an environment of uncertainty and imprecision [74]. A fuzzy set is a class of objects with a continuum of grades of membership. Such a set is characterized by a membership function which assigns to each object a grade of membership ranging between zero and one [73]. A linguistic variable is a type of variable which uses words to represent its values instead of numbers [20] (e.g. slow, medium and fast). The fuzzy inference is including fuzzification, rule base, and defuzzification. Fuzzification is a process considering crisp numerical inputs and calculations of the degree of membership for each linguistic input term [7]. The rule base contains a set of fuzzy if-then rules which defines the actions of the controller in terms of linguistic variables and membership functions of linguistic terms. Defuzzification is the process of converting the fuzzy output set into a single number [28].

Machine learning algorithms, while being complex in nature, are now being employed for complicated tasks where traditional systems are inefficient [55]. Clustering is an unsupervised learning process, which means that the data objects are clustered into several groups according to the similarities/dissimilarities among them, without prior knowledge [77]. K-means is an unsupervised machine learning algorithm, it is one of the most well-known clustering algorithms and has irreplaceable research value. Its advantages are simple thought, fast convergence speed and easy realization [30]. It groups data samples based on their feature values into $k$ clusters. Each cluster is associated with a center point called centroid, and data samples that belongs to the same cluster have similar feature values [1].

In this research, to enhance ‘Active VM load balancing algorithm’, described in the related work section, we model the imprecise requirements of memory size, processor speed and the number of processors through the use of fuzzy logic, then these parameters are considered to classify the different machines by the use of clustering (k-means algorithm). Moreover, we implement and evaluate a dynamic load balancing algorithm which could efficiently predict the virtual machine that will schedule the next job. The main contributions of this paper are summarized as follows:

(1)
The use of the fuzzy logic to represent the weight of the different VMs.
(2)
The use of the k-means algorithm to cluster the virtual machines.
(3)
Comparing the proposed algorithm with:

–
Active VM load balancing algorithm
–
Round Robin algorithm
–
Throttled algorithm
–
Ant colony optimization
–
Honey bees load balancer
–
Particle Swarm Optimization

In this comparison, we consider the following fundamental criteria: response time, overall data center processing time, data center request servicing times, virtual machine cost and data transfer cost. The experimental scenarios demonstrate that the proposed algorithm is very competitive when compared with existing approaches.

The remainder of this paper is divided into five sections. The second section introduces the related work and the third section depicts the proposed approach. In the fourth section, we compare the proposed algorithm against Equally Spread Current Execution Load, Throttled algorithm, Round Robin algorithm, Ant Colony Optimization (ACO) and Particle Swarm Optimization (PSO). The fifth section displays the detailed analysis of the proposed approach. Finally, the sixth section is dedicated to a conclusion and some future works.
2. Literature review

This section presents some of the frequently used load balancing algorithms available in the literature. In cloud system, there are many challenging issues that affect the performance of cloud computing and cloud service among multiple nodes, but the workload balancing and service brokering is major challenge in cloud computing [38]. Load balancing is the mechanism of detecting overloaded and underloaded nodes and then balance the load among them [53]. The benefits of load balancing would lead to maximizing the throughput, minimizing the response time, increase in resource utilization, further leading to better user satisfaction as well as increase in the overall performance of the system [24]. Load balancing algorithms are classified as static, dynamic and adaptive. In the static load balancing the cloud require prior knowledge about the system [54]. Static algorithms improve the execution time but they do not consider the current load of the virtual machine during the allocation [26]. Some static methods are min-min, spherical Robin, opportunistic load balancing (OLB) and max-min algorithms. In dynamic technique, the load balancer considers the current state of the system, and the task is allowed to move from the overloaded node to the lightly loaded node [4]. Some dynamic techniques are agent-based load balancing, honey bee behavior inspired load balancing, ant colony optimization and throttled [40]. Adaptive load balancing algorithms are a special class of dynamic algorithms [46]. They have the ability to change the rules based on the current load information.

Various algorithms of load balancing have been proposed in cloud computing to optimize different performance parameters. This section discusses about few important works.

2.1 General load balancing algorithms

This subsection presents an overview of realized works in the field of general load balancing techniques. Despite several algorithms are provided in this category, we have focused on new ones.

The Round Robin is one of the best-known and simplest algorithms for sending workloads to servers. All the nodes are aligned in a circular manner to allocate jobs without considering the current state of the virtual machines [61]. The time is divided into several slices, and each node is given a specific time quantum, and in this interval, the node will perform its operations [67]. This algorithm is not suitable for different processing performance [62].

Throttled load balancing algorithm is a dynamic algorithm that deploys completely the tasks on virtual mchines [50]. The load balancer maintains an index table that contains VMs (virtual machines) Id and its status (Available/Busy) [64]. When the data center receives the request (cloudlet), the LB scans the table and returns the Id of the first available virtual machine. If all VMs are busy then the value ‘0’ will be returned. This algorithm does not work perfectly when the virtual machines have different hardware architecture (performance).

Equally Spread Current Execution (ESCE) also called active VM load balancing algorithm, is based on spread spectrum technique. The load balancer spreads the load onto distinctive nodes, and thus, it is known as spread spectrum technique [64]. It is a dynamic load adjusting calculation, which handles the process with priority. It maintains a list of all virtual machines and jobs, then it, equally, distributes the tasks to the corresponding VMs [24]. It initially allocates VMs which are in free state. If all the VMs are allocated, the algorithm selects the VM (virtual machines) with the minimum number of allocations [37]. Table 1 summarizes the objectives, the advantages and the drawbacks of several techniques used in the literature review.

Table 1
General load balancing algorithms

References	Year	Algorithm	Technique	Pros	Cons
Wang et al. [70]	2015	Framework of LB and resource management for Swift	Monitoring workload to discover overloaded/underloaded VMs	Does not requires source code modification; guarantee the reliability of the storage system	Computation cost of LB operations; setting the parameters values for workload analysis; Can be Applied only to Swift
Bala and Chana [6]	2016	Predictive algorithm machine learning	Predicts host overutilization in Cloud using ML	Reduces SLA Violations, reduces VM migrations	It is not implemented on a real environment
Chien et al. [10]	2016	Estimating tech. for the end of service time	Is based on the method of end of service time	Improves processing time and response time	Increases energy consumption
Chen et al. [9]	2017	Cloud load balancing algorithm (CLB)	Considers server processing power and computer loading	Used for virtual web servers and physical servers; supports simultaneous access	Response time increases with the number of connections
Ghoneem and Kulkarni [25]	2017	Adaptive scheduling technique for MapReduce	Provides the scheduler with a classifier; input (node capabilities, jobfeatures). Output(executable/non-executable job)	Improves the performance of MapReduce	Does not consider average completion time, scheduling time and locality

2.2 Cluster and fuzzy-based load-balancing algorithms

This subsection summarizes several works that investigated the Clustering and the fuzzy logic in the field of load balancing. Narender et al. [39] proposed a solution, fuzzy row penalty method, for solving load balancing problem in cloud computing environment. They used fuzzy technique for solving uncertain response time and fuzzy row penalty method for solving both balanced fuzzy load balancing problem and unbalanced fuzzy load balancing problem. This technique increases performance and scalability, minimizes associated overheads, and avoids bottleneck problem. This approach can not predict the load scheduling.

Iranpour et al. [32] proposed a distributed load-balancing and admission-control algorithm based on a fuzzy game-theoretic model for large-scale SaaS clouds. To control the admission of requests, a Self-Adaptive Fuzzy type-2 Controller containing two fuzzy controllers is introduced. The proposed algorithm is scalable, in which the control tasks are divided among application and proxy servers. This algorithm, in comparison with other algorithms, offers average response time and average processing time.

Ragmani et al. [58] proposed a hybrid algorithm based on the Fuzzy logic and ant colony optimization (ACO) concepts to improve the load balancing in the Cloud environment. This algorithm used a fuzzy module to evaluate the pheromone value in order to improve the calculation duration. It uses also the Taguchi concept for selecting the best ACO parameters.

Priya et al. [56] proposed a fuzzy-based Multidimensional Resource Scheduling model, with Fuzzy Square inference that associates cloud user query based on the fuzzy rule, to obtain resource scheduling efficiency in cloud infrastructure. The F-MRSQN method includes three stages to be performed between the users and the servers in cloud environment: obtains incoming requests from the cloud users, online Fuzzy-based Multidimensional Resource Scheduling by resource manager, and perform load optimization using Multidimensional Queuing Network.

Adhikari et al. [2] proposed a load balancing approach, referred as LB-RC (load balancing resource clustering), for finding the optimal set of servers for task assignment to balance the load of the servers in a long-term process. The algorithm is divided into four phases, resource clustering, merging of clusters, resource optimization, and task assignment policy.

A heuristic based load balancing algorithm is developed by authors in [75], where the clustering approach is used. They have applied Baye’s theorem to obtain optimal clusters of physical hosts available for load balancing.

Kapoor et al. [36] proposed an algorithm, Cluster based load balancing, which works in heterogeneous nodes environment, considers resource specific demands of the tasks and reduces scanning overhead by dividing the machines into clusters. Table 2 presents an overview of realized works that use Clustering and fuzzy logic to balance th load over cloud system.

Table 2
Cluster and fuzzy-based load-balancing algorithms

References	Year	Algorithm	Technique	Pros	Cons
Daraghmi and Yuan [14]	2015	A LB algorithm for heterogeneous systems	Considers the LB technical-factors and the structure of the network executing the algorithm	Reduces resources;improves the network di-ameter and minimizes the communication-overhead	Increase the consumption of power
Kapoor and Dabas [36]	2015	Cluster based LB algorithm	Groups VMs into clusters	Works in heterogeneous environment; reduces scanning overhead	Increases energy consumption
Kang and Choo [35]	2016	Inter Cloud Manager job dispatching algo	Uses clustering and decision-making	Reduces response time; Improves scalability	Cannot use communication jobs (VoIP, video streaming, etc.)
Zhao et al. [76]	2016	LB based on Bayes and clustering (LB-BC)	Combines Bayes with the Clustering to obtain the optimal hosts set	Deploys tasks quickly; Reduces response time	Applied only to LAN
Han and Chronopoulos [29]	2017	Hierarchical Distributed Loop Self-scheduling techniques	based on a (super-master, master, worker) model; implemented on a homogeneous large-scale cluster	Validates the scalability, improves the performance	It is not tested using large-scale benchmarks

2.3 Nature inspired load balancing algorithms

In this subsection we present a set of works which have adopted nature inspired load balancing algorithms. Ant Colony Optimization (ACO) is a meta-heuristic approach based on the behavior of real ant while they search for their food [5]. Ants deposit a chemical substance on their path called pheromone. Other ants can smell pheromone and they tend to prefer paths with a higher pheromone concentration [21]. Like the ant find the optimum path to find the foods, communication and data transfer took part in optimum way [64]. With an ACO Algorithm we can build the shortest paths from a combination of several paths [63].

Honey Bees algorithm is derived from a detailed analysis of the behavior that honey bees adopt to find and reap food [41]. It consists of scout bees, forager bees and food source. Scout bees are responsible for searching food source randomly, employed bees share information of food to the onlooker bees, and onlooker bees discover the amount of nectar and compute the probability [23]. Finally, they return to their hive and do waggle dance to inform others about quality/fitness of food source [41]. This algorithm is suitable for independent tasks but it does not work perfectly in the case of dependent ones.

Particle Swarm Optimization (PSO) was first proposed by Eberhart and Kennedy in 1995 [42]. It is inspired by the social behavior of animal and swarm theory. It has several advantages, including quick convergence, high precision and relatively easy implementation [3]. This algorithm initializes randomly a swarm in population [47]. The swarm consists of many particles where each has its position, velocity, and current objective value [17]. Table 3 describes a number of existing nature inspired load balancing algorithms.

Table 3
Nature inspired load balancing algorithms

References	Year	Algorithm	Technique	Pros	Cons
Babu and Krishna [41]	2013	Honey bee behavior inspired LB (HBB-LB)	Considers priority of tasks as the main QoS parameter	Reduces the response time of VMs	Does not consider workflows with dependent tasks
De Falco et al. [15]	2015	Extremal Optimization (EO) for LB	Detects the best candidate tasks for migration based on a quality model	Executed in in parallel; Reduces the number of migrations	Does not consider the d multiobjective optimization
Wu et al. [72]	2017	A Genetic Ant-Colony Hybrid Algorithm for Task Scheduling in Cloud System	Combines genetic algorithm and ACO to solve the problem of task scheduling in Cloud System	VImproves time span; Reduces response time	It is not implemented in a real cloud environment
Gabi et al. [22]	2018	Orthogonal Taguchi Based-Cat Swarm Optimization	Taguchi orthogonal approach was incorporated into tracing mode of CSO to scheduled tasks on VMs with minimum execution time	Minimization of execution; Better system utilization time	Problem of convergence speed

2.4 Hybrid load balancing algorithms

Due to the weakness of each of the meta-heuristics mechanisms, they must be combined to achieve a very efficient load balancing in cloud computing [52].

Cho et al. [11] combines ant colony optimization and particle swarm optimization to solve the VM scheduling problem. This algorithm uses historical information to predict the workload of new input requests to adapt to dynamic environments without additional task information and rejects requests that cannot be satisfied before scheduling to reduce the computing time of the scheduling procedure.

Shojafar et al. [60], propose a hybrid approach using the fuzzy theory and Genetic Algorithm (GA) to do optimal load-balancing by considering the execution time and cost. The proposed algorithm allocates the tasks to resources by considering, virtual machine memory, virtual machine processing speed, job lengths, and virtual machine bandwidth.

A hybrid meta-heuristic is proposed in [27] using nature inspired genetic algorithm and particle swarm optimization approaches. The algorithm takes advantages of both the algorithms by avoiding slower convergence rate of GA and local optimum problem in PSO. In Table 4 we describe a number of existing hybrid load balancing algorithms and determine some defects and advantages of them.

Table 4
Hybrid load balancing algorithms

References	Year	Algorithm	Technique	Pros	Cons
Wang et al. [69]	2013	Adaptive Scheduling algorithm for hybrid cloud	Finds the near optimal resource allocation plan	Achieves good performance in term of cost/deadline constraints	Does not consider the energy, the execution time and the operational cost
Cho et al. [12]	2015	Combines ACO and PSO	Combines ACO and PSO to solve the VMs scheduling issues	Reduces the computing timen, improves the scheduling results	Does not consider VM scheduling as a multi-objective problem
Elmougy et al. [19]	2017	Hybrid task scheduling algorithm (SRDQ)	Combines Shortest- Job-First and Round Robin	Starvation and waiting time for tasks minimized, improved response time and turnaround Reduces turnaround, waiting times, response time and tasks starvation	Finding the task quantum value
Liu et al. [44]	2017	Hybrid scheduling scheme (DeMS)	Consists of 3 algo. (On Demand Scheduling, Querying and Migrating Task, Staged Task Migration)	Reduces the response times; supports parallelism	Does not consider: the network delay neither the task migration time

3. Proposed approach: Load balancing algorithm using fuzzy logic and k-means clustering

This section introduces the proposed load balancing algorithm. The main objective of this work is to propose a meta-heuristic algorithm adapted to a Cloud environment. The aim is to reduce the response time and to improve the use of resources.

To enhance active virtual machine load balancing algorithm, the proposed approach is structured in two main phases. First, weightings the different nodes, where we apply fuzzy logic to assign weights to the corresponding virtual machines based on its characteristics.

Second, the Clustering phase: This step consists of grouping several virtual machines into clusters using k-means clustering algorithm. This architecture allows to assign tasks to the most favorable virtual machine according to the hardware characteristics such as memory, processor speed, the number of processors, etc. Figure 1 describes the framework used to develop and implement the fuzzy clustering load balancer algorithm.

Figure 1.

Weighting virtual machines using fuzzy logic and k-means.

3.1 Weighting the virtual machines using fuzzy logic

This section gives details on the steps involved in design of the fuzzy logic controller to weighting each virtual machine based on its characteristics: processor speed, number of processors and memory size. The fuzzy controller used in the proposed work includes: Fuzzification, knowledge base, Fuzzy Inference System (FIS) and Defuzzification. The basic structure of a fuzzy controller is shown in Fig. 2.

Figure 2.

Fuzzy controller.

Fuzzification allows to convert crisp values into linguistic terms (linguistic variables), we consider five fuzzy linguistic variables: memory (verySmall, small, medium, large, veryLarge), processor speed (verySlow, slow medium, fast, veryFast) and number of processors (veryLow, low, medium, high, veryHigh). Trapezoidal shapes of membership functions are used in this configuration. Figure 3 shows member membership functions generated by our program.

Figure 3.

Membership functions.

Several rules are needed to describe the relationships between the results desired and the data available. These rules map the fuzzy inputs to fuzzy outputs. Fuzzy rules are expressed as a collection of “IF-THEN” statements. They can be easily implemented using fuzzy conditional statements in fuzzy logic. Some rules of the proposed knowledge base are described in Algorithm 1. The inference engine handles the way in which rules are combined. Mamdani Fuzzy Inference System (FIS) is used in this approach, and it is expressed as [49]:

$\displaystyle\mu_{\Re_{M}}(x,y)=\min[\mu_{A}(x),\mu_{B}(y)]$ (1)

where $\mu(x)$ is the membership value.

Defuzzification is the process of obtaining crisp number from the fuzzy output. For the defuzzification model, the associated linguistic variables used to describe the performance of each node (VM) are: veryLow, low, medium, high, veryHigh. We adopt the method of the ‘Center of Gravity’ determined according to following equation [71]:

$\displaystyle\mu_{\textit{COG}}=\frac{\int_{U}y.\mu(y).dy}{\int_{U}\mu(y).dy}$ (2)

where $y$ is a point in the universe of the conclusion, $\mu(y)$ is the membership value of the resulting conclusion set and $U$ is the universes of discourse. Figure 4 shows the output of the function of defuzzification generated by our program.

Figure 4.

Defuzzification using COG.

The Implementation of fuzzy controller using java API of the proposed approach is illustrated in Algorithm 1.

[h!] Pseudo-code: Fuzzy controller in FCL languageFUNCTION_BLOCK WEIGHT// Block definition

VAR_INPUT speed: REAL; processorsNumber: REAL; memory: REAL;

VAR_OUTPUT vm: REAL;

FUZZIFY memory // Fuzzify input variable ‘memory’

TERM verySmall:=(0, 1) (1604800, 1) (2404800, 0);

TERM small:= (1604800, 0) (2404800, 1) (4004800,1) (4804800,0);

TERM medium:= (4004800, 0) (4804800, 1) (6404800,1) (7204800,0);

TERM large:= (6404800, 0) (7204800, 1) (9104800, 1) (10404800, 0);

TERM veryLarge:= (9604800, 0) (10404800, 1) (12804800, 1);

END_FUZZIFY

……. //In the same way, we define the other parameters

RULEBLOCK No1

RULE 1:IF (memory IS verySmall) AND (processorsNumber IS veryLow) AND (speed IS verySlow) THEN vm IS veryLow;

…

END_RULEBLOCK

END_FUNCTION_BLOCK

3.2 Clustering virtual machine using k-means

Scheduling of $n$ tasks into $m$ virtual machines is a NP Complete problem. Therefore, balancing workload of incoming user requests and allocating the corresponding tasks to appropriate virtual machines is a challenging issue. We have to assign tasks to these virtual machines in such a way that cloud user can execute their requests in minimum makespan time, and average resource utilization should be maximum. The proposed load balancing algorithm balances the load among virtual machines having different hardware configurations and distributes the load based on hardware configuration (fuzzy weights) and states of virtual machines in data center.

The proposed algorithm uses clustering approach to divide VMs with similar capacities into groups. K-means clustering approach has been used to divide VMs into clusters. This will reduce the time required to find optimal VM for task migration. The load balancer maintains a list of VMs in each cluster. The proposed approach is dynamic, centralized, heterogeneous and it considers the performance of virtual machines, it also allocates the virtual machines which have least number of allocations and in a way that the workload is kept distributed effectively. The clusters are sorted in descending order according the obtained weight (from the fuzzy processing, described in the previous section) of the correspondent virtual machines. The proposed technique selects a VM which has highest capacity and lowest number of allocations as target VM. Algorithm 3.2 presents a pseudo-code of k-means algorithm used in our program.

[h!] Algorithm k-meansK: the number of clusters A set of k clusters

D: a data set containing n objects Select k points as initial centroids arbitrarily (the centroid positions do not change) each centroid c Estimate the Distance $D_{\textit{euc}}$ each data point i Assign each object to their closest cluster center using Euclidean Distance $D_{\textit{euc}}$ Compute new cluster center by calculating mean points

In this research, we use the Euclidean Distance which is majorly used in k-means for computing the distance among data objects, It is computed as [8]:

$\displaystyle d_{\textit{euc}}(x,y)=\sqrt{\sum_{i=1}^{n}(x_{i}-y_{i})^{2}}$ (3)

where $x$ and $y$ are two vectors of length $n$ .

Figure 5.

Virtual machines clustering using k-means.

Figure 5 presents a flowchart of the main steps of the method described in Algorithm 2.

The procedure of clustering technique is described in Algorithm 3.

[h!] Algorithm clustering VM R: Request (cloudlet) VmId which will handle the request maintains an index table of VMs initialize VMs status (Available/Busy) available VM is not allocated create a new one Clustering the VMs into K clusters using k-means algorithm Sorting Clusters by weight Job scheduler receives new task each cluster calculate the number of requests currently allocated to the VMs identify the VM whose active task count is least and vmWeight is max Vm is busy Increment the number of busy Vms go to 10 vmID $\leftarrow$ id of this virtual machine Assigns that task to that virtual machine Update the VM allocation table by incrementing active task count of corresponding VM by 1 statusVm $\leftarrow$ Busy any virtual machine has completed the assigned task Update the VM allocation table by decrementing the active task count all VMs are busy Choose another Cluster go to 10 Return vmId

[h!] Pseudo-code getStoredClusters function public ArrayList<List<Entry<Integer, Double> > > getStoredClusters() throws Exception { //***** Clustering Data using weka library ****************** SimpleKMeans kmeans = new SimpleKMeans(); kmeans.setNumClusters(numberOfClusters); data = Filter.useFilter(data, filter); kmeans.buildClusterer(data); //********* sorting Clusters by Centroid ********************** aListClusters = getSortedClstrCentoid(); /*sorting clusters by weight basis of sorted list of centroids using function getSortedClstrCentoid*/ sortedClusters = getSortedClusters(aListClusters); return sortedClusters;}

Algorithm 3 is described by the flowchart shown in Fig. 6.

Figure 6.

Flowchart-clustering virtual machines.

The implementation of virtual machine clusters using java API and Weka Library is shown in Algorithm 5.

An implementation in Java code for the main function getNextAvailbleVM() of the proposed load balancer is shown in Algorithm 6.

[h!] Pseudo-code – load balancerpublic int getNextAvailableVm(){ //If all available vms are not allocated, allocate the new ones if available(vmId) { vmId = allocateNewOnes(); } else { vmId = vmClusteringFuzzyWeights(); } allocatedVm(vmId); return vmId; } //***** Function vmClusteringFuzzyWeights ******************int vmClusteringFuzzyWeights() { //weights used bellow are obtained after execution of fuzzy logic processing getSortedClusters(); /* Start with the most perfomant cluster, if all VMs in this cluster have maxCount or all VMs are busy, go to the next cluster */ if (connectionCount >= maxCount) || (allVmState = basy){ nextCluster(); } else { vmID = getVM(weight = max, commections = min);} return vmId;}

Based on the weights obtained after executing of fuzzy logic, Algorithm 6 classifies the virtual machines in clusters. The clusters are sorted in a descending order according to the obtained weights using the getStoredClusters function described in Algorithm 5. The load balancer selects the most performant cluster and counts the number of allocations of each VM. If all VMs in this cluster have max allocations, the load balancer will select the next cluster. Algorithm 6 assigns tasks to the VMs which belong to the most performant cluster and share the minimum allocation count. If a set of VMs have the same minCount, the load balancer will allocate the one that weighs more. If a cluster is not loaded ( $\textit{minCount}\leqslant\textit{maxMinCount}$ ), tasks will be assigned to its virtual machines, otherwise they will be forwarded to another cluster. Counting the number of allocations for each cluster and for each VM allows to avoid overload.

4. Performance evaluation

In order to verify the performance of the proposed algorithm, we discuss, in this section, the experiment details of this work and evaluate it by depicting charts. To further demonstrate the effectiveness of the proposed technique, numerical results have been compared with a set of algorithms in the literature addressing the problem of workload in cloud computing environment.

We used fuzzy logic to represent the weights of different virtual machines based on their hardware characteristics. The basic structure of the fuzzy controller consists of four conceptual components: rule base, fuzzification, inference engine, and defuzzification. The task of converting input variables into linguistic term set is in the responsibility of the fuzzifier of this system. The responsibility of converting the fuzzy output of the fuzzy inference engine to a crisp value is in responsibility of defuzzifier, the fuzzy inference engine is also responsible for obtaining fuzzy output using the rules defined and stored in the database. These virtual machines are grouped into a cluster, using the famous non-hierarchical classification algorithm: K-means, according to their performance, ie their weight. The tasks will be assigned to virtual machines having more weight and having a minimum number of connections.

4.1 Tools and configuration

For the experiments, we use the following tools to evaluate our algorithm: CloudAnalyst, jFuzzyLogic v3.0, Weka Library 3.8 and JFreeChart Library 1.5.0. The simulation is conducted on Ubuntu 20.04.1 LTS, Linux Platform, Eclipse IDE 2020–06 and Java 1.8.0_201.

Cloud analyst is a Java based programming simulator with GUI. It extends the functionalities of CloudSim and consists of three components: Data Center, User Base and Internet [59].

JFuzzyLogic [13] is a fuzzy logic package fully written in Java. It is used to facilitate and accelerate the development of fuzzy systems. It offers a fully functional and complete implementation of a fuzzy inference system (FIS), and provides a programming interface (API) and an Eclipse plugin in order to make it easier to write and test FCL code.

Weka [68] is an open source machine learning software that can be accessed through a graphical user interface, standard terminal applications, or a Java API. It allows users to quickly try out and compare different machine learning methods on new data sets. It contains a wide range of learning algorithms such as regression, classification, clustering, association rule mining, and attribute selection.

JFreeChart [34] is a free chart library for Java that makes it easy for developers to display professional quality charts in their applications. It can generate a wide variety of charts for use in both client (Swing and JavaFX) and server (web) applications.

Figure 7.

Example of interface.

Figure 7 shows an example of an interface generated by our program, it allows to configure the settings of k-means algorithm used in the proposed load balancer. The work is simulated with six regions where data centers are available with region code (0–5). Data centers contain a set of hosts and help in managing the characteristics of virtual machines like RAM, Processing Elements, Central Processing Unit, Bandwidth, Million instructions per seconds (MIPS), Timeshared Scheduling Policy. etc. Table 5 summarizes a sample of five DC configurations which contains the characteritics of the virtual machines such as the speed range, the number of processors and the size of RAM.

Table 5

Data centers

DC	VmId	Memory (Hz)	Nbr of processors	Speed
DC1	0	420000	8	450000
	1	9600000	8	450000
	2	12800000	8	450000
	3	10000	2	10000
	4	204800	4	10000
	5	204800	4	10000
	6	204800	4	10000
	7	204800	4	10000
DC2	0	8000000	8	100000
	1	2000000	2	300000
	2	800000	4	100000
	3	800000	4	10000
DC3	0	12800000	8	450000
	1	2400000	8	200000
	2	400000	6	100000
	3	600000	6	300000
DC4	0	4800000	8	100000
	1	400000	8	100000
	2	7200000	8	450000
	3	400000	2	10000
DC7	0	12204800	4	300000
	1	9204800	4	10000

In the GUI, we configure ‘Advanced Configuration Parameters’ to include the ‘Client Grouping Factor’ with the value 1000, ‘Service Broker Policy’ used is ‘Closest Data Center’, the ‘Enquiry Grouping Factor’ is set to 10, the ‘Executable Instruction Length per Enquiry’ is 500 Byte and ‘Simulation Duration’ is set to 60 days.

4.2 Experimental results and analysis

In this section, we discuss the simulation result based on the following parameters: ‘Response Time’, ‘Data Center Request Servicing Time’ and ‘Processing Cost’, and their comparison with the existing Load balancing algorithms:

•
Our algorithm Fuzzy Clustering Load balancer (FCL)
•
Equally Spread Current Execution Load algorithm (ESP)
•
Round Robin algorithm (RRB)
•
Throttled algorithm (THR)
•
Ant Colony Optimization (ANT)
•
Honey Bees load balancer (BEE)
•
Particle Swarm Optimization (PSO)

4.2.1 Overall response time and data center processing time

In Table 6, we compute the overall response time and the DC processing time in a millisecond of the data center. The results are obtained after the execution of the different algorithms: our work, Equally Spread Current Execution Load, Round Robin, Throttled algorithm, Ant Colony Optimization (ANT), Honey Bees load balancer and Particle Swarm Optimization (PSO).

Table 6
Overall response time

Algorithm	Overall response time (ms)	DC processing time (ms)
FCL	57.38	0.54
ESP	57.47	0.61
RRB	57.51	0.65
THR	57.49	0.65
ANT	57.49	0.63
BEE	57.69	0.81
PSO	58.8	1.87

Figures 8 and 9 show the comparison of average response time and data center processing time for the different algorithms.

Figure 8.

Overall response time.

Figure 9.

Data center processing time.

From Figs 8 and 9, it can be seen that compared to other techniques, the proposed algorithm yields better in terms of response time and data center processing time. That is because the FCL avoids under-load and over-load of VMs.

4.2.2 Data center request servicing time

In this section, we conduct an empirical evaluation of the ‘data center request processing time’ for each algorithm. This factor presents the time spent to forward a user’s request to a data center. A summary of the obtained results is presented in Table 7 that includes a sample of nine elements.

The average ‘data center request processing time’ for various algorithms is depicted in the graph obtained as shown in Fig. 10.

Table 7
DCs request servicing time

DC	FCL	ESP	RRB	THR	ANT	BEE	PSO
DC1	0.48	0.44	0.48	0.45	0.51	0.53	0.81
DC2	0.56	0.64	0.7	0.75	0.71	0.95	2.95
DC3	0.49	0.53	0.48	0.51	0.49	0.58	0.82
DC4	0.6	0.58	0.56	0.6	0.62	0.98	3.37
DC5	0.59	0.62	0.77	0.71	0.67	0.74	1.15
DC6	0.58	0.97	0.97	0.95	0.8	1.18	2.68
DC7	0.41	0.41	0.74	0.72	0.67	0.41	0.43
DC8	0.42	0.41	0.38	0.37	0.44	0.43	0.4
Total	4.13	4.6	5.08	5.06	4.91	5.8	12.61

Figure 10.

Data center request servicing times.

From Fig. 10, we deduce that the ‘Data Center Request Servicing Time (DCRST)’ in the proposed algorithm (FCL) is shorter than it takes in the other load balancer algorithms. Because in this approach, tasks are forwarded to the most performant virtual machines with least number of allocations. Thus, the fuzzy clustering load balancer reduces the data center Request Servicing Time and improves the resources’ use.

4.2.3 Processing cost

Now, we compare the performance evaluation in terms of the ‘processing cost’ that can be obtained by computing the sum of the ‘overall virtual machine cost’ and the ‘total data transfer cost’. Table 8 includes a sample of nine elements.

Table 8
Overall processing cost

DC	FCL	ESP	RRB	THR	ANT	BEE	PSO
DC1	2.08	2.26	2.31	2.33	2.17	2.51	2.33
DC2	1.9	2.45	2.5	2.34	2.48	2.38	2.37
DC3	1.72	2.5	2.39	2.54	2.55	2.31	2.5
DC4	1.47	2.1	2.09	2.02	2.18	2.11	2.15
DC5	2	2.26	2.19	2.22	2.14	2.07	2.19
DC6	1.34	1.56	1.63	1.68	1.6	1.74	1.57
DC7	0.38	0.59	0.59	0.59	0.59	0.58	0.59
DC8	0.2	0.59	0.59	0.59	0.59	0.6	0.59
Total	11.09	14.31	14.29	14.31	14.3	14.3	14.29

Figure 11 shows the comparison between the seven services load balancer algorithms.

Figure 11.

Overall processing cost.

Table 8 illustrates that the ‘processing cost’ depends, in some cases, on the weight of each node. This is because the FCL (our algorithm) assigns tasks to VMs according to their loads, availability and weights i.e., tasks are assigned to the most performant VMs. This can lead to a minimum ‘transfer cost’ and a slightly higher ‘processing cost’ compared to other algorithms.

5. Discussion

Though there are several works available in the literature, some of the methods do not consider the characteristics of cloud computing environment yet, it needs to improve the performance in several aspects [16]. Therefore, there are opportunities to improve resource utilization, response time, and cost in the existing system. Active virtual machine load balancing algorithm, also called Equally Spread Current Execution (ESC) is one of the best-known and simplest algorithms for sending workloads to servers. However, this algorithm has a problem that it does not consider the specific characteristics of each virtual machine such as: performance, memory size, speed of processors, etc.

In this paper, we propose to enhance the aforementioned algorithm through the use of fuzzy logic and non-hierarchical clustering technique (k-means), which is an unsupervised learning algorithm.

Table 9
Comparison of load balancing algorithms

Algorithm	Description	Pros	Cons
Proposed algorithm (FCL)	Based on the weights of VMs; Assign weights to the corresponding VMs using Fuzzy logic; Groups VMs into clusters.	Considers the current load on VM; Considers the performance of VMs Priority of VMS, Fuzzy sets; Clustering.	Calculation of weights and fuzzy sets; In case of same performance of VMs, the results converge to equally spread algorithm.
Round Robin	Allocates the first request randomly; Tasks are assigned in circular manner.	One of the simplest scheduling techniques; Equal distribution of workload; Better performance for short CPU bursts.	Does not consider the task processing time; Some VMs get underloaded and others get overloaded; allocate tasks randomly; Does not consider the capacity of the VMs.
Throttled load balancing algorithm	Maintains the state VMs (available/busy); Assigns tasks to the first available VM.	Distribute the load evenly among the VMs. Performant in environments that contains the same hardware configurations.	Queues jobs if all VMs are busy; performance decreases if there is differenct hardware configurations; Does not consider the performance and the current load of VM.
Equal Spread Current Execution	Tasks are assigned to the first available VM; retributes tasks among VMS which have the least allocations.	Improves Response time and Processing time.	Does not consider the performance of the hardware configurations.
Ant Colony Optimization (ANT)	ACO is based on ant colony foraging behavior.	Used in dynamic applications; Applied for Traveling Salesman Problem (TSP) and similar problems such as JSP, QAP, VRP, GCP, etc.	Random decisions; convergence time is uncertain; local optimum; Probability distribution changes by iteration, low search efficiency.
Honey Bees load balancer (BEE)	Based on honey-bee behavior; VMs are divided into 3 groups: overloaded, under-loaded and balanced VMs.	Reduces response time; performant in fault tolerance; Improves scalability.	Ignores the idle VMS; works only for in dependent tasks.
Particle swarm optimization	Based on the social behaviors of natural swarms.	Can be used into academic research and engineering applications; the speed of the researching is very fast; Simple calculations; easy to implement.	Cannot be used out the problems of scattering and optimization; it is not clear to find the best parameter values.

The proposed FCL algorithm has been simulated using CloudAnalyst and compared against active VM Load Balancing algorithm (known as ESP), Round Robin algorithm (RRB), Throttled algorithm (THR), Ant Colony Optimization (ANT), Honey Bees load balancer (BEE) and Particle Swarm Optimization (PSO). The comparison between existing works considers different metrics which are: Response Time, Data Center Request Servicing Time and Processing Cost. Experiments demonstrate that the proposed algorithm (FCL) reduces the response time, minimizes the processing cost and improves data center processing time. Moreover, in a few occasions, the FCL costs slightly more than the other approaches at some nodes. This issue is because the virtual machines, in such situation, are used more frequently. In Table 9, we make comparison between the proposed approach and the existing algorithms based on different aspects, such as the main aims of the work, its advantages and the drawbacks of the scheduling algorithms.

6. Conclusion and future work

The cloud computing is commonly used by users. The technology of load balancing is not exploited to its full potential. The overall performance of cloud environment depends on the results of the techniques used to redistribute workloads among different nods, and to assign tasks to the appropriate VMs. This paper presents an enhanced algorithm based on fuzzy logic and k-means clustering, for optimizing load balancing in modern cloud computing systems. Virtual machines are arranged in a cluster form. This management improves the CPU utilization and redistributes the load efficiently. This work aims to enhance the performance of cloud system using clustering and fuzzy controller. The algorithms are implemented in the CloudAnalyst simulator. As shown in the results of the experiment, the proposed algorithm has obvious performance advantages concerning the overall performance, the throughput and load balancing adeptness.

In future research, we plan to improve the load balancing by considering other parameters such as bandwidth.

Footnotes

Author’s Bios

Mostefa Hamdani is a teacher/researcher at the Elwancharissi University, Algeria. He received his engineer diploma in computer science from Institute of computer science, University of Tiaret, Algeria, in 2003. He received his Post graduation degree in computer science in 2012. He is Phd student at the National High School for Computer Science (ESI), Algiers, working on Cloud Computing and web services since 2008, his recent research focuses on Cloud systems, web-services, multi-agent and fuzzy logic.

Youcef Aklouf (PhD) is a full professor at the Computer Science department of University of Science and Technology Houari Boumediene (USTHB), and is a member of Research laboratory in Informatics, Intelligence, Mathematics and Applications (RIIMA). He got his PhD from the USTHB University in April 2007 and from the University of Poitiers France in June 2007 where he was a member of the data engineering team of LISI/ENSMA.Aklouf received his engineering and MS degrees in computer science from the University of Science and Technology of Algiers (USTHB) in 1998 and 2002, respectively. He also teaches several courses at UTSHB: compiling, databases, algorithmic, web-programming tools, operating systems, ect. His research areas include: e-commerce, business-to-business, web-services, ontology and multi-agent systems, and Grid services. Otherwise, he was a General Manager of the National Agency for Promotion and Development of Technology Parks since August 2011, from November 2009 to July 2011, he was a Responsible of R&D department at Algerie Telecom company.

References

Abdelsalam

Krishnan

and Sandhu

, Clustering-based iaas cloud monitoring, in: 2017 IEEE 10th International Conference on Cloud Computing (CLOUD), 2017, pp. 672–679.

Adhikari

Nandy

and Amgoth

, Meta heuristic-based task deployment mechanism for load balancing in iaas cloud, Journal of Network and Computer Applications 128 (2019), 64–77.

Al-Turjman

Hasan

M.Z.

and Al-Rizzo

, Task scheduling in cloud-based survivability applications using swarm optimization in iot, Transactions on Emerging Telecommunications Technologies 30(8) (2019), e3539.

Alam

Haidri Raza

and Shahid

, Resource-aware load balancing model for batch of tasks (bot) with best fit migration policy on heterogeneous distributed computing systems, International Journal of Pervasive Computing and Communications 16(2) (2020), 113–141.

Arulkumar

and Bhalaji

, Performance analysis of nature inspired load balancing algorithm in cloud environment, Journal of Ambient Intelligence and Humanized Computing, 2020.

Bala

and Chana

, Prediction-based proactive load balancing approach through vm migration, Engineering with Computers 32(4) (2016), 581–592.

Bobyr

M.V.

Milostnaya

N.A.

and Kulabuhov

S.A.

, A method of defuzzification based on the approach of areas’ ratio, Applied Soft Computing 59 (2017), 19–32.

Chakraborty

Faujdar

Punhani

and Saraswat

, Comparative study of k-means clustering using iris data set for various distances, in: 2020 10th International Conference on Cloud Computing, Data Science & Engineering (Confluence), 2020, pp. 332–335.

Chen

S.-L.

Chen

Y.-Y.

and Kuo

S.-H.

, Clb: a novel load balancing architecture and algorithm for cloud services, Computers & Electrical Engineering 58 (2017), 154–160.

10.

Chien

N.K.

Son

N.H.

and Loc

H.D.

, Load balancing algorithm based on estimating finish time of services in cloud computing, in: 2016 18th International Conference on Advanced Communication Technology (ICACT), 2016, pp. 228–233.

11.

Cho

K.-M.

Tsai

P.-W.

Tsai

C.-W.

and Yang

C.-S.

, A hybrid meta-heuristic algorithm for vm scheduling with load balancing in cloud computing, Neural Computing and Applications 26(6) (2015), 1297–1309.

12.

Cho

K.-M.

Tsai

P.-W.

Tsai

C.-W.

and Yang

C.-S.

, A hybrid meta-heuristic algorithm for vm scheduling with load balancing in cloud computing, Neural Computing and Applications 26(6) (2015), 1297–1309.

13.

Cingolani

and Alcalá-Fdez

, Jfuzzylogic: a java library to design fuzzy logic controllers according to the standard for fuzzy control programming, International Journal of Computational Intelligence Systems 6(sup1) (2013), 61–75.

14.

Daraghmi

EY.

and Yuan

S.-M.

, A small world based overlay network for improving dynamic load-balancing, Journal of Systems and Software 107 (2015), 187–203.

15.

De Falco

Laskowski

Olejnik

Scafuri

Tarantino

and Tudruj

, Extremal optimization applied to load balancing in execution of distributed programs, Applied Soft Computing 30 (2015), 501–513.

16.

Devaraj

A.F.S.

Elhoseny

Dhanasekaran

Lydia

E.L.

and Shankar

, Hybridization of firefly and improved multi-objective particle swarm optimization algorithm for energy efficient load balancing in cloud computing environments, Journal of Parallel and Distributed Computing 142 (2020), 36–45.

17.

Dey

and Ashour

A.S.

, Chapter 1 – computing in medical image analysis, in: Dey

Ashour

A.S.

Shi

Balas

V.E.

, eds, Soft Computing Based Medical Image Analysis, Academic Press, 2018, pp. 3–11.

18.

Ebadifard

Babamir

S.M.

and Barani

, A dynamic task scheduling algorithm improved by load balancing in cloud computing, in: 2020 6th International Conference on Web Research (ICWR), April 2020, pp. 177–183.

19.

Elmougy

Sarhan

and Joundy

, A novel hybrid of shortest job first and round robin with dynamic variable quantum time task scheduling technique, Journal of Cloud Computing 6(1) (2017), 12.

20.

Fan

Zhu

Wang

and Zhao

, A graph database-based approach utilizing fahp and directed bipartite graph for service composition, Service Oriented Computing and Applications, 2020.

21.

Farahnakian

Ashraf

Pahikkala

Liljeberg

Plosila

Porres

and Tenhunen

, Using ant colony system to consolidate vms for green cloud computing, IEEE Transactions on Services Computing 8(2) (2015), 187–198.

22.

Gabi

Ismail

A.S.

Zainal

Zakaria

and Abraham

, Orthogonal taguchi-based cat algorithm for solving task scheduling problem in cloud computing, Neural Computing and Applications 30(6) (2018), 1845–1863.

23.

Gamal

Rizk

Mahdi

and Elnaghi

B.E.

, Osmotic bio-inspired load balancing algorithm in cloud computing, IEEE Access 7 (2019), 42735–42744.

24.

Geetha

and Robin

C.R.R.

, A comparative-study of load-cloud balancing algorithms in cloud environments, in: 2017 International Conference on Energy, Communication, Data Analytics and Soft Computing (ICECDS), 2017, pp. 806–810.

25.

Ghoneem

and Kulkarni

, An adaptive mapreduce scheduler for scalable heterogeneous systems, in: Proceedings of the International Conference on Data Engineering and Communication Technology, Singapore, Springer Singapore, 2017, pp. 603–611.

26.

Gupta

Bhadauria

H.S.

and Singh

, Load balancing based hyper heuristic algorithm for cloud task scheduling, Journal of Ambient Intelligence and Humanized Computing, 2020.

27.

Gupta

Choudhary

and Jana

P.K.

, A hybrid meta-heuristic approach for load balanced workflow scheduling in iaas cloud, in: Distributed Computing and Internet Technology, Cham, Springer International Publishing, 2019, pp. 73–89.

28.

Hamdani

Aklouf

and Bouarara

H.A.

, Improved fuzzy load-balancing algorithm for cloud computing system, in: Proceedings of the 9th International Conference on Information Systems and Technologies, icist 2019, New York, NY, USA, Association for Computing Machinery, 2019, pp. 1–4.

29.

Han

and Chronopoulos

A.T.

, Scalable loop self-scheduling schemes for large-scale clusters and cloud systems, International Journal of Parallel Programming 45(3) (2017), 595–611.

30.

Hou

, An improved k-means clustering algorithm based on hadoop platform, in: Xu

Choo

K.-K.R.

Dehghantanha

Parizi

Hammoudeh

, eds, Cyber Security Intelligence and Analytics, Cham, Springer International Publishing, 2020, pp. 1101–1109.

31.

Hsieh

H.-C.

and Chiang

M.-L.

, The incremental load balance cloud algorithm by using dynamic data deployment, Journal of Grid Computing 17(3) (2019), 553–575.

32.

Iranpour

and Sharifian

, A distributed load balancing and admission control algorithm based on fuzzy type-2 and game theory for large-scale saas cloud architectures, Future Generation Computer Systems 86 (2018), 81–98.

33.

Jain

and Hazra

, Hybrid cloud computing investment strategies, Production and Operations Management 28(5) (2019), 1272–1284.

34.

JFreeChart. Jfreechart. http://www.jfree.org/jfreechart/, Accessed:12/08/2020.

35.

Kang

and Choo

, A cluster-based decentralized job dispatching for the large-scale cloud, EURASIP Journal on Wireless Communications and Networking 2016(1) (2016), 25.

36.

Kapoor

and Dabas

, Cluster based load balancing in cloud computing, in: 2015 Eighth International Conference on Contemporary Computing (IC3), 2015, pp. 76–81.

37.

Khan

M.A.

, Optimized hybrid service brokering for multi-cloud architectures, The Journal of Supercomputing 76(1) (2020), 666–687.

38.

Kong

Mapetu

J.P.B.

and Chen

, Heuristic load balancing based zero imbalance mechanism in cloud computing, Journal of Grid Computing 18(1) (2020), 123–148.

39.

Kumar

and Shukla

, Load balancing mechanism using fuzzy row penalty method in cloud computing environment, in: Information and Communication Technology for Sustainable Development, Singapore, Springer Singapore, 2018, pp. 365–373.

40.

Kumar

and Kumar

, Issues and challenges of load balancing techniques in cloud computing: a survey, ACM Comput. Surv. 51(6) (Feb. 2019).

41.

D.B.L.D. and Venkata Krishna

, Honey bee behavior inspired load balancing of tasks in cloud computing environments, Applied Soft Computing 13(5) (2013), 2292–2303.

42.

Liang

and Ouyang

, A hybrid particle swarm optimization algorithm for load balancing of mds on heterogeneous computing systems, Neurocomputing 330 (2019), 380–393.

43.

Luo

Cheng

Yuan

Gao

and Liu

, An end-to-end load balancer based on deep learning for vehicular network traffic control, IEEE Internet of Things Journal 6(1) (2019), 953–966.

44.

Liu

Zhang

and Niu

, Dems: a hybrid scheme of task scheduling and load balancing in computing clusters, Journal of Network and Computer Applications 83 (2017), 213–220.

45.

Loubière

and Tomassetti

, Towards cloud computing, in: TORUS 1 – Toward an Open Resource Using Services, chapter 13, John Wiley & Sons, Ltd, 2020, pp. 179–189.

46.

Ludwig

S.A.

and Moallem

, Swarm intelligence approaches for grid load balancing, Journal of Grid Computing 9(3) (2011), 279–301.

47.

Luo

Yuan

Ding

and Lu

, An improved particle swarm optimization algorithm based on adaptive weight for task scheduling in cloud computing, in: Proceedings of the 2nd International Conference on Computer Science and Application Engineering, CSAE ’18, New York, NY, USA, Association for Computing Machinery, 2018, pp. 1–5.

48.

Mahapatra

P.K.

Tripathy

A.R.

Tripathy

and Mishra

, Security model for preserving privacy of image in cloud, in: Borah

Emilia Balas

Polkowski

, eds, Advances in Data Science and Management, Singapore, Springer Singapore, 2020, pp. 247–256.

49.

Mamdani

E.H.

, Application of fuzzy algorithms for control of simple dynamic plant, Proceedings of the Institution of Electrical Engineers 121(12) (1974), 1585–1588.

50.

Mesbahi

M.R.

Hashemi

and Rahmani

A.M.

, Performance evaluation and analysis of load balancing algorithms in cloud computing environments, in: 2016 Second International Conference on Web Research (ICWR), 2016, pp. 145–151.

51.

Mezni

Aridhi

and Hadjali

, The uncertain cloud: state of the art and research challenges, International Journal of Approximate Reasoning 103 (2018), 139–151.

52.

Milan

S.T.

Rajabion

Ranjbar

and Navimipour

N.J.

, Nature inspired meta-heuristic algorithms for solving the load-balancing problem in cloud environments, Computers & Operations Research 110 (2019), 159–187.

53.

Mishra

S.K.

Sahoo

and Parida

P.P.

, Load balancing in cloud computing: a big picture, Journal of King Saud University – Computer and Information Sciences 32(2) (2020), 149–158.

54.

Park

Kim

Yun

and Yeom

, Approach for selecting and integrating cloud services to construct hybrid cloud, Journal of Grid Computing, 2020.

55.

Patel

Mohan

and Kushwaha

D.S.

, Neural network based classification of virtual machines in iaas, in: 2018 5th IEEE Uttar Pradesh Section International Conference on Electrical, Electronics and Computer Engineering (UPCON), Nov 2018, pp. 1–8.

56.

Priya

Kumar

C.S.

and Kannan

, Resource scheduling algorithm with load balancing for cloud service provisioning, Applied Soft Computing 76 (2019), 416–424.

57.

Raghuwanshi

K.D.

and Himthani

, Multi-tier authentication for cloud security, in: Shukla

R.K.

Agrawal

Sharma

Chaudhari

N.S.

Shukla

K.K.

, eds, Social Networking and Computational Intelligence, Singapore, Springer Singapore, 2020, pp. 67–75.

58.

Ragmani

Elomri

Abghour

Moussaid

and Rida

, An improved hybrid fuzzy-ant colony algorithm applied to load balancing in cloud computing environment, Procedia Computer Science 151 (2019), 519–526.

59.

Shishira

S.R.

Kandasamy

and Chandrasekaran

, Comparative study of simulation tools and challenging issues in cloud computing, in: Smart Secure Systems – IoT and Analytics Perspective, Communications in Computer and Information Science, book section Chapter 1, Springer, Singapore, 2018, pp. 3–11.

60.

Shojafar

Javanmardi

Abolfazli

and Cordeschi

, Fuge: a joint meta-heuristic approach to cloud job scheduling algorithm using fuzzy theory and a genetic method, Cluster Computing 18(2) (2015), 829–844.

61.

Somula

and Sasikala

, A load and distance aware cloudlet selection strategy in multi-cloudlet environment, International Journal of Grid and High Performance Computing 11(2) (2019), 85–102.

62.

Song

and Huang

, An improved load balancing algorithm based on neural network, in: Xu

Choo

K.-K.R.

Dehghantanha

Parizi

Hammoudeh

, eds, Cyber Security Intelligence and Analytics, Cham, Springer International Publishing, 2020, pp. 730–736.

63.

Srivastava

and Singh

, Implementation of ant colony optimization in economic load dispatch problem, in: 2020 7th International Conference on Signal Processing and Integrated Networks (SPIN), 2020, pp. 1018–1024.

64.

Subha

, Addressing security and privacy issues of load balancing using hybrid algorithm, in: Kolhe

M.L.

Tiwari

Trivedi

M.C.

Mishra

K.K.

, eds, Advances in Data and Information Sciences, Singapore, Springer Singapore, 2020, pp. 157–169.

65.

Suliman Mohamed

Ayman Kamel

Ibrahim

and Ahmed Sameh

, Modelling virtual machine workload in heterogeneous cloud computing platforms, Journal of Information Technology Research (JITR) 13(4) (2020), 1–15.

66.

Ullah

and Nawi

N.M.

, Enhancing the dynamic load balancing technique for cloud computing using hbataabc algorithm, International Journal of Modeling, Simulation, and Scientific Computing 0(0), 2050041

67.

Volkova

V.N.

Chemenkaya

L.V.

Desyatirikova

E.N.

Hajali

Khodar

and Osama

, Load balancing in cloud computing, in: 2018 IEEE Conference of Russian Young Researchers in Electrical and Electronic Engineering (EIConRus), 2018, pp. 387–390.

68.

Waikato. Weka. https://www.cs.waikato.ac.nz/ml/weka/index.html, Accessed:30/06/2020.

69.

Wang

W.-J.

Chang

Y.-S.

W.-T.

and Lee

Y.-K.

, Adaptive scheduling for parallel tasks with qos satisfaction for hybrid cloud environments, The Journal of Supercomputing 66(2) (2013), 783–811.

70.

Wang

Chen

Liu

and Ban

, Workload balancing and adaptive resource management for the swift storage system on cloud, Future Generation Computer Systems 51 (2015), 120–131.

71.

Zhou

Chen

and Zhou

, An improved fuzzy risk analysis by using a new similarity measure with center of gravity and area of trapezoidal fuzzy numbers, Soft Computing 24(6) (2020), 3923–3936.

72.

Xing

Cai

Xiao

and Ming

, A genetic-ant-colony hybrid algorithm for task scheduling in cloud system, in: Qiu

, ed, Smart Computing and Communication, Cham, Springer International Publishing, 2017, pp. 183–193.

73.

Zadeh

, Fuzzy sets, Information and Control 8(3) (1965), 338–353.

74.

Zadeh

L.A.

, Knowledge representation in fuzzy logic, in: An Introduction to Fuzzy Logic Applications in Intelligent Systems, chapter Chapter 1, Springer US, Boston, MA, 1992, pp. 1–25.

75.

Zhao

Yang

Wei

Ding

and Xu

, A heuristic clustering-based task deployment approach for load balancing using bayes theorem in cloud environment, IEEE Transactions on Parallel and Distributed Systems 27(2) (2016), 305–316.

76.

Zhao

Yang

Wei

Ding

and Xu

, A heuristic clustering-based task deployment approach for load balancing using bayes theorem in cloud environment, IEEE Transactions on Parallel and Distributed Systems 27(2) (2016), 305–316.

77.

Zhou

and Yang

, Effect of cluster size distribution on clustering: a comparative study of k-means and fuzzy c-means clustering, Pattern Analysis and Applications 23(1) (2020), 455–466.

Enhanced active VM load balancing algorithm using fuzzy logic and K-means clustering

Abstract

Keywords

1. Introduction

2.1 General load balancing algorithms

Table 1 General load balancing algorithms

Table 2 Cluster and fuzzy-based load-balancing algorithms

Table 3 Nature inspired load balancing algorithms

Table 4 Hybrid load balancing algorithms

4.1 Tools and configuration

Table 6 Overall response time

Table 7 DCs request servicing time

Table 8 Overall processing cost

Table 9 Comparison of load balancing algorithms

Footnotes

Author’s Bios

References

Table 1
General load balancing algorithms

Table 2
Cluster and fuzzy-based load-balancing algorithms

Table 3
Nature inspired load balancing algorithms

Table 4
Hybrid load balancing algorithms

Table 6
Overall response time

Table 7
DCs request servicing time

Table 8
Overall processing cost

Table 9
Comparison of load balancing algorithms