Heuristic-based load balancing for identical virtual machines: a fair scheduling approach using probabilistic methods

Notation

Table 2 presents the principal notations employed in this article. It specifies parameters pertinent to programs and virtual machines, as well as indices and completion time metrics. These notations underpin the proposed workload scheduling model and its ensuing analysis.

Problem presentation

Let the set J a specific of $n$ distinct programs that are to be systematically organized and appropriately scheduled across $m$ parallel virtual machines that operate simultaneously. Each program, designated as $j$, possesses and is characterized by a unique set of attributes that dictate its operational requirements and constraints within the scheduling framework.

The diagram depicted in Fig. 1 meticulously delineates five fundamental components that are crucial to the overall architecture, which can be outlined as follows:

• •

  API gateway: This component serves as the primary interface through which all incoming program submissions are received and processed, effectively acting as the first line of interaction between external requests and the internal architecture.

• •

  Load balancer: This fundamental system is important for spreading out incoming requests across various schedulers, guaranteeing that these requests are managed in a proficient and coordinated fashion without triggering any delays or holdups.

• •

  Scheduler: Operating as a crucial manager, the scheduler is in charge of the thoughtful task assignment to diverse virtual machines, or VMs, and it skillfully directs the execution of these tasks to ensure superior performance.

• •

  VM instances $(V{M}_1,V{M}_2,V{M}_3,\dots ,V{M}_m)$: These virtual machine instances represent the actual computational environments where programs are executed, providing the necessary infrastructure for running applications in a cloud-native ecosystem.

• •

  Resource monitor: This sophisticated component is tasked with continuously collecting real-time metrics, including, but not limited to, CPU usage, memory consumption, and overall load from each virtual machine. Subsequently, it relays this information back to the scheduler through a dashed feedback loop, which facilitates dynamic adjustments to resource allocation.

This architectural framework epitomizes a quintessential cloud-native workflow and vividly illustrates the cooperative dynamics of monitoring and orchestration that work in tandem to uphold both performance standards and fairness across the various components involved. Should you seek a more comprehensive investigation into specific elements, such as a container orchestrator like Kubernetes, a dedicated datastore, or the subtleties of network layers, please inform me for more clarity.

System assumptions and applicability

In this research, the proposed framework operates based on a defined set of explicit assumptions to ensure both clarity and applicability. The context examined is a virtualized cloud computing infrastructure, wherein a finite collection of independent workloads (or applications) must be allocated to a selection of VMs. It is argued that the workloads are not subject to interruption, implying that once an application is put on a VM, it will run to its end without any breaks. Each workload possesses a known and deterministic processing duration ( $p_j$), and all VMs are homogeneous in their execution capabilities unless stated otherwise. Furthermore, there are no interdependencies among workloads, and communication or migration overheads are regarded as negligible. These assumptions accurately represent numerous practical scenarios within cloud and data center environments where task scheduling and resource allocation are of paramount importance. Even though the model is built for consistent scenarios, it can be adjusted to meet fluctuating or irregular workloads via additional tools established to confront uncertainties.

This research presumes that all VMs within the system exhibit homogeneity, signifying that they possess identical computational power, memory, and storage capabilities. This assumption facilitates a more precise examination of the fairness and workload balancing mechanisms proposed in the proposed heuristics. Nonetheless, it is recognized that in practical cloud environments, VMs frequently display heterogeneity, characterized by differing central processing unit (CPU) speeds, graphics processing unit (GPU) capabilities, and memory limitations. The existing heuristics can be modified for heterogeneous environments by integrating weights or normalization factors that reflect VM capabilities during the workload allocation process. For example, processing times $p_j$ could be calibrated in relation to VM performance, and the assignment probabilities in the proposed probabilistic methodologies could be adjusted to prioritize VMs with superior capacities for resource-intensive tasks. Expanding the heuristics to accommodate such heterogeneity presents a promising avenue for future work.

In this research, it is assumed that all tasks possess fixed and deterministic processing durations $p_j$ and that the complete workload is predetermined. This assumption of a static workload enables the assessment of the efficacy of the proposed heuristics in reducing completion time disparities under controlled conditions. Nevertheless, it is recognized that actual cloud environments frequently display dynamic characteristics, encompassing varying task priorities, real-time influx of new workloads, and possible task cancellations. The proposed heuristics can be tailored to accommodate such dynamic settings by incorporating online scheduling mechanisms that progressively adjust allocations in response to variations in workload. For instance, the probabilistic assignment phase could be refined to include newly arriving tasks without disrupting existing assignments, while ensuring fairness and load balancing among virtual machines. Evaluating and validating the heuristics within dynamic workload contexts represents a promising avenue for future work.

Mathematical model

To thoroughly assess and analyze the disparities that exist among the various virtual machines, a comprehensive selection of pertinent indicators has been meticulously identified and chosen for this evaluative process. Within the boundaries of this research document, the distinct parameter that is presented for review and detailed investigation is conveyed mathematically as the distinction between the utmost completion timeframe, signified as $C_{max}$, and the least completion timeframe, indicated as $C_{min}$. When the entire set of virtual machines under investigation, the overall gap in total completion times is quantitatively represented in the mathematical formulation provided in Eq. (1).

(1) $$min\sum _{k=1}^m[C_k-C_{min}].$$

In Eq. (1), the variation for a designated value of $k$ is labeled $di{f}_k$, which is mathematically delineated as the difference between $C_k$ and $C_{min}$. Consequently, it follows that Eq. (1) can be reformulated in the following manner: $min\sum _{k=1}^{m}di{f}_k$. This aggregate is referred to as $gap$, which is mathematically represented by the summation $gap=\sum _{k=1}^{m}di{f}_k$. The problem under investigation is categorized as NP-hard, thereby indicating that the objective is to devise a scheduling strategy that effectively minimizes the cumulative discrepancies, or gaps, that exist between the virtual machine exhibiting the least total completion time and all other virtual machines within the system.

Proof 1 Denote, for the purpose of clarity and specificity, by the notation $J_k$ the comprehensive set of all computing programs that are executed within the operational confines of a designated virtual machine denoted by $k$. Therefore, the aggregate summation of the processing time associated with each individual program contained within the set $J_k$ can be articulated mathematically as ${\mathrm{\Sigma }}_{j\in J_k}{p}_j$, which is equivalently expressed as $C_k$, representing the total computational time consumed by the programs executed by this particular virtual machine. Conversely, it is imperative to consider that all programs that are executed by the virtual machine denoted by $k$, given the condition that

(3) $$\sum _{j=1}^n{p}_j=\sum _{k=1}^m\sum _{j\in J_k}{p}_j.$$

Finally, Eq. (2) is proven.

Probabilistic heuristic

The proposed probabilistic heuristic ( $P{H}_{\beta }$) is designed to allocate workloads across VMs in a manner that minimizes disparities in their completion times. The algorithm systematically investigates various probabilistic assignment strategies by adjusting a parameter $\beta$, which governs the level of randomness in task selection.

Initially, all programs are ordered in non-increasing sequence based on their processing times $p_j$, thereby prioritizing larger workloads that exert a significant influence on the overall system equilibrium. Within the boundaries of [0.1, 0.9], for each $\beta$, the algorithm executes a loop internally where it probabilistically assigns programs. With each round, a random digit $au$ is drawn evenly from the boundaries [1,100]. In the event that $\beta imes100$ encompasses $\beta$ values from 1 to $\beta imes100$, the program that exhibits the longest processing duration from the leftover group $ildeJ$ is selected; if not, the program with the next longest processing duration is chosen. This probabilistic decision-making introduces a controlled element of randomness, enabling the algorithm to circumvent suboptimal deterministic assignment patterns.

Once a program is selected, the assign procedure allocates it to an appropriate VM, updates the VM’s load, and removes the program from the set $\tilde{J}$. After the allocation of all programs, the algorithm calculates the gap $ga{p}_{\beta }$, which quantifies the disparity between the maximum and minimum completion times across all VMs for the current value of $\beta$. This procedure is reiterated for each $\beta$, with the minimum observed gap being returned as the final outcome.

The parameter $\beta$ is instrumental in balancing exploitation and exploration. Lower values of $\beta$ favor deterministic selections of the largest workloads, whereas higher values of $\beta$ introduce greater randomness, which may reveal more advantageous workload distributions. By examining multiple values of $\beta$, $P{H}_{\beta }$ determines the most efficient probabilistic strategy for achieving an optimal balance in system load.

The probabilistic heuristic ( $P{H}_{\beta }$) is illustrated in Algorithm 1.

Proof 2 The sorting mechanism that is employed within the confines of the algorithmic framework in question is characterized as heapsort, which is a well-known and widely studied sorting technique in computer science. In computational terms, heapsort is defined as an algorithm that has a time complexity of $O(n\log n)$, pointing out that its effectiveness is logarithmically linked to the input data size, marked by $n$. Also, it is imperative to indicate that an aggregate of $n-1$ random numerical outputs are created, and based on the specific application that is preferred, the related computational assignments are distributed as necessary; this whole procedure is executed within a time complexity of $O(n)$. The various programs that are contained within each specific set are systematically assigned to a virtual machine, which inherently requires a time complexity of $O(n)$ for their execution. The process involves the repetition of the execution for each distinct value of $\beta$, leading to a comprehensive analysis of performance across these parameters. In this context, a total of 9 discrete values is considered. It is also significant to assert that $n$ is notably much greater than 9, represented mathematically as $n\gg 9$. Consequently, the overall complexity associated with the PH heuristic is determined to be $O(n\log n)$, aligning with the established theoretical understanding of its performance characteristics.

Repetitive probabilistic heuristic

The iterative probabilistic heuristic ( $P{H}_{\beta }^{lm}$) enhances the foundational $P{H}_{\beta }$ algorithm by performing it multiple times to improve both the quality and dependability of the solution. This methodology seeks to mitigate the variability introduced by randomization and to ascertain a more resilient allocation strategy.

The algorithm accepts the number of iterations $lm$ as input. For each iteration $k\in \{1,2,\dots ,lm\}$, the $P{H}_{\beta }$ algorithm is executed a single time, yielding a gap value $ga{p}_k$. Each $ga{p}_k$ quantifies the difference between the maximum and minimum completion times across all virtual machines for that specific iteration. Upon the conclusion of all $lm$ iterations, the algorithm identifies the smallest gap $g=\underset{1\le k\le lm}{min}ga{p}_k$ as the conclusive result and returns it.

Through the repeated execution of the probabilistic heuristic, $P{H}_{\beta }^{lm}$ amplifies the probability of discerning a superior workload distribution that minimizes disparities in completion times. This iterative process is particularly efficacious in counterbalancing the stochastic nature of $P{H}_{\beta }$, thereby ensuring that the final solution exhibits diminished sensitivity to the random decisions made during task allocation.

In practical applications, it is feasible to configure the value of $lm$ to be equal to 500, thereby establishing a robust framework for the iterative process and ensuring the heuristic explores a wide solution space to minimize completion time disparities effectively.

The Repetitive probabilistic heuristic ( $P{H}_{\beta }^{lm}$) is illustrated in Algorithm 2.

Proposition 3 The repetitive probabilistic algorithm $P{H}_{\beta }^{lm}$ running with a complexity of $O(n^2)$.

Proof 3 The sorting procedure that is implemented within the confines of this sophisticated algorithm is none other than the heapsort, which is renowned for its efficiency and effectiveness in systematically arranging data. The heapsort procedure, which is categorized as an $O(n\log n)$ algorithm, signifies that the time complexity grows logarithmically with the number of elements, thereby ensuring optimal performance even as the dataset expands in size. Furthermore, it is crucial to note that a total of $n-1$ random numbers are provided as input, and the assignment of jobs is determined based on the specific job that has been selected; under these circumstances, this particular procedure operates within a time complexity of $O(n)$. The various jobs that are grouped together in each set are subsequently scheduled to be executed on a virtual machine, which itself necessitates a time complexity of $O(n)$ for proper execution and management of the tasks at hand. The execution of this process is repeated a total of 500 times, and this repetition is recorded as maintaining a consistent running time order proportional to $n$. Considering these points, one can definitely conclude that the complexity linked to the PH heuristic is defined by an $O(n\log n)$ computational complexity.

Mixed-probabilistic heuristic

The mixed-probabilistic heuristic (MPH) presents an advanced task ordering methodology designed to optimize workload distribution among virtual machines. This arrangement results in the programs J being partitioned into two equivalent sections. The initial subset, $J_1$, which consists of 50% of the programs, is organized in a non-increasing sequence based on their processing times $p_j$. This arrangement prioritizes larger workloads at the outset of the assignment procedure. In contrast, the second subset, $J_2$, which encompasses the remaining 50% of programs, is arranged in a non-decreasing order of $p_j$, thereby postponing the assignment of smaller workloads. Upon joining $J_1$ and $J_2$ to produce the restructured group J, a chance-based approach is utilized to support task distribution. Should the original probabilistic heuristic $P{H}_{\beta }$ be utilized, the resultant algorithm is designated as $MP{H}_{\beta }$. In another approach, employing the repetitive probabilistic heuristic $P{H}_{\beta }^{lm}$ leads to designate the resultant algorithm as $MP{H}_{\beta }^{lm}$. This dual-phase sorting strategy introduces variation in task ordering, enabling the heuristic to effectively balance the prompt allocation of substantial workloads with the delayed assignment of lighter ones, thereby enhancing the equity of the resultant workload distribution.

The mixed-probabilistic heuristic is illustrated in Algorithm 3.

Reverse-mixed probabilistic heuristic

The reversed mixed-probabilistic heuristic (RMPH) represents a sophisticated adaptation of the mixed-probabilistic strategy, specifically crafted to implement an alternative mechanism for task ordering in workload distribution. This system necessitates a first division of the array of programs J into two uniform portions, $J_1$ and $J_2$. The first subset, $J_1$, is organized in a non-decreasing sequence based on the processing times $p_j$, thereby facilitating the precedence of allocating lighter workloads at the outset of the process. In contrast, the second subset, $J_2$, is arranged in a non-increasing order of $p_j$, thus ensuring that heavier workloads are postponed to the subsequent phases of allocation. As $J_1$ and $J_2$ are integrated to develop the reordered collection J, a probabilistic strategy is implemented to allocate the workloads to the virtual machines.

Should the original probabilistic heuristic $P{H}_{\beta }$ be utilized, the resultant algorithm is designated as $RMP{H}_{\beta }$. Conversely, if the repetitive probabilistic heuristic $P{H}_{\beta }^{lm}$ is applied, the resulting algorithm is termed $RMP{H}_{\beta }^{lm}$. This reversed ordering methodology engenders a distinct allocation dynamic in comparison to MPH, thereby facilitating a more extensive exploration of potential workload distributions and offering an additional strategy to mitigate completion time disparities among virtual machines.

The reversed mixed-probabilistic heuristic is illustrated in Algorithm 4.

Instances

In the researches referenced in Eljack et al. (2024, 2023), a variety of distinct instances are meticulously presented, which are derived from several categorized classes that have been rigorously analyzed. The study specifically focuses on two primary types of statistical distributions that are under consideration, namely the uniform distribution, which is represented symbolically as UD[], and the normal distribution, which is denoted by the notation ND[]. Through this comprehensive examination, the research endeavors to elucidate the characteristics and implications of these two fundamental classes within the broader context of statistical analysis and its applications.

The specified duration that is necessary for the execution of a particular computational program, denoted as $j$, which is represented mathematically as $p_j$, has been articulated in the following manner:

• Class $C_1$: $p_j\in UD[1,100]$.

• Class $C_2$: $p_j\in UD[10,150]$.

• Class $C_3$: $p_j\in UD[100,500]$.

• Class $C_4$: $p_j\in ND[50,100]$.

• Class $C_5$: $p_j\in ND[25,100]$.

Two categories of instances were generated: Small Instances and Big Instances. The $(n,m)$ configurations for the small instances are summarized in Table 4. Moreover, the configurations for the big instances are summarized in Table 5.

In relation to each individual value represented by the triplet $(n,m,class)$, a total of ten distinct instances were systematically generated to ensure a comprehensive exploration of the parameter space. Upon analyzing the information presented in Table 4, it can be deduced with a high degree of certainty that the aggregate total of all instances produced amounts to a substantial figure of 1,250 for the small instances.

Based on Table 5, a total of 1,000 big instances was generated. In addition, 1,250 small instances were produced (see Table 4), bringing the overall total to 2,250 instances.

Metrics

In this article, the following metrics were used:

• $A_b$: The best heuristic value is found after the execution of all heuristics.

• A: the value of the heuristic suggested

• $G_b=\frac{A-A_b}{A}$: the distance between the minimum heuristic value and the given one.

• $Time$: average running time in seconds. Running times below 0.001 s are indicated “-”.

• $Per$: fraction of files where $A_b=A$ among all the 1,250 cases.

Performance analysis on small instances

This subsection presents a detailed analysis of the results obtained from the 1,250 small instances. All statistical evaluations discussed herein are based solely on this subset of instances.

Table 6 provides a comprehensive illustration demonstrating that the heuristic denoted as $P{H}_{\beta }^{lm}$ not only stands out as the most effective option but also yields the most favorable gap, achieving a performance percentage of $Per=82.2\mathrm{\%}$, while concurrently maintaining an average gap value of 0.11, all accomplished within a remarkably brief average processing time of 0.036 s. In stark contrast, the heuristic identified as $MP{H}_{\beta }$ emerges as the least effective choice, as it produces the most significant gap, registering a performance percentage of merely $Per=4.4\mathrm{\%}$, and accomplishing this in a time frame that is less than 0.001 s, alongside a gap value represented as $G_b$ equal to 0.83.

Table 7 provides a comprehensive presentation of the variations in both the gap denoted as $G_b$ and the corresponding execution time referred to as $Time$, all in relation to the varying parameter $n$. This detailed analysis clearly demonstrates that the algorithm designated as $MP{H}_{\beta }$ achieves an impressive maximum value of the gap, which is recorded at an exceptional level of 0.94, specifically when the parameter $n$ is set to 120. Conversely, it is noteworthy to mention that the most favorable gap, characterized by a remarkably low value of less than 0.01, is realized through the implementation of the algorithm $P{H}_{\beta }^{lm}$. Furthermore, it is significant to highlight that the algorithm $P{H}_{\beta }^{lm}$ reaches its peak execution time of 0.105 s precisely when the value of $n$ is increased to 200.

Table 8 presents an extensive analysis of the various values associated with $G_b$ and $Time$ that emerge as a consequence of alterations in the quantity of support storage, thereby illustrating the intricate relationships between these parameters. Upon reviewing the data illustrated in the table, it is evident that the most beneficial gap is achieved through the algorithm identified as $P{H}_{\beta }^{lm}$ when the variable $m$ equals 2, while the algorithm $MP{H}_{\beta }^{lm}$ results in the least favorable gap, noted at 0.95, when the variable $m$ is heightened to 10. In the context of the heuristics denoted as $P{H}_{\beta }$, $MP{H}_{\beta }$, and $RMP{H}_{\beta }$, it is noteworthy that the mean duration of execution remains consistently below 0.001 s, indicating a remarkable efficiency in their operational performance. In stark contrast, the algorithm identified as $MP{H}_{\beta }^{lm}$ demonstrates a significantly longer average execution time that can escalate to 0.072 s when the parameter $m$ is elevated to the value of 15, thereby highlighting a marked discrepancy in computational efficiency between the various algorithms under consideration.

Table 9 meticulously delineates the comprehensive results that elucidate the fluctuations observed in both $G_b$ and $Time$ as a function of the alterations in class categories. This table explicitly indicates that classes 4 and 5 present a significantly greater level of difficulty in comparison to the other classes for the algorithms $P{H}_{\beta }$, $P{H}_{\beta }^{lm}$, and $MP{H}_{\beta }$, as evidenced by the fact that the average gap yields notably higher numerical values for these specific class categories. Conversely, with regard to the algorithms $MP{H}_{\beta }^{lm}$, $RMP{H}_{\beta }$, and $RMP{H}_{\beta }^{lm}$, there is a discernible reduction in the average gap for classes 4 and 5 when juxtaposed with the other class categories, suggesting a contrasting performance outcome.

In the comprehensive presentation of the findings, a greater level of detail is meticulously provided in Table 10, which serves to elucidate the performance metrics encompassing both the average gap achieved and the time expended for all heuristics that have been developed throughout this research endeavor.

Figure 3 presents a comprehensive visual representation of the varying values of the average gap in relation to the numerical variable denoted as $nb$, specifically for the heuristic methodologies referred to as $P{H}_{\beta }$ and $P{H}_{\beta }^{lm}$. This particular figure effectively demonstrates that the graphical representation of the curve associated with the heuristic $P{H}_{\beta }$ consistently resides at a higher position on the graph compared to the curve linked to the heuristic $P{H}_{\beta }^{lm}$. Therefore, this analysis reveals that the heuristic $P{H}_{\beta }^{lm}$ is positioned to offer a more advantageous solution than the heuristic $P{H}_{\beta }$ when the assorted values of the parameter $nb$ are considered.

Figure 4 presents a comprehensive depiction of the varying numerical values associated with the average gap in relation to the parameter denoted as $nb$, which is being analyzed for the two distinct heuristics, namely $MP{H}_{\beta }$ and $MP{H}_{\beta }^{lm}$. This particular figure serves to elucidate the observation that the graphical representation of the heuristic $MP{H}_{\beta }$ consistently resides at a higher position on the plotted axis when compared to the graphical representation of the heuristic $MP{H}_{\beta }^{lm}$. As a result, this deduction leads to the assertion that the heuristic $MP{H}_{\beta }^{lm}$ demonstrates a greater efficacy in producing a more optimal solution relative to the heuristic $MP{H}_{\beta }$ when assessed against a range of specified values for the parameter $nb$.

Performance analysis on big instances

Table 11 presents a comparative evaluation of six algorithms predicated on three performance indicators: solution percentage ( $Perc$), average deviation from the optimal known solution ( $G_b$), and computational duration ( $Time$). The findings show that local improvement variants, $P{H}_{\beta }^{lm}$, $MP{H}_{\beta }^{lm}$, and $RMP{H}_{\beta }^{lm}$, consistently surpass their base versions in solution quality. Notably, $P{H}_{\beta }^{lm}$ achieves the highest success rate of 72.6%, with a minimal average gap of 0.17, significantly outperforming $P{H}_{\beta }$, which has a 55.5% success rate and a gap of 0.20, despite its faster runtime (0.010 s vs. 3.553 s).

On the other hand, the multi-population variants $MP{H}_{\beta }$ and $MP{H}_{\beta }^{lm}$ demonstrate suboptimal performance regarding $Perc$, achieving only 1.8% and 1.9% success rates, alongside high average gaps approximately 0.80, which suggests a possible misalignment with the problem configuration. In contrast, the randomized multi-population variant $RMP{H}_{\beta }^{lm}$ provides a balanced option with a success rate of 36.0% and a gap of 0.43, while keeping a runtime similar to other local improvement variants (3.504 s).

In summary, $P{H}_{\beta }^{lm}$ stands out as the most effective algorithm for solution quality, whereas $P{H}_{\beta }$ is the fastest. The data brings to light the gains from incorporating local search frameworks into fundamental algorithms to raise solution quality, even if it does mean more computational time.

Table 12 presents an extensive comparison of six algorithmic variants—specifically $P{H}_{\beta }$, $P{H}_{\beta }^{lm}$, $MP{H}_{\beta }$, $MP{H}_{\beta }^{lm}$, $RMP{H}_{\beta }$, and $RMP{H}_{\beta }^{lm}$—assessed across various instance classes ( $n=500$ to 2,500). The assessment of performance utilizes two main metrics: the average optimality gap ( $G_b$) and the average execution time ( $Time$ in seconds). The analysis reveals that including local moves, indicated by the “^lm” suffix, consistently boosts solution quality for every algorithm variant. In particular, $P{H}_{\beta }^{lm}$ achieves the lowest average gaps across all instance sizes, attaining a minimum of 0.07 for $n=\mathrm{2,500}$, thereby significantly surpassing its foundational counterpart $P{H}_{\beta }$. Likewise, the reordered variants, $RMP{H}_{\beta }$ and $RMP{H}_{\beta }^{lm}$, exhibit competitive performance, with the latter evidently benefiting from local refinement, achieving $G_b=0.28$ at $n=\mathrm{2,000}$ and subsequently improving to $G_b=0.57$ at $n=\mathrm{2,500}$ in contrast to $0.62$ in the absence of local moves. Conversely, this enhancement in validity is offset by an extension in computational time. All “^lm” variants exhibit a considerable increase in execution time, particularly as the problem size escalates—e.g., $MP{H}_{\beta }^{lm}$ escalates from 0.869 s ( $n=500$) to over 6 s ( $n=\mathrm{2,500}$). Conversely, the basic variants devoid of local moves maintain remarkable speed but exhibit noticeably higher optimality gaps. In summary, the locally improved editions deliver higher solution quality albeit with increased computational demands, whereas the more straightforward options ensure scalability and quick processing, thus fitting well in time-critical situations.

Discussion

The heuristics that have been put forth in this study are fundamentally grounded in the principles of the probabilistic method, which is further enhanced and diversified through the implementation of various distinct variants. These defined variations connect to the unique choice and implementation of the iterative framework, which can be approached in diverse manners relative to the context of the problem at play. The findings from this research decisively confirm the exceptional efficiency and effectiveness of the probabilistic technique, especially when utilized alongside an iterative framework that supports the refinement and enhancement of results. Indeed, it has been rigorously established through comprehensive analysis that the synergistic combination of the probabilistic method alongside the iterative approach yields significantly superior results when juxtaposed with alternative methodologies that may be employed in similar scenarios.

Trade-off between solution quality and runtime efficiency

Though the considered heuristic algorithms perform well in fairness and load balance, especially when the smallest completion time is desired, it is worth noting that there are some trade-offs between the quality of solutions and the computation time. This can be clearly seen for the multiple repetitions of the heuristics, for example $P{H}^{lm}\beta$, $MP{H}^{lm}\beta$ and $RMP{H}_{\beta }^{lm}$, which in a recurrent way apply the probabilistic assignment to obtain better scheduling results.

While such algorithms provide better solutions by considering a wider range of possible task assignments, they also have higher computational cost with the number of repetitions ( $lm$). For the large-scale scenarios having hundreds or thousands of programs and virtual machines, the repeated implementation of the heuristic may have longer running time, which is infeasible for the real time or latency-sensitive tasks in large cloud systems. Also, the current work takes a sequential approach, which is adequate for a simulation study, but it may not be able to utilize available parallelism in cloud or distributed systems. This even more emphasizes the trade-off between complexity of the algorithms and scalability.

To mitigate these issues, future research could explore adaptive stopping criteria, parallel implementations of the heuristics, or the integration of online learning approaches to adjust algorithm parameters on-the-fly and according to the workload properties. These improvements can ensure both solution quality and less computation cost, and make the proposed scheme more feasible in practical cloud scenarios.

Limitation on task duration assumptions

The scheduler model considered throughout this article is based on the notion that task durations are given a priori, indicating that the scheduler operates in a deterministic setting. This assumption allows the problem to be modeled in a less complex way and facilitates a meaningful comparison of the proposed heuristics on instances with different settings. It is recognized that in realistic cloud settings, such dynamism is inherent since task execution times can be unpredictable owing to resource availability fluctuations, system up and down states, and variability of external dependencies. The exclusion of random or variable processing times is thus a limitation of this study. Dealing with this limitation is a promising path for future research, in which integration of predictive modeling, adaptive scheduling, or stochastic optimization methods may enable the potential application of the proposed approach to more realistic cloud computing contexts.