Optimization enabled elastic scaling in cloud based on predicted load for resource management

Abstract

Cloud computing epitomizes an important invention in the field of Information Technology, which presents users with a way of providing on-demand access to a pool of shared computing resources. A major challenge faced by the cloud system is to assign the exact quantity of resources to the users based on the demand, while meeting the Service Level Agreement (SLA). Elasticity is a major aspect that provides the cloud with the capability of adding and removing resources “on the fly” for handling load variations. However, elastic scaling requires suspension of the application tasks forcibly, while performing resource distribution; thereby Quality of Service (QoS) gets affected. In this research, an elastic scaling approach based on optimization is developed which aims at attaining an improved user experience. Here, load prediction is performed based on various factors, like bandwidth, CPU, and memory. Later, horizontal as well as vertical scaling is performed based on the predicted load using the devised leader Harris honey badger algorithm. The devised optimization enabled elastic scaling is evaluated for its effectiveness based on metrics, such as predicted load error, cost, and resource utilization, and is found to have attained values of 0.0193, 153.581, and 0.3217.

Keywords

Cloud computing load prediction elastic scaling leader Harris hawks optimization honey badger algorithm

1. Introduction

Cloud computing is an evolving computing model that is gaining popularity nowadays. It is a paradigm, which facilitates sharing of computing devices, and resources based on the user demand. Cloud computing provides a way to provide shared resources, such as storage applications, networks, data centres, and servers with less effort. Additionally, cloud computing enables users, as well as organizations for keeping their data in third-party or private data centres/storage locations, which may be present anywhere in the world [9]. The definition of cloud computing as given by the National Institute of Standards and Technology (NIST) is, “A model for enabling ubiquitous, convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, servers, storage, applications, and services) that can be rapidly provisioned and released with minimal management effort or service provider interaction” [10]. The resources on the cloud are provided to the users on a pay-per-use basis. However, allocating these resources correctly along with the satisfaction of user requirements require effective allocation schemes. With the ever-increasing requirements, the process of assigning resources to users has become tedious and challenging [11]. Users can access the information available in the cloud storage over the internet, wherein the resources from various locations can be considered as a centralized resource over the network. If the user requirements are very high, the network will be provided by cloud computing [12]. Cloud computing has the following important aspects, such as Measured service, rapid elasticity, resource pooling, broad network access, and on-demand self-service. Here, the pool of resources is allocated to the users based on the user demand, which requires scaling in and out of the resources. Moreover, the resources must be constantly monitored, to provide transparency of service [13].

The performance of any cloud-oriented system depends upon three aspects, namely efficiency, elasticity, and scalability. The efficiency of the system depends on how accurately the resources are matched according to the user requirements, whereas the scalability of the system depends on the capability of the cloud to enhance the resources available by expanding them to meet the user requirements. Elasticity refers to the ability of the cloud to automatically adapt itself in accordance with the varying demand [14]. The efficiency of the cloud depends on the effective utilization of the resources, wherein resource management is established by using effective resource scalability, allocation, and scheduling methods. The resources are made available as Virtual Machines (VMs) (to the users through the process of virtualization, which enables the utilization of a single PM as multiple virtual resources [15]. The process of delivering the services to the user is highly complex and is carried out by the Cloud Service Provider [16]. In the cloud, the cost of hosting services can be effectively reduced by using elasticity, which can be achieved by using virtualization, which guarantees isolation of operations for various users [17]. Cloud-based systems can adapt to the varying workload through the process of scaling, which denotes the ability of the system to scale according to the load received. Characterization of the load is done by considering the complexity as well as the count of the queries and the speed at which the tasks are received [18].

Elastic scaling is the process of matching the resources available to the demand automatically by the cloud data center. It is done with the target of ensuring that the services are made available to the users adaptively, and constantly devoid of any resource wastage [19]. Moreover, it enables us to meet the Service Level Agreement (SLA) along with efficient resource utilization, thereby reducing the cost of hardware and software is required [20]. Further, dynamic scaling in and out of the system can be achieved, thereby avoiding idle resources and unanticipated spikes in load [21]. For achieving elastic scaling, the load associated with the computing resources has to be predicted [22]. In the cloud, elastic scaling is ensured by using two mechanisms, namely vertical, as well as horizontal scaling. Vertical scaling performs dynamic modification of the physical resources in a VM, thus modifying the resource interfaces through programming languages. It doesn’t require restarting the system, as it is carried out using two processes, namely VM adjustment and VM migration. Horizontal scaling is a coarse-grained technique, which considers VMs as units for performing allocation. Here the number of VMs is enhanced or reduced on a horizontal layer, thereby adjusting the resources available by rebooting applications. This type of scaling cannot adjust when only one resource type is needed, thus it increasing the cost [23]. A major issue faced by the scaling techniques is determining, when scaling in or out has to be performed [24]. Though many studies have been carried out for implementing auto-scaling using VM migration and placement or machine learning, attaining Quality of Service (QoS) is still a major issue [25].

In this paper, an effective technique named, leader Harris honey badger algorithm based scaling is devised for performing elastic scaling. Here, load prediction is performed using the cloud model depending on the bandwidth, memory, and CPU. The predicted load is then compared with the predefined threshold to decide whether elastic scaling has to be performed. If the predicted load is greater than the threshold, then horizontal scaling is performed, otherwise, vertical scaling is performed. The devised leader Harris honey badger algorithm is utilized for carrying out elastic scaling depending on the CPU, memory, and hard disk.

The major contribution of this article is given below. Introduced leader Harris honey badger algorithm for elastic scaling for resource management: A novel leader Harris honey badger algorithm is developed for performing elastic scaling, based on the load predicted. The devised leader Harris honey badger algorithm is created by adapting the leader Harris hawks optimization with respect to the honey badger algorithm, for enhancing the performance of the optimizer. Here, load prediction is performed based on the bandwidth, CPU, and memory.

The remaining part of the paper is divided into the following sections: Section 2 details the prevailing related works, Section 3 describes the system model of the cloud, and the devised method is detailed in Section 4. The results of the developed scheme are provided in Section 5 and the discussion is provided in Section 6. Finally, the conclusion is provided in Section 6.

2. Literature review

Scaling in the cloud has been studied in detail in several researches and many techniques have been proposed. Here, we consider eight of the prevailing works, and these methods are shortly briefed. In 2019, Toosi et al. [1] introduced an Elastic Service Function Chain (SFC) for performing auto-scaling in the cloud. The Elastic SFC technique is an algorithm, which was developed to perform vertical, as well as horizontal scaling of Virtualized Network Function and dynamically allocating the bandwidth. A Virtualized Network Function migration, as well as dynamic flow scheduling technique, was employed for enabling proficient resource utilization. The Elastic SFC was highly successful for satisfying the latency as well as cost reduction, but this method was not implemented in real-time scenarios, for analyzing the impact of the technique. Liu et al. [2] presented a bottleneck detection algorithm for eliminating the resource bottleneck in the cloud system in 2020. Here, the system load was monitored and iteratively increased by the automatically generated test module. The variation in the metric was analyzed with the help of the bottleneck detection algorithm for determining the bottleneck, and a vertical scaling technique was provided for overcoming the system deficiency. This technique was effective for eliminating the feeble point of the target services; however, it did not consider the integration of horizontal scaling for dealing with large-scale applications. Also, in 2020, Li et al. [3] presented an integer programming algorithm for performing dynamic elastic scaling. This system was realized using two parts, such as load prediction and elastic scaling. Initially, the present trends and the past features of the load were utilized to predict load using the load prediction model. Based on the load, the resources were assigned for satisfying the user demand. Elastic scaling was then carried out using horizontal as well as vertical scaling. Multiple combinations were generated to satisfy the resource needs, and the integer programming algorithm selected the cost-effective scaling from the various combinations. This method was highly effective for minimizing the scaling cost as well as enhancing the utilization of resources; but this scheme did not consider the minimization of dynamic resource cost. Yu et al. [4] created an elastic Network Function Virtualization (NFV), in 2020, for provisioning resources in cloud for Virtualized Network Function. The Elastic NFV was implemented using two modules, namely the Scaling Conflict Handling, and Resource Elastic Provisioning modules. The current resource requirements were captured by using a Dynamic Multi-Resource for provisioning elastic resources. Further the Scaling Conflict Handling module was used to estimate the time for triggering the migration. The Elastic NFV method was highly effective in minimizing the embedding cost and migration time, however this technique failed to consider a hybrid of both vertical and horizontal scaling for enhancing the resource allotment.

In the same year, Brabra et al. [5] devised a Cloud Resource Description Model for managing cloud resources using elasticity. Here, a high-level abstraction set was utilized for describing the cloud resources, while taking into account the behavior of the resources based on elasticity with time using cloud resource requirement State Machine. Moreover, it offered an effortless method of simplifying cloud resources based on elasticity. Further, it considerably minimized the effort and time required for designing the system. However, the technique failed to utilize learning techniques for identifying the autonomic features for handling unanticipated situations. Also, Shahidinejad et al. [6] proposed an auto-elastic colored Petri nets for automatic management of cloud resources. The system behavior was explored by considering the system states as well as the incidents causing state variations. Here, an elastic controller based on colored Petri nets was used for modeling the host, controller as well as arrival transitions. This system was successful in enhancing the QoS of the cloud services, although it failed to utilize the colored Petri nets for scheduling for improving accuracy. In 2021, Sahni and Vidyarthi [7] developed a StreamScale-H auto-scaling algorithm for performing elastic scaling. StreamScale-H was a heterogeneity-aware scaling technique that utilized a hybrid auto-scaling technique for identifying the positions at which scaling was needed. Moreover, it identified the suitable VM sizes based on the heterogeneity of VMs. The technique was highly efficient for offering high QoS with minimal costs, but it was unsuccessful for reducing the overhead. In the same year, Yan et al. [8] developed a HANSEL system for optimizing horizontal scaling using the Kubernetes platform. Here, a Bidirectional Long-term and Short-Term Memory (Bi-LSTM) was employed for estimating the load along with an attention scheme and also reinforcement learning was utilized for realizing elastic scaling. This system was highly efficient for enhancing resource utilization; however, it did not consider cooperation and satisfaction of the distributed management needs and also failed to adapt with varying scenarios.

The main challenges encountered by the prevailing approaches of scaling in cloud are listed below.

A bottleneck detection scheme was proposed in [2] for performing resource allocation by recommending scaling in case of a bottleneck. The major challenge faced by this approach was that it did not consider the integration of horizontal and vertical scaling algorithms to handle large-scale resource allocations. An integration of horizontal and vertical scaling algorithms was considered in [3], where integer programming algorithm was devised for implementing dynamic scaling. This approach did not take into account the prediction of load using various metrics apart from memory and CPU for improving the accuracy. The drawback in [3] was overcome in [6], where the colored Petri net based elastic controller was proposed, which was highly efficient in estimating the resources with the varying workload. However, the technique did not consider the utilization of auto-scaling methods for improving its performance, which remained a key challenge. An efficient auto-scaling technique was proposed in [7], wherein the StreamScale-H was utilized for performing elastic scaling. This technique was unsuccessful in considering the incorporation of the approach with the prevailing open-source Stream Processing Systems for validating it in cloud platforms. Existing techniques of scaling pose a great challenge where they have to adapt to the rapidly varying workload requirement in a very short time. Moreover, the random workloads forbid the utilization of fixed models for scaling. In addition to this, the scaling approaches have to provide flexible resource allocation on the PMs without affecting QoS, which remains a key challenge.

3. System model of cloud

The advancement in the field of digital technology has led to the explosion of data that is generated daily. This ever-increasing data poses a requirement for development of technology for their storage and processing, which can be realized by using cloud computing. Cloud computing provides users with opportunity of accessing the huge amount of information, data and other computing devices on a pay per use basis. The increasing user demand for resources can be met by the usage of virtualization, wherein the virtual versions of the resources are created by using the limited physical resources. A single PM can be considered to have multiple versions of VMs, and each VM can be utilized for performing individual tasks. The allocation of VMs is a critical process, as improper allocation can result in overloading, or under-loading, thereby affecting the performance of the cloud. Figure 1 depicts the system model of cloud.

Figure 1.

System model of cloud.

Consider the system model of the cloud computing, assume that there a set of PMs denoted by $Z=\{{Z_{1},Z_{2},\ldots,Z_{b},\ldots,Z_{z}}\}$ , wherein $Z_{b}$ denote the $b^{\text{th}}$ PM and $z$ denotes the total number of PMs. Let us assume that the $b^{\text{th}}$ PM comprises of a set of VMs represented by, $Y=\{{Y_{1},Y_{2},\ldots,Y_{c},\ldots,Y_{y}}\}$ , which perform a set of tasks denoted by $A=\{{A_{1},A_{2},\ldots,A_{d},\ldots,A_{o}}\}$ based on parameters, such as CPU, memory and bandwidth.

Figure 2.

Schematic view of the developed leader Harris honey badger algorithm based elastic scaling for resource management.

4. Introduced leader Harris honey badger algorithm based elastic scaling for resource management

Scaling is a key process that enables the smooth handling of services provided by the cloud. However, the limited number of PMs make it a challenging task to allocate the resources based on user demand without causing any wastage and affecting the user experience. Additionally, scaling has to be done with a reduced cost. In this paper, a hybrid optimized scaling technique is devised. The developed leader Harris honey badger algorithm based scaling is realized using the following steps. Initially, the tasks are submitted by the user to the cloud. Based on the tasks, the load prediction is carried out on the VM using the cloud considering the bandwidth, CPU, and memory. If the predicted load is high, i.e. if the VM is overloaded, then scaling has to be performed, whereas no scaling is performed during the predicted load is low. The predicted load is compared to the predefined threshold, when the predicted load is greater than the threshold, horizontal scaling is carried out, or else vertical scaling is done. Horizontal scaling is performed by adding nodes to the overloaded system from the underloaded system using the devised leader Harris honey badger algorithm, based on the horizontal cost that depends on CPU, memory, and hard disk. On the other hand, vertical scaling adds CPU, RAM, etc. to the system using the developed leader Harris honey badger algorithm. Here, the leader Harris honey badger algorithm is devised by integrating the leader Harris hawks optimization [26] algorithm with respect to the honey badger algorithm [27]. Figure 2 depicts the schematic view of the developed leader Harris honey badger algorithm based elastic scaling, and the process of the devised elastic scaling is detailed in the upcoming sections.

The process of scaling is carried out using Algorithm 1.

Algorithm 1: Scaling using leader Harris honey badger algorithm
1 Initially, the tasks are assigned to the VM
2 Predict the load $P_{l}$ based on the cloud model considering parameters, like CPU, memory, and bandwidth.
3 Check whether the predicted load $P_{l}$ is overloaded.
4 If not overloaded, no scaling.
5 Else compare $P_{l}$ with the threshold.
6 If $P_{l}>\textit{threshold}$ , then demand for horizontal scaling
7 else, Demand for vertical scaling.
8 Perform horizontal and vertical scaling based on the devised optimization algorithm

4.1 Incoming task

Let us assume the incoming tasks by denoted by,

$\displaystyle A=\{{A_{1},A_{2},\ldots,A_{d},\ldots,A_{o}}\}$ (1)

where $A_{d}$ represents the $d^{\text{th}}$ task among a total of $o$ incoming tasks.

4.2 Load prediction based on the cloud model

Load prediction [3] is performed by performing transformation of the quantitative data into qualitative concept, wherein a concept leap is made by considering the ideas of overlapping, as well as intimate clouds. Later the prediction model is established by considering the relation between memory, and CPU. Load prediction is performed by considering the historic or past data and the present data. The collected historic data comprises the bandwidth, CPU consumption of the VM, and memory consumption. Let us consider that the data is gathered over a long time period $L_{1}$ and a short period $L_{2}$ , as well as the predicted time $t$ is computed by using the following expression,

$\displaystyle t=t_{1}+p\cdot L_{1}+q\cdot L_{2}$ (2)

where $p$ and $q$ are integers, and time $t_{1}\in[{0,L_{2}}]$ .

The past dataset is given by,

$\displaystyle H_{1}=\{({t_{j},w_{j}}),0\leqslant t_{j}\leqslant p\cdot L_{1}\}$ (3) $\displaystyle H_{2}=\{({t_{j},w_{j}}),p\cdot L_{1}\leqslant t_{j}\leqslant q% \cdot L_{2}\}$ (4)

The present dataset is given by,

$\displaystyle C=\{({t_{j},w_{j}}),p\cdot L_{1}+q\cdot L_{2}\leqslant t_{j}% \leqslant t\}$ (5)

At last, the above three datasets are utilized for generating the cloud models, which are combined for predicting load using the inertial weighting technique. In the cloud system, load data is present in the time-series format. This data has to be normalized, and then fitted for converting the quantitative data into qualitative concepts, for performing load prediction. The transformation is based on the principle that low frequency elements contribute less to the qualitative concept than those at high-frequency and is represented by,

$\displaystyle B(w)\approx\sum\limits_{i=1}^{p}{x_{i}\cdot e^{\frac{-(w-E_{w})^% {2}}{2E_{ni}^{2}}}}$ (6) $\displaystyle 0<B(w)-\sum\limits_{i=1}^{p}{x_{i}\cdot e^{\frac{-(w-E_{w})^{2}}% {2E_{ni}^{2}}}}<\gamma$ (7) $\displaystyle p_{j}(w)=e^{\frac{-(w-E_{w})^{2}}{2E_{ni}^{2}}}$ (8)

where $p_{j}(w)$ denotes the probability distribution function depending on the cloud, $B(w)$ represents the data distribution function, $x_{j}$ indicates the weight coefficient, and $\gamma$ refers to the maximal permissible error based on user definition, and $p$ refers to the overlap cloud count. High values of $p$ contribute to low error, as the data distribution is effective owing to the increased number of clouds.

Here, the load, comprising of CPU and memory consumption is transformed into qualitative concept, which contains several clouds. The qualitative concept, thus generated is coarse as the distance among the neighboring clouds is low. Hence, for selecting the best concept count, and making the concept of individual clouds clear and the distance suitable, concept leap is required. The overlap and similar cloud concept are determined using overlap and similarity, wherein overlap refers to the percentage of small clouds created by the overlapping of abscissa and two neighboring clouds. Similarity can be described as the distance among two neighboring clouds, which is computed by finding the absolute value of the variation in the expected values. Consider the expected curve of the two neighboring clouds be represented by the distribution functions, $u(w)\sim N({E_{wj},({E_{nj}})^{2}})$ and $v(w)\sim N({E_{w({j+1})},({E_{n({j+1})}})^{2}})$ , wherein $E_{wj}$ and $E_{w({j+1})}$ represents the expected value of the neighboring clouds. The similarity is given by,

$\displaystyle S=|{E_{wj}-E_{w(j+1)}}|$ (9)

As there is no certainty on the location and size of the neighboring clouds, three scenarios can exists where the clouds can intersect at two points, one point or no point. The cloud can be considered to cover the adjacent cloud completely in case of no intersection, and in this case, the overlapping degree $O=1$ and area of the small cloud gives the overlapping area, indicating overlapping clouds. When there are intersection points, these points should assure that the criteria of $[{E_{w}-3E_{n},E_{w}+3E_{n}}]$ as per the rule of $3E_{n}$ and the overlap degree is computed by using the following expression.

$\displaystyle O=\frac{\textit{area}}{\min({\sqrt{2\pi E_{nj}},\sqrt{2\pi E_{n(% {j+1})}}})}$ (10)

where area indicates the overlap area $\sqrt{2\pi E_{nj}}$ and $\sqrt{2\pi E_{n(j+1)}}$ represent the area formed by the neighboring cloud with the abscissa.

The clouds are regarded as overlap or similar clouds, when the overlap degree is higher than the threshold value $\alpha$ and the similarity is lower than the threshold $\beta$ , and the clouds can be combined to form concept cloud. Once the concept cloud is formed, the data is mined using Apriori algorithm. At last, multiple appropriate association rules are attained, from which multiple double conditional single-rule generators $X_{1}$ , $X_{2}$ and $W$ are created. Here, $X_{1}$ and $X_{2}$ indicate the rule premises which represents the cloud concept of CPU and memory consumption at the past and $W$ denotes the rule consequent representing the present CPU consumption. Let the load predicted be indicated by $P_{l}$ , which is forwarded to the scaling phase.

4.3 Devised leader Harris honey badger algorithm for elastic scaling

This section details the process of elastic scaling using the devised leader Harris honey badger algorithm scheme. The predicted load $P_{l}$ is checked to determine if the VM is overloaded or not, if not overloaded, no scaling is required. In case of overloading, the predicted load is compared with the threshold value $T$ , if $P_{l}>T$ , then horizontal scaling is carried out, else vertical scaling is performed. The entire process is explained in depth in the forthcoming sections.

4.3.1 Horizontal scaling

When the predicted load $P_{l}$ is higher than the threshold, horizontal scaling is performed, wherein the machines from the overloaded PM are added to the under loaded PM, thereby increasing the resource available and thus balancing the demand and supply of resources. Horizontal scaling assigns resources by varying the number of VMs available.

4.3.1.1. Solution encoding

Solution encoding is a way of representing the solution of any problem using a pictorial representation. Here, the solution indicates the underloaded PM, to which the VMs have to be added from the overloaded PM. Figure 3 represents the solution encoding of horizontal scaling.

Figure 3.

Solution encoding of horizontal scaling.

4.3.1.2. Fitness function

The optimal solution is calculated considering the fitness function, wherein the minimal fitness function yields the best solution. The horizontal expansion cost is considered as the fitness function, and is given by,

$\displaystyle\textit{fit}_{1}=\sum\limits_{j=1}^{n_{a}}{({D_{j}^{VM_{b}}+D_{j}% ^{VM_{a}}})}$ (11)

where $n_{a}$ indicates the overall count of VM ahead of resource expansion, $D_{j}^{VM_{b}}$ and $D_{j}^{VM_{a}}$ indicates the cost of the $j^{\text{th}}$ VM before and after expansion, which are given by,

$\displaystyle D_{j}^{VM_{b}}=D_{j}^{VM_{b},M}+D_{j}^{VM_{b},\textit{CPU}}+D_{j% }^{VM_{b},HD}$ (12) $\displaystyle D_{j}^{VM_{a}}=D_{j}^{VM_{a},M}+D_{j}^{VM_{a},\textit{CPU}}+D_{j% }^{VM_{a},HD}$ (13)

where $D_{j}^{H}$ , $D_{j}^{\textit{CPU}}$ , and $D_{j}^{M}$ designates the hard disk, CPU, and memory cost of the $j^{\text{th}}$ VM. These equations are based on the following constraints.

$\displaystyle\sum\limits_{j=1}^{n}{SZ_{j}^{HD}\geqslant}SZ_{\textit{need}}^{HD}$ (14) $\displaystyle\sum\limits_{j=1}^{n}{SZ_{j}^{\textit{CPU}}\geqslant}SZ_{\textit{% need}}^{\textit{CPU}}$ (15) $\displaystyle\sum\limits_{j=1}^{n}{SZ_{j}^{M}\geqslant}SZ_{\textit{need}}^{M}$ (16)

where $SZ_{j}^{HD}$ , $SZ_{j}^{\textit{CPU}}$ , and $SZ_{j}^{M}$ represents the hard disk, CPU, and memory cost of the $j^{\text{th}}$ VM.

4.3.1.3. Devised leader Harris honey badger algorithm

This section elaborates the developed leader Harris honey badger algorithm for performing horizontal scaling, wherein the developed leader Harris honey badger algorithm is created by adapting the exploration capability of the leader Harris hawks optimization [26] corresponding to the honey phase of the honey badger algorithm [27]. The leader Harris hawks optimization algorithm was developed for enhancing the exploration ability of the Harris hawks optimization. The Harris hawks optimization algorithm is inspired from the supportive conduct and the surprise pounce strategy of the Harris’ hawks while chasing a prey. Multiple hawks wait for the prey and besiege in from various directions cooperatively for surprising it, and attacking the prey at last. The Harris hawks optimization algorithm reveals multiple chase patterns and escaping strategies, however suffers from limited exploration, which is overcome in leader Harris hawks optimization by constraining the adaptive perch probability and using a leader-oriented mutation-selection approach. The leader Harris hawks optimization is highly efficient in minimizing the complexity of the system and avoiding local optima; however, it is computationally expensive. On the other hand, the honey badger algorithm is modeled based on the foraging features of the honey badger, wherein the dynamic way of finding honey by smelling or digging or following a honey guide bird is considered. Two modes, namely digging, as well as honey mode are considered for finding the food. The honey badger employs its ability to smell for determining the food source location, and the prey is captured by digging the site after appropriate selection, in the digging mode. In the honey mode, the badger follows the honey guide bird for identifying the beehive location. The honey badger algorithm offers the advantage of rapid convergence, and it is efficient in determining the problem solutions from a complex search area, but it failed to consider multiple objectives while optimization. By amalgamating the honey badger algorithm and leader Harris hawks optimization, the merits of both the optimization strategies can be obtained in the hybrid scheme, thus improving the effectiveness of the optimizer. The leader Harris honey badger algorithm performs optimization in two phases, namely exploration, as well as exploitation based on the escape energy, which is given by,

$\displaystyle En=2En_{0}\left({1-\frac{v}{V_{\max}}}\right)$ (17)

where $v$ represents the current iteration and $V_{\max}$ indicates the maximum number of iterations, $E_{n0}$ signifies the initial prey energy, which has a random value in the range [ $-$ 1, 1], which is represented by,

$\displaystyle En_{0}=2*\textit{rand}(\cdot)-1$ (18)

The algorithmic steps of the developed leader Harris honey badger algorithm are given below;

Step 1) Initialize the position vectors of hawks

Let us consider a population of hawks, whose position vectors are represented by using the following expression,

$\displaystyle L=\{{L_{1},L_{2},\ldots,L_{s},\ldots,L_{f}}\},{1\leqslant s% \leqslant f}$ (19)

where $f$ indicates the total number of hawks and $L_{s}$ denotes the position vector of the $s^{\text{th}}$ hawk expressed as, $L_{s}(v=1)=({l_{n}^{1},l_{n}^{2},\ldots,l_{n}^{G}})$ , where $G$ indicates the dimension of the problem.

Step 2) Evaluation of fitness

The fitness parameter is already defined using Eq. (11).

Step 3) Exploration phase ( $|{En}|>1$ )

The hawks perform exploration of the prey position in this phase, the adaptive perch probability of each hawk is considered for performing exploration,

$\displaystyle pr^{s}=\frac{|{\textit{fit}({L_{s}})-\textit{fit}({L_{\textit{% prey}}})}|}{|{\textit{fit}({L_{\textit{worst}}})-\textit{fit}({L_{\textit{prey% }}})}|}\quad{s=1,2,\ldots,f}$ (20)

wherein $L_{s}$ , $L_{\textit{prey}}$ and $L_{\textit{worst}}$ denotes the position vector of $s^{\text{th}}$ hawk, prey, and the worst acting hawk, and fit indicates the fitness function. The following equation represents the exploration phase,

$\displaystyle L_{s}({v+1})=\left\{\begin{array}[]{ll}L_{\textit{rand}}(v)-m_{1% }|L_{\textit{rand}}(v)-2m_{2}L_{s}(v)|&k\geqslant pr^{s}\\ (L_{\textit{prey}}(v)-L_{m}(v))-m_{3}(l_{b}+m_{4}({u_{b}-l_{b}}))&{k<pr^{s}}\\ \end{array}\right.$ (21)

where $L_{m}$ indicates the mean position vector of entire $f$ hawks, and $m_{1},m_{2},m_{3},m_{4}$ , and $k$ are arbitrary numbers having values in between 0 and 1, $l_{b}$ and $u_{b}$ represent the lower as well as upper bounds of the search space. $L_{s}(v+1)$ and $L_{s}(v)$ indicates the new and current position of the hawk.

Now, consider $k\geqslant pr^{s}$ , then Eq. (21) can be written as,

$\displaystyle L_{s}({v+1})=L_{\textit{rand}}(v)-m_{1}|{L_{\textit{rand}}(v)-2m% _{2}L_{s}(v)}|$ (22) $\displaystyle L_{s}({v+1})=L_{\textit{rand}}(v)-m_{1}L_{\textit{rand}}(v)+2m_{% 1}m_{2}L_{s}(v)$ (23) $\displaystyle L_{s}({v+1})=L_{\textit{rand}}(v)({1-m_{1}})+2m_{1}m_{2}L_{s}(v)$ (24)

The honey phase in honey badger algorithm, where the honey guide bird is followed by the badger can be represented by the expression given below,

$\displaystyle L_{s}({v+1})=L_{\textit{prey}}(v)+R*m_{5}*\chi*g_{s}$ (25)

where, $R$ is the disturbance which varies the direction of search, $m_{5}$ is an arbitrary number in [0, 1], $g_{s}$ represents the distance of the prey to the badger, and $\chi$ signifies the density factor. $R$ , $\chi$ , and $g_{s}$ are expressed using the following equations.

$\displaystyle R=\left\{{{\begin{array}[]{ll}1&\text{if }m_{6}\leqslant 0.5\\ {-1}&\text{otherwise}\\ \end{array}}}\right.$ (26) $\displaystyle g_{s}=L_{\textit{prey}}(v)-L_{s}(v)$ (27) $\displaystyle\chi=\lambda\times\exp\left({\frac{-v}{V_{\max}}}\right)$ (28)

where $m_{6}$ is a random number in the range [0, 1]and $\lambda$ is a constant with value greater than 1.

Substituting Eq. (27) in Eq. (25), we get,

$\displaystyle L_{s}({v+1})=L_{\textit{prey}}(v)+R*m_{5}*\chi*({L_{\textit{prey% }}(v)-L_{s}(v)})$ (29) $\displaystyle L_{s}({v+1})=L_{\textit{prey}}(v)+R*m_{5}*\chi*L_{\textit{prey}}% (v)-R*m_{5}*\chi*L_{s}(v)$ (30) $\displaystyle L_{s}({v+1})=L_{\textit{prey}}(v)({1+R*m_{5}*\chi})-R*m_{5}*\chi% *L_{s}(v)$ (31) $\displaystyle R*m_{5}*\chi*L_{s}(v)=L_{\textit{prey}}(v)({1+R*m_{5}*\chi})-L_{% s}({v+1})$ (32) $\displaystyle L_{s}(v)=\frac{L_{\textit{prey}}(v)({1+R*m_{5}*\chi})-L_{s}({v+1% })}{R*m_{5}*\chi}$ (33)

Substituting Eq (33) in Eq. (24), we get

$\displaystyle L_{s}({v+1})=L_{\textit{rand}}(v)({1-m_{1}})+2m_{1}m_{2}\left[{% \frac{L_{\textit{prey}}(v)({1+R*m_{5}*\chi})-L_{s}({v+1})}{R*m_{5}*\chi}}\right]$ (34) $\displaystyle L_{s}({v+1})+\frac{2m_{1}m_{2}L_{s}({v+1})}{R*m_{5}*\chi}=L_{% \textit{rand}}(v)({1-m_{1}})$ (35) $\displaystyle{}+2m_{1}m_{2}\left[{\frac{L_{\textit{prey}}(v)({1+R*m_{5}*\chi})% }{R*m_{5}*\chi}}\right]$ $\displaystyle\frac{L_{s}({v+1})({R*m_{5}*\chi})+2m_{1}m_{2}L_{s}({v+1})}{R*m_{% 5}*\chi}=L_{\textit{rand}}(v)({1-m_{1}})$ (36) $\displaystyle{}+\frac{2m_{1}m_{2}*L_{\textit{prey}}(v)({1+R*m_{5}*\chi})}{R*m_% {5}*\chi}$ $\displaystyle\frac{L_{s}({v+1})({R*m_{5}*\chi+2m_{1}m_{2}})}{R*m_{5}*\chi}$ (37) $\displaystyle=\frac{R*m_{5}*\chi*L_{\textit{rand}}(v)({1-m_{1}})+2m_{1}m_{2}*L% _{\textit{prey}}(v)({1+R*m_{5}*\chi})}{R*m_{5}*\chi}$ $\displaystyle L_{s}({v+1})({R*m_{5}*\chi+2m_{1}m_{2}})=R*m_{5}*\chi*L_{\textit% {rand}}(v)({1-m_{1}})$ (38) $\displaystyle{}+2m_{1}m_{2}*L_{\textit{prey}}(v)({1+R*m_{5}*\chi})$ $\displaystyle L_{s}({v+1})=\frac{1}{({R*m_{5}*\chi+2m_{1}m_{2}})}[R*m_{5}*\chi% *L_{\textit{rand}}(v)({1-m_{1}})$ (39) $\displaystyle{}+2m_{1}m_{2}*L_{\textit{prey}}(v)({1+R*m_{5}*\chi})]$

where $L_{s}({v+1})$ signifies the position of the $s^{\text{th}}$ solution an iteration $v+1$ .

Step 4) Exploitation phase ( $|{En}|<1$ )

The hawks carry out the surprise pounce based on the seven kill tactics for hunting the prey. The prey always attempts to evade the attacks, which leading to different attack schemes from the hawks. Consider the prey has a chance $h$ of escaping from the hawks, with $h<0.5$ denoting the successful escape and $h\geqslant 0.25$ representing unsuccessful escape. When the value of $|{En_{0}}|\geqslant 0.5$ , soft besiege occurs and when $|{En_{0}}|<0.5$ , hard besiege occurs. Based on these, four different tactics are utilized during exploitation, which are explained below,

i) Soft besiege

While $|{En_{0}}|\geqslant 0.5$ and $h\geqslant 0.5$ , the prey still poses sufficient energy in escaping and tries to evade the attacks by taking arbitrary confusing jumps, however it cannot escape. The hawks, on the other hand, keeps encircling the prey softly for making it tired and finally it pounces on the prey. This is represented by using the following expression,

$\displaystyle L_{s}(v+1)=L_{\textit{prey}}(v)-L_{s}(v)-En|{UL_{\textit{prey}}(% v)-L_{s}(v)}|$ (40)

Here, $U$ indicates the jump strength of the prey given by,

$\displaystyle U=2({1-m_{8}})$ (41)

where $m_{8}$ is an arbitrary number with values in the range [0, 1].

ii) Hard besiege

While $|{En_{0}}|<0.5$ and $h\geqslant 0.5$ , the prey is tired and has very low energy to escape, and the hawk surrounds the prey hardly and pounces upon it. This can be modeled as,

$\displaystyle L_{s}(v+1)=L_{\textit{prey}}(v)-En|{L_{\textit{prey}}(v)-L_{s}(v% )}|$ (42)

iii) Soft besiege with progressive rapid dives

While $|{En_{0}}|\geqslant 0.5$ and $h<0.5$ , the prey has sufficient energy to evade attacks, but still a soft besiege is performed before the attack. The prey tries to escape by using the levy flight movements. The hawk evaluates its present move to the earlier one, and if found unworthy, fast, abrupt and irregular dives are performed by the hawk as it approaches the prey. This can be represented by,

$\displaystyle L_{s}(v+1)=\left\{{{\begin{array}[]{lll}{M_{s}}&\text{if}&% \textit{fit}(M_{s})<\textit{fit}(L_{s}(v))\\ {N_{s}}&\text{if}&{\textit{fit}(N_{s})<\textit{fit}(L_{s}(v))}\\ \end{array}}}\right.$ (43)

where $M_{s}$ and $N_{s}$ are given by,

$\displaystyle M_{s}=L_{\textit{prey}}(v)-En|{UL_{\textit{prey}}(v)-L_{s}(v)}|$ (44) $\displaystyle N_{s}=M_{s}+F\times LF(G)$ (45)

Here, $L F$ indicates the LF movements, $F$ represents an arbitrary vector with size $1\times G$ , and $L F$ is given by,

$\displaystyle LF(v)=0.01\times\frac{k\times\mu}{|u|^{\frac{1}{\rho}}},\mu=% \left({\frac{\Gamma({1+\rho})\times\sin\left({\frac{\pi\rho}{2}}\right)}{% \Gamma\left({\frac{1+\rho}{2}}\right)\times\rho\times 2^{({\frac{\rho-1}{2}})}% }}\right)$ (46)

where $\rho$ signifies a constant with value 0.5, $k$ , and $u$ are arbitrary variables with values in [0, 1].

iv) Hard besiege with progressive rapid dives

While $|{En_{0}}|<0.5$ and $h<0.5$ , the prey does not have sufficient energy to evade attack and the hawk performs a hard besiege ahead of surprise pouncing and killing the prey. The hawks attempt to reduce the distance with the prey and this is expressed as,

$\displaystyle L_{s}(v+1)=\left\{{{\begin{array}[]{lll}{M_{s}}&\text{if}&{% \textit{fit}(M_{s})<\textit{fit}(L_{s}(v))}\\ {N_{s}}&\text{if}&{\textit{fit}(N_{s})<\textit{fit}(L_{s}(v))}\\ \end{array}}}\right.$ (47)

Here, $M_{s}$ and $N_{s}$ are given by,

$\displaystyle M_{s}=L_{\textit{prey}}(v)-En|{UL_{\textit{prey}}(v)-L_{m}(v)}|$ (48) $\displaystyle N_{s}=M_{s}+F\times LF(G)$ (49)

where $L_{m}(v)=\frac{1}{f}\sum\limits_{j=1}^{f}{L_{j}(v)}$ .

Step 5) Leader-based mutation-selection

The mutation position vector of the hawk is computed by considering the best, second best, and the third best position vectors of the hawks, represented by $L_{\textit{best}}^{v}$ , $L_{\textit{best}-1}^{v}$ and $L_{\textit{best}-2}^{v}$ depending on the fitness of latest position vector $L_{s}(v+1)$ from the total $f$ hawks. The latest mutation position vector is given by,

$\displaystyle L_{s}(\textit{mut})=L_{s}(v+1)+2\ast\left({1-\frac{u}{U_{\max}}}% \right)\ast({2\ast m_{7}-1})({2\ast L_{\textit{best}}^{v}-({L_{\textit{best}-1% }^{v}+L_{\textit{best}-2}^{v}})})$ $\displaystyle{}+({2\ast m_{7}-1})({L_{\textit{best}}^{v}-L_{s}(v+1)})$ (50)

The position vector for the next iteration can be obtained by the following expression,

$\displaystyle L_{s}(\textit{new})=\left\{{{\begin{array}[]{lll}{L_{s}(\textit{% mut})}&\text{if}&{\textit{fit}(L_{s}(\textit{mut}))<\textit{fit}(L_{s}(v+1))}% \\ {L_{s}(v+1)}&\text{if}&{\textit{fit}(L_{s}(\textit{mut}))\geqslant\textit{fit}% (L_{s}(v+1))}\\ \end{array}}}\right.$ (51)

Similarly, the prey location is updated as,

$\displaystyle L(\textit{prey})=\left\{{{\begin{array}[]{lll}{L_{s}(\textit{mut% })}&\text{if}&{\textit{fit}(L_{s}(\textit{mut}))<\textit{fit}(L(\textit{prey})% )}\\ {L_{s}(v+1)}&\text{if}&{\textit{fit}(L_{s}(\textit{mut}))\geqslant\textit{fit}% (L(\textit{prey}))}\\ \end{array}}}\right.$ (52)

Step 6) Re-evaluate fitness

Once the new solution is generated, the fitness of the solution obtained is recomputed. If the generated solution has a lower fitness value than the previous one, it will replace the existing solution.

Step 7) Terminate

The above process is kept repeated till the maximum value of iteration $V_{\max}$ is achieved. Algorithm 2 depicts the pseudocode of the devised leader Harris honey badger algorithm.

Algorithm 2: Pseudocode of the devised leader Harris honey badger algorithm
1 Assign the parameters $f$ , $G$ , $l_{b}$ , $u_{b}$ , and $V_{\textit{mas}}$
2 Initialize the hawk population $L$
3 Begin
4 Determine the fitness function for each hawks
5 Identify the best position vector $L_{\textit{best}}$ and worst position vector $L_{\textit{worst}}$ based on fitness
6 While ( $v<V_{\max}$ )
7 For each hawk ( $L_{s}$ ) do
8 Update escape energy $E n$ with Eq. (18)
9 Compute jump strength $U$ with Eq. (41)
10 Compute adaptive perch probability $pr^{s}$ with Eq. (19)
11 If ( $\|{En}\|>1$ )
12 Update $L_{s}({v+1})$ using Eq. (4.3)
13 If $\|{En}\|<1$
14 If $\|{En_{0}}\|\geqslant 0.5$ and $h\geqslant 0.5$ ,
15 Update $L_{s}({v+1})$ using Eq. (40)
16 else if $\|{En_{0}}\|<0.5$ and $h\geqslant 0.5$
17 Update $L_{s}({v+1})$ using Eq. (42)
18 else if $\|{En_{0}}\|\geqslant 0.5$ and $h<0.5$
19 Update $L_{s}({v+1})$ using Eq. (43)
20 else $\|{En_{0}}\|<0.5$ and $h<0.5$
21 Update $L_{s}({v+1})$ using Eq. (47)
22 ii) Re-evaluate fitness of the hawks
23 iii) Determine the top three position vectors $L_{\textit{best}}^{v}$ , $L_{\textit{best}-1}^{v}$ and $L_{\textit{best}-2}^{v}$ based on step ii)
24 iv) for each hawk $L_{s}({v+1})$ do
25 Compute the new mutation position vector $L_{s}(\textit{mut})$ with Eq. (4.3)
26 Compute fitness of $L_{s}(\textit{mut})$
27 Find the next generation position vector with Eq. (51)
28 Update position of prey $L(\textit{prey})$ using Eq. (52)
29 $v=v+1$
30 Return the best solution $L(\textit{prey})$
31 End

The best solution corresponds to position vector of the prey $L(\textit{prey})$ . Thus, by integrating leader Harris hawks optimization algorithm with honey badger algorithm, the devised leader Harris honey badger algorithm achieved faster convergence rate, with low computational cost.

4.3.2 Vertical scaling

Vertical scaling is performed when the predicted load is less than the threshold value. Here, scaling is carried out by adding CPU, RAM to the existing system, for meeting the user demand. Vertical scaling aims at improving the capacity of the system by upgrading the resources available.

4.3.2.1. Solution encoding

In this section, the solution encoding of vertical scaling is briefed, wherein the solution represents the VMs. Here, $n$ number of machines is considered, and each machine is added with CPU and RAM for performing vertical scaling. Figure 4 depicts the solution encoding of vertical scaling.

Figure 4.

Solution encoding of vertical scaling.

4.3.2.2. Fitness function

The fitness function used to find the optimal solution while performing vertical scaling is briefed here. The fitness function is computed by considering the vertical cost [28], which is given by

$\displaystyle fit=\sum\limits_{j=1}^{n_{a}}{({D_{j}^{VM_{a}}+D_{j}^{l}})}$ (53)

where $n_{a}$ specifies the overall count of VM ahead of resource expansion, $D_{j}^{VM_{b}}$ of the $j^{\text{th}}$ VM after expansion and $D_{j}^{l}$ indicates the license cost, which are estimated by using the equations given below,

$\displaystyle D_{j}^{VM_{a}}=D_{j}^{VM_{a},M}+D_{j}^{VM_{a},\textit{CPU}}+D_{j% }^{VM_{a},HD}$ (54) $\displaystyle D_{j}^{l}=\sum{\textit{Cost}({\textit{license}_{j}})}$ (55)

where $D_{j}^{H}$ , $D_{j}^{\textit{CPU}}$ , and $D_{j}^{M}$ designates the hard disk, CPU, and memory cost of the $j^{\text{th}}$ VM, and $D_{j}^{l}$ is obtained by adding the license costs of scaled VMs in VM scaling, where license cost indicate the fee paid in case of business software’s. The solution is found by considering the fitness function that has a minimum value.

4.3.2.3. Devised leader Harris honey badger algorithm for vertical scaling

Virtual scaling is performed by using the developed leader Harris honey badger algorithm, which is created by adapting the leader Harris hawks optimization algorithm in line with the honey badger algorithm technique. The devised leader Harris honey badger algorithm is already elaborated in the section 4.3.1.3. Here, only the fitness function differs and the fitness function is given by Eq. (53), and the optimal solution corresponds to the one with minimum fitness.

5. Results

In this section, the experimental outcomes of the developed leader Harris honey badger algorithm (LHHBA) based elastic scaling are examined in order to reveal its effectiveness. The devised LHHBA based elastic scaling is realised by implementing it using Python tool using simulation on a Personal Computer with Windows 10 Operating System, Intel i3 core processor and 8 GB RAM. Moreover, the devised elastic scaling approach is compared with the prevailing approaches based on various metrics, which are also briefed in the sub sections.

5.1 Evaluation measures

The evaluation of the devised LHHBA based elastic scaling is carried out using measures, like predicted load error, cost, and resource utilization. These metrics are shortly briefed in the upcoming sections.

5.1.1 Predicted load error

The predicted load error is estimated by determining the difference between the actual load and the predicted load and is represented as,

$\displaystyle\textit{Error}=|{P_{l}(t)-\textit{Act}_{l}(t)}|$ (56)

where $P_{l}(t)$ indicates the predicted load and the term $\textit{Act}_{l}(t)$ refers to the actual load at time $t$ .

5.1.2 Cost

Cost is computed by considering the total cost of scaling the resources during the process of elastic scaling, and is expressed as,

$\displaystyle\textit{Total}_{c}=\sum\limits_{t=1}^{Q}{Cs(t)}$ (57)

where $Cs(t)$ is the scaling cost for the time period $t$ , which is given by,

$\displaystyle Cs(t)=\sum\limits_{j=1}^{x}{K_{j}I_{j}}$ (58)

where $x$ is the present count of the resource types provided by the cloud service, $I_{j}$ indicates the count of the resources corresponding to type $j$ available post scaling and $K_{j}$ specifies the cost per unit time for the resource type $j$ .

5.1.3 Resource utilization

Resource utilization is determined by using the following expression,

$\displaystyle Rs_{utl}=\frac{Rs_{\textit{cons}}}{Rs_{\textit{tot}}}$ (59)

where $Rs_{\textit{cons}}$ indicate the resource utilized in the time period $t$ , and the term $Rs_{\textit{tot}}$ signifies the total resources deployed over the time period $t$ .

5.2 Comparative assessment

In this section, the developed LHHBA based elastic scaling technique is compared to the state-of-art approaches, like Integer Programming Algorithm [3], Bottleneck detection algorithm [2], StreamScale-H auto scaling [7] and Elastic Service Function Chain (SFC) [1], in order to reveal the effectiveness of the devised approach.

5.2.1 Comparative assessment with task size as 100

This section details the assessment of the developed LHHBA based elastic scaling technique when the task size is considered to be 100, by considering various measures, and the same is displayed using Fig. 5. Figure 5a depicts the comparative evaluation of the developed technique based on predicted load error. The prevailing techniques, such as Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC computed values of predicted load error at 0.2732, 0.1263, 0.1238, and 0.0952 for 5 epochs. The devised LHHBA elastic scaling measured a value of low predicted load error at 0.0196. In Fig. 5b, the assessment of the developed LHHBA based elastic scaling is depicted using cost. For 10 epochs, the existing approaches, like Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC and the devised LHHBA based elastic scaling calculated cost of 1128.676, 830.286, 561.854, 489.784, and 253.075. The analysis of the devised LHHBA based elastic scaling is illustrated in Fig. 5c based on resource utilization. The proposed LHHBA based elastic scaling attained a resource utilization of 0.3376, but the state-of-art methods, like Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC attained a higher value of resource utilization at 0.5342, 0.4656, 0.5039, and 0.4467, respectively.

Figure 5.

Comparative evaluation with task size 100.

5.2.2 Comparative assessment with task size as 200

Figure 6 depicts the comparative assessment of the developed LHHBA based elastic scaling when the task size is 200 by considering multiple values of epochs. In Fig. 6a, the analysis of the devised LHHBA based on predicted load error is displayed. For epoch as 10, the prevailing methods, such as Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC obtained values of predicted load error at 0.2817, 0.1251, 0.1262, and 0.0982. The devised technique achieved a low value of prediction error rate at 0.0187. Figure 6b portrays the evaluation of the developed technique based on cost. The proposed LHHBA based elastic scaling achieved a cost of 281.471, which is less than the value of cost at 1282.471, 821.422, 582.168, and 601.154 attained by the prevailing approaches, such as Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC for 15 epochs. The evaluation of the introduced LHHBA based elastic scaling with respect to resource utilization is portrayed in Fig. 6c. The proposed elastic scaling scheme achieved a low resource utilization of 0.3547, whereas the value corresponding to the existing methodologies, like Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC is 0.5374, 0.4639, 0.4418, and 0.4996, for 5 epochs.

Figure 6.

Comparative evaluation with task size 200.

5.2.3 Comparative assessment with task size as 300

In Fig. 7, the comparative analysis of the developed LHHBA based elastic scaling with task size as 300 by considering various epochs. Figure 7a depicts the analysis based on predicted load error. For 15 epochs, the conventional methods, like Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC and the proposed LHHBA technique attained value of predicted load error at 0.2703, 0.1336, 0.1447, 0.0948, and 0.0191 respectively. The evaluation of the devised LHHBA based elastic scaling based on cost is displayed in Fig. 7b. The cost calculated by the devised approach is 76.887, whereas the conventional techniques, like Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC attained cost of 868.570, 818.045, 486.174, and 555.129, for 5 epochs. In Fig. 7c, the evaluation of the developed LHHBA based elastic scaling is represented using resource utilization. With 10 epochs, the prevailing methods, such as Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC computed resource utilization values of 0.5410, 0.4795, 0.4766, and 0.4520, while the developed LHHBA scaling technique achieved low resource utilization of 0.3431.

Figure 7.

Comparative evaluation with task size 300.

Figure 8.

Comparative evaluation with task size 400.

5.2.4 Comparative assessment with task size as 400

In Fig. 8, the analysis of the devised LHHBA based elastic scaling is displayed by considering task size as 400, by varying the number of epochs. The assessment based on predicted load error is displayed in Fig. 8a. The state-of-art techniques, like Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC and the introduced LHHBA approach computed predicted load error of 0.2781, 0.1399, 0.1255, 0.0938, and 0.0192, for 15 epochs. In Fig. 8b, the cost-based analysis of the developed scheme is shown. At 5 epochs, the devised LHHBA approach measured value of cost at 301.249, which is less than the values of 1617.606, 832.428, 523.216, and 494.079, computed by the existing schemes, like Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC. Figure 8c illustrates the assessment of the developed LHHBA technique using resource utilization. The prevailing methods, such as Integer Programming Algorithm, Bottleneck detection algorithm, StreamScale-H auto scaling and Elastic SFC attained resource utilization of 0.5242, 0.4565, 0.4702, and 0.4540, which is higher than the value 0.3223 calculated by the developed LHHBA based elastic scaling for 10 epochs.

6. Discussion

The comparative discussion of the introduced LHHBA based elastic scaling is explained in this section. The devised elastic scaling technique is compared with the state-of-art approaches for examining its effectiveness based on measures, such as predicted load error, cost, and resource utilization. Table 1 displays the values attained for the various approaches based on the metrics corresponding to 20 epochs, for task sizes of 100, 200, 300, and 400. It can be observed from the table that the devised LHHBA based elastic scaling attained a minimum value of predicted load error, cost, and resource utilization at 0.0193, 153.581, and 0.3217, thereby proving its effectiveness. The low value of load predicted error is caused by the performing transformation of the past data into qualitative concepts during the prediction process. Further, the utilization of the hybrid optimization process while performing scaling minimized the cost and the elastic scaling process reduced the resource utilization. Also, the proposed LHHBA minimizes the complexity of the system, avoids local optima, and increases the convergence speed. Hence, the proposed method offers the high performance than the existing methods, such as Integer Programming Algorithm [3], Bottleneck detection algorithm [2], StreamScale-H auto scaling [7] and Elastic SFC [1].

Table 1
Metrics discussion for various task sizes

Task size	Metrics	Integer programming algorithm	Bottleneck detection algorithm	StreamScale-H auto scaling	Elastic SFC	Proposed LHHBA
100	Predicted load error	0.2745	0.1233	0.1400	0.0930	0.0193
	Cost	1045.233	829.242	502.028	508.915	367.651
	Resource utilization	0.5242	0.4531	0.4444	0.4211	0.3338
200	Predicted load error	0.2579	0.1247	0.1468	0.0990	0.0194
	Cost	1333.603	830.146	500.523	554.803	260.148
	Resource utilization	0.5278	0.4592	0.4420	0.4117	0.3311
300	Predicted load error	0.2829	0.1513	0.1452	0.0954	0.0195
	Cost	1407.878	819.442	590.358	498.104	200.702
	Resource utilization	0.5480	0.4814	0.4529	0.4412	0.3338
400	Predicted load error	0.2619	0.1487	0.1440	0.0927	0.0194
	Cost	1277.773	815.141	569.874	511.563	153.581
	Resource utilization	0.5224	0.4893	0.4043	0.4201	0.3217

7. Conclusion

This paper devises an efficient technique of elastic scaling, which provides an effective way of utilizing the multiple resources available in cloud computing without affecting the user experience. Here, the load is initially predicted by utilizing the cloud model considering parameters, like CPU, and memory, the value obtained is checked to find if overloaded. If overloaded, vertical scaling and horizontal scaling are carried out by comparing the predicted load with a threshold value. A new optimization algorithm is developed for performing the process of scaling, based on parameters, such as bandwidth, CPU and memory. The developed leader Harris honey badger algorithm is devised by adapting the exploration ability of the hawks leader Harris hawks optimization algorithm in line with the honey phase of the honey badger algorithm. The devised leader Harris honey badger algorithm based elastic scaling is scaling is evaluated for its effectiveness based on metrics, such as predicted load error, cost, and resource utilization, and is found to have attained values of 0.0193, 153.581, and 0.3217. Further investigation will focus on the utilization of other metrics, like response time, and throughput for improving the effectiveness of the scaling approach.

Footnotes

Author’s Bios

Naimisha S. Trivedi received the degree of Bachelor of Engineering in Information Technology in 2007 from Saurashtra University, Master of Engineering in ITengineering in 2013 from Gujarat Technological University. Currently she is pursuing her PhD from Gujarat Technological University. Her current research interest includes Cloud Computing, Edge Computing and Parallel & Distributed Computing. ORCID: 0000-0003-3726-3624.

Shailesh D. Panchal received the degree of Bachelor of Engineering in Electronics and Communication in 1999 from Hemchandracharya North Gujarat University, Master of Technology in Computer Science Engineering in 2010 from Nirma University and PhD in 2017 from CHARUSAT University. Currently he is Professor and Director at Graduate School of Engineering and Technology, Gujarat Technological University, Ahmedabad. He has more than 24 years of teaching experience. His current research interest includes Cyber Security, Image Processing, Ad-hoc Networks and Internet of Things.

References

Toosi

A.N.

Son

Chi

and Buyya

, ElasticSFC: Auto-scaling techniques for elastic service function chaining in network functions virtualization-based clouds, Journal of Systems and Software 152 (2019), 108–119.

Liu

Sheu

R.K.

W.T.

and Yuan

S.M.

, Automatic cloud service testing and bottleneck detection system with scaling recommendation, Concurrency and Computation: Practice and Experience 32(1) (2020), e5161.

Tang

and Luo

, Elastic edge cloud resource management based on horizontal and vertical scaling, The Journal of Supercomputing 76(10) (2020), 7707–7732.

Yang

and Fung

, Fine-grained cloud resource provisioning for virtual network function, IEEE Transactions on Network and Service Management 17(3) (2020), 1363–1376.

Brabra

Mtibaa

Gaaloul

and Benatallah

, Toward higher-level abstractions based on state machine for cloud resources elasticity, Information Systems 90 (2020), 101450.

Shahidinejad

Ghobaei-Arani

and Esmaeili

, An elastic controller using Colored Petri Nets in cloud computing environment, Cluster Computing 23(2) (2020), 1045–1071.

Sahni

and Vidyarthi

D.P.

, Heterogeneity aware elastic scaling of streaming applications on cloud platforms, The Journal of Supercomputing 77(9) (2021), 10512–10539.

Yan

Liang

and Zhang

, HANSEL: Adaptive horizontal scaling of microservices using Bi-LSTM, Applied Soft Computing 105 (2021), 107216.

Ahmed

, A brief review: Security issues in cloud computing and their solutions, Telkomnika 17(6) (2019).

10.

Mell

and Grance

, The NIST definition of cloud computing, 2011.

11.

Alnajdi

Dogan

and Al-Qahtani

, A survey on resource allocation in cloud computing, International Journal on Cloud Computing: Services and Architecture (IJCCSA) 6(5) (2016).

12.

Logesswari

Jayanthi

KalaiSelvi

Muthusundari

and Aswin

, A study on cloud computing challenges and its mitigations, Materials Today: Proceedings, 2020.

13.

Suryateja

P.S.

, Threats and vulnerabilities of cloud computing: A review, International Journal of Computer Sciences and Engineering 6(3) (2018), 297–302.

14.

Ahmad

A.A.S.

and Andras

, Scalability analysis comparisons of cloud-based software services, Journal of Cloud Computing 8(1) (2019), 1–17.

15.

Jain

and Choudhary

, Overview of virtualization in cloud computing, in: The Proceedings of 2016 Symposium on Colossal Data Analysis and Networking (CDAN), IEEE, 2016, pp. 1–4.

16.

Afzal

and Kavitha

, Load balancing in cloud computing – A hierarchical taxonomical classification, Journal of Cloud Computing 8(1) (2019), 1–24.

17.

Rameshan

Liu

Navarro

and Vlassov

, Hubbub-Scale: Towards Reliable Elastic Scaling under Multi-Tenancy, in: Proceedings of IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing (CCGrid), 2016, pp. 233–244.

18.

Heinze

Aniello

Querzoni

and Jerzak

, Tutorial: Cloud-based Data Stream Processing, in: Proceedings of the 8th ACM International Conference on Distributed Event-Based Systems, 2014, pp. 238–245.

19.

Wang

Xia

Sun

and Cheng

, Research on Microservice Application Performance Monitoring Framework and Elastic Scaling Mode, in: Proceedings of Journal of Physics: Conference Series, Vol. 1617(1), 2020, p. 012048.

20.

Yazdanov

and Fetzer

, Vertical scaling for prioritized VMs provisioning, in: Proceedings of Second International Conference on Cloud and Green Computing, 2012, pp. 18–125.

21.

Heinze

Roediger

Meister

Jerzak

and Fetzer

, Online Parameter Optimization for Elastic Data Stream Processing, in: Proceedings of the Sixth ACM Symposium on Cloud Computing, 2015, pp. 276–287.

22.

Wang

and Zhang

, Cloud computing resource elasticity scaling method based on neural network time series prediction, in: Proceedings of Journal of Physics: Conference Series, Vol. 1650(3), 2020, p. 032125.

23.

Wang

and Qi

, Load Prediction-based Automatic Scaling Cloud Computing, in: Proceedings of International Conference on Networking and Network Applications (NaNA), 2016, pp. 330–335.

24.

Heinze

Pappalardo

Jerzak

and FetzerAuto-scaling

, Techniques for Elastic Data Stream Processing, in: Proceedings of IEEE 30th International Conference on Data Engineering Workshops, 2014, pp. 296–302.

25.

Verma

and Bala

, Auto-scaling techniques for IoT-based cloud applications: A review, Cluster Computing 24(3) (2021), 2425–2459.

26.

Naik

M.K.

Panda

Wunnava

Jena

and Abraham

, A leader Harris hawks optimization for 2-D Masi entropy-based multilevel image thresholding, Multimedia Tools and Applications 80(28) (2021), 35543–35583.

27.

Hashim

F.A.

Houssein

E.H.

Hussain

Mabrouk

M.S.

and Al-Atabany

, Honey badger algorithm: New metaheuristic algorithm for solving optimization problems, Mathematics and Computers in Simulation 192 (2022), 84–110.

28.

Yang

Liu

Shang

Mao

and ChenWorkload

, predicting-based automatic scaling in service clouds, in: The Proceedings of 2013 IEEE Sixth International Conference on Cloud Computing, IEEE, June 2013, pp. 810–815.

Optimization enabled elastic scaling in cloud based on predicted load for resource management

Abstract

Keywords

1. Introduction

2. Literature review

3. System model of cloud

4.1 Incoming task

4.3.1 Horizontal scaling

4.3.1.1. Solution encoding

4.3.1.2. Fitness function

4.3.1.3. Devised leader Harris honey badger algorithm

Step 1) Initialize the position vectors of hawks

Step 2) Evaluation of fitness

Step 3) Exploration phase ( | E ⁢ n | > 1 )

Step 4) Exploitation phase ( | E ⁢ n | < 1 )

i) Soft besiege

ii) Hard besiege

iii) Soft besiege with progressive rapid dives

iv) Hard besiege with progressive rapid dives

Step 5) Leader-based mutation-selection

Step 6) Re-evaluate fitness

Step 7) Terminate

4.3.2.1. Solution encoding

4.3.2.2. Fitness function

4.3.2.3. Devised leader Harris honey badger algorithm for vertical scaling

5.1 Evaluation measures

5.1.1 Predicted load error

5.2.1 Comparative assessment with task size as 100

6. Discussion

Table 1 Metrics discussion for various task sizes

Footnotes

Author’s Bios

References

Step 3) Exploration phase ( $|{En}|>1$ )

Step 4) Exploitation phase ( $|{En}|<1$ )

Table 1
Metrics discussion for various task sizes