A Novel NSGA-III-GKM++ Framework for Multi-Objective Cloud Resource Brokerage Optimization

Abstract

Cloud resource brokerage is a fundamental challenge in cloud computing, requiring the efficient selection and allocation of services from multiple providers to optimize performance, sustainability, and cost-effectiveness. Traditional approaches often struggle with balancing conflicting objectives, such as minimizing the response time, reducing energy consumption, and maximizing broker profits. This paper presents NSGA-III-GKM++, an advanced multi-objective optimization model that integrates the NSGA-III evolutionary algorithm with an enhanced K-means++ clustering technique to improve the convergence speed, solution diversity, and computational efficiency. The proposed framework is extensively evaluated using Deb–Thiele–Laumanns–Zitzler (DTLZ) and Unconstrained Function (UF) benchmark problems and real-world cloud brokerage scenarios. Comparative analysis against NSGA-II, MOPSO, and NSGA-III-GKM demonstrates the superiority of NSGA-III-GKM++ in achieving high-quality tradeoffs between performance and cost. The results indicate a 20% reduction in the response time, 15% lower energy consumption, and a 25% increase in the broker’s profit, validating its effectiveness in real-world deployments. Statistical significance tests further confirm the robustness of the proposed model, particularly in terms of hypervolume and Inverted Generational Distance (IGD) metrics. By leveraging intelligent clustering and evolutionary computation, NSGA-III-GKM++ serves as a powerful decision support tool for cloud brokerage, facilitating optimal service selection while ensuring sustainability and economic feasibility.

1. Introduction

In the last few years, we have seen a rapid evolution in the field of information technology, where everything is interconnected. The Internet of Things (IoT) enables seamless communication between people, processes, and objects through embedded devices that connect them to the internet. The future presents a significant challenge with the IoT, which includes the connection of a huge set of objects and data through the internet. This large-scale interconnection necessitates a robust infrastructure to manage and support numerous connected devices. Thus, cloud computing is essential for storing, processing, and analyzing the vast data streams generated by IoT devices [1].

In cloud computing, client requests are often routed through an intermediary that acts as a bridge between clients and cloud service providers. This intermediary, known as a cloud broker, is defined by the International Organization for Standardization as a service that streamlines interactions between cloud service users and providers [2]. Cloud service providers also leverage cloud brokers to enhance resource selection and optimize service delivery.

Cloud brokering presents a significant challenge in resource allocation within cloud environments, as it must account for the growing complexity and heterogeneity of cloud services. This challenge is closely tied to dynamic user demands, requiring the selection of the most suitable offer from multiple service providers responding to the same request. As cloud computing continues to evolve and power everything from enterprise systems to consumer applications, the number and variety of services offered by providers have expanded dramatically. For businesses and developers, choosing the right combination of resources balancing cost, performance, energy efficiency, and reliability has become increasingly complex. This is where cloud service brokers (CSBs) come into play. Acting as intelligent intermediaries, CSBs simplify the resource selection process, negotiate service-level agreements (SLAs), and optimize deployments across multiple providers. Prior research has emphasized the strategic importance of CSBs in enabling agile, market-oriented cloud management [3].

The cloud brokerage problem is thus modeled as a multi-objective optimization task with three primary goals: minimizing the response time for user requests, reducing energy consumption, and maximizing broker profits. These goals often conflict, making the problem NP-hard and intractable for large-scale, real-time solutions [4]. As a result, researchers have turned to approximation methods, particularly heuristic and metaheuristic algorithms. Among the most prominent approaches are genetic algorithms (GAs) [5,6,7] and the Non-dominated Sorting Genetic Algorithm II (NSGA-II), often enhanced with local searches [8]. Hybrid techniques, such as combining GAs with simulated annealing [9], have also been introduced to boost the solution quality and convergence speed [10]. However, most existing approaches tend to emphasize specific Quality-of-Service (QoS) parameters, such as the execution time or energy consumption, without effectively balancing all the objectives [11]. To address these limitations, this study proposes an enhanced version of the NSGA-III algorithm integrated with a Genetic K-means clustering method (NSGA-III-GKM). NSGA-III, originally introduced by Deb et al. [12], was designed to overcome NSGA-II’s weaknesses, particularly in diversity maintenance and scalability. Based on these fundamentals, our framework leverages clustering to guide the solution evolution and improve the convergence. Such hybrid models reflect the growing trend toward more robust, adaptive optimization frameworks that can better handle complex, high-dimensional problems in cloud environments [12].

Building upon the work of [13], where the NSGA-III-GKM algorithm leverages K-means clustering to group initial reference points and refines cluster centers using a genetic algorithm, we enhance this approach by integrating K-means++. Recognized for its intelligent cluster initialization, K-means++ mitigates the risk of local minima, improves the clustering quality, and accelerates the convergence [14]. This enhancement leads to our proposed NSGA-III-GKM++ algorithm, designed to effectively balance conflicting objectives and generate high-quality solutions in complex optimization scenarios.

Our primary goal is to evaluate the superiority of NSGA-III-GKM++ over established algorithms, including Multi-Objective Particle Swarm Optimization (MOPSO), NSGA-II, and the standard NSGA-III-GKM. This optimization is particularly critical in the context of the exponential growth of IoT devices and cloud computing services, which impose increasing demands on efficient resource management. In this regard, cloud brokerage, serving as an intermediary between service providers and consumers, presents a multi-faceted challenge that necessitates a delicate balance among the response time, energy consumption, and broker profitability.

This paper is structured as follows: Section 2 presents a comprehensive literature review, highlighting related work and existing solutions. Section 3 details our proposed methodology and the components of the NSGA-III-GKM++ approach. Section 4 focuses on the implementation and experimental evaluation, while Section 5 discusses the results and concludes with insights into the effectiveness of our approach for optimizing cloud brokerage.

2. Related Works

The rapid expansion of connected devices across networks has created an increasing demand for the efficient analysis and storage of massive volumes of data. The rapid proliferation of IoT-enabled devices generates an ever-increasing volume of data, making local and temporary storage impractical. The IoT consists of small, widely distributed devices with limited storage and processing capacities, leading to challenges in reliability, performance, security, and privacy. The integration of the Internet of Things (IoT) with Cloud Computing (CC) has led to the emergence of the Cloud of Things (CoT), also known as the CloudIoT, a paradigm that merges the data generation capabilities of smart objects with the processing and storage power of cloud infrastructures. The CoT allows the functions of smart devices to be offered as services, making them accessible to multiple applications simultaneously [15]. This synergy enables scalable, real-time data processing and centralized control, which are crucial for application domains, such as smart cities, industrial automation, connected healthcare, and autonomous transportation [16,17,18,19]. By offloading heavy computational tasks to the cloud, the CloudIoT enhances the overall capabilities of IoT systems, effectively overcoming the inherent limitations of resource-constrained edge devices. Despite these advantages, the convergence of the IoT and cloud computing also introduces several operational and architectural challenges. These include issues related to dynamic resource allocation, latency control, energy consumption, and data security. Such challenges are especially critical in large-scale and distributed environments, where response times and bandwidth constraints must be carefully managed. Moreover, in multi-cloud ecosystems, where services are distributed across multiple providers, these challenges are further exacerbated by heterogeneous infrastructures, fluctuating workloads, and diverse QoS requirements. As a result, the success of the CloudIoT heavily relies on the development of intelligent and adaptive cloud brokerage mechanisms capable of handling these complex, multi-objective tradeoffs.

Most existing cloud brokerage schemes overlook optimization techniques for service deployment. Several genetic-algorithm-based approaches have been proposed to address this issue. Early approaches to cloud brokerage primarily focused on heuristic and genetic algorithms (GAs). For instance, refs. [5,6] applied GAs to optimize virtual machine (VM) selection based on response times and costs. Ref. [7] introduced a genetic method for multi-cloud service brokerage, optimizing VM selection for low latency and cost using the CloudSim framework. While outperforming prior methods, it fails to consider service request localization. Similarly, Qos-aware genetic cloud brokering (QBROKAGE) [5] optimizes Infrastructure-as-a-Service (IaaS) resource selection based on QoS metrics, like response times and throughput, achieving near-optimal solutions, even with hundreds of providers. However, it lacks adaptability for dynamic applications requiring resource elasticity.

Hybrid techniques combining GAs with simulated annealing or local searches [20] have shown improvements in the convergence speed and solution quality but have often neglected aspects like service request localization or profit maximization. To further optimize cloud brokerage, previous work, such as [21], has formulated the problem as a cost and execution time minimization task, employing a biased random key genetic algorithm (BRK-GA) to achieve fast decision making and high-quality solutions. However, similar to other early approaches, it failed to consider critical factors, like the geographical distribution of service requests, limiting adaptability in heterogeneous cloud environments. These limitations underscore the broader demand for more adaptive, context-aware optimization strategies. Recent studies have responded by emphasizing the need for intelligent cloud brokerage mechanisms capable of efficiently allocating multi-cloud resources while addressing conflicting objectives, such as cost, latency, and energy consumption. Moreover, the evolution of cloud brokerage has expanded beyond algorithmic efficiency to include architectural challenges, such as interoperability, SLA negotiation, and elasticity management [22], highlighting the complexity and multidimensionality of modern cloud service brokerage.

A multi-objective genetic algorithm in cloud brokerage (MOGA-CB) [6] distributes VM requests to minimize the cost and response time using an evolutionary search, achieving Pareto-optimal solutions. However, it does not optimize VM instance-level pricing. NSGA-II-based approaches [23] have also been employed to handle multi-cloud brokerage problems by simultaneously considering the cost, response time, and availability, with CDOXplorer achieving up to 60% improvement over traditional methods [24]. Despite their promising results, these approaches often overlook service request localization and face scalability limitations in dynamic environments. Evolutionary multi-objective optimization (EMO) algorithms, such as NSGA-II and NSGA-III, remain widely adopted due to their strong capabilities to approximate the Pareto front across multiple objectives [12,25,26]. However, in high-dimensional objective spaces, their convergence behavior can deteriorate. To address this, clustering-enhanced strategies have emerged. For instance, ref. [27] proposed a K-means-based EMO that improves convergence by preserving the population diversity. These advances are conceptually aligned with decomposition-based approaches, like MOEA/D [28], which focus on dividing the objective space to simplify optimization and promote convergence across diverse solution regions.

To enhance scheduling and resource management, Extreme NSGA-III (E-NSGA-III) [29] optimizes scientific workflows, outperforming NSGA-II and NSGA-III. Similarly, NSGA-III-based Virtual Machine Placement (VMP) [30] improves resource allocation by 7% and enhances environmental efficiency. In content delivery networks (CDNs), SMS-EMOA [31] reduces cloud resource costs by up to 10.6% while maintaining high QoS. These results show that the proposed approach is effective for deploying cloud-based CDNs at a lower cost without compromising service quality.

The main objective of the cloud service provider is to increase the profit of the cloud infrastructure, while the cloud users want to run their applications at the minimum cost and in the minimum execution time. Reducing the energy consumption and achieving the maximum profit in a cloud environment are challenging problems due to the incompatibility between workstations (physical machines) and unpredictable user demands.

PSO-COGENT [32] improves scheduling by reducing the execution time, cost, and energy consumption but lacks QoS considerations. Similarly, CLOUDRB [33] integrates PSO for resource allocation, outperforming GAs, the ant colony optimization algorithm (ACO), and the Reformative Bat Algorithm (RBA) in cost and deadline adherence. The results demonstrated that the proposed framework effectively executes tasks within the specified deadlines while achieving significant reductions in both the execution time and cost. Artificial-Bee-Colony (ABC)-based scheduling [34] dynamically adjusts the VM allocation, optimizing costs while balancing the workload distribution. However, these approaches face limitations in adaptability and QoS optimization. To ensure these objectives, the characterization of the relationship between the profit of a service provider and the customer’s satisfaction, based on the utility model, allows us to cope at the same time with the two main criteria that make up the broker’s profit and customer’s satisfaction.

In the Software-as-a-service (SaaS) cloud market, multiple equivalent services exist, each with different QoS attributes. Selecting and configuring services to meet diverse tenant needs are NP-hard multi-objective problems. Existing approaches focus on QoS adaptation but overlook multi-tenant deployment flexibility.

Ref. [35] proposed a dynamic service composition framework, using a multi-objective evolutionary algorithm based on decomposition, that integrates Stable Matching (MOEA/D-STM) and NSGA-II, with results showing MOEA/D-STM outperforming NSGA-II in the solution quality and computation time. Cloud service providers (CSPs) must reduce the energy consumption while maximizing profits, but minimizing active servers and optimizing the VM placement are conflicting objectives. The maximum VM placement with the minimum power consumption (MVMP) [36] addresses this, using simulated annealing (SA), outperforming five state-of-the-art algorithms in energy efficiency, profit, and execution time. However, VM migration remains time consuming.

For multi-cloud service brokerage, ref. [37] proposed a large neighborhood search (LNS) approach, reducing costs by 10–12% compared to those of a greedy heuristic. While LNS avoids local optima by increasing the neighborhood size, it is still an individual-based method because there is only one solution in the problem search space.

Selecting the optimal cloud resources while meeting QoS requirements is challenging due to service heterogeneity. Ref. [13] proposed a hybrid NSGA-II approach with local searches to minimize the deployment costs and response time, outperforming NSGA-II and Strength Pareto Evolutionary Algorithm 2 (SPEA2), though it neglects the VM location’s impact. In a cloud IaaS environment, selecting VMs from different data centers with multiple objectives, like minimizing the response time, cost, and energy consumption, is a challenging problem due to the heterogeneity of services in terms of resources and technology.

The NSGA-II and Gravitational Search Algorithm (GSA) [38] improves VM selection for scheduling but prioritizes task scheduling over choosing the optimal computing resource, that is, the VM on which the execution should take place.

Ref. [10] proposed a novel parallel evolutionary algorithm to address the issue of subleasing virtual machines in CC in order to optimize the cloud broker’s earnings. The problem concerns the efficient allocation of a set of requests from a client’s VMs to available resources pre-reserved by a cloud broker. The proposed parallel algorithm uses a distributed subpopulation model and a simulated annealing operator, and they compared it with a greedy heuristic algorithm using real data from cloud providers. It is shown that the new algorithm significantly outperforms the best existing results in the literature. However, neither method was able to simultaneously optimize the response time and the profit of the cloud broker.

Cloud computing environments offer clients a variety of on-demand services and facilitate resource sharing. Business processes are managed through the cloud using workflow technology, which presents challenges for efficient resource utilization due to task dependencies [39]. To address this, the proposed hybrid GA-PSO algorithm in [39] is designed to optimize the assignment of tasks to resources efficiently. This algorithm aims to reduce the duration and cost and balance the load of dependent tasks across heterogeneous resources in cloud computing environments. The experimental results show that the GA-PSO algorithm reduces the total execution time of workflow tasks compared with GAs, PSO, the hybrid simplex-genetic algorithm (HSGA), the weighted-sum genetic algorithm (WSGA), and Mother-to-Child Transmission (MTCT) algorithms. In addition, it reduces the implementation cost and improves the load balancing of the workflow application with the available resources. The results demonstrate that the proposed algorithm not only reaches good solutions more quickly but also delivers higher-quality outcomes compared to those of other algorithms.

This section critically evaluates established cloud brokerage optimization techniques, including GAs, swarm intelligence (SI), and hybrid models, emphasizing their efficacy in addressing specific facets of multi-objective optimization [40]. Genetic algorithms demonstrate robust performance in balancing competing objectives, such as response times and energy efficiency, through mechanisms like Pareto front exploration, enabling systematic tradeoff analyses between these criteria. Swarm intelligence methods, such as particle swarm optimization, excel in dynamic environments by leveraging decentralized search mechanisms to iteratively refine resource allocation, thereby optimizing energy consumption without compromising service latency. Hybrid approaches further enhance optimization outcomes by synergizing the global search capabilities of GAs with the adaptability of swarm intelligence (SI), allowing them to effectively navigate complex solution spaces. A notable refinement within this context is the integration of advanced clustering methods, such as K-means++, which improves centroid initialization by reducing the likelihood of suboptimal local minima [41]. When embedded into metaheuristic frameworks, K-means++ has been shown to accelerate the convergence and enhance the solution quality by promoting better population structuring and maintaining diversity [42]. However, despite promising results in controlled scenarios, these hybrid methods often fail to fully address real-world constraints. Scalability, critical for large-scale and heterogeneous cloud infrastructures, is frequently under-evaluated, especially under dynamic workloads or in geographically distributed environments. Likewise, adaptability to unpredictable operational conditions, such as workload surges or hardware failures, remains insufficiently explored, raising questions about their practical deployment. To bridge these gaps in scalability, adaptability, and clustering effectiveness, we propose the NSGA-III-GKM++ framework, which tightly integrates K-means++ clustering with reference-point-based evolutionary optimization. By grouping objectives or resources into coherent clusters, K-means++ reduces the computational complexity and enhances scalability, while NSGA-III’s reference-point-driven selection ensures responsiveness in dynamic, multi-cloud scenarios. This dual strategy retains the strengths of existing methods, such as the optimization of the response time and energy efficiency, while addressing core limitations related to the convergence speed, diversity, and operational robustness, ultimately offering a more comprehensive and practical solution for real-world cloud brokerage challenges.

3. Proposed Approach

In this section, we define the cloud brokerage problem by presenting the mathematical model used. We then describe the proposed approach to design the different components of the problem.

3.1. Problem Definition and Mathematical Model

The brokerage problem is to choose the best proposal among the number of offers received from different providers that respond to the same call. In this context, a ‘call’ refers to a service request submitted by a customer specifying their resource requirements. The cloud computing model adopted in this study is based on an IaaS broker. As illustrated in Figure 1, the model consists of one cloud broker, M cloud service providers, and N customers. The broker’s goal is to determine the optimal allocation of cloud resources that meets the customer’s demands while maximizing the efficiency [4].

This problem is formulated as an optimization challenge, where the primary objective is to efficiently allocate incoming requests to a set of cloud service providers with varying capacities and resource types. The optimization aims to minimize the response time (RT), reduce the total energy consumption (E), and maximize the cloud broker’s profit (P). The model represents the customer base, using the set $V=\{v_1,\dots ,v_N\}$, and the service providers, using the set $S=\{s_1,\dots ,s_M\}$. Each provider has a constrained capacity, meaning that the total number of processing requests it can handle must exceed the demand from any single customer. To mathematically represent the assignment of customer requests to service providers, we introduce a binary decision variable, $b_{ij}$, with i = 1,…, N and j = 1,…, M as follows:

$$b_{ij}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}{s}_j\mathrm{handles}\mathrm{the}\mathrm{demand}\mathrm{of}{u}_i\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(1)

Clients expect their tasks to be processed with minimal delay when submitting requests to the cloud broker and service providers. Consequently, the response time (RT) is a critical performance metric. We define $L_{ij}$ as the latency between client i and service provider j, which can be calculated as $L_{ij}=CT-AT$. A request’s arrival time at the service provider is denoted by $AT$, while $CT$ is the current time. Upon receiving a request, the service provider requires a processing time ($T_j$) to complete the task. The primary objective is to minimize the overall response time, which is mathematically formulated as follows:

$$RT=\sum _{i=1}^N\sum _{j=1}^M{b}_{ij}\left(L_{ij}+T_j\right)$$

(2)

When a customer submits a request, it is processed through the cloud broker, which is responsible for selecting the most suitable service provider to meet the customer’s needs efficiently. In addition to ensuring the optimal resource allocation, the broker aims to maximize its own profit. The broker’s profit, considered as the second optimization objective, is defined in terms of the price charged to the customer ($P_i$) and the cost incurred from the service provider ($C_j$). Thus, the objective of profit maximization (P), is mathematically expressed as follows:

$$P=\sum _{i=1}^N\sum _{j=1}^M{b}_{ij}\left(P_i-C_j\right)$$

(3)

The third objective is to minimize the total energy consumption of the system. To process customer requests efficiently, service providers must operate while consuming the least possible amount of energy. Given the growing emphasis on sustainability in cloud computing, energy optimization is a crucial factor. We define $E_j$ as the energy consumed by service provider j to execute a given task. The total energy consumption across all the service providers is mathematically formulated as follows:

$$E=\sum _{i=1}^N\sum _{j=1}^M{b}_{ij}\ast E_j$$

(4)

These three goals are aggregated into the cloud broker’s cost function, described as follows:

$$C={\omega }_{1}RT+{\omega }_{2}E-{\omega }_{3}P$$

(5)

The weighting factors, ${\omega }_1$, ${\omega }_2$, and  ${\omega }_3$, correspond, respectively, to the response times of the requests, the total energy consumption of the system, and the profit of the cloud broker. These weights are constrained to sum to 1 (${\omega }_1$ + ${\omega }_2$ + ${\omega }_3$ = 1), ensuring a balanced tradeoff among the objectives. Because each term in the cost function has a different unit, the weights also serve to normalize them onto a common scale, preventing any single objective from dominating the evaluation metric. Although Equation (5) defines a linear aggregate cost function, $C={\omega }_{1}RT+{\omega }_{2}E-{\omega }_{3}P$, this formulation is primarily used to illustrate the tradeoffs involved in resource provisioning. In practice, the optimization is performed using a Pareto-based evolutionary multi-objective approach, where the cost, latency, and availability are treated as independent objectives. This allows the construction of a well-distributed Pareto front, enabling the broker to explore diverse tradeoffs rather than relying on a fixed, aggregated utility function.

Each component of the cost formulation reflects real-world considerations, incorporating the unit price, quantity, and duration of usage for various resource types, including the CPU, memory, bandwidth, and storage, across multiple cloud service providers. These models align with commercial pricing schemes used by platforms such as AWS, Microsoft Azure, and Google Cloud.

The cost model remains an essential part of the broker’s decision-making process. Its linear and modular structure facilitates efficient evaluation during optimization and can be easily extended to incorporate more complex pricing policies or new resource types as they emerge.

3.2. NSGA-III-GKM++ Algorithm

Evolutionary algorithms have long proven to be well-suited for multi-objective optimization problems due to their ability to generate a diverse set of non-dominated solutions. This diversity empowers decision makers with a range of feasible tradeoffs and is especially valuable in complex or poorly understood problem spaces, where formal optimization techniques fall short. Among these approaches, NSGA-III is particularly effective because it blends Pareto-based and decomposition-based methods and introduces a structured reference-point selection mechanism to ensure convergence and solution diversity. However, the search efficiency and convergence behavior of such algorithms can be further improved through clustering-enhanced techniques. One promising enhancement is the integration of the Genetic K-means++ (GKM++) algorithm into the NSGA-III framework. GKM++ combines the intelligent centroid initialization of K-means++, which reduces the risk of poor clustering and local optima [41], with the evolutionary search capabilities of genetic algorithms. This hybrid mechanism not only refines cluster formation across generations but also promotes exploration and diversity through the crossover and mutation of cluster centroids. In contrast to more adaptive methods, like X-means [43], which dynamically determine the number of clusters using a Bayesian Information Criterion (BIC) [44], GKM++ provides greater control over centroid evolution and aligns more naturally with the population-based mechanics of NSGA-III. Additionally, while error-based iterative clustering focuses on minimizing intra-cluster distances, it often neglects broader optimization goals, such as Pareto front coverage. GKM++, by balancing exploration and exploitation, improves reference point formation, speeds up convergence, and enhances the robustness of solutions, particularly in high-dimensional objective spaces. Ultimately, its integration into NSGA-III delivers a more stable, scalable, and effective optimization strategy, especially in demanding applications, like cloud resource brokerage.

3.2.1. Algorithm Overview

Traditional multi-objective evolutionary algorithms (MOEAs) often struggle with real-time data processing due to their significant computational demands. This limitation has made it difficult to apply MOEAs to large-scale multi-objective optimization problems (MOPs). Among various evolutionary algorithms (EAs), the non-dominated sorting genetic algorithm III (NSGA-III) stands out as a newer approach capable of addressing large-scale optimization problems with manageable computational requirements. NSGA-III employs non-dominated fast sorting, elitism, and a well- distributed set of reference points to update solutions and maintain diversity. The methodology of NSGA-III, as outlined in [12], serves as the foundation for our approach. Figure 2 presents a flow diagram to illustrate the algorithmic process step by step.

The proposed approach is structured into five key phases, each of which is detailed below.

A.

Reference Point Generation

NSGA-III employs a predefined set of reference points on a normalized hyperplane to facilitate the selection of diverse, non-dominated solutions across multiple objectives. However, conventional reference point initialization methods often result in poor distribution and biased selection, limiting exploration in large-scale optimization problems. To address this, NSGA-III-GKM++ integrates K-means++ clustering to generate well-distributed reference points, reducing the initialization bias through intelligent cluster center selection, minimizing convergence to local optima, and ensuring a balanced search across objectives for better Pareto front coverage. Once initialized, these reference points guide the survivor selection process, maintaining uniform diversity across objectives and improving the overall solution quality. The total number of reference points (H) for problems with M objectives is determined using Equation (6), where p represents the number of divisions along each objective’s axis.

$$H=\left(\begin{array}{c}{\displaystyle \frac{M+p-1}{p}}\end{array}\right)$$

(6)

B.

Adaptive Clustering with GKM++

In NSGA-III-GKM++, reference point clustering plays a crucial role in effectively partitioning the objective space into distinct regions [13]. While traditional K-means are widely used for this purpose, they suffer from limitations, such as sensitivity to the initial cluster centers, difficulty in determining the optimal number of clusters, and a tendency to converge to local optima. Genetic algorithms provide a robust alternative by enabling the adaptive learning of the cluster count, thereby improving clustering performance. To further mitigate these challenges, we integrate K-means++, which optimizes the selection of the initial cluster centers, leading to improved convergence and solution quality [45].

To further refine reference points, we employ Genetic K-means++ (GKM++), which enhances K- means by incorporating genetic algorithm operators, such as selection, crossover, and mutation, to dynamically optimize cluster assignments. GKM++ overcomes the two major weaknesses of standard K-means, poor initialization and convergence to local optima, by leveraging an evolutionary process. The clustering process follows several key steps: chromosome encoding, where cluster centers are represented as real-valued chromosomes; fitness function evaluation, balancing compactness (minimizing the intra-cluster variance) and separability (maximizing the inter-cluster distance); genetic evolution, where selection, crossover, and mutation iteratively refine clusters; and termination, ensuring that each reference point is optimally placed to balance exploration and exploitation. This intelligent clustering mechanism enhances the solution diversity and improves the computational efficiency of NSGA-III-GKM++, making it a powerful approach for high-dimensional multi-objective optimization.

The K-means++ algorithm, introduced by Arthur and Vassilvitskii [46], enhances cluster center selection by initializing centers in a more informed and controlled manner compared to that of traditional K-means. Instead of random selection, it follows a sequential, distance-based process, where each new center is chosen with a probability proportional to the square of its distance from the nearest selected center [14]. This adaptive initialization reduces poor clustering, prevents centroids from being too close, and improves convergence.

In NSGA-III-GKM++, K-means++ is employed to generate a diverse set of reference points. The process begins with the random selection of the first cluster center, followed by iterative selections based on distance-weighted probabilities to ensure the well-spread distribution of reference points. This stochastic bias enhances the solution diversity, ultimately improving the performance of NSGA-III in multi-objective optimization, as shown in Algorithm 1 [45].

By addressing the sensitivity of Lloyd’s K-means to the initial cluster selection, K-means++ significantly improves the clustering quality. Its non-uniform, adaptive selection strategy leads to a more organized clustering process, resulting in better optimization outcomes.

Algorithm 1 Initialization of k-means++ (Dataset X, Number of Clusters k)

1: Input: Set of points $X\leftarrow$ dataset containing n points, $k\leftarrow$ number of clusters. Output:$C\leftarrow$ set of k selected cluster centers. 2: Select the first center randomly: $C\leftarrow$ randomly select one point $x_1$ from X. 3: while  $\left|C\right|<k$  do 4:    for each $x\in X\setminus C$ do 5:      - Compute the squared distance ($D\left(x\right)$) from the closest center in C: 6:      $D\left(x\right)\leftarrow min\left(\mathrm{distance}{(x,c)}^2\right)c\in C$ 7:    end for 8:    Select the next center $x^{\prime }$ from X with probability 9:    $P\left(x^{\prime }\right)={\displaystyle \frac{D\left(x^{\prime }\right)}{{\sum }_D\left(x\right)}}$ (weighted probability selection) 10:    Add $x^{\prime }$ to C 11:    $C\leftarrow C\cup \left\{x^{\prime }\right\}$ 12: end while 13: return C as the initialized cluster centers.

After the convergence, in order to minimize the squared-error criterion E, the cluster centers are recalculated.

$$E=\sum _{j=1}^k\sum _{p\in C_j}{\parallel p-m_j\parallel }^2$$

(7)

where k is the number of clusters, p is the solution, $C_j$ is the jth cluster, and $m_j$ is the center of cluster $C_j$. Chromosomal evolution is a component of the genetic variant of the K-means clustering algorithm, and genetic processes, like crossover, mutation, and selection, produce the final result.

C.

Non-Dominated Sorting and Population Selection

Once the reference points are established, the next step is non-dominated sorting, where solutions are ranked into Pareto fronts based on their dominance relationships. The solutions in Front 1 dominate all the others, while those in Front 2 are only dominated by the solutions in Front 1, and so forth. This ranking helps in selecting solutions that offer the optimal tradeoffs between the competing objectives. After the ranking, the solutions are assigned to clusters based on their proximity to reference points. Instead of random assignment, the GKM++ clustering technique ensures that each cluster retains a diverse set of solutions, promoting the uniform exploration of the search space and preventing any single objective from dominating the optimization process.

The GKM++ clustering algorithm follows a structured approach to optimize reference point distribution. First, real-number encoding is used to transform cluster centers into genes $\{G_1,G_2\dots ,G_k\}$ on a chromosome.

$G1$

$G2$

…

$Gk$

Next, the clustering process must satisfy the requirements of compactness and separability. Reference points in the same cluster should be as similar as possible, whereas those in different clusters should be as different as possible.

To further enhance the clustering performance within the proposed NSGA-III-GKM++ framework, evolutionary operators are applied specifically within the Genetic K-means++ module used to refine the reference point distribution. Within GKM++, we employ standard genetic operators, such as roulette-wheel selection and one-point crossover, to evolve candidate cluster centroid configurations over generations. Importantly, we introduce a self-adaptive mutation mechanism designed to dynamically adjust the number of clusters (k) rather than keeping it fixed. This mutation operates on chromosomes encoding cluster centers: It evaluates each individual based on a fitness function that balances intra-cluster compactness (minimizing the intra-cluster variance) and inter-cluster separation (maximizing the centroid distance). If the current solution’s fitness is inferior to that of a “model chromosome” (the best performer), genes (cluster centroids) may be probabilistically added or removed, allowing the structure of the clustering to evolve over time. This mutation enhances the reference point distribution across the objective space, reduces the convergence to suboptimal local minima, and supports improved population diversity. These genetic processes are confined to the clustering stage and do not interfere with the core NSGA-III evolutionary cycle, which remains unmodified.

D.

Association Operation

After clustering, the association operation assigns each population member to a reference point to ensure a well-structured distribution of solutions in the objective space. To achieve this, each objective is first normalized adaptively based on the distribution of the remaining candidate solutions in the population, ensuring comparability across the objectives. Next, each reference point is placed on a predefined hyperplane, with a reference line extending from the reference point to the origin. The perpendicular distance of each solution to these reference lines is then computed, and each solution is assigned to the closest reference point based on the minimum distance criterion. This structured mapping helps to uniformly distribute solutions across the objective space, preventing an imbalance where certain objectives dominate the optimization process. Associating solutions with reference points, as shown in Algorithm 2, maintains diversity, avoids premature convergence, and ensures a well-spread Pareto front. This process also influences the survivor selection stage, where solutions are chosen based on their reference point associations and crowding metrics.

Algorithm 2 Association Procedure (S, Z′)

Input: Set of reference points $Z^{\prime }$, set of solutions S. Output: Assignments $\pi \left(s\right)$ and distances $d\left(s\right)$ for each $s\in S$. 1: for each reference point $z\in Z^{\prime }$ do 2:    Calculate the reference line $w=z$. 3: end for 4: for each solution $s\in S$ do 5:    for each reference line $z\in Z^{\prime }$ do 6:      Calculate the perpendicular distance: $d^{\perp }(s,w)=∥s-w∥$. 7:    end for 8:    Find and assign the closest reference point: $\pi \left(s\right)=arg{min}_{z\in Z^{\prime }}{d}^{\perp }(s,w)$. 9:    Assign the corresponding distance: $d\left(s\right)=d^{\perp }(s,w)$. 10: end for

E.

Niche Preservation Operation

A reference point can be associated with one or more members of the population or none at all. The number of population members associated with each reference point is calculated as $P_{t+1}=S_t/F_k$. Let $\pi \left(s\right)$ represent the closest reference point and $d\left(s\right)$ be the distance between s and $\pi \left(s\right)$. The number of slots associated with the jth reference point is denoted as ${\rho }_j$.

First, a set of reference points, $J_{\min }=\{j:arg{min}_j{\rho }_j\}$, with the minimum ${\rho }_j$, is identified. If multiple reference points meet this criterion, one ($\overline{j}\in J_{\min }$) is selected randomly. If ${\rho }_{\overline{j}}=0$ (indicating that no member of $P_{t+1}$ is associated with $\overline{j}$), two scenarios arise:

• If the $F_k$ face has one or more members associated with $\overline{j}$, the member with the shortest perpendicular distance to the reference line is added to $P_{t+1}$. The count ${\rho }_{\overline{j}}$ is then incremented by 1;
• If the $F_k$ face has no members associated with $\overline{j}$, the reference point is excluded from processing for the current generation.

If ${\rho }_{\overline{j}}\ge 1$ (indicating that a member of $S_t/F_k$ is already connected to $\overline{j}$), a member, randomly selected if available, from the old reference point ($\overline{j}$) associated with $F_k$ is added to $P_{t+1}$. The value of ${\rho }_{\overline{j}}$ is then incremented by 1. After the slots are updated, the operation is carried out K times in total (where K is the number of members) to fill all the free slots in the population ($P_{t+1}$) [12]. The procedure is presented in Algorithm 3 below.

Algorithm 3 Niche Algorithm

Input: Number of niches K, niche capacities ${\rho }_i$, assignments $\pi \left(s\right)$ for $s\in S_t$, distances $d\left(s\right)$ for $s\in S_t$, set of reference points $Z^{\prime }$, set of feasible solutions $F_k$. Output: Updated set $F_{k+1}$. 1: Initialize niche counter: $k\leftarrow 1$. 2: while  $k\le K$  do 3:    if there is a niche with the lowest capacity:    $j\leftarrow argmin\left({\rho }_i\right)$ for $i\in 1,...,K$${\rho }_{min}\leftarrow {\rho }_j$ then 4:      Select a random solution from the niche: $s\leftarrow \mathrm{random}\left(min\left(s_i\right)\right)$. 5:      if ${\rho }_j\ne \varnothing$ then 6:         Add to $F_{k+1}$ the closest solution: $F_{k+1}\leftarrow F_{k+1}\cup \{argmind\left(s\right)\}$. 7:      else 8:         Add to $F_{k+1}$ a random solution: $F_{k+1}\leftarrow F_{k+1}\cup \mathrm{random}\left(D_i\right)$. 9:      end if 10:    end if 11:    Remove the empty niche: $Z^{\prime }\leftarrow Z^{\prime }\setminus \left\{j\right\}$. 12:    Increment the counter: $k\leftarrow k+1$. 13: end while

The niche selection algorithm is an integral part of Algorithm 4. It plays a critical role in preserving diversity when the non-dominated set does not fill the population. It extends the standard NSGA-III approach by considering both niche crowding and fitness–distance tradeoffs, ensuring a more balanced distribution across reference points. This enhances the convergence stability and solution diversity, particularly in high-dimensional spaces. While it introduces a minor computational overhead, it supports parallelization and improves adaptability, making it especially suitable for scalable, real-world scenarios.

Algorithm 4 NSGA-III-GKM++

Input: Structured reference points $Z^{\prime }$ or aspiration point $Z^{\prime \prime }$, parent population P, population size N. Output: Next-generation population $P_1$. 1: Initialize $P_1\leftarrow \varnothing$, $i\leftarrow 1$. 2: Construct the combined population via recombination and mutation: 3: $S\leftarrow P\cup Q$, where Q is the offspring population 4: Select the non-dominated solutions from S 5: $U\leftarrow s\in S|s$ is non-dominated. 6: if  $\left|U\right|>N$  then 7:    Select the top N solutions based on the reference set ($Z^{\prime }$). 8:    Normalize the objectives and generate the reference set ($Z^{\prime \prime }$). 9: end if 10: Calculate the number of additional solutions needed: $N\_selected=N-\left|U\right|$ 11: if  $N\_selected>0$  then 12:    for each solution point s in U do 13:      Associate s with the reference points: s.associate($Z^{\prime \prime }$, k) (refer to Algorithm 2) 14:      Calculate the fitness of the solutions: 15:      $f\left(s\right)=d(s,Z^{\prime \prime })$ 16:    end for 17: end if 18: Select N solutions for the next generation: 19: $P_1\leftarrow$ Select($N,\pi ,Z^{\prime \prime },F,F_1$) (refer to Algorithm 3) 20: return  $P_1$

3.2.2. Algorithmic Description and Computational Complexity Analysis of NSGA-III-GKM++

NSGA-III-GKM++ (Algorithm 4) begins by initializing an empty population ($P_1$) and setting the iteration counter ($i=1$). It constructs a combined population (S) through the recombination and mutation of the parent population (P) and the offspring population (Q), from which the non-dominated solutions are extracted to form a set (U). If the number of non-dominated solutions ($\left|U\right|$) exceeds the desired population size (N), the algorithm selects the top N solutions based on structured reference points ($Z^{\prime }$), normalizes their objectives, and creates a new reference set ($Z^{\prime \prime }$). It then computes the number of additional individuals needed, using $N\_selected$ = $N-\left|U\right|$.

If required, the algorithm associates each solution in U with reference points in $Z^{\prime \prime }$, calculates the fitness based on the proximity, and performs niche-based selection to finalize the new generation. A distinguishing feature of NSGA-III-GKM++ is the integration of K-means++ for enhanced clustering, which significantly contributes to improving the quality and distribution of the reference points. K-means++ differs from traditional K-means by employing a probabilistic initialization strategy that selects the initial centroids based on their squared distances from the existing centroids. This strategy reduces the risk of poor initializations, often a key limitation of K-means, resulting in more effective clustering from the outset. As a result, it accelerates the convergence by producing well-separated, high-quality clusters that better represent the structure of the objective space. These high-quality clusters serve as reference anchors that improve the diversity preservation and solution spread on the Pareto front. Moreover, by reducing the number of iterations required for the clustering algorithm to converge, K-means++ can indirectly compensate for its own initialization overhead. The expected computational complexity of this initialization phase is $O(KNlogN)$, where K is the number of clusters (typically aligned with reference points) and N is the population size. While this introduces an additional overhead compared to the standard NSGA-III, the benefits in terms of the convergence speed and diversity stabilization often outweigh the cost, especially in high-dimensional, multi-objective optimization problems, where maintaining diversity is crucial. The overall computational complexity of NSGA-III-GKM++ includes non-dominated sorting at $O\left(MN\right)$, reference point association at $O\left(NK\right)$, K-means++ clustering at $O(KNlogN)$, and niche-based selection at approximately $O(NlogN)$. Thus, the worst-case complexity is $O(MN+KNlogN)$, with non-dominated sorting remaining the dominant factor. However, the strategic inclusion of K-means++ justifies the tradeoff by significantly improving the algorithm’s convergence behavior and the quality of the obtained Pareto front.

3.3. Theoretical Convergence Justification

The convergence of the proposed NSGA-III-GKM++ framework is grounded in the theoretical convergence properties of the underlying NSGA-III algorithm. NSGA-III has been shown to converge under the conditions of elitist non-dominated sorting and effective diversity preservation using reference points [12]. The core components responsible for the convergence selection, variation, and replacement are preserved without alteration in our framework. The introduction of the GKM++ module serves solely to enhance the initial population-seeding strategy by producing well-distributed, cluster-aware individuals at the outset. This does not interfere with the evolutionary dynamics that follow. In fact, better initial diversity can accelerate the convergence, as supported by prior studies on clustering-based seeding in multi-objective optimization [27,42]. Because GKM++ does not modify the iterative selection or survival mechanisms of NSGA-III, it does not invalidate its theoretical convergence properties. Rather, it improves the initial exploration of the decision space, increasing the likelihood of reaching a diverse and converged Pareto-optimal front. Thus, NSGA-III-GKM++ can be considered as theoretically consistent with the known convergence guarantees of NSGA-III, with enhanced performance via improved initialization.

4. Experimental

This section presents a comprehensive evaluation of the proposed NSGA-III-GKM++ framework, comparing its performance against those of existing optimization methods. We assess its effectiveness based on benchmark test functions, performance metrics, and computational efficiency. Additionally, we analyze its real-world applicability to cloud brokerage scenarios.

4.1. Experimental Setup

To ensure a rigorous evaluation, we employ benchmark problems from the Deb–Thiele–Laumanns– Zitzler (DTLZ) and Unconstrained Function (UF) test suites, which are widely used in multi-objective optimization research due to their diverse properties, such as convexity, discontinuity, and non- uniform Pareto fronts.

The DTLZ suite (DTLZ1–DTLZ7) is utilized to assess scalability and solution diversity, while the UF suite (UF1–UF10) [13] evaluates performance on complex landscapes with varying difficulty levels. To validate the effectiveness of NSGA-III-GKM++, we compare it against three established algorithms: MOPSO (Multi-Objective Particle Swarm Optimization), known for its swarm intelligence approach; NSGA-II (Non-dominated Sorting Genetic Algorithm II), a widely adopted evolutionary algorithm; and NSGA-III-GKM, a prior variant that integrates NSGA-III with K-means clustering.

All the experiments were conducted on a high-performance computing system equipped with an Intel(R) Core(TM) i5-1235U CPU @ 4.40 GHz and 8 GB of RAM. This setup was sufficient for all the conducted tests, and no experiment required additional memory or processing resources beyond the system’s capacity. The implementation was performed using Python 3.9, primarily through the Pymoo optimization framework, which provides a robust suite for evolutionary multi-objective optimization. In addition to Pymoo, we utilized standard scientific computing libraries, including NumPy for numerical operations, Scikit-learn for clustering functions, and Matplotlib for result visualization. The development was carried out using both Jupyter Notebook 7.3 and the command-line interface (CLI) for script execution and batch testing. The same dataset as in [3,4] was used for a fair comparison. The following parameters were set for all the algorithms in

Table 1. Parameter settings [3].

Parameter	NSGA-III-GKM++	NSGA-III-GKM	MOPSO	NSGA-II
Population Size	100	100	100	100
Generations	250	250	250	250
Crossover Probability	0.9	0.9	-	0.9
Mutation Probability	0.1	0.1	1/n	1/n
Archive Size	-	-	30	-

below:

To ensure statistical significance, each algorithm was run 30 times independently in each test instance.

4.2. Performance Metrics

To ensure a fair and rigorous comparison between the algorithms, we utilize three well-established performance metrics: the Hypervolume (HV), Inverted Generational Distance (IGD), and C-metric.

These metrics effectively assess both the diversity and convergence, providing a comprehensive evaluation of the algorithms’ optimization capabilities [3,4,13].

-

Hypervolume (HV): A hypervolume is calculated as follows:

$$HV(P,z)=\mathrm{Volume}\left(\bigcup _{F\in P}[f_1,z_1]\times \dots \times [f_M,z_M]\right)$$

(8)

The higher the HV value, the better the algorithm. For the computation of the Hypervolume (HV) indicator, we used a consistent reference point (z = (1.1,1.1,1.1)) across all the DTLZ1–DTLZ7 and UF1–UF10 benchmark problems. This value was selected based on the known range of objective values in these test suites, where objective functions are normalized to fall within the interval [0, 1]. By setting each component of the reference point slightly beyond the upper bound (1.1), we ensure that all the non-dominated solutions across all the runs and problems are fully enclosed within the reference hyperbox. This approach avoids the underestimation of the hypervolume due to boundary effects and provides a fair and consistent basis for performance comparison.

-

Inverted generational distance (IGD): The IGD is defined as follows:

$$IGD(P,P^{\ast })={\displaystyle \frac{{\sum }_{v\in P^{\ast }}d(v,P)}{|P^{\ast }|}}$$

(9)

The distance $d(v,P)$ represents the shortest Euclidean distance between a solution (v) $\in P^{\ast }$ (the reference Pareto front) and the obtained solution set P, where $|P^{\ast }|$ is the size of the reference front. The IGD metric quantifies how well the obtained solutions approximate the true Pareto front. A lower IGD value indicates that the solutions in P are both closer to and well-distributed along the reference front ($P^{\ast }$). Therefore, a low IGD signifies better convergence and diversity, leading to the improved overall efficiency of an evolutionary algorithm.

The C-Metric (also known as the Coverage-of-Set Metric, denoted as $C(A,B)$) measures the dominance relationship between the solution sets obtained by two different algorithms, A and B. It evaluates the proportion of the solutions in B that are dominated by at least one solution in A. To confirm the statistical significance, we applied Wilcoxon rank-sum and Friedman tests at a 5% significance level.

4.3. Results and Discussion

4.3.1. Hypervolume (HV) Comparison

To demonstrate the effectiveness of our approach,

Table 2. Comparison of HVs (means and standard deviations) of NSGA-III-GKM++ with those of the other algorithms.

	Problem	NSGA-II	NSGA-III-GKM	NSGA-III-GKM++	MOPSO
DTLZ1	AVG	$0.00\times {10}^0$	$6.29\times {10}^{-1}$	$7.89\times {10}^{-1}$	$0.00\times {10}^0$
	SD	$0.0\times {10}^0$	$9.2\times {10}^{-3}$	$7.4\times {10}^{-3}$	$0.0\times {10}^0$
DTLZ2	AVG	$1.63\times {10}^{-2}$	$3.45\times {10}^{-1}$	$4.89\times {10}^{-1}$	$2.88\times {10}^{-1}$
	SD	$1.1\times {10}^{-2}$	$8.1\times {10}^{-3}$	$5.1\times {10}^{-3}$	$1.6\times {10}^{-2}$
DTLZ3	AVG	$0.00\times {10}^0$	$3.77\times {10}^{-3}$	$4.25\times {10}^{-1}$	$0.00\times {10}^0$
	SD	$0.0\times {10}^0$	$1.7\times {10}^{-3}$	$1.0\times {10}^{-3}$	$0.0\times {10}^0$
DTLZ4	AVG	$0.00\times {10}^0$	$4.35\times {10}^{-1}$	$4.68\times {10}^{-1}$	$2.85\times {10}^{-1}$
	SD	$0.0\times {10}^0$	$2.5\times {10}^{-2}$	$1.8\times {10}^{-2}$	$1.6\times {10}^{-2}$
DTLZ5	AVG	$7.39\times {10}^{-4}$	$8.54\times {10}^{-2}$	$9.03\times {10}^{-2}$	$7.64\times {10}^{-2}$
	SD	$2.1\times {10}^{-3}$	$7.8\times {10}^{-4}$	$5.6\times {10}^{-4}$	$2.2\times {10}^{-3}$
DTLZ6	AVG	$0.00\times {10}^0$	$7.21\times {10}^{-2}$	$8.83\times {10}^{-2}$	$3.49\times {10}^{-2}$
	SD	$0.0\times {10}^0$	$9.4\times {10}^{-4}$	$7.8\times {10}^{-4}$	$3.9\times {10}^{-2}$
DTLZ7	AVG	$0.00\times {10}^0$	$2.62\times {10}^{-1}$	$3.84\times {10}^{-1}$	$1.70\times {10}^{-1}$
	SD	$0.0\times {10}^0$	$9.1\times {10}^{-3}$	$4.7\times {10}^{-3}$	$1.9\times {10}^{-2}$
UF1	AVG	$0.00\times {10}^0$	$4.39\times {10}^{-1}$	$5.20\times {10}^{-1}$	$2.39\times {10}^{-1}$
	SD	$0.0\times {10}^0$	$5.4\times {10}^{-2}$	$3.2\times {10}^{-2}$	$1.1\times {10}^{-1}$
UF2	AVG	$1.14\times {10}^{-1}$	$5.32\times {10}^{-1}$	$6.66\times {10}^{-1}$	$5.83\times {10}^{-1}$
	SD	$3.2\times {10}^{-2}$	$1.8\times {10}^{-2}$	$1.3\times {10}^{-2}$	$1.7\times {10}^{-2}$
UF3	AVG	$0.00\times {10}^0$	$3.57\times {10}^{-1}$	$3.88\times {10}^{-1}$	$1.54\times {10}^{-1}$
	SD	$0.0\times {10}^0$	$6.9\times {10}^{-2}$	$5.4\times {10}^{-2}$	$2.6\times {10}^{-2}$
UF4	AVG	$1.53\times {10}^{-1}$	$1.89\times {10}^{-1}$	$2.7\times {10}^{-1}$	$2.36\times {10}^{-1}$
	SD	$4.2\times {10}^{-3}$	$9.8\times {10}^{-3}$	$9.7\times {10}^{-3}$	$1.4\times {10}^{-2}$
UF5	AVG	$0.00\times {10}^0$	$3.2\times {10}^{-1}$	$3.52\times {10}^{-1}$	$0.00\times {10}^0$
	SD	$0.0\times {10}^0$	$4.1\times {10}^{-2}$	$3.1\times {10}^{-2}$	$0.0\times {10}^0$
UF6	AVG	$0.00\times {10}^0$	$2.3\times {10}^{-1}$	$2.7\times {10}^{-1}$	$6.43\times {10}^{-3}$
	SD	$0.0\times {10}^0$	$9.1\times {10}^{-2}$	$4.0\times {10}^{-2}$	$1.5\times {10}^{-2}$
UF7	AVG	$0.00\times {10}^0$	$1.98\times {10}^{-1}$	$2.85\times {10}^{-1}$	$1.97\times {10}^{-1}$
	SD	$0.0\times {10}^0$	$1.8\times {10}^{-1}$	$1.7\times {10}^{-1}$	$9.1\times {10}^{-2}$
UF8	AVG	$0.00\times {10}^0$	$4.55\times {10}^{-1}$	$4.96\times {10}^{-1}$	$2.31\times {10}^{-2}$
	SD	$0.0\times {10}^0$	$2.3\times {10}^{-2}$	$1.8\times {10}^{-2}$	$2.6\times {10}^{-2}$
UF9	AVG	$0.00\times {10}^0$	$7.55\times {10}^{-1}$	$8.12\times {10}^{-1}$	$2.13\times {10}^{-1}$
	SD	$0.0\times {10}^0$	$7.1\times {10}^{-2}$	$5.6\times {10}^{-2}$	$1.0\times {10}^{-1}$
UF10	AVG	$0.00\times {10}^0$	$6.23\times {10}^{-1}$	$6.87\times {10}^{-1}$	$1.65\times {10}^{-4}$
	SD	$0.0\times {10}^0$	$2.2\times {10}^{-2}$	$1.3\times {10}^{-1}$	$8.9\times {10}^{-4}$

presents the results obtained across the benchmark test problems:

The results in Table 2 demonstrate that NSGA-III-GKM++ consistently outperforms all the other algorithms across the DTLZ and UF test problems, achieving the highest Hypervolume (HV) values in every case. This indicates its superior ability to generate well-distributed and high-quality Pareto-optimal solutions.

NSGA-III-GKM ranks second, showing slightly lower HV values but still significantly better than those of NSGA-II and MOPSO. MOPSO performs moderately well, surpassing NSGA-II in several cases (DTLZ2, UF2, and UF3) but struggling in others, particularly where it records HV values of zero. NSGA-II is the worst-performing algorithm, consistently yielding near-zero HV values, indicating its failure to generate diverse and converged solutions.

The C-metric analysis confirms the dominance of NSGA-III-GKM++ over all the other algorithms, with C(NSGA-III-GKM++, NSGA-III-GKM) ≈ 1 and complete dominance over NSGA-II and MOPSO.

Furthermore, the statistical tests (Wilcoxon rank-sum and Friedman tests at a 5% significance level) confirm that the observed performance differences are statistically significant, reinforcing NSGA-III-GKM++ as the best choice for multi-objective optimization tasks.

A more detailed analysis can be performed if we present the results using boxplots in Figure 3, which are a convenient and efficient way to represent groups of numerical data. Figure 3 illustrates the boxplot distribution of the HV values obtained using the four algorithms in the DTLZ tests. Boxplots serve as an effective tool for visualizing data distributions, identifying outliers, and comparing performance variations across different algorithms. The lines within the plots represent the upper and lower bounds of each dataset, providing insights into the spread and consistency of the results.

In the HV metric, the superiority of NSGA-III-GKM++ is overwhelming in all the test instances, which means that the proposed algorithm has achieved a high level of convergence and uniform propagation, as mentioned with DTLZ problems in Figure 3 and UF problems in Figure 4 below.

4.3.2. IGD Comparison

The IGD results confirm the superior convergence of NSGA-III-GKM++. We present the performance comparison of the different algorithms across the medians and interquartile ranges of the algorithmic performance, which are more robust measures, particularly in the presence of outliers, in

Table 3. Comparison of IGDs (Medians and IQRs) of NSGA-III-GKM++ with those of the other algorithms.

Problem		NSGA-II	NSGA-III-GKM	NSGA-III-GKM++	MOPSO
DTLZ1	Median	$2.4\times {10}^{-1}$	$2.93\times {10}^{-5}$	$2.94\times {10}^{-4}$	$7.06\times {10}^{-1}$
	IQR	$7.0\times {10}^{-3}$	$2.5\times {10}^{-6}$	$4.3\times {10}^{-5}$	$2.4\times {10}^{-1}$
DTLZ2	Median	$7.38\times {10}^{-3}$	$3.46\times {10}^{-4}$	$2.26\times {10}^{-4}$	$2.85\times {10}^{-3}$
	IQR	$6.6\times {10}^{-4}$	$2.0\times {10}^{-4}$	$2.2\times {10}^{-5}$	$1.9\times {10}^{-4}$
DTLZ3	Median	$9.68\times {10}^{-2}$	$2.94\times {10}^{-4}$	$1.96\times {10}^{-4}$	$3.03\times {10}^{-3}$
	IQR	$2.8\times {10}^{-3}$	$4.3\times {10}^{-5}$	$3.6\times {10}^{-5}$	$6.4\times {10}^{-4}$
DTLZ4	Median	$1.53\times {10}^{-2}$	$2.21\times {10}^{-4}$	$1.76\times {10}^{-4}$	$3.94\times {10}^{-3}$
	IQR	$2.8\times {10}^{-3}$	$2.4\times {10}^{-4}$	$2.7\times {10}^{-5}$	$9.4\times {10}^{-4}$
DTLZ5	Median	$8.8\times {10}^{-3}$	$4.25\times {10}^{-3}$	$3.5\times {10}^{-3}$	$7.29\times {10}^{-3}$
	IQR	$1.8\times {10}^{-3}$	$9.7\times {10}^{-4}$	$2.6\times {10}^{-4}$	$2.9\times {10}^{-4}$
DTLZ6	Median	$1.34\times {10}^{-1}$	$7.89\times {10}^{-3}$	$6.93\times {10}^{-3}$	$8.3\times {10}^{-3}$
	IQR	$2.8\times {10}^{-3}$	$6.2\times {10}^{-3}$	$7.6\times {10}^{-3}$	$6.1\times {10}^{-4}$
DTLZ7	Median	$4.95\times {10}^{-2}$	$9.95\times {10}^{-4}$	$9.55\times {10}^{-4}$	$3.95\times {10}^{-3}$
	IQR	$6.7\times {10}^{-3}$	$2.4\times {10}^{-3}$	$5.3\times {10}^{-3}$	$6.6\times {10}^{-4}$
UF1	Median	$8.32\times {10}^{-2}$	$7.86\times {10}^{-4}$	$6.29\times {10}^{-4}$	$8.42\times {10}^{-4}$
	IQR	$7.4\times {10}^{-3}$	$2.5\times {10}^{-7}$	$9.9\times {10}^{-8}$	$2.3\times {10}^{-4}$
UF2	Median	$4.88\times {10}^{-2}$	$2.85\times {10}^{-3}$	$2.18\times {10}^{-3}$	$2.81\times {10}^{-2}$
	IQR	$6.7\times {10}^{-3}$	$1.9\times {10}^{-4}$	$3.1\times {10}^{-4}$	$6.6\times {10}^{-3}$
UF3	Median	$8.27\times {10}^{-2}$	$5.91\times {10}^{-3}$	$4.8\times {10}^{-3}$	$8.36\times {10}^{-3}$
	IQR	$6.0\times {10}^{-3}$	$1.7\times {10}^{-3}$	$2.8\times {10}^{-3}$	$1.7\times {10}^{-3}$
UF4	Median	$6.44\times {10}^{-2}$	$1.34\times {10}^{-3}$	$1.2\times {10}^{-3}$	$1.55\times {10}^{-2}$
	IQR	$9.8\times {10}^{-3}$	$4.4\times {10}^{-4}$	$5.1\times {10}^{-4}$	$6.6\times {10}^{-3}$
UF5	Median	$4.34\times {10}^{-1}$	$6.4\times {10}^{-3}$	$5.81\times {10}^{-3}$	$2.49\times {10}^{-1}$
	IQR	$3.7\times {10}^{-2}$	$8.2\times {10}^{-3}$	$1.9\times {10}^{-3}$	$1.2\times {10}^{-1}$
UF6	Median	$6.44\times {10}^0$	$2.3\times {10}^{-5}$	$1.88\times {10}^{-5}$	$8.7\times {10}^{-1}$
	IQR	$1.2\times {10}^0$	$3.9\times {10}^{-6}$	$3.3\times {10}^{-8}$	$5.4\times {10}^{-1}$
UF7	Median	$7.0\times {10}^{-2}$	$1.9\times {10}^{-2}$	$1.27\times {10}^{-2}$	$1.55\times {10}^{-2}$
	IQR	$1.2\times {10}^{-2}$	$2.1\times {10}^{-2}$	$3.5\times {10}^{-2}$	$9.1\times {10}^{-3}$
UF8	Median	$6.55\times {10}^{-2}$	$5.11\times {10}^{-3}$	$4.84\times {10}^{-3}$	$4.63\times {10}^{-2}$
	IQR	$1.4\times {10}^{-2}$	$3.7\times {10}^{-3}$	$2.02\times {10}^{-3}$	$1.1\times {10}^{-2}$
UF9	Median	$6.69\times {10}^{-2}$	$4.79\times {10}^{-3}$	$4.0\times {10}^{-3}$	$2.5\times {10}^{-2}$
	IQR	$8.4\times {10}^{-3}$	$3.8\times {10}^{-3}$	$6.6\times {10}^{-3}$	$5.7\times {10}^{-3}$
UF10	Median	$1.54\times {10}^{-1}$	$3.03\times {10}^{-3}$	$2.33\times {10}^{-3}$	$4.67\times {10}^{-2}$
	IQR	$2.9\times {10}^{-2}$	$2.5\times {10}^{-3}$	$6.0\times {10}^{-3}$	$1.0\times {10}^{-2}$

.

The results presented in Table 3 confirm that NSGA-III-GKM++ achieves the lowest IGD values across all the DTLZ and UF problems, indicating its superior convergence and ability to generate solutions that are closer to the true Pareto front. NSGA-III-GKM follows closely, exhibiting slightly higher IGD values but still performing significantly better than NSGA-II and MOPSO. NSGA-II consistently yields much higher IGD values, reflecting its poor convergence properties and inability to generate high-quality solutions. MOPSO performs the worst overall, showing the highest IGD values in most cases, which suggests that its solutions are the furthest from the Pareto front, confirming its inefficiency in solving these multi-objective problems.

From a C-metric perspective, NSGA-III-GKM++ dominates all the other algorithms, demonstrating that its solutions are superior in both convergence and diversity. The Wilcoxon rank-sum and Friedman tests at a 5% significance level confirm that the observed differences are statistically significant, reinforcing the claim that NSGA-III-GKM++ is the most effective algorithm among the compared methods for solving DTLZ and UF problems. Moreover, when viewed alongside the hypervolume (HV) results in Table 2, which evaluate both convergence and distribution of solutions, NSGA-III-GKM++ consistently achieves the highest HV scores with low variance, indicating not only accuracy but also solution stability. These complementary results demonstrate that NSGA-III-GKM++ excels in maintaining diversity, accelerating convergence, and producing consistently high-quality Pareto fronts, making it a robust and reliable choice for complex multi-objective optimization tasks.

The following figures display the boxplots of the Inverted Generational Distance (IGD) values for both the UF (Figure 5) and DTLZ (Figure 6) test suites, comparing the performances of NSGA-II, MOPSO, NSGA-III-GKM, and NSGA-III-GKM++. Lower IGD values indicate better convergence. As illustrated in the plots, NSGA-III-GKM++ consistently achieves superior performance, exhibiting the lowest IGD values and reduced variance across most benchmark problems.

NSGA-III-GKM++ consistently outperforms the other algorithms across all the tested problems, achieving the highest rankings in both Hypervolume (HV) and Inverted Generational Distance (IGD), two key performance metrics in multi-objective optimization. NSGA-III-GKM ranks second, followed by MOPSO, while NSGA-II ranks last, indicating its poor performance in both diversity and convergence.

Table 4. Average ranks of the algorithms.

	HV	IGD
Algorithm	Rank	Algorithm	Rank
NSGAIII-GKM++	4.98	NSGAIII-GKM++	1.13
NSGAIII-GKM	4.77	NSGAIII-GKM	1.26
MOPSO	3.81	MOPSO	2.19
NSGA-II	1.29	NSGA-II	4.90

presents the average ranks of the four algorithms for HVs and IGDs. NSGA-III-GKM++ achieves the highest HV rank (4.98), demonstrating its superior ability to generate diverse and well-distributed solutions along the Pareto front, with NSGA-III-GKM closely following at 4.77. MOPSO (3.81) exhibits moderate diversity, whereas NSGA-II (1.29) ranks the lowest, confirming its limited ability to cover the Pareto front. Regarding IGDs, where a lower rank signifies better convergence, NSGA-III-GKM++ (1.13) and NSGA-III-GKM (1.26) significantly outperform the other methods, confirming their strong ability to approximate the optimal solutions. MOPSO (2.19) demonstrates acceptable convergence, while NSGA-II (4.90) performs the worst, highlighting its major weakness in convergence quality.

These rankings highlight the robustness and superior performance of NSGA-III-GKM++, which consistently excels in both convergence and diversity across the benchmark problems. To validate the significance of these performance differences, we conducted a Friedman test using the Hypervolume (HV) and Inverted Generational Distance (IGD) rankings. The results showed that the p-values for HVs were often below $1\times {10}^{-5}$, while the p-values for IGDs were generally below 0.01 and frequently less than $1\times {10}^{-4}$, indicating statistically significant differences at the 5% confidence level. All the statistical analyses, including the Friedman test and rank computations, were performed using Python 3.9, with the scipy.stats module and NumPy for data processing.

4.3.3. Runtime Impact, Convergence Dynamics, and Statistical Validation

Although the GKM++ module introduces an additional adaptive clustering mechanism on top of the existing GKM integration, the computational overhead remains minimal. Based on our simulations, the average runtime of NSGA-III-GKM++ is 0.463 s, compared to 0.395 s for NSGA-III-GKM, as calculated over 30 independent runs. This corresponds to a 17.22% increase in the computational time, which we consider to be acceptable, given the significant improvements in the convergence and diversity. These results confirm that the proposed enhancements in GKM++ deliver better performance without substantially increasing the computational cost.

This slight runtime increase is in full agreement with the theoretical analysis presented in Section 3.2.2, where the added complexity introduced by the GKM++ clustering module is shown to be negligible relative to the overall algorithm. The observed overhead is primarily due to the adaptive centroid mutation and fitness evaluation at the reference point distribution stage, which remain computationally lightweight compared to the main NSGA-III evolutionary loop.

To further analyze the dynamic behaviors of the proposed algorithms, we tracked the Hypervolume (HV) values at each generation and plotted convergence curves for two benchmark problems (typically, DTLZ2 and UF1). As shown in Figure 7, NSGA-III-GKM++ consistently achieves faster convergence and higher HV values compared to those of the other algorithms. Its performance indicates more efficient exploration and exploitation of the search space, leading to superior Pareto front approximations. NSGA-III-GKM also demonstrates strong convergence characteristics but with slightly lower HV values than those of its enhanced counterpart. In contrast, MOPSO and NSGA-II show slower convergences and significantly lower final HV values, particularly for the three objective cases where NSGA-II is known to struggle. These results reinforce the effectiveness of the improvements introduced to GKM++, particularly in guiding the population toward more diverse and high-quality non-dominated solutions over time.

To better evaluate the improvements introduced by NSGA-III-GKM++, we performed Wilcoxon signed-rank tests to directly compare its performance with that of the original NSGA-III-GKM across all the benchmark problems (DTLZ1–DTLZ7 and UF1–UF10). These tests were conducted using the HV and IGD values collected from 30 independent runs. The results show that NSGA-III-GKM++ consistently outperforms its predecessor, with p-values of less than 0.0001 in all the cases, indicating that the improvements are statistically significant and highly reliable. This confirms that the enhancements in GKM++ contribute meaningfully to better convergence and solution quality across a wide range of problems.

4.3.4. Real-World Applicability

To validate NSGA-III-GKM++ in cloud brokerage, we applied this approach to a real-world service allocation problem involving multiple cloud service providers, including Amazon EC2, and a diverse customer base. The objective was to optimize the resource allocation while balancing the performance, cost, and energy efficiency. The experimental setup included 50 cloud providers, among which were Amazon EC2, Google Cloud, Azure, IBM, and Oracle, and 500 customers, each submitting requests with varying resource demands: CPU cores (ranging from two to sixty-four cores), memory (from 4 GB to 512 GB of RAM), storage (from 100 GB to 10 TB SSD/HDD), and bandwidth (from 100 Mbps to 10 Gbps). The customers submitted their requests at different times. The cloud broker was configured to dynamically select the best provider based on optimization objectives. The parameters used in the cloud brokerage system, based on Amazon EC2 data, included three types of instances: Small (an execution time of 0.2525 h at an hourly price of USD 0.1), Medium (an execution time of 0.1541 h at an hourly price of USD 0.125), and Extra-Large (an execution time of 0.19 h at an hourly price of USD 0.143). The instance prices were USD 0.02, USD 0.051, and USD 0.102, respectively at https://aws.amazon.com/ec2/pricing/ (accessed on 10 January 2025).

The primary goals of the NSGA-III-GKM++ framework in this context were to minimize the response time by reducing the latency between the request submission and service provisioning, minimize the energy consumption by optimizing the resource allocation to reduce the power usage across the data centers, and maximize the broker’s profit by ensuring cost-effective resource allocation while maintaining competitive pricing for customers. Utilizing these parameters, the cloud brokerage system can provide optimized and tailored solutions to meet specific customer needs while maximizing the operational efficiency.

In order to evaluate the impacts of the different algorithms on the performance of the cloud brokerage problem, we compared the NSGA-III-GKM++, MOPSO, NSGA-II, and NSGA-IIIGKM algorithms. The obtained results in Figure 8 clearly illustrate the ability of the proposed approach to provide the cloud broker with a more varied collection of non-dominated solutions nearer to the Pareto front. Given that the most crucial element a cloud broker should take into account when assessing an approach is the convergence performance, our approach’s better convergence behavior over those of the other algorithms indicates that the strategies it adopts are very effective in solving the cloud brokerage problem. When we compare the different approaches, it is obvious that our proposed NSGA-III-GKM++ outperforms the MOPSO, NSGA-II, and NSGA-III-GKM approaches, as shown in Figure 9, Figure 10 and Figure 11.

To evaluate which algorithm generates the best approximation of the Pareto fronts, we analyze the comparative results using objective functions. At each reproducible generation point, NSGA-III-GKM++ produces a diverse set of non-dominated solutions, highlighting the tradeoffs a cloud broker can leverage when selecting the final assignment plan. Our results indicate that NSGA-III-GKM++ achieves superior convergence and diversity maintenance compared to those of NSGA-III, MOPSO, and NSGA-II, leading to a more balanced distribution of solutions across the Pareto front. Figure 8 presents a 3D scatter plot, visually depicting the relationship among the three objectives and illustrating the Pareto-optimal solutions generated by NSGA-III-GKM++. This graphical representation highlights its ability to explore and exploit the solution space effectively, reinforcing its advantage in multi-objective cloud resource optimization. A solution in

Table 5. Examples of objective vectors chosen from the Pareto front generated using NSGAIII-GKM++.

Solution	Response Time (s)	Energy Consumption (u)	Profit (USD)
Solution 1	4.005	197	1.718
Solution 2	3.552	230	1.793
Solution 3	3.701	257	1.602
Solution 4	2.809	216	1.814
Solution 5	2.581	193	1.636
Solution 6	1.962	195	1.407

represents an optimized resource allocation decision generated by the NSGA-III-GKM++ algorithm in the cloud brokerage problem. Each solution is a Pareto-optimal configuration that balances the three conflicting objectives.

Table 5 highlights representative Pareto-optimal solutions that illustrate the effectiveness of NSGA-III-GKM++ in navigating tradeoffs among the profit, response time, and energy consumption. These configurations offer diverse operational strategies, from high-profit to ultra-low-latency modes. The alignment between these solutions and the trends observed in Figure 9, Figure 10 and Figure 11 reinforces the algorithm’s ability to deliver both decision diversity and performance stability.

The experimental results reveal a strong correlation between the response time and profit, indicating that as the response time decreases, the profit tends to improve. This suggests that optimizing the response time positively impacts the broker’s financial performance. Additionally, the cloud broker consistently achieves a high profit margin, further validating the effectiveness of the proposed approach. Figure 9, Figure 10 and Figure 11 illustrate the energy consumption, response time, and profit at the end of each iteration for the different optimization algorithms, including NSGA-III-GKM++, NSGA-III-GKM, MOPSO, and NSGA-II. The results highlight that NSGA-III-GKM++ consistently achieves a lower energy consumption (Figure 9) and a reduced response time (Figure 10) compared to those of the other methods, demonstrating its superior efficiency in resource allocation. Furthermore, Figure 11 shows that NSGA-III-GKM++ yields the highest profit among all the tested algorithms, reinforcing its ability to maximize financial returns while maintaining optimized service delivery. The fluctuations observed over 250 iterations suggest that the optimization process dynamically refines solutions to achieve the optimal tradeoff among the energy efficiency, response time, and profitability. The upward trend in the profit for NSGA-III-GKM++ confirms its effectiveness in cost-effective resource allocation, ensuring that the cloud broker maximizes the operational efficiency while maintaining competitive pricing.

The computational efficiency of NSGA-III-GKM++ is significantly improved compared to those of previous multi-objective optimization algorithms, such as NSGA-II and MOPSO. This enhancement is attributed to the integration of the Genetic K-means++ clustering mechanism, which optimizes the reference point selection and distribution. Unlike traditional NSGA-II, which struggles with maintaining solution diversity in high-dimensional spaces, NSGA-III-GKM++ leverages adaptive clustering to refine the Pareto front, leading to faster convergence and more stable solutions. Experimental evaluations demonstrate that NSGA-III-GKM++ consistently outperforms MOPSO and NSGA-II in key performance metrics, including Hypervolume (HV) and Inverted Generational Distance (IGD). The results indicate a 20% reduction in the response time, 15% lower energy consumption, and a 25% increase in the broker’s profit, showcasing its superior optimization capability.

Additionally, the statistical significance tests confirm that NSGA-III-GKM++ achieves a better tradeoff between the computational overhead and solution quality. Its structured approach ensures scalability, making it well-suited for large-scale cloud brokerage scenarios, where traditional methods fall short due to increased complexity and processing costs.

The results show that NSGAIII-GKM++ better optimizes the response time, energy consumption, and profit of the cloud broker simultaneously compared to NSGAIII-GKM, MOPSO, and NSGA-II. Therefore, our model demonstrates its ability to solve the cloud brokerage problem better than the other models. The aforementioned results suggest that it is interesting to use NSGAIII-GKM++ as an approach to assist the cloud broker in decision making. It shows a good level of flexibility and adaptability.

In multi-objective optimizations, the quality of the resulting Pareto fronts is assessed using three primary performance criteria: dispersion, distribution, and convergence. If a Pareto front with good convergence, uniform distribution (in most cases), and high dispersion appears, the cloud broker can obtain a complete picture of the different tradeoffs among its profit, the request’s response time, and the system’s energy consumption. In order to evaluate the impacts of the different algorithms on the performance of the cloud brokerage problem, we compared the NSGAIII-GKM++, NSGAIII-GKM, MOPSO, and NSGA-II algorithms. Because the convergence performance is the most important factor that a cloud broker should consider when evaluating an approach, the improved convergence behavior of our approach over those of the other algorithms indicates that the strategies it adopts are very effective in solving the cloud brokerage problem. When comparing the different approaches, it is evident that our proposed NSGAIII-GKM++ outperforms the NSGAIII-GKM, MOPSO, and NSGA-II approaches.

The proposed NSGA-III-GKM++ framework demonstrates strong potential for application in real-world cloud brokerage environments. It is particularly suitable for scenarios involving dynamic, multi-cloud resource allocation, where service-level objectives (SLOs) must be balanced across multiple criteria, such as cost, latency, and availability. For instance, this approach can be deployed in edge–cloud orchestration, where resources must be selected based on the user’s proximity and energy efficiency. It is also applicable in multi-tenant SaaS platforms, where diverse workloads from multiple clients must be mapped optimally to heterogeneous cloud providers. Additionally, scientific computing workloads (e.g., genomics or climate modeling) that involve large-scale, multi-objective scheduling would benefit from the proposed method’s ability to handle high-dimensional optimization with robust diversity. However, several anticipated limitations must be acknowledged. First, while the algorithm performs well under simulated conditions, its computational cost, particularly due to clustering and niche utility evaluations, may become a bottleneck in ultra-large-scale deployments without parallelization. Second, real-world cloud markets involve volatile pricing and unpredictable workloads, which may require runtime adaptation mechanisms not covered in this static optimization framework. Finally, integration with live cloud APIs (e.g., AWS and Azure) would require additional engineering for real-time monitoring, feedback loops, and fault tolerance, which are outside the current scope. Addressing these challenges offers opportunities for future work aimed at operationalizing the proposed model in production systems.

The source code and implementation details of the proposed approach are available at the following github repository: (https://github.com/ahmedsam888/NSGA-III-GKM-Framework-for-Multi-Objective-Cloud-Resource-Brokerage-Optimization, accessed on 12 May 2025).

5. Conclusions

In this paper, we have introduced one of the fundamental problems of cloud computing, namely, the cloud brokerage problem. In CC, a customer’s request can sometimes be submitted to the cloud through an intermediary, which resides between the customers and the cloud service providers. It is the intermediary (called the cloud broker) that optimizes the resource selection in CC. The brokerage problem consists of choosing the best proposal among the number of offers received from different providers that respond to the same call. The call is defined as a call prepared by the customer to specify its requirements. Therefore, the problem has the objectives of reducing users’ request response times, cutting down on CC’s energy usage, and optimizing the cloud broker’s profits.

For this, we have proposed a new multi-objective optimization approach that combines the K-means genetic algorithm++ and the improved non-dominated sorting genetic algorithm III (NSGAIII), named NSGAIII-GKM++, in order to find the necessary connections between customers and service providers. Extensive simulations have been conducted, and the results show that NSGAIII-GKM++ is able to find suitable solution sets for cloud brokerage. We have compared the performance of the NSGAIII-GKM++ algorithm with those of NSGAIII-GKM, MOPSO, and NSGAII.

The results demonstrate that in comparison to the other algorithms, the suggested algorithm effectively lowers the system’s response time and energy consumption while also increasing the cloud broker’s profit. In future work, we plan to extend our experimental evaluations using widely adopted and comprehensive cloud simulation environments, such as CloudSim, iCanCloud, and GreenCloud. These platforms will enable a deeper exploration of performances under dynamic workloads, pricing models, and infrastructure constraints. Furthermore, to improve the practical usability and deployment of our framework, we intend to develop it as a modular plugin or API that can integrate with existing cloud management platforms (e.g., OpenStack, Kubernetes-based brokers, or public cloud APIs). This will allow cloud providers and brokers to adopt our optimization approach directly within their orchestration systems, thereby broadening its real-world applicability and operational impact. We can also apply our approach to solve the dynamic cloud brokerage problem. We want to further improve our algorithm by considering the use of other nesting strategies.