 Research
 Open Access
 Published:
Task grouping and optimized deep learning based VM sizing for hosting containers as a service
Journal of Cloud Computing volume 12, Article number: 65 (2023)
Abstract
Containers as a service (CaaS) are a kind of services that permits the organization to handle the containers more effectively. Containers are lightweight, require less computing resources, portable, and facilitate better support for microservices. In the CaaS model, containers are deployed in virtual machines, and the virtual machine runs on the physical machine. The objective of this paper is to estimate the resource required by a VM to execute a number of containers. VM sizing is a directorial process where the system administrators have to optimize the allocated resources within the permitted virtualized space. In this work, the VM sizing is carried out using the Deep Convolutional Long Short Term Memory Network (DeepConvLSTM), where the weights are updated by Fractional Pelican Optimization (FPO) Algorithm. Here, the FPO is configured by hybridizing the concept of Fractional Calculus (FC) within the updated location of the Pelican Optimization Algorithm (POA). Moreover, the task grouping is done with Deep Embedded Clustering (DEC), where the grouping is established with respect to the various task parameters, such as task length, submission rate, scheduling class, priority, resource usage, task latency, and Task Rejection Rate (TRR). In addition, the performance analysis of VM sizing is done by taking 100, 200, 300, and 400 tasks. We got the best resource utilization of 0.104 with 300 tasks, a response time of 262ms with 100 tasks, and a TRR of 0.156 with 100 tasks and makespan of 0.5788 with 100 tasks.
Introduction
With the progressive development in Information Technology (IT), a new substitute has emerged in the form of cloud computing for the conventional computing methods to provide services to clients without any constraint on location or time, thereby enabling access to a pool of distributed computing resources to the users [1, 2]. Cloud computing provides various benefits in terms of reducing operational expenses and funds. It develops an environment based on networks that allow the distribution of resources and computations irrespective of the user’s location [3]. Recently, several firms are migrating to cloud computing applications due to the high efficiency, Quality of Service (QoS), accessibility, and reduced cost. Moreover, the pool of resources offers high scalability and flexibility because of the dispersed nature of storage and computational resources [4].
Services in the cloud are provided based on three service models such Infrastructure as a Service (IaaS), Platform as a Service (PaaS), and Software as a Service(SaaS). In the IaaS service model, web portals and the Application Program Interface (API) provide the hardware necessary for storage and computation. The PaaS is a platformoriented model where applicationoriented services, like database services and scripting environments, are provided, and the SaaS offers appbased services [5]. In addition to the three classical models mentioned above, a new model known as Container as a Service (CaaS) has been devised, making cloud computing more powerful and efficient in terms of resource utilization. Virtualization using container have gained high acceptance due to the lightweight solution offered, which permits the bunching of data and applications in a simple and performancedirected way that makes them suitable to be executed on various cloud frameworks [6]. A CaaS model comprises containers that are packed with applications. The Virtual Machines (VMs) run the containers, and each VM is hosted in Physical Machines (PMs) [7]. CaaS model lies in between the IaaS and PaaS [8]. Container refers to the virtualization technology operated at the system level, which can be positioned on PMs or VMs. The prime purpose of using CaaS is to provide an isolated atmosphere for the application execution. The container can share Operating System (OS) kernel compared to a VM, which requires all the resources available in the OS. Hence, it is a lightweight model requiring minimum time and resources [8, 9].
The inefficient utilization of resources can occur when more resources are allocated than necessary. These results in a workload executed by many PMs than that required [10]. The consumption of energy in CaaS can be reduced by considering the Dynamic Voltage and Frequency Scaling (DVFS), VM consolidation, or both. But the efforts would be meaningless without considering the customization of the VM sizes to enhance support of the deployed containers [8]. VM sizing can be defined as the measure of the total quantity of resources that have to be assigned to a VM. VM sizing is done with the objective of ensuring that the VM capacity is proportionate to the workload assigned to a VM [11]. The number of resources required by a VM wills be estimated by the Cloud Service Provider (CSP), which collects and analyses data associated with the VM. The CSP considers the applications that are executed in a VM as a black box [10]. Recently, Deep learning (DL) techniques using Recursive Neural Networks (RNN), Convolutional Neural Networks (CNN), etc., have a high ability to detect hidden information from the training data, and this can be utilized to analyze the data using black box approach [12].
The major aim of this research is the modeling of a VM sizing scheme with task grouping. Here, the VM sizing is done using DeepConvLSTM, where its weight is trained with an invented FPO algorithm. Moreover, the FPO algorithm is modeled by applying the FC concept in the updated POA location. Furthermore, the task grouping is carried out using DEC, which is done based on the task parameters, such as task length, submission rate, scheduling class, priority, resource usage, task latency, and task rejection rate. In the VM sizing, horizontal and vertical sizing are applied to each task group. The significant contributions of this research are:

FPO assisted DeepConvLSTM for VM sizing: The VM sizing is carried out using DeepConvLSTM, which is trained with the invented FPO algorithm. Here, the devised FPO algorithm is modeled by including the concept of FC with the updated condition of POA such that the optimal location is updated. Thereby better prediction performance is attained.

The proposed approach is validated with Google’s cluster trace data set, which indicates that it outperforms the other techniques, such as VM size selection technique, Hurst exponent +Markov transition based VM scaling, InterCloud Load Balancer (ICLB), VM size IaaS multitenant public cloud [6], Online MultiResource Feedforward Neural Network (OMFNN), DeepConvLSTM_Gradient Descendant (GD), and DeepConvLSTM ADAM for virtual machine sizing in CaaS cloud.
The rest of the paper is structured as follows; Section “Literature survey and motivation” portrays the literature survey of VM sizing techniques in the cloud, the cloud system model is explained in Section “System model”, Section “Proposed task grouping and optimized deep learning based VM sizing for hosting CaaS” indicates the proposed methodology for hosting CaaS, and Section “Results and discussion” portrays the results and discussion of devised model. Section “Discussion” presents the numerical results and finally in Section “Conclusion”, we conclude the paper with some future directions.
Literature survey and motivation
Literature survey
The challenges of conventional VM sizing techniques in the cloud are explained below. In [8], Piraghaj, S.F. et al., modeled the VM size selection technique for performing the VM sizing. The method achieved minimal energy utilization by decreasing the wastage of resources. However, it failed to reflect on predicting workload for estimating the actual container utilization. Lu, C.T. et al., [13] introduced the Hurst exponent and Markov transitionbased VM scaling based on empirical cloud information to reflect the predicting overload. Moreover, this approach successfully enhanced the host availability by increasing the usage of inactive resources. Though, it was unsuccessful in aggregating more data to enhance the strengthening of the transition matrix to improve accuracy. To progress the accuracy, Sotiriadis S. et al. [14] modeled the InterCloud Load Balancer (ICLB) for configuring the VM. Here, the devised scheme successfully eradicates the downtime without affecting the flow of information. However, it failed to tune the method for defining thresholds based on realtime data utilization. Guo, Y. et al. [15] modeled the Shadow algorithm for performing the VM autoscaling for devising the VM scaling scheme based on realtime data utilization. This method attained high scalability, which enabled the handling of a larger cloud, but it did not find any ways to scale the resources to minimize the count of teardowns and VM boots. To diminish the teardown and VM boots count, Alsadie D., et al. [16] designed the Dynamic Resource Allocation to minimize the energy usage in cloud computing. This method successfully minimized the energy utilization in cloud data centers. However, it produced a high overhead with the increased number of VMs. To diminish the computational overhead, Derdus, K.M. et al., [17] introduced the VM rightsizing IaaS multitenant public cloud for sizing the VM in cloud data centers. This method efficiently reduced the operating costs required by the CSP. However, it failed to use a VM allocation algorithm for estimating the peak resources needed before allocating them. To estimate the peak resources, Kenga, D.M. et al., [10] designed the VM sizing in IaaS multitenant public cloud for performing the VM sizing and predicting the resource usage. This method effectively predicted the resource utilization for multitenant IaaS cloud, but it was unsuccessful in seeing the deep learning approaches and various other cloud infrastructures to improve the performance. For attaining a superior outcome based on a deep learning scheme, Saxena, D. and Singh, A.K., [18] invented the Online MultiResource Feedforward Neural Network (OMFNN) for performing the autoscaling and VM allocation in the cloud data center. It instantaneously estimated numerous resource usage in reduced space and time complexity. Though, the developed approach failed to minimize the percentage of power saved with the rise in data center size.
Sareh Fotuhi Piraghaj, in her research [19], emphasizes different resource management strategies in the CaaS cloud system. She has used a clusteringbased approach for task grouping and a virtual machine sizing technique for efficient resource utilization in CaaS. Jialei Liu et al. [20] explore the cloud resource utilization using container consolidation. The proposed approach considers usage prediction to achieve the objective, such as reducing the number of running virtual machines, migrating containers, and reducing energy consumption while satisfying SLA. Vasiliki Liagkou et al. [21] presented a CaaS model where container clustering is done and deployed in a virtual machine. They proposed a hedonic model for pricing that analyzes the provider’s price and the correlation between different requirements. Weiwen Zhang et al. [22] try to improve resource utilization in the CaaS cloud by achieving load balancing and minimizing migration. They have investigated container migration and placement techniques for developing the constrained optimization problem. The proposed BACP algorithm for placement and ATCM algorithm for migration solve the optimization problem. An optimal container migration model has been presented in [23] by considering latency, downtime, and dependencies in the edge cloud environment. Table 1 present the detailed review on VM sizing techniques.
Motivation
VM sizing is a method to optimize the allocation of resources within the allotted spaces. Efficient VM sizing plays an important role in improving the overall performance of a CaaS cloud system. Generally, a physical machine consumes more resources than a virtual machine. To increase the overall system performance and resource utilization, containers with the packed application need to be placed in a virtual machine that requires fewer resources than a physical machine [7]. Hence, it is essential to allocate resources for a VM so that the container is executed without any wastage of resources. The ability to run multiple operating systems (OS) at the same time while utilizing different components of the hardware is the primary advantage of using virtual machines (VM). However, in the absence of virtual machines (VM), processing several operating systems would require separate physical units. In addition, the virtual machine has a low overhead, the ability to scale, and a high degree of flexibility and is used for disaster recovery. Considering all of these benefits motivates us to model the research in virtual machine sizing that is being implemented in CaaS cloud systems.
Research challenges
The different challenges encountered by the prevailing techniques of VM sizing are listed below.

The rejection rate was increased due to the lack of correlation analysis while placing the VM.

The accurate estimation of the resources required by the VMs was difficult due to the failure in the memory and network activity.

The ICLB system did not consider the exploration of past resource utilization by the VM to forecast the resource usage in adapting the placement algorithms.

The OMFNN was unsuccessful in scheduling the predicted tasks on VMs when making decisions about the management of resources.

In some methods, defining an optimum setting is a major challenge due to the different usage of resources.
System model
Consider the CaaS cloud model shown in Fig. 1, with u number of PMs is represented as \(B=\{B_1, B_2, .., B_v, ..,B_u\}\). Here, each PM is comprises of a set of VMs, and is represented as V. The \(u^{th}\) PM \(B_u\) contains x number of VM, and is represented as \(V=\{V_1, V_2, .., V_w, .., V_x\}\). Moreover, each PM contains distinct containers, and is indicated as L, where \(L=\{L_1, L_2, .., L_s, .., L_t\}\). Moreover, the task executes in \(s^{th}\) container is represented as \(U= \{U_1, U_2, .., U_s, .., U_z\}\), where z specifies the overall task count.
CaaS cloud model
The CaaS cloud model is presented in Fig. 2, where host OS present on top of the infrastructure, and the hypervisor is running in host OS. There are multiple VMs hosted in a single host machine and more than one containers can be deployed in a single virtual machine. All virtual machines are completely isolated from each other but containers in a particular VM shares same operating system [24, 25].
Proposed task grouping and optimized deep learning based VM sizing for hosting CaaS
Cloud computing is a novel archetype that provides access to services and resources available on the internet over distributed platforms. The main objective of this work is to implement an efficient VM sizing technique based on Task grouping and optimized deep learning for hosting CaaS [8]. The method is implemented using the following steps. Initially, the incoming task is acquired from the dataset. Once the incoming tasks are acquired, tasks are grouped using the Deep Embedding clustering (DEC) algorithm [26], based on the task parameters, such as task length, submission rate, scheduling class, priority, resource usage, and task latency, and task rejection rate. The task groups thus formed are denoted by G1, G2, and G3. After task grouping, VM sizing is established by using the Deep Convolutional LSTM Network (DeepConvLSTM) [27, 28] based on the task parameters of the groups. The DeepConvLSTM is tuned with the introduced Fractional Pelican Optimization (FPO) Algorithm. The introduced FPO algorithm is developed by modifying the Pelican Optimization Algorithm (POA) [29] in accordance with the Fractional calculus (FC) [30]. Once the VM requirement is determined, horizontal and vertical sizing of the VM is performed, where horizontal sizing refers to the number of containers and vertical sizing denotes the number of CPUs required. Finally, the scaling setup is reconfigured. Figure 3, depicts the schematic representation of the developed VM sizing technique based on Task grouping and optimized deep learning for hosting CaaS.
Incoming tasks
The number of incoming task to the system is mathematically derived as,
where, G indicates the total number of incoming tasks. Here, the incoming task G is given to the input of task grouping.
Task grouping using DEC
The incoming task is directed to the task grouping process in the task grouping. Here, the processing is carried out using DEC, where the grouping is done based on certain task parameters, such as task length, submission rate, scheduling class, priority, resource usage, task latency, and task rejection rate. In this research, the task grouping process groups the entire incoming task into three groups, such as \(D_1\), \(D_2\), and \(D_3\), based on the task parameters. The explanation for DEC is explained in the coming subsection.
Deep embedded clustering
DEC [26] comprises two phases, such as pretraining and clustering process for performing the task grouping. The pretraining process is performed to train the low dimensional embedded illustrations through the autoencoder. The second phase is the clustering phase where the decoder is initially discarded and then the encoder is trained to optimize the joining of embedded illustration as well as clustering centers. For each iteration, the soft clustering assignment \(b_{mh}\) is calculated with respect to the student’s tdistribution. Here, \(b_{mh}\) shows the assessment amongst embedded data point \(p_m\) and centre \(\alpha _h\) . Let us assume the cluster centre as \(\{\alpha _1, \alpha _2, ..., \alpha _n\}\), latent feature as p , then the student’s tdistribution computes the similarity amongst cluster centre \(\alpha _h\) and data points \(p_m\), which is expressed as,
where, Student’s tdistribution freedom degree is indicated as 1. The probability of allocating data points \(p_m\) to cluster \(\alpha _h\) is indicated as \(b_{mh}\), \(argmax_hb_{mh}\) is represented as assigned cluster. Moreover, the clustering algorithm continually modifies the clusters based on the learning of high confidence assignments. To learn from the assignment of high confidence, an auxiliary target distribution \(a_{mh}\) is denoted as,
Moreover, the KLdivergence among \(b_{mh}\) and \(a_{mh}\) learns the higher confidence soft cluster assignment, then the clustering loss is portrayed as,
where, the cluster center is indicated as m, n specifies the cluster count, \(d_h\) and \(d_n\) specifies the soft cluster frequencies. Moreover, the task grouping is done by considering several task parameters, such as task length, submission rate, scheduling class, priority, resource usage, task latency and task rejection rate, which are explained as below.
Task parameters
The task parameters used for performing the task grouping based on DEC is explained in this section. Thus, the task parameters are task length, submission rate, scheduling class, priority, resource usage, task latency, and task rejection rate, which are given below.
Task Length: Task length is the time taken for executing the task in a machine, which is represented as \(T_l\).
Submission Rate: Submission rate is defined as how much times the task have been submitted to the data center. The submission rate is indicated as \(S_r\).
Scheduling Class: The sensitive to latency is referred to as task/job. Here, the scheduling class is indicated by an integer among 0 and 3. The scheduling class ‘0’ depicts the nonproduction task. The higher scheduling class is the greatest latency sensitive task. Moreover, the scheduling class is indicated as \(S_c\).
Priority: The priority of task is decided based on the importance of task. The maximum preference is given to the higher priority task when compared with low priority task. Moreover, the priority is an integer, which lies among 0 to 10, and is portrayed as P.
Resource usage: The average resource usage \(R_U\) of task is derived based on memory, CPU and disk during the observed time, which is indicated as,
where, c indicates the task usage count in observable period. The resource usage is depicted as \(R_U\).
Task latency: Task latency is the proportion of overall waiting time of task to the total task count, which is derived as,
where, \(W_t\) depicts the overall waiting time of task and \(n_t\) denotes the overall task count. Then, the task latency is depicted as \(T_l\).
Task Rejection Rate (TRR): It describes the ratio of rejected task since they cannot be ordered within the time limit [31], which is described as,
where, \(r_t\) signifies the failure task count and \(n_t\) denotes the overall task. Moreover, the TRR is specified as \(T_r\).
Furthermore, the task grouping is done based on the used task parameters, which is given by,
Based on the task parameters, the task grouping is done based on DEC. Once the grouping is done, then the partitioned task groups are indicated as \(D_1\), \(D_2\), and \(D_3\). After the completion of task grouping, then the VM sizing is done with DeepConvLSTM based on the task parameters. Here, the evaluated task parameters are used to determine the amount of task for configuring the virtual machines.
VM sizing using DeepConvLSTM
VM sizing is a method that computes the resource allocation for VM within a physical machine. The resources include CPU, memory allocation and so on. This section explains the process of VM sizing using DeepConvLSTM by considering the task parameters as input. In task grouping, the task groups, such as \(D_1\), \(D_2\), and \(D_3\) are obtained based on the task parameters, and is processed under the horizontal sizing and vertical sizing using DeepConvLSTM in order to obtain the quantity of container and quantity of CPU size. Moreover, in each group, VM sizing is done using DeepConvLSTM based on the group parameters. Figure 4 shows the process of VM sizing using DeepConvLSTM.
From Fig. 3, in VM sizing, the horizontal and vertical sizing is applies on each groups. Here, the horizontal sizing is carried out to predict the number of containers, whereas the vertical sizing is performed to predict the number of CPU size. Moreover, the architecture of DeepConvLSTM is explained in the below section.
Structure of DeepConvLSTM
The DeepConvLSTM [27, 28] is comprised of the combination of recurrent layers of LSTM and convolutional layers. The DeepConvLSTM is designed to train the representation of sparse features for modeling the temporal dependencies among every activation of feature illustration. Here, the convolutional layer behaves as a feature extractor in representing the extracted feature into feature maps. Likewise, the recurrent layer is employed to model the temporal dynamics of mapped features. The structure of DeepConvLSTM is given in Fig. 5. In DeepConvLSTM, the convolution layer does not perform the pooling operation. Here, the group parameters are subjected to the input layer that contains the convolutional layer, which excavates the spatial illustration of input parameters. Here, the convolutional layer computes properly only when the kernel and input fully overlap. Thus, the feature map length is computed by,
where, \(W^c\) signifies the kernel length in layer c . The conv layers utilizes the rectified linear units (ReLUs) to calculate the feature maps, whose nonlinear function is portrayed as,
where, \(y_f^i(\lambda )\) designates the feature map in layer 1, \(\chi\) be the nonlinear function, \(Q^i\) specifies the feature map count, \(W^i\) denotes the kernel length, \(e^i\) be the bias vector. Thus, the output produced by the DeepConvLSTM is predicted container by performing the horizontal sizing and CPU size by performing the vertical sizing. Moreover, the outcome of DeepConvLSTM is indicated as \(G_k\).
Training of DeepConvLSTM using devised FPO
This section portrays the training process of DeepConvLSTM using devised FPO. Here, the newly invented FPO is the integration of FC [30] and POA [29]. POA is a swarmbased optimization approach that mimics the hunting tactics of Pelicans. The pelican has long beak along with its throat, which is used to intake the prey. The pelicans like to live in a group, and they prefer to eat fishes, turtles, frogs and sea foods. While hunting, the pelicans work together for catching the food. Moreover, the pelicans search their food at various locations. In addition, the pelicans dive from at a distance of 10 to 20m after recognizing the location of prey in order to catch the fish. In some cases, the prey may descent from it, and then they spread their wings at the posterior of water to pull the fish so that they can get the food easily. Furthermore, excess amount of water inhales into the beak bag while catching the food, and then the excess water can be drained by extending their neck outward before swallowing the food. This strategy is used for the POA, which provides the better optimization outcome, but the convergence rate of this scheme was low. The FC is the generalization of the integer order calculus (IOC), which useful in solving complex or real order problems. Engineers are interested in the Laplace and Fourier classical transforms, which are useful for solving FC differential equations as well as for simplifying procedures like convolution. The FC is integrated with optimization algorithms for effective performance. In order to improve the convergence rate and effective computation, the theory of FC is applied on the exploration behavior of POA such that the better outcome is attained. Thus, the devised FPO acquired the better convergence rate, less computational complexity and high processing speed. Thus, the algorithmic processes of invented FPO algorithm are explained as below.

1
Initialization In POA [29], the pelicans are considered as members of population, which are initialized in the initialization step. Moreover, each member in the population is considered as a candidate solution. Here, the population members are arbitrarily initialized based on the lower and upper bound issues, which is given by,
$$\begin{aligned} d_{k, l}=w_l + M(r_l  w_l), \;\;\;\;\;\;\;\; k = 1, 2, ...,Z \;\;\;\;\;\;\;\; l = 1, 2, ...,\chi \end{aligned}$$(11)where, \(d_{k,l}\) specifies the \(l^{th}\) variable value represented by \(k^{th}\) candidate solution, Z specifies the population member count, \(\chi\) specifies the problem variable count, M indicates the random variable, \(w_i\) specifies the \(l^{th}\) lower bound, and \(r_l\) indicates the \(l^{th}\) upper bound.

2
Fitness Computation The importance of fitness computation is to predict the optimal solution. In this research, the number of containers and CPU size is predicted using DeepConvLSTM, which is trained by FPO in order to attain the optimal outcome. Moreover, the optimal outcome is attained based on the fitness function using Mean squared Error (MSE). In addition, the least value of MSE is considered as an optimal solution, and is portrayed as,
$$\begin{aligned} B_j = \frac{1}{j}\sum \limits _{k=1}^{j}\left[ G_k^*  G_k\right] ^2 \end{aligned}$$(12)where, j specifies the overall sample count, \(G_k\) specifies the predicted outcome of DeepConvLSTM and \(G_k^*\) indicates the expected outcome. In addition, the hunting tactics of pelicans includes exploration as well as exploitation phase. In the exploration phase, the pelicans are moving towards the prey, whereas in the exploitation phase, the pelicans are flying on the surface of water.

3
Exploration Phase In this step, the pelicans are searching the food by scanning the water surface, and then it moves nearer to the food after finding the prey location. In POA, the prey location is created arbitrarily in the search space, which progresses the exploration rate of optimization algorithm. Then, the mathematical derivation for moving the prey towards the food source is given by,
$$\begin{aligned} d_{k,l}^{p1} = \left\{ \begin{array}{ll} d_{k,l} (o)+M\left( J_l  N.d_{k,l}(o)\right) , &{} B_j < B_k\\ d_{k,l} (o)+M.\left( d_{k,l}(o)  J_l\right) , &{} \text {otherwise}. \end{array}\right. \end{aligned}$$(13)where, \(d_{k,l}^{p1}\) specifies the new position of \(k^{th}\) pelican in \(l^{th}\) dimension in phase 1, N indicates the random integer, \(J_l\) be the prey position in \(l^{th}\) dimension and \(B_j\) specifies the objective function. In this research, condition (1) from equation (13) is considered for finding the optimal location, which is given below. When \(B_j < B_k\), then the updated expression becomes,
$$\begin{aligned} d_{k,l}(o+1)= & {} d_{k,l}(o) + M\left( J_l  N.d_{k,l}(o)\right) \nonumber \\= & {} d_{k,l}(o) + M.J_l  M.N.d_{k,l}(o)\\= & {} d_{k,l}(o)\left( 1M.N\right) + M.J_l \nonumber \end{aligned}$$(14)Subtract \(d_{k,l}(o)\) on both sides,
$$\begin{aligned} d_{k,l}(o+1)  d_{k,l}(o) = d_{k,l}(o)\left( 1M.N\right) + M.J_l  d_{k,l}(o) \end{aligned}$$(15)In order to upsurge the prediction performance of devised scheme, the concept of FC is applied on the updated location of POA. From FC,
$$\begin{aligned} R^\varepsilon \left[ d_{k,l}(o+1)\right] = d_{k,l}(o)\left( 1M.N1\right) + M.J_l \end{aligned}$$(16)$$\begin{aligned} d_{k,l}(o+1)\varepsilon .d_{k,l}(o)\frac{1}{2}d_{k,l}(o1)\frac{1}{6}(1\varepsilon )d_{k,l}(o2)\frac{1}{24}\varepsilon (1\varepsilon )(2\varepsilon )d_{k,l}(o3) = d_{k,l}(o)\left( M.N\right) + M.J_l \end{aligned}$$(17)$$\begin{aligned} d_{k,l}(o+1)= d_{k,l}(o)\left( M.N\right) +M.J_l+\varepsilon .d_{k,l}(o)+\frac{1}{2}d_{k,l}(o1)+\frac{1}{6}(1\varepsilon )d_{k,l}(o2)+\frac{1}{24}\varepsilon (1\varepsilon )(2\varepsilon )d_{k,l}(o3) \end{aligned}$$(18)where, \(d_{k,l}(o+1)\) depicts the location of \(k^{th}\) solution in \(l^{th}\) dimension at iteration \(0+1\), \(d_{k,l}(o1)\) depicts the location of \(k^{th}\) solution in \(l^{th}\) dimension at iteration \(o1\), \(d_{k,l}(o2)\) depicts the location of \(k^{th}\) solution in \(l^{th}\) dimension at iteration \(o2\) , \(d_{k,l}(o3)\) depicts the location of \(k^{th}\) solution in \(l^{th}\) dimension at iteration \(o3\), \(J_l\) denotes the position of prey in \(l^{th}\) dimension, M signifies the random variable and N indicates the parameter, which is equal to 1 or 2.

4
Exploitation Phase In this step, the pelicans spread their wings when it comes nearer to the surface of water such that the fish move upwards, then the pelicans gathered their food in the mouth. In this tactic, large amount of food is gotten by the pelicans. Then, the hunting aspects of pelicans are referred to as,
$$\begin{aligned} d_{k,l}^{p2}\left( o+1\right) = d_{k,j}\left( o\right) + E.\left( 1\frac{a}{T}\right) .\left( 2.M1\right) .d_{k,l}\left( o\right) \end{aligned}$$(19)where, \(d_{k,l}^{p2}\) signifies the new location of \(k^{th}\) pelican in \(l^{th}\) dimension in phase 2, T indicates the maximum iteration count, a specifies the iteration counter and \(\left( 1\frac{a}{T}\right)\) depicts the nearest radius of \(d_{k,l}\). Moreover, the effective updated solution is utilized to remove or accept the new position of pelicans, and is articulated as,
$$\begin{aligned} D_{k} = \left\{ \begin{array}{ll} D_{k}^{p2}, &{} B_k^{p2} < B_k\\ D_{k}, &{} \text {otherwise}. \end{array}\right. \end{aligned}$$(20)where, \(D_{k}^{p2}\) shows the new location of \(k^{th}\) pelican, and \(B_k^{p2}\) indicates the objective function of phase 2.

5
Reevaluation of Feasibility Here, the feasibility is evaluated based on the fitness function. The fitness function is computed for all iteration. If the predicted fitness is better than the previous one, then the devised FPO replaces the older solution with newer one such that the optimal location is updated at all iteration.

6
Termination The steps from (i) to (v) is repeated till the optimal solution is attained. Moreover, the pseudocode of invented FPO algorithm is explained in Algorithm 1. Here, the optimal predicted solution is attained using DeepConvLSTMbased FPO, where the FPO is configured by the joining of POA and FC, such that the better solution is acquired.
Scaling setup and reconfigure
After the completion of VM sizing, then the scaling setup and reconfiguration process is initialized based on the number of containers and number of CPU size such that the overall system is reconfigured.
Results and discussion
The results and discussion of devised DeepConvLSTM_FPO is deliberated in this section. Moreover, the utilized dataset, metrics and implementation tool is explained in this section.
The devised DeepConvLSTM_FPO scheme is implemented in Java with CloudSim tool having PC with Windows 10 OS and intel i3 core processor. The dataset used for the DeepConvLSTM_FPO scheme is Google trace dataset [32]. The Google trace dataset contains various fields, such as job ID, task index, cache memory usage, machine ID, average CPU usage rate, maximum CPU usage and so on. The performance metrics used for devised task grouping and VM sizing are task capacity, task rejection rate, and resource utilization. Response time is the time taken to give the first response.
Performance analysis
The performance of the devised DeepConvLSTM_FPO is evaluated with various population sizes by varying the iteration, and the results are discussed in this section. Here, the evaluation is carried out by adjusting the task sizes, such as 100, 200, 300, and 400.
Performance assessment based on task size 100
Table 2 shows the performance analysis of the DeepConvLSTM_FPO scheme based on the resource utilization, response time, TRR, and Makespan using the task size as 100. Here, the analysis is done based on varying the iterations as 5, 10, 15, and 20, and the performance is maximum at iteration=20. The FPO is configured by combining POA and FC to achieve better performance.
Performance assessment based on task size 200
The performance analysis of the DeepConvLSTM_FPO scheme based on the resource utilization, response time, TRR, and makespan using the task size of 200 is shown in Table 3. The iteration considered for the evaluation is 5, 10, 15, and 20, and the proposed model’s population size is 5, 10, 15, and 20. The performance of the DeepConvLSTM_FPO scheme is improved when increasing the number of iterations.
Performance assessment based on task size 300
Table 4 presents the analysis of the DeepConvLSTM_FPO scheme based on resource utilization, response time, TRR, and makespan using task size 300. Considering the task size 300, the maximum performance offered by the DeepConvLSTM_FPO is 0.0936 for resource utilization, 472 ms for response time, 0.3088 for Task Rejection Rate, and 0.6368 for makespan.
Performance assessment based on task size 400
The analysis of the DeepConvLSTM_FPO scheme based on the resource utilization, response time, TRR, and makespan using the task size 400 is depicted in Table 5. From this table, it is clear that the proposed DeepConvLSTM_FPO offers maximum results when considering the iteration is 20 and the population size is 20.
Comparative methods
The various traditional techniques used for comparing the performance of DeepConvLSTM_FPO scheme are VM size selection technique [8], Hurst exponent +Markov transition based VM scaling [13], ICLB [14], VM size IaaS multitenant public cloud [17], OMFNN [18], DeepConvLSTM GD, and DeepConvLSTM ADAM.
Comparative analysis
The comparison of DeepConvLSTM_FPO scheme with existing methods is analyzed by adjusting the task sizes, such as 100, 200, 300 and 400.
Comparative analysis based on task size 100
Table 6, shows the analysis of the DeepConvLSTM_FPO scheme based on the resource utilization, response time, TRR, and Makespan using the task size as 100. Here, the analysis is done based on varying the iterations as 5, 10, 15, and 20, and the maximum performance is observed with 20 iterations. The performance of the DeepConvLSTM_FPO acquired better outcomes because of the better convergence rate, less computational complexity, and high processing speed of the devised FPO.
Comparative analysis based on task size 200
The analysis of the DeepConvLSTM_FPO scheme based on the resource utilization, response time, TRR, and Makespan using the task size of 200 is shown in Table 7. The iteration considered for the evaluation is 5, 10, 15, and 20. The performance of all the models is improved when increasing the iterations, which the DeepConvLSTM_FPO attains maximum results than other conventional methods.
Comparative analysis based on task size 300
Table 8, presents the analysis of DeepConvLSTM_FPO scheme based on resource utilization, response time, TRR, and Makespan using the task size 300. Considering the task size 300, the maximum performance offered by the DeepConvLSTM_FPO is 0.1041 for resource utilization, 482ms for response time, and 0.3387 for Task Rejection Rate.
Comparative analysis based on task size 400
The analysis of the DeepConvLSTM_FPO scheme based on the resource utilization, response time, TRR, Makespan using the task size 400 is depicted in Table 9. From this table, it is clear that the proposed DeepConvLSTM_FPO offers maximum results than other existing methods, such as VM size selection technique, Hurst exponent+Markov transition , ICLB, OMFNN, VM size IaaS multitenant public cloud, DeepConvLSTM GD, and DeepConvLSTM ADAM.
Performance assessment based on makespan
We also compared the proposed method with all existing methods by considering makespan. Compared to existing approaches, the time it takes to complete a set of tasks utilizing the proposed DeepConvLSTM FPO is significantly shorter. The performance of the proposed model using makespan is shown in Fig. 6.
Discussion
Table 10 shows the comparative discussion of the proposed DeepConvLSTM_FPO for task grouping and VM sizing. Here, the proposed method is evaluated with four different task sizes, such as 100, 200, 300, and 400. Moreover, the assessment is done by considering different metrics, such as resource utilization, response time, and TRR. From Table 10, it is observed that the developed method attained better values than the comparative methods. In this research, the proposed scheme achieved better performance than other approaches due to the accuracy of task grouping. The grouping of tasks is done based on several effective task parameters, such as task length, submission rate, scheduling class, priority, resource usage, task latency, and TRR. An efficient VM sizing can increase resource utilization, reduce response time, and minimize TRR.
Threat to validity
Even though we made every effort to ensure that our experiment was carried out correctly, there is still a chance that it was flawed in a number of different ways. When interpreting or immediately applying the findings or conclusions presented in this study, future efforts should consider these limitations and account for them.
The extent to which inferences made about the discovered ideas are accurate is known as construct validity. One danger that fits into this category is that we tend to group multiple ideas under the umbrella of a single term. The problem of construct validity arises whenever insufficient measurement of the variables is employed. The construct of the experiment, its design, and its trustworthiness can threaten the results. A semantic mistake in the firewall policy or an incorrect packet delivery on the networks might negatively impact the results. To mitigate the impact of the threat, we decided to experiment with some guidelines that were actually released publicly.
The term “internal validity” describes the extent to which findings about the connection between examined resources and data gathered may be categorized as casual. The term “maturation”, which refers to a negative effect, such as tiredness, on participants while participating in an experiment, poses a threat to the study’s internal validity. During the execution of DeepConvLSTM, it was our responsibility to carry out operations that needed us to perform the same actions many more than once. For example, we had to cluster the data set into three groups and acquire the input data.
The extent to which conclusions that are only true on an internal level can be generalized is known as the study of external validity. The phrase “interaction of context and therapy” is a good illustration of this type of danger. The setting to which the results should be applied is not the same as our DeepConvLSTM uses. Hence the two settings cannot be compared. As a result, the community being addressed (cloud engineers, cloud customers, researchers, and cloud architects) has varying expertise compared to the field that the sources that were reviewed originated from. To protect ourselves against this danger, we have modified our search keywords to include the term “cloud computing,” expecting that this will make the search results better for the intended audience.
Conclusion
This paper devises the newly modeled task grouping and VM sizing approach, DeepConvLSTM FPO. Here, the devised FPO algorithm is modeled by incorporating FC with POA, which is used to train the weights of DeepConvLSTM by considering MSE as a fitness value. In this research, the VM sizing is carried out with DeepConvLSTM by applying it separately to each group obtained by the task grouping. Moreover, horizontal sizing and vertical sizing are applied to each group, where horizontal sizing is performed to predict the number of containers. In contrast, vertical sizing is performed to predict CPU sizes. The task grouping is done by DEC, which considers several task parameters, such as task length, submission rate, scheduling class, priority, resource usage, task latency, and TRR. Furthermore, the devised scheme reconfigures the entire system after completing the horizontal and vertical sizing. In addition, the performance of VM sizing is done based on the metrics such as utilization, response time, TRR, and makespan of 0.035, 262 ms, and 0.198, and 0.5788 correspondingly. In the future, the performance can be further enhanced by introducing an excess quantity of task parameters. Also, dynamic task scheduling will be considered in the further extension of the proposed method.
Availability of data and materials
We have used Google Traces Data sets which is publicly available and can be downloaded from, https://research.google/tools/datasets/googleclusterworkloadtraces2019/.
References
Kumar P, Kumar R (2019) Issues and challenges of load balancing techniques in cloud computing: A survey. ACM Comput Surv (CSUR) 51(6):1–35
Cloud H (2011) The nist definition of cloud computing, vol 800. National Institute of Science and Technology, Special Publication, pp 145
Subramanian N, Jeyaraj A (2018) Recent security challenges in cloud computing. Comput Electr Eng 71:28–42
Malomo O, Rawat DB, Garuba M (2018) A survey on recent advances in cloud computing security. J Next Gener Inf Technol 9(1):32–48
Hussein MK, Mousa MH, Alqarni MA (2019) A placement architecture for a container as a service (caas) in a cloud environment. J Cloud Comput 8(1):1–15
Boukadi K, Rekik M, Bernabe JB, Lloret J (2020) Container description ontology for caas. Int J Web Grid Serv 16(4):341–363
Zhang R, Chen Y, Zhang F, Tian F, Dong B (2020) Be good neighbors: A novel application isolation metric used to optimize the initial container placement in caas. IEEE Access 8:178195–178207
Piraghaj SF, Dastjerdi AV, Calheiros RN, Buyya R (2015) Efficient virtual machine sizing for hosting containers as a service (services 2015). In: 2015 IEEE World Congress on Services, IEEE, pp 31–38
Zhang R, Chen Y, Dong B, Tian F, Zheng Q (2019) A genetic algorithmbased energyefficient container placement strategy in caas. IEEE Access 7:121360–121373
Kenga DM, Omwenga VO, Ogao PJ (2019) Autonomous virtual machine sizing and resource usage prediction for efficient resource utilization in multitenant public cloud. Int J Inf Technol Comput Sci(IJITCS) 11(5):11–22
Meng X, Isci C, Kephart J, Zhang L, Bouillet E, Pendarakis D (2010) Efficient resource provisioning in compute clouds via vm multiplexing. In Proceedings of the 7th international conference on Autonomic computing, pp 11–20
Jahani A, Lattuada M, Ciavotta M, Ardagna D, Amaldi E, Zhang L (2019) Optimizing ondemand GPUs in the Cloud for Deep Learning Applications Training 2019, 4th International Conference on Computing, Communications and Security (ICCCS), Rome, pp 1–8. https://doi.org/10.1109/CCCS.2019.8888151
Lu CT, Chang CW, Li JS (2015) VM scaling based on Hurst exponent and Markov transition with empirical cloud data. J Syst Softw 99:199–207. https://doi.org/10.1016/j.jss.2014.10.011
Sotiriadis S, Bessis N, Amza C, Buyya R (2019) Elastic Load Balancing for Dynamic Virtual Machine Reconfiguration Based on Vertical and Horizontal Scaling, vol 12. In: IEEE Transactions on Services Computing, (no. 2), pp 319–334. https://doi.org/10.1109/TSC.2016.2634024
Guo Y, Stolyar AL, Walid A (2020) Online VM AutoScaling Algorithms for Application Hosting in a Cloud, vol 8. In: IEEE Transactions on Cloud Computing, (no. 3), pp 889–898. https://doi.org/10.1109/TCC.2018.2830793
Alsadie D, Tari Z, Alzahrani EJ, Zomaya AY (2018) Dynamic resource allocation for an energy efficient VM architecture for cloud computing. In: Proceedings of the Australasian Computer Science Week Multiconference (ACSW '18). Association for Computing Machinery, New York, Article 16, pp 1–8. https://doi.org/10.1145/3167918.3167952
Derdus K, Omwenga V, Ogao P (2019) Virtual machine sizing in virtualized public cloud data centres. Int J Sci Res Comput Sci Eng Inf Technol 5(4). https://doi.org/10.32628/CSEIT1953124
Saxena D, Singh AK (2021) A proactive autoscaling and energyefficient VM allocation framework using online multiresource neural network for cloud data center. Neurocomputing 426:248–264
Piraghaj SF (2016) Energyefficient management of resources in containerbased clouds. PhD thesis, Ph. D. dissertation, University of Melbourne, Australia
Liu J, Wang S, Zhou A, Xu J, Yang F (2020) Sladriven container consolidation with usage prediction for green cloud computing. Front Comput Sci 14(1):42–52
Liagkou V, Fragiadakis G, Filiopoulou E, Michalakelis C, Kamalakis T, Nikolaidou M (2022) A pricing model for containerasaservice, based on hedonic indices. Simul Model Pract Theory 115:102441
Zhang W, Chen L, Luo J, Liu J. A twostage container management in the cloud for optimizing the load balancing and migration cost. Future Generation Comput Syst 135(2022):303–314
Aleyadeh S, Moubayed A, Heidari P, Shami A (2022) Optimal container migration/reinstantiation in hybrid computing environments. IEEE Open J Commun Soc 3:15–30
Patel D, Patra MK, Sahoo B (2020) Gwo based task allocation for load balancing in containerized cloud. In: 2020 International Conference on Inventive Computation Technologies (ICICT), IEEE, pp 655–659
Patra MK, Patel D, Sahoo B, Turuk AK (2020) Game theoretic task allocation to reduce energy consumption in containerized cloud. In: 2020 10th International Conference on Cloud Computing, Data Science & Engineering (Confluence), IEEE, pp 427–432
Xie J, Girshick R, Farhadi A (2016) Unsupervised deep embedding for clustering analysis. In: International conference on machine learning, PMLR, pp 478–487
Ordóñez FJ, Roggen D (2016) Deep convolutional and lstm recurrent neural networks for multimodal wearable activity recognition. Sensors 16(1):115
Lim XY, Gan KB, Abd Aziz NA (2021) Deep convlstm network with dataset resampling for upper body activity recognition using minimal number of imu sensors. Appl Sci 11(8):3543
Trojovskỳ P, Dehghani M (2022) Pelican optimization algorithm: A novel natureinspired algorithm for engineering applications. Sensors 22(3):855
Bhaladhare PR, Jinwala DC (2014) A clustering approach for thediversity model in privacy preserving data mining using fractional calculusbacterial foraging optimization algorithm. Adv Comput Eng 2014:12
Marahatta A, Wang Y, Zhang F, Sangaiah AK, Tyagi SKS, Liu Z (2019) Energyaware faulttolerant dynamic task scheduling scheme for virtualized cloud data centers. Mob Netw Appl 24(3):1063–1077
Datasets GT (2019) Clusterdata 2019 traces. https://research.google/tools/datasets/googleclusterworkloadtraces2019/. Accessed 6/7/2022
Funding
No funding available.
Author information
Authors and Affiliations
Contributions
Manoj Kumar Patra: Conceptualization, Methodology, Writing Original draft preparation. Bibhudatta Sahoo: Data curation, Supervision. Ashok Kumar Turuk: Methodology, Supervision. Sanjay Misra: Investigation, Validation, Reviewing and finalising the paper. The author(s) read and approved the final manuscript.
Corresponding author
Ethics declarations
Ethics approval and consent to participate
Not applicable.
Competing interests
The authors declare no competing interests.
Additional information
Publisher’s Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Rights and permissions
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.
About this article
Cite this article
Patra, M.K., Sahoo, B., Turuk, A.K. et al. Task grouping and optimized deep learning based VM sizing for hosting containers as a service. J Cloud Comp 12, 65 (2023). https://doi.org/10.1186/s13677023004417
Received:
Accepted:
Published:
DOI: https://doi.org/10.1186/s13677023004417
Keywords
 Cloud computing
 Container as a service
 Long short term memory
 Pelican optimization algorithm
 Fractional calculus
 Deep embedded clustering
 Convolutional LSTM network