Abstract
This paper explores the complexity of project planning in a cloud computing environment and recognizes the challenges associated with distributed resources, heterogeneity, and dynamic changes in workloads. This research introduces a fresh approach to planning cloud resources more effectively by utilizing fuzzy waterfall techniques. The goal is to make better use of resources while cutting down on scheduling costs. By categorizing resources based on their characteristics, this method aims to lower search costs during project planning and speed up the resource selection process. The paper presents the Budget and Time Constrained Heterogeneous Early Completion (BDHEFT) technique, which is an enhanced version of HEFT tailored to meet specific user requirements, such as budget constraints and execution timelines. With its focus on fuzzy resource allocation that considers task composition and priority, BDHEFT streamlines the project schedule, ultimately reducing both execution time and costs. The algorithm design and mathematical modeling discussed in this study lay a strong foundation for boosting task scheduling efficiency in cloud computing environments, which provides a broad perspective to improve the overall system performance and meet user quality requirements.
Keywords: Task scheduling, Fuzzy clustering, HEFT algorithm, Cloud computing
Subject terms: Computational science, Computer science
Introduction
Cloud computing has been booming in recent years, driven by the virtualization of hardware and software to meet the demand for more robust and scalable Internet services1. Cloud computing is a distributed system with enormous computing power and many different shared resources2. Cloud computing resources are distributed, autonomous, heterogeneous, and have different workload characteristics, Due to these factors, project planning in a cloud computing environment is more complex than in a traditional distributed environment3. In high-performance heterogeneous cloud computing systems, cloud project planning is an essential area of research4. Scheduling refers to how processes, threads, tasks, and data flows access system resources5. Effective and efficient algorithms are the fundamental to exploiting cloud computing systems rich resource potential. Traditional task scheduling algorithms for parallel distributed systems work well for evenly distributed resources but must be more adequate in cloud environments6. Planning is a mission requires a lot of calculation and communication, especially in astronomy, biology, and other scientific fields that require dynamic environments. Task scheduling matches are individual tasks with available resources7 to satisfy users Quality of Service (QoS) requirements such as budget and execution time. In cloud computing, service providers offer resources with different service options at different prices, the more efficiently a resource works, the higher its price. Therefore, cloud computing workflow planning projects must meet users’ time and cost requirements. Cost and time constraints mean that the project must be completed within a specific budget and ensure a quick completion. There are many reasons why the overall project plan adds time and cost. One reason for programming costs is the time to find the right computer program for your project8. Thoroughly considered users’ specific needs, budgets, time, and proposed the Biological Heterogeneous Early Final Time BHEFT optimization algorithm, which achieved good results. The allocation means searching for resources globally, which wastes too much time. A cloud computing environment has enormous computing power. This computing power requires massive resource support. The large amount of resource data and the distribution of various resources directly lead to an ample resource space9. In global resource search, the search space is also significant. However, the possibility of finding suitable resources is minimal. Ensuring the correct allocation of resources to projects reduces the resource search space, saves search time and execution costs, and is a good scheduling algorithm for optimizing project scheduling needs10. Problem solving based on the above problem analysis the article proposes using fuzzy clustering to solve the search time and operational cost problems caused by the giant search space when searching for suitable resources at the beginning of project planning sort clouds. The resources are based on the properties and characteristics of resources distribution.
This paper discusses the efficient preprocessing of cloud resources using fuzzy fusion techniques. Combining project planning techniques with art can reduce the cost of finding the right resources for a project11. Meanwhile, to achieve the two conflicting goals of reducing project completion time and execution cost in project planning, an improved HEFT algorithm based on the heterogeneous completion time of Acyclic Directed Graph (DAG) is proposed12. An improved algorithm is called BDHEFT (heterogeneous finite time). This algorithm realizes planning based on resource composition, considers project execution time and budget in detail, reduces execution time and costs, and achieves the dual goal of reducing costs and execution activities.
Literature review
A recent study by13–15 provides a detailed description of the complexity of project planning in a cloud computing environment1. The author13 highlight the critical role of scheduling in optimizing the utilization of cloud resources, thereby increasing performance and minimizing wasted time and workload. The theoretical basis is discussed through a detailed review of various scheduling algorithms16. It provides a practical evaluation of their effectiveness using metrics such as execution time, performance, and cost. The researcher17,18 fielded planning methods and proposed a comprehensive taxonomy including traditional, heuristic, and metaheuristic methods. By grouping these strategies based on schedule constraints and goals, the authors provide a systematic framework for understanding the nuances of cloud project planning19. Furthermore, the study highlights new trends and topics that pave the way for future research. Author20 mentions server less computing makes cloud development a breeze by taking away the hassle of managing infrastructure, all while providing scalability and saving costs9. However, one of the key challenges in this approach is figuring out where to place functions essentially, choosing the best spots for execution to make the most of resources and keep delays to a minimum20. This article dives deep into function placement strategies, categorizing them into three main types; model-based, heuristic-based, and machine learning-based21. It carefully weighs the pros and cons of each approach, helping researchers and developers find more effective solutions without unnecessary repetition.
The researcher22 contribute to this debate by emphasizing the need for efficient scheduling algorithms to achieve optimal resource allocation in cloud environments. Focusing on heuristic methods, this article explains the theoretical basis of planning and provides practical information on its implementation. The author23 mention the server less computing has its share of cold start challenges, it still provides a more budget-friendly and scalable solution. This article takes a look at the current research surrounding cold starts and introduces a classification system that includes two primary approaches: improving loading times like container-based and checkpoint-based methods and enhancing resource use through machine learning based, optimization-based, and heuristic-based strategies. Traditional scheduling methods such as ant colony optimization, round robin, and first come first serve have been commonly utilized in various cloud computing systems24. Quick client tasks are sent to the cloud, and managing resources for these tasks requires careful planning. The hybrid bio inspired algorithm takes charge of resource allocation and management based on job requirements, assign jobs to virtual machines using the modified particle swarm optimization technique16. Experimental results indicate that hybrid algorithm surpasses other research and benchmark algorithms in terms of shorter average response times, improved reliability, and better utilization of cloud resources.
Fog computing is an exciting new approach that makes computer resources more accessible and efficient for Internet of Things (IoT) users25. However, it does come with a downside: it can lead to higher energy consumption, which in turn increases carbon emissions and electricity costs16.
In fog computing, having movable processing nodes can sometimes put the system’s reliability at risk26. To tackle the energy consumption challenges in fog computing workflows, this paper introduces the Minimal Schedule Time with Energy Constraint (MSTEC) algorithm, which is designed for low-delay scheduling16. The main aim here is to significantly reduce the time it takes to finish tasks while keeping energy use within set limits. On the other hand, the High Dependability with Energy Constraint (HDEC) framework is particularly effective for fog computing operations that need to manage energy consumption27. This is crucial for enhancing the reliability of fog computing systems, especially in mobile settings. The HREC approach boosts system dependability by 22%, while the MSTEC algorithm achieves an average reduction of 16.5% in completion time compared to the baseline method16. This shows that these methods are quite effective in fog computing scenarios where energy efficiency in scheduling is a key concern. Through a thorough review of various scheduling algorithms, the authors provide a comprehensive overview of the field and provide researchers and practitioners with valuable tools to solve complex cloud scheduling problems efficiently. Overall, these studies provide a valuable resource that provides a comprehensive overview of the challenges, methodologies, and emerging trends in cloud project planning.
Materials and methods
When it comes to scheduling algorithms, list-based scheduling methods are proving to be essential for managing workflow activities efficiently, particularly in the ever-changing landscape of cloud computing. By prioritizing specific tasks within a process, we can ensure they get done faster, ultimately shortening the overall project timeline. Some popular examples of these algorithms are the pain, min-min, and max–min algorithms, each bringing its own unique strategy to task prioritization. Many of these algorithms have garnered significant interest from modern heuristics because of their effectiveness in fine-tuning project scheduling. The leading contenders in this field are the dynamic critical path algorithm, dynamic gate planning, Critical Path Processor (CPOP) algorithm, and HEFT algorithm. Among these, HEFT stands out for its excellent optimization results. However, a standard limitation of these algorithms is their tendency to ignore operational costs associated with workflows and highlight critical optimization gaps that require further investigation and refinement.
Heuristic scheduling algorithms beyond list scheduling
Researchers have explored several instantiations to improve modern and traditional scheduling methods to address the multifaceted challenges of task scheduling in cloud computing environments. Researcher28,29 were introduce the Particle Swarm Algorithm (PSO) specifically for solving everyday task scheduling and transportation costing problems in cloud environments. Similarly,30 emphasize the importance of integrating cost and schedule constraints into planning algorithms, although they mainly focus on homogeneous resource models. Researcher31 proposed pipeline workflow scheduling algorithms, such as IC-PCP and IC-PCPD2, to reduce operational costs in time-constrained environments, especially for large workflows. Together, these efforts reflect a concerted effort to expand the scope of heuristic planning beyond traditional concepts to adapt to the complex and changing cloud environment.
Integration of advanced techniques into scheduling algorithms
Integrating advanced technologies into traditional scheduling algorithms is a promising optimization strategy that synergistically improves throughput and efficiency. Author32 demonstrate this approach by seamlessly integrating deep learning techniques to decompose the HEFT algorithm, thus leveraging the power of neural networks to complement traditional planning methods. Similarly,33 optimized the HEFT algorithm regarding computation time, reflecting a concerted effort to improve efficiency without sacrificing performance. Furthermore,34 propose to improve the HEFT algorithm by considering the load balance and financial constraints of cloud users, thus adopting a multi-objective optimization approach that considers the goals and constraints of different stakeholders.
Problem description
Project planning focuses mainly on two aspects: Shortening the time from project submission to completion and shortening working hours. It is time to finish the mission. This section discusses a project scheduling model based on resource preprocessing. Suppose a cloud computing system has n tasks for system calls; then the system has average resources among them, user n assigns a budget B and a deadline D to a submitted project. The schematic diagram is shown in Fig. 1.
Fig. 1.
Task resource allocation diagram.
The issue with job scheduling can be summed up like this: You need to allocate minutes to a task while keeping an eye on your resource budget, making sure everything gets done within the set timeframe. Also, figure out the costs and the time required to finish the job. Remember, the project’s budget limit is budgeting B. Find the minimum cost to complete the project. If the minimum construction time after project completion exceeds deadline D or the minimum construction cost exceeds budget B, the project plan will not be met. To distribute tasks to appropriate resources to reduce delivery time and cost, therefore, the problem is defined as follows.
Definition 1
The 
tasks submitted by the user are described by a Directed Acyclic Graph 
where 
represents a task set with 
tasks and 
is an edge set, which represents the dependency relationship between tasks. If 
, The analysis indicates that there’s no connection between the execution sequences of tasks ti and tj. When eij equals 0, it suggests that task tj can be finished only after task ti is done. Additionally, the value of eij shows how much data needs to be transferred between these two tasks, ti and tj.
Definition 2
The available resources in the cloud computing system are represented by 
where 
is the number of resources.
Definition 3
The matrix 
is all about the time costs involved in processing tasks, where 
indicates how long it takes to handle task 
on resource 
.
Definition 4
The matrix 
looks at the communication or data transfer capacity between two resources. Here, the variable 
shows how well resource 
can transmit data to resource 
Definition 5
We refer to the method for allocating tasks to resources as X. The way we allocate a specific set of tasks T to a set of resources R is outlined in Eq. 1 below.
 |
1 |
where 
, indicating whether to assign task 
to resource 
. Then, the Total Processing Time (TPT) of all tasks is calculated as follows:
 |
2 |
TPT represents the total processing time spent when all tasks are assigned to appropriate processing resources, and 
represents the processing time of task 
assigned to resource 
. According to Eq. 2, the total processing cost of all tasks is calculated as follows as Eq. 3:
 |
3 |
where cost indicates that the total processing cost of the task is equal to the product of the processing time of each task and the unit time price 
allocated to a specific resource. The 
represents the cost spent by resource 
to perform the task in unit execution.
According to the task allocation strategy 
, it can be concluded that task 
is assigned to resource 
for processing; task 
is assigned for resource 
to execute; then for all tasks, the total data transmission time 
is calculated as follows:
 |
4 |
According to Eqs. 2 and 4, it can be concluded that the maximum completion time make span of all tasks is calculated as follows:
 |
5 |
The total time it takes to complete all tasks is made up of three parts: the time spent searching for resources (S), the processing time for each task (TPT), and the overall data transmission time (DTT). Based on the study mentioned earlier, the task resource allocation model can be mathematically defined as finding the best way to allocate a given set of resources (R) to a set of tasks (T) so that once the tasks are assigned to the resources, the task completion time and execution cost minimum. According to Eqs. 3 and 5, the objective function is defined as follows:
 |
6 |
The purpose of Eq. 6 is to minimize the cost, and its constraints are:
 |
7 |
 |
8 |
Constraints state that budget and time constraints can be maintained while minimizing costs and time to completion. According to Eqs. 3, 5, and 6, to achieve the optimization goal, the main factors that affect the optimization goal are the resource search time 
in Eq. 5, the execution completion time of all tasks 
and the time of all tasks. The total data transmission time 
is mainly affected by the scheduling algorithm itself. Therefore, how to reduce the values of 
, and 
is the primary consideration of the scheduling algorithm.
Task scheduling strategy based on HEFT algorithm
The HEFT algorithm35 which focuses on selecting the most important tasks and assigning the necessary processing resources to them when used in a heterogeneous distributed environment, is a clever way to schedule a wide range of resources. Its main objective is to decrease the amount of time required to complete activities, and it has been successful in lowering the earliest task scheduling completion time.
HEFT algorithm process
The HEFT algorithm process consists of three key phases: selecting resources, assigning task priorities, and determining weight assignments. During the task priority assignment phase, we establish the priority for each path, create a list based on that priority, and then derive a task list from the prioritized paths before scheduling the tasks. Meanwhile, the weight assignment phase primarily focuses on updating the relevant node or edge weights. This method ensures that resources are allocated to tasks based on the principle of assigning each job to the resource node that can complete it the quickest.
Weight assignment stage
Since the resources allocated to tasks have different values in terms of CPU, memory, disk space, etc., the original weight of edges between tasks cannot accurately reflect their priority. It needs to be based on the computing and transmission performance of resources. Task nodes and edges between tasks are given new weights.
Definition 6:
Use an undirected graph 
to describe resources, where R represents a collection of resources, which has been specifically described in definition 2, where 
represents the computing performance of the 
resource;
represent the edges between resources and the data transmission capability between resources.
The average computing performance of the resource collection is as follows:
 |
9 |
According to Eq. 9, the computing performance heterogeneity factor is calculated as follows:
 |
10 |
Use 
to measure the difference in resource computing performance. The smaller the value of 
, the smaller the difference between resources and the average transmission performance between resources is as follows:
 |
11 |
According to Eq. 11, the transmission performance heterogeneity factor is calculated as follows:
 |
12 |
Use 
to measure the difference in transmission performance between resources. The larger the value of 
, the greater the difference in transmission performance between resources.
According to Eqs. 10 and 12, the new weight 
of task nodes and the new weight 
of edges between tasks can be calculated as follows:
 |
13 |
 |
14 |
According to Eqs. 13 and 14, update the task node and edge weights between task nodes.
Priority assignment phase
To figure out the priority of each path in the task-directed graph, you’ll need to use the updated weights for the task nodes and the edge weights that link them. The paths are then organized by their priority values, from highest to lowest, creating a list that can be handy for scheduling tasks down the line.
The priority 
for path 
is calculated as follows:
 |
15 |
The priority 
of path 
equals the weight of all tasks 
on the path and the sum of the weights of the edges between task 
and its successor tasks. After the path list is formed, the subsequent task scheduling operation will start from the path with higher priority in the path list. When scheduling task 
in the path, all the predecessor tasks of task 
have been scheduled; then, task 
will be inserted into the task scheduling list until all tasks are selected.
Resource allocation phase
When task 
needs to be scheduled for execution, it is necessary to calculate the earliest completion time 
of task 
on each resource 
. For this purpose, calculate the earliest start time 
of task 
placed on resource rj and free time slot 
.
For the earliest start time 
of task 
assigned to resource 
, the calculation formula is as follows:
 |
16 |
To determine the earliest start time (EST) for task 
, we first need to find the maximum value of the sum of the data transmission time, which is represented as max 
, along with the earliest completion time of its predecessor task. Once we have that maximum value, we can use it as the EST for task 
, but only after comparing it with the initial load time avail(
) of resource 
for all predecessor tasks 
. It’s important to note that the earliest start time for the entry node is 
. Meanwhile, 
refers to the initial load time of the resource, which indicates when the resource is ready to take on the next task after completing its current assignments. The set of parent tasks for task 
is denoted as pred(
). Lastly, the data transmission time between task tk and task 
, or 
, is calculated directly, assuming that job tk is assigned to resource 
.
 |
17 |
The earliest completion time EFT(ti,rj) of task ti on resource rj is calculated as follows:
 |
18 |
Then, the earliest completion time EFT is equal to the sum of the earliest start time EST of the task and the execution time of the task resource. The free time slot 
describes the waiting time of task 
on resource 
, and its calculation is as follows:
 |
19 |
When calculating the earliest start time 
of task 
placed on resource 
and the free time slot 
, it is necessary to determine whether task 
has an unexecuted predecessor task and, if so, whether the predecessor task tk satisfies:
Condition 1:
 |
20 |
 |
Condition 2: Resource 
never executes task 
. When task 
meets the above conditions, insert it into the free time slot and update its 
and 
on the resource. Execute the above condition judgment in a loop until the condition is not satisfied or the predecessor task has been executed. At this time, calculate the earliest completion time 
of task 
on resource 
according to Eq. 18.
The earliest completion time 
of task 
on each resource 
is calculated by the above method, and compared the resource with the shortest earliest completion time is selected for task execution. When the task queue is empty, the resource allocation process ends.
HEFT-based task scheduling algorithm
The HEFT method uses a combination of resource allocation, weight allocation, and priority calculation to figure out which job should take precedence for effective task scheduling. Here’s a quick rundown of the steps involved in executing the algorithm:
Algorithm 1: HEFT algorithm
-
i.
Input the workflow and convert it into a directed acyclic graph DAG;
-
ii.
Update task node weights and weights of edges between tasks according to Eq. 13 and Eq. 14;
-
iii.
Calculate the priority of the DAG graph path according to Eq. 15;
-
iv.
Construct a path list according to the path priority;
-
v.
Build a task list based on the path list;
-
vi.
Make sure to finish every task on your list;
-
vii.
Go through each resource in the collection to check if the previous task has been completed;
-
viii.
If the task before it isn’t done yet, it will keep checking to see if it meets Conditions 1 and 2 and whether it’s finished; if it’s not, it will break out of the loop; if it is, it will jump straight to the next step;
-
ix.
Look for the earliest expected finish time (EFT) for the task on this resource;
-
x.
Choose the resource that can complete the task the quickest, assign the tasks, and update the task list once you’ve gone through all the resources.
Algorithmic analysis
During the scheduling process, HEFT assigns tasks to resources by looking at the earliest completion time for each available resource. It hands out assignments to the resource that can finish the earliest, which helps to reduce the overall completion time. However, while HEFT is quite effective, it does come with some drawbacks. One major issue is that figuring out the earliest completion time for every task across all resources adds to the computational complexity of the HEFT method. This exhaustive computation process results in a vast resource search space and incurs high resource search costs. Consequently, the algorithm may need help with scalability, mainly when scheduling workflows of considerable size or complexity. Its pursuit of minimizing completion time, the HEFT algorithm overlooks the user’s requirements regarding task execution costs. While prioritizing completion time optimization is crucial, the algorithm’s failure to account for users’ varying cost constraints or preferences may lead to suboptimal resource allocations. This limitation becomes particularly pronounced when users prioritize cost-effectiveness or have specific budget constraints that must be addressed during task execution.
Hierarchical task scheduling strategy
The HEFT method tackles the task serial scheduling problem by using list scheduling to ensure tasks are completed as quickly as possible. However, this approach comes with its downsides. The serial scheduling strategy of the HEFT algorithm can lead to high computational costs, as it searches for all resources in a broad manner, which drives up the resource search expenses. Additionally, it doesn’t take the budget cost factor into account during task scheduling, making it less practical. To address the issue of resource search costs, this section introduces a resource preprocessing technique to enhance the HEFT algorithm through hierarchical task scheduling. It introduces a segmented scheduling mechanism to enable HEFT to achieve parallel scheduling of tasks and save task execution time. Budget and time constraints are introduced in the HEFT algorithm to minimize the task execution cost.
Resource preprocessing
Cloud resource fuzzy clustering
This section uses fuzzy clustering to preprocess cloud computing resources. The decentralized and independent cloud computing resources are divided into several categories according to their characteristics to solve the problems of low efficiency, resource waste, and high time complexity caused by the large search space of task scheduling resources. Clustering is dividing objects according to their characteristic similarity and dividing objects with similar characteristics into the same class. Currently, research on clustering methods mainly focuses on merging, partitioning, and modeling. Clustering methods are also widely used. When the clustered objects have distinct group characteristics, the clustering process will strictly divide specific objects into a particular class according to the objective function, and the relationship between objects and classes only exists between inclusion and non-inclusion. However, most objects that need to be clustered show outstanding individual characteristics, and their class relationship is not clear when they are divided, so fuzzy clustering is required. In the cloud computing environment, cloud resources have characteristics such as uncertainty and diversity. It is necessary to use the fuzzy clustering method to divide cloud computing resources into different categories according to the multiple characteristics of resources to assign different tasks to different types of resources. In the cloud computing environment, the fuzzy clustering model is shown in Fig. 2.
Fig. 2.
Fuzzy clustering model.
Fuzzy clustering is mainly the process of processing resource feature matrices. The completed fuzzy clustering process first needs to collect the data of cloud computing resources and establish the initial data matrix according to the characteristic attributes of the resources. The initial matrix describes the multi-attribute characteristics of each resource. Due to the differences in the order of magnitude and dimension of the characteristic attributes of each resource, it is necessary to transform the initial data matrix properly, that is, to standardize the data, standardize the value of each characteristic attribute to a specific range, and eliminate the influence of the order of magnitude on subsequent calculations. The data normalization operation limits the range of values in the standard matrix between 0 and 1, which is convenient for subsequent clustering.
Resource fuzzy clustering process
This paper uses 
to represent the collection of resources to be clustered, where 
represents the number of resources; use the vector 
represent the characteristic attribute of the 
resource, where 
represents the 
characteristic attribute of the 
resource. 
represents the number of characteristic attributes. Each computing resource 
in the set 
has a model vector 
represents the characteristic attribute of the 
resource, where 
represents the value of the 
computing resource on the 
quality attribute. The characteristics of cloud computing resources mainly include computing power, data transmission capacity, memory size, storage capacity, data transmission capacity limit, network location, number of connections, etc., and clustering cloud computing resources according to their characteristic attributes will have similar characteristics. The choice of attribute characteristics is crucial when grouping resources. In this section, 
is selected, indicating that cloud computing resources have four characteristics, which are defined as follows:
The computing performance of resource nodes refers to the average processing power available within a cloud computing system, and we denote this performance with the term t1. This computing performance is closely tied to how long it takes to execute jobs, significantly influencing the time costs involved in task scheduling.
On the other hand, t2 represents the system’s data transmission capability. We can think of the average edge weights between resources, or the average communication capabilities of the connections, as a way to describe how well data is transmitted between resources in a cloud computing environment. The level of performance in data transmission directly impacts the time it takes to transfer data between different processes.
represents its maximum transmission capacity. In the cloud computing system, the maximum amount of data is transferred between resources each time. The number of data transfers per time directly affects this.
represents its link number. In cloud computing, multiple resources are connected to this resource node. Tasks assigned to this resource can perform data transfers with tasks from multiple other resources.
The rest of the feature tasks have little impact on the scheduling performance and are not considered here. If too many feature attributes are considered, the fuzzy clustering process’s time complexity will be too high, which deviates from the purpose of this paper.
This paper’s fuzzy clustering resource preprocessing procedure has four steps: normalization of the experimental data range, realization of the fuzzy matrix, and evaluation of clustering information.
1) Normalize the range of experimental data:
The primary purpose of this step is to eliminate the effect of magnitude on subsequent calculations. To obtain standardized data for the original data S′, the normalized value 
of each data is calculated as follows:
 |
21 |
where 
represents the 
eigenvector in 
′
is the mean of 
. 
is the standard deviation of tk. Since the standardized value 
is not all in 
we use the range standardization method to transform 
into 
. The range normalization method is defined as follows:
 |
22 |
where 
and 
are the minimum and the maximum values 
, respectively.
2) Fuzzy matrix implementation:
The main goal of this stage is to help organize resources in the future based on how similar their cloud computing features are. Using the exponential similarity coefficient approach, the fuzzy similarity relation 
of the processing unit 
may be determined as follows:
 |
23 |
Among them 
is the variance of the kth feature, and rij is the similarity between processing units pi and pj. At the same time, the fuzzy equivalence relation Re with transitive closure is obtained through the synthesis operation of the similarity coefficient matrix.
(3) Evaluate the clustering information with the evaluation function:
Use the merit function to estimate the clustering results. Set different values for the cutset level alpha to get different clustering results. A higher degree of resemblance between clusters is indicated by an alpha value near 1, whereas a lesser degree of similarity is indicated by an alpha value close to 0. In this paper, according to the historical experimental data, α = 0.8 can get a better clustering result, and at this time, the cut set 
is obtained.
The clustering result can be obtained through the 
matrix, represented by 
. In this case, the overall performance of each cluster can be estimated as follows:
 |
24 |
where w is the cluster’s total number of processing units, 
represents the 
cluster, and the value of 
, which denotes the weight of the processing unit’s 
feature, can often be determined using historical data or experimental results. By calculating the overall performance of each cluster, the updated 
can be obtained, where 
are sorted according to their performance. The clustering flowchart is shown in Fig. 3.
Fig. 3.
Fuzzy clustering flow chart.
Introduction of budget and time constraints
Considering the time and cost requirements of user requests for task execution, budget and time constraints are introduced to effectively control the execution time and execution cost of task execution and achieve the two goals of minimizing completion time and execution cost.
Budget constraints
The user submits the workflow to the cloud computing system and stipulates the budget limit B for the workflow execution, requiring that the workflow execution cost should not be higher than the budget limit B. According to the requirements of the total cost of task execution, cost constraints need to be added to the task selection conditions. To this end, this subsection introduces the following three variables:
The Remaining Budget (SWB) describes the cost constraints for tasks not performed. The Budget Adaptation Factor (BAF) is used to adjust the budget constraints of the current task.
Current Task Budget CTB: Describes the execution cost constraints for the current task.
For task ti, its remaining budget SWB is calculated as follows:
 |
25 |
The remaining budget 
of task ti equals the total budget B of all task executions minus the sum of execution costs 
of all predecessor tasks of task 
. Its execution cost 
is calculated as follows:
 |
26 |
The cost of executing a task, which we call 
, comes from multiplying the unit time price of the resource, noted as 
, by the execution time of the task, 
. To determine which resource is assigned to task 
, we use the allocation procedure X. For task TI, we calculate the budget adaptation factor 
using Eqs. 25 and 26:
 |
27 |
The budget adaptation component of 
involves calculating the ratio of the average execution cost of task 
(let’s call it 
) to the total average execution cost of all tasks in the flow. This ratio, known as 
for task 
, helps in adjusting the cost budget for the current job. Meanwhile, the average execution cost for task 
is simply the average of its execution costs across all available resources.
 |
28 |
According to Eqs. 25 and 28, the current task budget CTB for task 
is calculated as follows:
 |
29 |
According to Eq. 29, task 
current task budget 
is the product of its budget adaptation factor BAF and the remaining budget SWB.
Execution time constraints
The user sends the workflow to the cloud computing system for execution, sets a time limit for the whole process to ensure it doesn’t go over the designated execution time, and outlines the specific time requirements for the workflow. Additionally, the task selection criteria must include the execution time limit in accordance with the overall execution length needed for the job. Consequently, this paragraph brings in three key variables:
Remaining Execution Time SWD: Describes the execution time limit of unexecuted tasks.
Execution time adaptation factor DAF: Used to adjust the execution time limit of the current task.
Current Task Execution Time CTD: Describes the execution time limit of the current task.
For task ti, its remaining deadline is calculated as follows:
 |
30 |
The remaining deadline 
of task 
is equal to the total execution time D of all tasks minus the sum of execution times 
of all predecessor tasks of task 
. The execution time 
of the task is calculated according to the resource allocation strategy X as follows:
 |
31 |
According to Eq. 31, the deadline adaptation factor for task ti is calculated as follows:
 |
32 |
The budget adaptation factor 
for task 
is determined by comparing its average execution time to the total average execution times of all tasks in the flow. This factor helps in fine-tuning the execution time for the current job. The formula 
represents the average execution time of task 
across all available resources.
 |
33 |
According to Eqs. 30–32, the current task execution time CTD for task ti is calculated as follows:
 |
34 |
According to the above formula, task 
current task execution time 
is the product of its execution time adaptation factor DAF and the remaining execution time SWD.
Constraint introduction
Based on the budget and execution time requirements of task 
, a resource set 
that can be allocated to task 
is constructed. First, for each resource set 
in the resource clustering set CLUSTER, by predicting whether the execution cost and execution time required for task 
to be executed on resource 
satisfy the condition 
keep the resources that meet the conditions to form a resource set 
,
that can be allocated to task 
, expressed by the following formula:
 |
35 |
The set 
represents the allocable resource set constituted by all the resources in 
 |
36 |
Task scheduling mainly involves selecting appropriate resources from 
to assign to tasks.
Hierarchical scheduling
Service-level scheduling
The work done during the service-level scheduling phase mainly sets the stage for task-level scheduling. This usually involves tasks like prioritizing lists, pooling resources, and setting budget time limits to create resource sets that can be assigned. By following these steps, you can save both time and money when it comes to scheduling tasks later on. Plus, it helps cut down the time you spend sifting through resources when you’re assigning them to jobs.
Task-level scheduling
At the task-level scheduling stage, the key responsibility is to match the best-suited resource to a project. We’ve established some allocation criteria, and we’ve also included a time–cost balance factor to help meet the user’s needs for both time and cost.
-
If
the resource that makes the following expression minimum will most likely be selected.
37 The α is the cost-time balance factor, and the value range is
, representing the execution time and execution cost of user preference. When task 
is assigned to a resource in the primary set 
, the value of the above formula is equal to the value obtained by assigning to another resource in 
, and the “another resource" is strictly assigned by the parent task of task 
When a resource arrives, another resource is preferred. If
all available resources can be selected as long as the minimum of the above formula is met.
If 
, choose the resource with the lowest price and the highest overall performance among the available resources.
Algorithm implementation
BDHEFT implements task scheduling by introducing resource preprocessing and budget and time constraints. The algorithm is as follows:
Algorithm 2: BDHEFT algorithm
The user submits the workflow to the cloud computing system, and the cloud computing system converts the workflow into a 
graph and updates the weight distribution between the task node and the task according to the formula to calculate the priority of the path and construct the task path list. At the same time, according to the path list information, construct a task list that considers task priority and sequence. At the same time, the resources are fuzzy clustered. The resource performance is calculated according to the performance evaluation function. The resource clustering results are sorted in descending order according to the performance to facilitate the subsequent resource selection operation. According to the user’s requirements for task execution budget and time, construct an allocable resource set 
. For each task in the task list, traverse the allocable resource set 
; while traversing, judge whether the predecessor task of the task is completed; if not, then loop to judge whether the predecessor task satisfies Condition 1, Condition 2 and predecessor task Whether the execution is completed until the predecessor task does not meet any of the above conditions, then jump out of the loop.
Once you’ve figured out the earliest completion time (EFT) for each task on every resource, go ahead and pick the resource allocation task that has the smallest EFT. Keep repeating this process until there are no more jobs left on the list.
Experimental results
By enhancing its core architecture to incorporate workflow scheduling, the CloudSim tool serves as a simulator for experimental research. In this study, we compare the BDHEFT method with the BHEFT algorithm36 and the HEFT algorithm35, focusing on cost and running time. This allows us to thoroughly and effectively evaluate the performance of both methods, the simulation experiments were run 20 times when the number of task nodes was 10, 20, 50, 100, 150, 200, 250, and 300, and the average values of the experimental results were obtained.
The cost
According to30, the normalized schedule cost (NSC) is selected as the cost performance index of the evaluation algorithm when scheduling tasks. The normalized schedule cost NSC is calculated as follows:
 |
38 |
The 
represents the cost associated with utilizing the most affordable resource for each job. As the NSC value increases so does the cost; conversely, when the NSC value decreases, the cost also drops. In Table 1, you can find the operational cost results from the performance comparison of the BDHEFT, BHEFT, and HEFT algorithms. Figure 4 illustrates the histogram corresponding to Table 1.
Table 1.
NSC values of different algorithms under different task numbers.
| Number of tasks | BDHEFT | BHEFT | HEFT |
|---|---|---|---|
| 10 | 1.9 | 2.2 | 2.24 |
| 20 | 1.8 | 2.1 | 2.35 |
| 50 | 1.75 | 1.87 | 2.3 |
| 100 | 1.83 | 1.94 | 2.43 |
| 150 | 1.89 | 2.05 | 2.59 |
| 200 | 1.94 | 2.09 | 2.76 |
| 250 | 2.04 | 2.17 | 2.82 |
| 300 | 2.11 | 2.24 | 2.87 |
Fig. 4.
NSC values of different algorithms under different task numbers.
From the chart based on the experimental data, it’s clear that the BDHEFT algorithm outperforms the BHEFT method, and both of these algorithms are more cost-effective than the HEFT algorithm when it comes to scheduling workflow activities. This improvement can be attributed to the introduction of the BDHEFT algorithm, which effectively lowers task scheduling costs due to its stringent cost restriction.
Execution time
According to the literature, the normalized schedule length (NSL) is selected as the performance index of the time the evaluation algorithm spends scheduling tasks. The normalized schedule length NSL is calculated as follows:
 |
39 |
is the workflow’s execution time to execute all tasks on the fastest resource. The NSL value goes up as you spend more time executing jobs, while a lower NSL value means you’re spending less time on tasks. You can see the experimental data comparing the performance of the BDHEFT, BHEFT, and HEFT algorithms in terms of running time in Table 2, which is visually represented in Fig. 5. As the number of tasks increases, Fig. 5 clearly shows that the NSL values for all three methods trend upward. However, the BDHEFT method still maintains a lower NSL value compared to the BHEFT and HEFT algorithms. Interestingly, the NSL value for the BDHEFT algorithm doesn’t rise with the number of jobs. Overall, the experimental results indicate that the BDHEFT algorithm excels at scheduling workflow jobs. This is due to the resource preprocessing strategy of the BDHEFT algorithm, which effectively reduces the resource search time when assigning resources to tasks, and the introduction of time constraints when selecting resources for allocation, which limits the execution time.
Table 2.
NSL values of different algorithms under different task numbers.
| Number of tasks | BDHEFT | BHEFT | HEFT |
|---|---|---|---|
| 10 | 0.624 | 0.746 | 0.849 |
| 20 | 0.672 | 0.759 | 0.865 |
| 50 | 0.693 | 0.824 | 0.96 |
| 100 | 0.812 | 0.915 | 1.123 |
| 150 | 0.843 | 0.947 | 1.158 |
| 200 | 0.847 | 0.953 | 1.201 |
| 250 | 0.846 | 0.954 | 1.2 |
| 300 | 0.847 | 0.953 | 1.202 |
Fig. 5.
NSL values of different algorithms under different task numbers.
Speedup ratio
Algorithm execution acceleration ratio Speedup37 represents the ratio of the minimum execution time of all tasks to the actual completion time. Speedup is calculated as follows:
 |
40 |
The term “makespan” refers to how long it actually takes to complete a task when using algorithm scheduling. To evaluate how well an algorithm is doing, we often look at its speedup. A higher speedup value indicates better performance, while a lower value suggests the algorithm isn’t doing so well. You can find the speedup results from the performance comparison experiment involving the BDHEFT, BHEFT, and HEFT algorithms in Table 3.
Table 3.
Speedup values of different algorithms under different task numbers.
| Number of tasks | BDHEFT | BHEFT | HEFT |
|---|---|---|---|
| 10 | 2.87 | 2.15 | 2.01 |
| 20 | 3.13 | 2.42 | 2.32 |
| 50 | 4.41 | 3.16 | 3.07 |
| 100 | 4.99 | 3.69 | 3.41 |
| 150 | 5.17 | 4.99 | 3.22 |
| 200 | 5.12 | 4.99 | 3.21 |
| 250 | 5.13 | 4.23 | 3.63 |
| 300 | 5.12 | 4.21 | 3.61 |
Take a look at Fig. 6, which illustrates the Speedup performance of the BDHEFT, BHEFT, and HEFT algorithms across various task counts. When we compare the different task counts, it’s clear that the BDHEFT method stands out, delivering better acceleration performance and execution efficiency than the other two algorithms.
Fig. 6.
Speedup values of different algorithms under different task numbers.
BDHEFT stands out as the top performer with the lowest value, while HEFT lags behind as the least effective. Additionally, Table 4 shows that BDHEFT consistently outshines the others, exhibiting the least variation in performance. Based on the experimental findings, when all three algorithms are given the same deadline, budget, and pricing model, the resource preprocessing-based BDHEFT algorithm proves to be more efficient than the other two, both in terms of execution cost and completion time.
Table 4.
Descriptive statistical analysis.
| Metric | BDHEFT | BHEFT | HEFT |
|---|---|---|---|
| Mean | 4.49 | 3.73 | 3.18 |
| Std Dev | 0.93 | 1 | 0.52 |
| Variance | 0.27 | 1 | 0.86 |
Conclusion
The paper takes a closer look at the challenges of job scheduling in a cloud computing environment, highlighting how the vast resource search space can make the scheduling process quite time-consuming. It emphasizes the importance of allocating the right amount of resources to each project. Since longer execution times can drive up both the algorithm’s runtime and costs, it’s crucial to use resources efficiently. Before diving into a mathematical model that breaks down the scheduling problem into two parts—resource allocation and resource planning—the study first categorizes resources based on their characteristics to tackle the question of how many project plans to develop. It suggests using a fuzzy clustering approach for resource preparation. To help prioritize projects and organize them according to resource allocation criteria, while also considering the project’s budget and execution time, the paper proposes a heuristic method called BDHEFT, which is built on the HEFT algorithm.
Author contributions
The manuscript is written analyze and completed by the author Nawaf R. Alharbe itself.
Funding
This research project is funded by Taibah University Madinah, Saudi Arabia.
Availability of data and materials
The data are available from the corresponding author on reasonable request.
Declarations
Competing interests
The authors declare no competing interests.
Footnotes
Publisher’s note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
References
- 1.Nadeem, M., Pathak, P. C., Ahmad, M. & Farooqui, N. A. Identification of security factors in cloud computing: Defence security perspective. In Computational Intelligence Applications in Cyber Security pp. 78–99 (CRC Press, 2024).
- 2.Dai, F., Hossain, M. A. & Wang, Y. State of the art in parallel and distributed systems: Emerging trends and challenges. Electronics10.3390/electronics14040677 (2025). [Google Scholar]
- 3.Alka, T. A., Sreenivasan, A. & Suresh, M. Entrepreneurial strategies for sustainable growth: A deep dive into cloud-native technology and its applications. Futur. Bus. J.11(1), 14. 10.1186/s43093-025-00436-7 (2025). [Google Scholar]
- 4.Shen, W., Lin, W., Wu, W., Wu, H. & Li, K. Reinforcement learning-based task scheduling for heterogeneous computing in end-edge-cloud environment. Cluster Comput.28(3), 179. 10.1007/s10586-024-04828-2 (2025). [Google Scholar]
- 5.Nadeem, M., Ahmad, M., Ahmad, M., Pathak, P. C., Gupta, S. & Pandey, H. Evaluating the factors of CGTMSE scheme in bank by using fuzzy AHP. In 2023 6th International Conference on Contemporary Computing and Informatics (IC3I), vol. 6, pp. 56–61 (2023). 10.1109/IC3I59117.2023.10397669
- 6.Jazayeri, F., Shahidinejad, A. & Ghobaei-Arani, M. A latency-aware and energy-efficient computation offloading in mobile fog computing: A hidden Markov model-based approach. J. Supercomput.77(5), 4887–4916. 10.1007/s11227-020-03476-8 (2021). [Google Scholar]
- 7.Mathew, T., Sekaran, K. C. & Jose, J. Study and analysis of various task scheduling algorithms in the cloud computing environment. In 2014 International Conference on Advances in Computing, Communications and Informatics (ICACCI), pp. 658–664 (2014) 10.1109/ICACCI.2014.6968517
- 8.Jazaeri, S. S., Asghari, P., Jabbehdari, S. & Javadi, H. H. S. Toward caching techniques in edge computing over SDN-IoT architecture: A review of challenges, solutions, and open issues. Multimed. Tools Appl.83(1), 1311–1377. 10.1007/s11042-023-15657-7 (2024). [Google Scholar]
- 9.Tari, M., Ghobaei-Arani, M., Pouramini, J. & Ghorbian, M. Auto-scaling mechanisms in serverless computing: A comprehensive review. Comput. Sci. Rev.53, 100650. 10.1016/j.cosrev.2024.100650 (2024). [Google Scholar]
- 10.Ebrahimi, A., Ghobaei-Arani, M. & Saboohi, H. Cold start latency mitigation mechanisms in serverless computing: Taxonomy, review, and future directions. J. Syst. Archit.151, 103115. 10.1016/j.sysarc.2024.103115 (2024). [Google Scholar]
- 11.Alharbi, A. et al. A link analysis algorithm for identification of key hidden services. Comput. Mater. Contin.10.32604/cmc.2021.016887 (2021). [Google Scholar]
- 12.Ghorbian, M. & Ghobaei-Arani, M. Function offloading approaches in serverless computing: A Survey. Comput. Electr. Eng.120, 109832. 10.1016/j.compeleceng.2024.109832 (2024). [Google Scholar]
- 13.Maji, I. K. Impact of clean energy and inclusive development on CO2 emissions in sub-Saharan Africa. J Clean Prod240, 118186. 10.1016/j.jclepro.2019.118186 (2019). [Google Scholar]
- 14.Al-Ismail, F., Alam, M. & Shafiullah, M. M. H.- Sustainability, and undefined 2023. Impacts of Renewable Energy Generation on Greenhouse Gas Emissions in Saudi Arabia: A Comprehensive Review,” mdpi.com, Accessed: Apr. 11, 2023. [Online]. https://www.mdpi.com/2071-1050/15/6/5069.
- 15.Nadeem, M. et al. Multi-level hesitant fuzzy based model for usable-security assessment. Intell. Autom. Soft Comput.10.32604/IASC.2022.019624 (2022). [Google Scholar]
- 16.Li, H., Zhang, X., Li, H., Duan, X. & Xu, C. SLA-based task offloading for energy consumption constrained workflows in fog computing. Futur. Gener. Comput. Syst.156, 64–76. 10.1016/j.future.2024.03.013 (2024). [Google Scholar]
- 17.Ghorbian, M., Ghobaei-Arani, M. & Asadolahpour-Karimi, R. Function placement approaches in serverless computing: A survey. J. Syst. Archit.157, 103291. 10.1016/j.sysarc.2024.103291 (2024). [Google Scholar]
- 18.Shi, L., Udemba, E., Emir, F. & Khan, N. S. H.-R. Policy, and undefined 2023 Mediating role of finance amidst resource and energy policies in carbon control: A sustainable development study of Saudi Arabia. Elsevier, Accessed: Apr. 11, 2023. [Online]. https://www.sciencedirect.com/science/article/pii/S0301420723002295.
- 19.Abedi, S., Ghobaei-Arani, M., Khorami, E. & Mojarad, M. Dynamic resource allocation using improved firefly optimization algorithm in cloud environment. Appl. Artif. Intell.36(1), 2055394. 10.1080/08839514.2022.2055394 (2022). [Google Scholar]
- 20.Ghorbian, M., Ghobaei-Arani, M. & Esmaeili, L. A survey on the scheduling mechanisms in serverless computing: A taxonomy, challenges, and trends. Cluster Comput.27(5), 5571–5610. 10.1007/s10586-023-04264-8 (2024). [Google Scholar]
- 21.Ghorbian, M. & Ghobaei-Arani, M. A survey on the cold start latency approaches in serverless computing: An optimization-based perspective. Computing106(11), 3755–3809. 10.1007/s00607-024-01335-5 (2024). [Google Scholar]
- 22.Li, H., Zheng, P., Wang, T., Wang, J. & Liu, T. A multi-objective task offloading based on BBO algorithm under deadline constrain in mobile edge computing. Cluster Comput.26(6), 4051–4067. 10.1007/s10586-022-03809-7 (2023). [Google Scholar]
- 23.Lu, R., Heung, K., Lashkari, A. H. & Ghorbani, A. A. A lightweight privacy-preserving data aggregation scheme for fog computing-enhanced IoT. IEEE Access5, 3302–3312. 10.1109/ACCESS.2017.2677520 (2017). [Google Scholar]
- 24.Domanal, S. G., Guddeti, R. M. R. & Buyya, R. A hybrid bio-inspired algorithm for scheduling and resource management in cloud environment. IEEE Trans. Serv. Comput.13(1), 3–15. 10.1109/TSC.2017.2679738 (2020). [Google Scholar]
- 25.Raptis, T. P., Cicconetti, C. & Passarella, A. Efficient topic partitioning of Apache Kafka for high-reliability real-time data streaming applications. Futur. Gener. Comput. Syst.154, 173–188. 10.1016/j.future.2023.12.028 (2024). [Google Scholar]
- 26.Kaur, J., Agrawal, A. & Khan, R. A. Security issues in fog environment: A systematic literature review. Int. J. Wirel. Inf. Netw.27(3), 467–483. 10.1007/s10776-020-00491-7 (2020). [Google Scholar]
- 27.Almotiri, S. H., Nadeem, M., Al Ghamdi, M. A. & Khan, R. A. Analytic review of healthcare software by using quantum computing security techniques. Int. J. Fuzzy Log. Intell. Syst.23(3), 336–352. 10.5391/IJFIS.2023.23.3.336 (2023). [Google Scholar]
- 28.Zhou, G. & Su, J. Named entity recognition using an HMM-based chunk tagger. In Proceedings of the 40th Annual Meeting on Association for Computational Linguistics, pp. 473–480 (2002) 10.3115/1073083.1073163
- 29.Masdari, M., Salehi, F., Jalali, M. & Bidaki, M. A survey of PSO-based scheduling algorithms in cloud computing. J. Netw. Syst. Manag.25(1), 122–158. 10.1007/s10922-016-9385-9 (2017). [Google Scholar]
- 30.Verma, A. & Kaushal, S. Bi-criteria priority based particle swarm optimization workflow scheduling algorithm for cloud. In 2014 Recent Advances in Engineering and Computational Sciences (RAECS), pp. 1–6 (2014) 10.1109/RAECS.2014.6799614
- 31.Abrishami, S., Naghibzadeh, M. & Epema, D. H. J. Deadline-constrained workflow scheduling algorithms for Infrastructure as a Service Clouds. Futur. Gener. Comput. Syst.29(1), 158–169. 10.1016/j.future.2012.05.004 (2013). [Google Scholar]
- 32.Kaur, A., Singh, P., Singh Batth, R. & Peng Lim, C. Deep-Q learning-based heterogeneous earliest finish time scheduling algorithm for scientific workflows in cloud. Softw. Pract. Exp.52(3), 689–709. 10.1002/spe.2802 (2022). [Google Scholar]
- 33.Gupta, S. et al. Efficient prioritization and processor selection schemes for HEFT algorithm: A makespan optimizer for task scheduling in cloud environment. Electronics10.3390/electronics11162557 (2022). [Google Scholar]
- 34.Samadi, Y., Zbakh, M. & Tadonki, C. E-HEFT: Enhancement heterogeneous earliest finish time algorithm for task scheduling based on load balancing in cloud computing. In 2018 International Conference on High Performance Computing & Simulation (HPCS), pp. 601–609 (2018). 10.1109/HPCS.2018.00100
- 35.Topcuoglu, H., Hariri, S. & Wu, M.-Y. Performance-effective and low-complexity task scheduling for heterogeneous computing. IEEE Trans. Parallel Distrib. Syst.13(3), 260–274. 10.1109/71.993206 (2002). [Google Scholar]
- 36.Zheng, W. & Sakellariou, R. Budget-deadline constrained workflow planning for admission control. J. Grid Comput.11(4), 633–651. 10.1007/s10723-013-9257-4 (2013). [Google Scholar]
- 37.Cao, H., Jin, H., Wu, X., Wu, S. & Shi, X. DAGMap: Efficient and dependable scheduling of DAG workflow job in Grid. J. Supercomput.51(2), 201–223. 10.1007/s11227-009-0284-7 (2010). [Google Scholar]
Associated Data
This section collects any data citations, data availability statements, or supplementary materials included in this article.
Data Availability Statement
The data are available from the corresponding author on reasonable request.