An extended container placement mechanism to enhance the efficiency of cloud systems

Introduction

The swift advancement of cloud computing has revolutionized resource management and application deployment, enabling dynamic scalability and enhanced cost efficiency (Buyya, Yeo & Venugopal, 2008). Recently, a wide range of cloud service providers utilize containerization technology (Pahl, 2015) instead of virtualization technology (Rosenblum & Garfinkel, 2005) to host a wide range of cloud applications (Alahmad, Daradkeh & Agarwal, 2018). Lightweight isolation platforms, such as Docker (Merkel, 2014) and LXC (Randal, 2020), have gained widespread adoption as they enable virtualization without the need to boot an entire virtual machine. Containers can typically launch within a few seconds leveraging a user-level engine (Ahmed et al., 2019).

Within Containers-as-a-Service (CaaS) environments, containerized applications have emerged as a popular choice due to their lightweight and portable nature (Bernstein, 2014). Containerized applications have emerged as a cornerstone of modern cloud and edge computing architectures due to their lightweight, portable, and efficient design. Unlike traditional virtualization styles that rely on full operating system virtualization, containers enable isolated execution environments while sharing the host kernel, resulting in reduced overhead and faster launch times (Pahl et al., 2019). This efficiency makes them highly suitable for microservices-based systems, which demand rapid scalability and dynamic resource management (Zhou, Zhou & Hoppe, 2023). Furthermore, the widespread adoption of container orchestration frameworks has significantly enhanced the deployment and management of containerized workloads, promoting resilience and high availability in distributed environments.

However, as containerized workloads grow in complexity and scale, ensuring efficient resource allocation and performance improvements while minimizing energy consumption has become a critical challenge. Effective container placement plays a vital role in dealing with these concerns by optimizing the placement of containers to physical machines (PMs). Container placement mechanisms can contribute in performance enhancement in various aspects in data centers such as minimizing operational costs, reducing energy consumption and/or improving resource utilization (Ahmad et al., 2022).

Containerized based applications can become complex as large number of isolated containers may be required in production which necessitates efficiency in container scheduling and management (Zhou, Zhou & Hoppe, 2023). Various strategies for container placement have been proposed in recent years, ranging from linear programming models such as the work by Mseddi et al. (2019) to heuristic and metaheuristic algorithms such as the work by Al-Moalmi et al. (2021). While these methods have demonstrated improvements in energy efficiency, resource utilization, or network cost reduction, they often suffer from limitations such as high computational complexity, performance overhead, or scalability issues in large-scale infrastructures. Hybrid optimization approaches offer a promising avenue to overcome these challenges by balancing multiple objectives such as energy efficiency, load balancing, and quality of service (QoS).

In this study, we introduce an Extended Directed Container Placement (E_DCP) mechanism, a novel container placement that extends our prior research (Alwabel, 2023) and introduces a scoring-based evaluation strategy leveraging the Whale Optimization Algorithm (WOA) (Mirjalili & Lewis, 2016). The contribution of this article is as follows. Firstly, this work proposes a scoring mechanism to evaluate various solutions with an aim to identify the best among them. By optimizing multiple objectives, including search time, resource utilization and energy efficiency.

To assess resource utilization, this article introduces the overutilized level threshold (OLT) metric within its scoring mechanism. The OLT defines a specific utilization level for a computer machine; if this threshold is exceeded, the machine’s performance can degrade, compromising overall system performance and service quality (Katal, Dahiya & Choudhury, 2023). Furthermore, overutilized machines are more susceptible to hardware failures due to overheating, which increases the frequency of system outages and raises maintenance costs (Lee, Viswanathan & Pompili, 2017).

Secondly, designing a multi-objective optimization framework to enhance container placement efficiency in both homogeneous and heterogeneous cloud environments. The mechanism develops an optimization method which reduces the number of overutilized PMs to improve performance. Thirdly, The proposed mechanism enhances container placement by addressing critical limitations of previous approaches, scalability, search time inefficiencies, and utilization when the number of containers grows.

The mechanism outperforms recent methods in both heterogeneous and homogeneous cloud infrastructures in terms of search time and resource utilization, particularly as the number of containers increases significantly. Extensive simulations demonstrate significant improvements in search time and resource utilization with acceptable energy consumption level. This research contributes to advancing the performance of containerized cloud systems, offering practical insights for large-scale deployments.

The reminder of this article is organized as follows: ‘Related Works’ section discusses the state-of-art works in container placement area. ‘Proposed Mechanism’ proposes our mechanism. The findings of this article is presented in ‘Experiments and Evaluation’. The conclusion of this article is drawn in ‘Conclusion’.

Related works

The authors in Piraghaj et al. (2015) addressed a power optimization problem in the CaaS environment. The proposed mechanism effectively improved energy efficiency by optimizing container placement and reducing the number of active servers. They introduced a correlation-aware placement algorithm, demonstrating that overload and underload threshold algorithms performed better than others, particularly when migrating larger containers.

A dynamic resource placement mechanism in heterogeneous CaaS data centers was proposed by Mao et al. (2017). The mechanism selects the PM to deploy a container based on both the available resources and service demand. Performance comparison with similar approaches demonstrated a more efficient and balanced usage of resources. However, network consumption was high as a result of employing this mechanism (Carvalho & Macedo, 2023).

The authors in Zhang et al. (2017) introduced a container placement based on linear programming model (ILP) for allocating containers to computing nodes, taking into account various optimization criteria, including energy consumption and network cost. Compared to Docker Swarm’s binpack strategy, the placement mechanism achieved approximately a 45% cost reduction. Another ILP based approach was developed by Wan et al. (2018) with an aim to minimize cost. The approach accounted for networking costs and addressed the scheduling problem in a distributed manner. However, the approach suffered of high computational complexity and overlooked key optimization factors, such as energy consumption and response time (Ahmad et al., 2022).

The authors in Shi, Ma & Chen (2018) proposed an energy-based model for optimizing container scheduling that is based on a particle swarm optimization approach. The results demonstrated that the proposed method has shown significant improvements in energy efficiency while maintaining an acceptable level of QoS.

The authors in Lin et al. (2019) developed an optimization technique that is based on ant colony optimization algorithm (Dorigo, Birattari & Stutzle, 2006) with an aim to trade off between resource utilization, network consumption, and failure events of microservices cloud applications. The proposed mechanism demonstrated efficient outcome in service reliability, load balancing and network transmission overhead. The mechanism, however, failed to consider energy consumption.

A novel heterogeneous container placement strategy is presented in Zhong & Buyya (2020) to enhance the cost efficiency of container orchestration in Kubernetes-based cloud systems. The experiments demonstrated significant cost savings compared to the default Kubernetes framework under various workload patterns. However, their work was not tested under conditions of high service demand.

A article presents a novel locality-aware scheduling model aimed at improving the performance of containerized cloud services by addressing key challenges in resource contention and network efficiency (Zhao, Mohamed & Ludwig, 2020). The model implements load balance heuristic to improve application performance. The performance, however, the proposed mechanism could dramatically degrade when the workloads scales up (Deng et al., 2024).

The authors in Santos, Paulino & Vardasca (2020) proposed a novel scaling mechanism to scale a group of containers to various workloads with an aim to improve quality of experience (QoE) metrics. Similarly, the work presented in Carvalho & Macedo (2023) emphasizes improving service scheduling by prioritizing QoE over QoS objectives. It utilizes deep learning models to incorporate QoE metrics, providing a more accurate representation of user satisfaction to predict user QoE. Experimental results demonstrated that the proposed scheduler improved average QoE by about 61.5% compared to conventional schedulers.

The researchers in Al-Moalmi et al. (2021), developed a container placement mechanism based on whale optimization algorithm (Mirjalili & Lewis, 2016) in order to optimize resource utilization and power consumption in cloud systems. The results showed that the placement mechanism is superior over other placement mechanism in heterogeneous test environment. However, the study did not take the performance overhead such as resource over utilization of this method into consideration.

The authors in Chuqiao Lin et al. (2023) designed a novel multi-objective container migration strategy based binary grey wolf optimizer algorithm on with an aim to optimize resource utilization and energy consumption. To enhance the efficiency of container migration, it established a node coordination matrix model to address resource fragmentation. The results of this study demonstrate that the proposed strategy outperformed existing mechanism, indicating its effectiveness in real-world applications. However, the study did not address the issue of large container and PM number in the evaluation.

Our previous work in Alwabel (2023) presented a novel container mechanism that utilizes a meta-heuristic algorithm called whales optimization algorithm with an aim to minimize energy consumption cloud systems. However, this work has a negative impact on performance criteria such as service violation and search time.

The authors in Patra, Sahoo & Turuk (2024) proposed a method for container consolidation in CaaS cloud systems using fractional pelican hawks optimization. The proposed approach includes two main modules: a host status module for predicting PM load and a consolidation module for managing container migration. The method aims to optimize multiple objectives, including energy consumption, resource utilization, and costs, to achieving significant efficiency improvements. However, the scalability of the proposed method in larger, more complex cloud infrastructures was not addressed.

In conclusion, this section discusses several related works and their focus o the area of task scheduling mechanisms. Table 1 presents a comparison of related works with our work in terms of power consumption, Qos/QoE, cost reduction, resource utilization and heavy demand. The next section explains our work in more details.

Proposed mechanism

While prior methods have achieved significant improvements in energy efficiency and resource utilization, they often neglect the interplay between search time and performance degradation in the presence of large number of tasks. The E_DCP mechanism addresses these gaps through an optimized approach, balancing multiple objectives in both homogeneous and heterogeneous environments. This mechanism extended our previous work proposed in Alwabel (2023). Figure 1 depicts the E_DCP mechanism. The first phase of this algorithm is to create a NW of solutions. Each solution is initialized by placing a list of containers randomly to a number of PMs. Algorithm 1 illustrates this allocation process. This process is inspired by the concept of WOA approach.

The mechanism identifies the best solution among this list of solution using the Algorithm 2. The algorithm employs an evaluation mechanism EV in order to compare two solutions $s_1$ and $s_2$ to determine which one yields a better outcome using a scoring mechanism. The scoring mechanism is based on three evaluation criteria: energy consumption $powe$, utilization level $olt$ and number of active PMs $apm$. The evaluation is given as follows:

(1) $$Ev(s_1,s_2)=po{w}_{ev}(s_1,s_2)+ol{t}_{ev}(s_1,s_2)+ap{m}_{ev}(s_1,s_2)$$where $po{w}_{ev}(s_1,s_2)$ refers to the evaluation of these two solutions in terms of energy consumption. It is given as follows:

(2) $$po{w}_{ev}(s_1,s_2)=\frac{pow(s_1)-pow(s_2)}{pow(s_2)}$$where $pow(s_1)$ is the total power consumption for a single solution. Energy efficiency plays a key role in reducing running costs in data centers as well as reducing carbon footprint (Gill & Buyya, 2019). It is calculated according to the authors in Khan et al. (2019) as follows:

(3) $$pow(solution)=\sum _{i=1}^p(p{m}_i^{p.idle}+(p{m}_i^{p.max}-p{m}_i^{p.idle})\times U(p{m}_i))$$where $p$ refers to the total number of PMs in a data center. $p{m}_i^{p.idle}$ denotes the power consumption by a PM $i$ when it remains idle. $p{m}_i^{p.max}$ refers to the maximum power consumed by this PM. $U(p{m}_i)$ denotes the utilization level of this machine and is given as follows (Alwabel, 2023):

(4) $$U(p{m}_i)=\frac{p{m}_i^{cur.cpu}}{p{m}_i^{tot.cpu}}$$where $p{m}_i^{cur.cpu}$ and $p{m}_i^{tot.cpu}$ refers to used CPU and total CPU of PM $i$ respectively. However, the result of using an approach to reduce power consumption can lead to resources being overutilizaed which leads to performance downgrade (Katal, Dahiya & Choudhury, 2023). Overutilization of PMs can significantly degrade overall system performance and service quality. When a PM exceeds a certain threshold resource capacity, it may lead to an increase in queuing delays, higher response times, and reduced throughput. Furthermore, overutilized PMs are more prone to hardware failures as a result of overheating, which can increase the frequency of outages and maintenance costs.

As a consequence, overutilized PMs can negatively affect the performance of hosted VMs or containers, potentially violating QoS requirements and SLAs (Gao et al., 2013). In dynamic and time-sensitive applications such performance degradation can be particularly critical. Therefore, effective resource scheduling mechanisms are essential to reduce the impact of overutilization and to ensure efficient container placement mechanism in virtualized environments. Let $ol{t}_{ev}$ denote the number of PMs in a solution where each PM’s utilization level exceeds a certain threshold. It is calculated as:

(5) $$ol{t}_{ev}(s_1,s_2)=\frac{olt(s_1)-olt(s_2)}{olt(s_2)}.$$

If a utilization level in a server exceeds a certain threshold, this can lead to a negative impact on the performance of this server (Çağlar & Altılar, 2022). Therefore, we consider the number of OLT PMs in a solution as an evaluation criteria. It is given as follows:

(6) $$olt(solution)=\sum _{i=1}^{p}oltPM$$where $oltPM$ refers to over level threshold of PM’s utilization level and it is given as follows:

(7) $$oltPM=\{\begin{array}{cc}0\hfill & U(pm)<ot\hfill \\ 1\hfill & otherwise\hfill \end{array}$$where $ot$ is an overloaded threshold. So if a PM exceeds this threshold, it is considered overloaded. Improving utilization can lead to reduction in energy consumption when idle PMs are set to power mode saving (Manvi & Krishna Shyam, 2014). However, the downgrade of this approach is that it may cause performance degradation as explained before. The number of active PM ( $apm$) is introduced in order to balance these two conflicting factors. The following equation is given to calculate the number of active PMs of two solutions $s_1$ and $s_2$:

(8) $$ap{m}_{ev}(s_1,s_2)=\frac{apm(s_1)-apm(s_2)}{apm(s_2)}$$where $apm(solution)$ is:

(9) $$apm(solution)=\{\begin{array}{cc}0\hfill & U(pm)=0\hfill \\ 1\hfill & otherwise\hfill \end{array}$$

The next phase is to update these solutions according to the work proposed by Mirjalili & Lewis (2016) and explained thoroughly by our previous work in Alwabel (2023). Algorithm 3 details the process of updating solutions. The, best solution is reevaluated against these updated solutions. If there is a solution which yields a better outcome according to Eq. (1), then it becomes the new best solution. This step is repeated for a number of times.

The last step is further optimize the best best solution. This step assumes that the best solution produced by the previous step can have some overloaded PMs. Therefore, the E_DCP utilizes Algorithm 4 to migrate some containers from those PMs to PMs with the lowest utilization level.

Experiments and evaluation

This section presents the results of the proposed container placement approach and compares them with state-of-the-art mechanisms. The proposed mechanism is compared with the DCP mechanism (Alwabel, 2023) and the IGA mechanism (Zhang et al., 2019). The DCP mechanism is a container placement mechanism based on WOA algorithm that places containers with an aim to reduce energy consumption. Similarly, the IGA mechanism is a genetic based placement mechanism that places containers on cloud data centers to reduce power consumption. The mechanisms are evaluated under three criteria: search time, OLT ad energy consumption.

Search time

This section presents our investigation about the search time required to find a solution among the evaluated mechanisms. The search time refers to the time that is required to find a solution (i.e. find a hosting PMs to a group of containers). A good mechanism aims at reducing this time in order to improve the efficiency of cloud systems (Ahmad et al., 2022).

Figure 2 demonstrates that the proposed mechanism outperformed the DCP and IGA mechanisms in terms of search time in homogeneous infrastructure. For example, the search time to in Fig. 2A that was carried out by E_DCP is 3.1 s while it is 54.94 and 7.06 s for the DCP and IGA mechanisms respectively. Figure 2D shows that Our mechanism reduced the search time by about 94% compared to the DCP mechanism.

The E_DCP mechanism behaved similarly in heterogeneous cloud systems in term of search time as it is depicted in Fig. 3. It outperformed other mechanisms in all container types: small, medium, large and multi as it is demonstrated in Figs. 3A, 3B, 3C and 3D respectively. When the container number is 5,000 and the container type is large, the proposed mechanism’s search time is about 3 s while the DCP mechanism scored about 65 s and the IGA scored about 522 s.

Energy efficiency

Energy efficiency is an important factor in cloud systems for two reasons. The first is to reduce running costs and the second is to reduced the negative impact of these systems on the the environment.

The results demonstrated that the proposed mechanism managed to consume less power in comparison to the DCP mechanism when it was applied to a homogeneous cloud system as it is depicted in Fig. 4. The worst scenario is when the container type is large and the number of containers is 5,000 because it will require more PMs to host high container requirements and large number of them. In this case, the E_DCP improve energy efficiency by about 5%. Similar improvements occurred in medium and multi container types. However, the energy consumed by our method is exactly the same as the DCP mechanism when the mechanisms were used in the small container type. This is because the requirements of this type of containers is quite low which leads to a similar behavior in these two mechanisms.

The total power consumed by a heterogeneous system yielded a different outcome. The DCP mechanism outperformed our mechanism by reducing consumption as it is illustrated in Fig. 5. This because our approach aims at reducing the number of OLT PMs which leads to more active PMs as it was explained in the previous subsection. The increase of active PMs means more energy consumption.

High service demand

Previous sections briefly outlined the implications of high service demand. This section provides a more rigorous analysis of the behavior of the E_DCP mechanism under such conditions. High service demand, defined as the increasing number of containers (Alwabel, 2023), poses a considerable challenge to system performance. As illustrated in Fig. 6A, the proposed mechanism achieves a substantial reduction in search time compared to the DCP and the IGA mechanisms, while sustaining comparable power consumption levels (Fig. 6B). Furthermore, Fig. 6C indicates that the E_DCP mechanism consistently maintains OLT levels at a minimum, highlighting its ability to ensure efficiency and scalability under intensive workloads.

Conclusion

Although containerized cloud services provide dynamic scalability and enhanced cost efficiency, it poses new challenges such as resource utilization and power consumption. This article presents a container placement mechanism that focuses on enhancing the performance of cloud systems by reducing search time and improving resource utilization while maintaining an acceptable level of power consumption in the case of large number of containers. The article employs WOA to find the best solution to place containers on PMs. The best solution is evaluated based on a scoring approach which this article discusses. Finally, the best solution is optimized to improve resource utilization with minimum affect on performance. The experiments demonstrate that our mechanism outperformed other mechanisms in terms of search time and resource utilization.

The E_DCP mechanism is evaluated in two cloud environments: homogeneous and heterogeneous. The experiments consider the large scale of workload (i.e., the number of containers become quite high). The results demonstrated that the mechanism outperform the DCP and IGA mechanisms in both performance and resource utilization in both cloud environments. However, the price of this improvements is the increase of power consumption in comparisons to the DCP mechanism.

There are three major future research directions with this work. Firstly, the mechanism should consider resource availability as an evaluation criteria in the presence of failure events. In addition, a dynamic and migration approaches should be employed to further enhance the proposed method in terms of energy consumption. However, the overhead of migration should be taken into account in this study. Lastly, the evaluation approached presented in this article consider there factors and treat them equally. A work can investigate the effectiveness of assigning various weight for each factor in order to study if it can yield a better outcome.

Supplemental Information