Abstract
Grid computing emerged as a powerful computing domain for running large-scale parallel applications. Scheduling computationally intensive parallel applications such as scientific, commercial etc., computational grids is a NP-complete problem. Many researchers have proposed several task scheduling algorithms on grids based on formulating and solving it as an optimization problem with different objective functions such as makespan, cost, energy etc. Further to address the requirements/demands/needs of the users (lesser cost, lower latency etc.) and grid service providers (high utilization and high profitability), a task scheduler needs to be designed based on solving a multi-objective optimization problem due to several trade-offs among the objective functions. In this direction, we propose an efficient multi-objective task scheduling framework to schedule computationally intensive tasks on heterogeneous grid networks. This framework minimizes turnaround time, communication, and execution costs while maximizing grid utilization. We evaluated the performance of our proposed algorithm through experiments conducted on standard, random, and scientific task graphs using the GridSim simulator.
Similar content being viewed by others
Introduction
Applications with high computational and data demands, such as climate modelling, drug discovery, genomics, bioinformatics, financial modelling, data analytics, and healthcare informatics, are fueling the demand for computational grids1,2,3,4,5,6,7,8,9,10. Computational grids have emerged as powerful computational paradigms, facilitating large-scale, distributed computing through the utilization of interconnected computing and storage resources. The optimal allocation of tasks to resources in computational grids becomes increasingly intricate due to various constraints, including resource heterogeneity, dynamic workload characteristics, system dynamics, and adherence to user Quality of Service (QoS) parameters, such as latency and cost.
Grid service providers typically aim to maximize profits, while users seek to minimize execution costs, communication costs, and turnaround time for their applications. One approach to achieve this is by designing efficient task schedulers to schedule user applications on computational grids. Efficient task schedulers play a crucial role in achieving these objectives, enabling intelligent decisions regarding task allocation and resource management within specified constraints. Despite being an NP-complete problem11, designing efficient task scheduling algorithms for computational grids is essential in meeting user-defined QoS requirements.
The design of task scheduling algorithms is based on either single or multi-objective functions. Task scheduling algorithms based on a single objective function are not suitable for scheduling complex real-time applications. Single-objective task scheduling algorithms primarily focus on optimizing a specific objective ( minimizing makespan, cost, energy etc) based on heuristics, metaheuristic algorithms, or mathematical optimization techniques to find near-optimal scheduling sequences. Single objective functions will find the best solution, which corresponds to either minimum or maximum value. However, they often fail to consider other objectives, resulting in imbalanced resource utilization, increased energy consumption etc. These algorithms are based on meta-heuristic algorithms12, greedy13, fuzzy model14, game theory15, bio-inspired16, and more. However, in real-world applications, it is necessary to take into account several conflicting goals at once. For instance, maximizing resource utilisation, minimizing turnaround time, minimizing task execution cost etc are equally crucial for improving system efficiency. On the other hand task scheduling algorithms based on multi-objective criteria will address these limitations by simultaneously optimizing multiple objectives, offering more robustness for users to prioritize one or more criteria over other and diverse solutions.
Multi-objective function optimization involves optimizing multiple conflicting objectives simultaneously. Common heuristic approaches for multi-objective task scheduling include the application of genetic algorithms (NSGA, NSGA-II)17,18, particle swarm optimization (MOPSO)19, simulated annealing(MOSA)20, ant colony optimization (MOACO)21, and other evolutionary (MOEAs)22 etc.These methods leverage principles inspired by natural processes to explore the solution space and find trade-off solutions among conflicting objectives. In our proposed method, heuristics are utilized as general problem-solving strategies, employing intuitive, trial-and-error methods to quickly find effective solutions. This systematic approach is designed to identify the best solution based on a defined objective function or set of criteria. Heuristics serve as rule-of-thumb methods, particularly valuable when an exhaustive search or an exact solution is impractical. The objective of incorporating heuristic approaches into our framework is to strike a balance among competing objectives. This includes minimizing turnaround time, execution cost, and communication cost while maximizing resource utilization. The application of heuristics enables the derivation of practical and computationally efficient solutions, especially in scenarios where finding an optimal solution proves challenging or unfeasible. In this article, we propose a task scheduling algorithm based on multi-objective optimization formulation with different objective functions such as minimising turnaround time (TAT), task execution cost, data communication cost between resources, and maximising grid utilization in a heterogeneous multi-grid environment. The proposed framework is plugged into a gridsim architecture as shown in Fig. 1(green colour). The framework contains five different schedulers namely 1. Greedy scheduler: prioritizes minimizing turnaround time, communication cost, and execution cost while maximizing grid utilization. 2. Greedy communication cost scheduler: minimizes communication cost by distributing tasks across computing resources within a single Grid. 3. Greedy execution cost scheduler: aims to minimize execution cost by scheduling each task on the most suitable subset of computing resources based on their cost-to-performance ratio. 4. Greedy no fragmentation scheduler: task as fragmented and schedule tasks on individual computing resources. 5. Random scheduler: schedules tasks on a random subset of computing resources.
We summarize our contributions as follows:
(1) Formulating a task scheduling framework with multiple objectives. (2) The proposed framework is integrated with Grid-sim (simulator) and performance is evaluated. (3) We applied a Technique for Order Preference by Similarity to Ideal Solution (TOPSIS) to solve the proposed multi-objective optimization for task scheduling.
The rest of this paper is organized as follows. Section "Related work" describes the related work. Section "System model" describes the system model. In Sect. "Formulation of multi-objective optimization for task scheduling", objective functions are formulated for TAT, execution cost, communication cost and grid utilization. The task scheduling algorithm is presented in Sect. "Proposed task scheduling algorithm" In Sect. "Demonstration of the proposed task scheduling algorithm" demonstration of our proposed task scheduling is discussed. In Sect. "Results and discussion" results are discussed. Multi-Objective Decision Making Problem is presented in Sect. "Formulation of the multi-Objective-decision-making problem". Finally, in Sect. "Conclusion and future work" we conclude the paper.
Related work
In this section, we present a brief discussion on existing multi-objective task scheduling frameworks/algorithms/models etc. A Grid-based Evolutionary Algorithm (GrEA) is proposed in Ref.23 to tackle multi-objective optimization issues by utilising the grid-based resource capacity to boost selection pressure in the best direction while maintaining a broad and uniform distribution of choices. A framework is designed to evaluate multi-objective functions (makespan, cost, deadline violation rate, and resource utilization.) for scheduling tasks24 based on the Ant Colony Algorithm in Cloud Computing. A new bio-inspired diversity metric, Pure Diversity (PD) is proposed in Ref.25 to assess the performance of diversity of multi-objective evolutionary algorithms (MOEAs) for solving Many-objective optimization problems(MaOPs). A MATLAB-based PlatEMO is developed to use it for performing comparative experiments, embedding new algorithms, creating new test problems, and developing performance indicators26. This platform includes more than 50 multiobjective evolutionary algorithms and more than 100 multi-objective test problems. Multi-objective particle swarm optimizer(NMPSO) algorithm with a Balanceable Fitness Estimation(BFE) method was designed in Ref.27 to tackle many-objective optimization problems( MaOPs). A multi-objective optimization method based on a non-dominated sorting genetic algorithm (NSGA-II) is applied and tested on an IEEE 17-bus test system28, which simultaneously minimizes two contradicting objective functions such as voltage deviation at buses and total line loss. A multi-objective charging framework that incorporates a vehicle-to-grid (V2G) strategy to optimally manage the real power dispatch of electric cars. The objective functions minimizing load fluctuation and charging costs related with EVs in residential areas29. Partitional Clustering Method (PCM) and Hierarchical Clustering Method (HCM) are used in clustering-based evolutionary algorithms for tackling MaOPs30. For determining congestion thresholds in low-voltage (LV) grids, authors in Ref.31 used a multi-objective particle swarm optimisation (MOPSO) approach paired with data analytics via affinity propagation clustering. A virtual machine migration method is designed to maximize host release and minimize virtual machine migration is proposed in32. Task Scheduling for Deadline and Cost Optimization (DCOTS) is presented in Ref.33. This work ensures the fulfilment of user requirements while simultaneously aiming to maximize the profitability for cloud providers. The objective functions for building a multi-objective cloud task scheduling model include34 execution time, execution cost, and virtual machine load balancing. Subsequently, the task scheduling problem is addressed using the multi-factor optimization (MFO) technique, and the characteristics of task scheduling are integrated with the multi-objective multi-factor optimization (MO-MFO) algorithm to formulate an assisted optimization task. A Task Scheduling technique35 based on a Hybrid Competitive Swarm Optimization Algorithm (HCSOA-TS) within the context of the CC platform. The proposed HCSOA-TS efficiently schedules tasks to maximize resource utilization and overall performance. The construction of a multi-objective task scheduling model for cloud computing36, aimed at optimizing cloud computing tasks, utilizes the Cat Swarm Optimization (CSO) model. The task objectives for cloud computing were scrutinized, leading to the formulation of a multi-objective task scheduling model with execution time and system load as key scheduling objectives. Study in Ref.37 presents a parallel algorithm for task scheduling, where both the priority assignment to tasks and the construction of the heap are concurrently executed. Authors in Ref.38 present edge scheduling stage, tasks are arranged based on the latest start times of their successors instead of their sub-deadlines, with the goal of mitigating lateness in subsequent tasks.
In Grid Computing, the resource optimisation problem is treated as a Multi-Objective Optimisation problem39, and PSO is used to search the problem area for possible solutions. To find non-dominated solutions for the multi-objective issue and to optimise and search for the best Grid resources, the Functional Code Sieve algorithm is used. Similarly, various task scheduling algorithms40,41,42,43,44,45,46,47 based on multi-objective optimization are studied.
Resource management and task scheduling are intricate operations in computational grids. To manage distributed resources and evaluate scheduling algorithms and their performance with different numbers of resources, a toolkit named GridSim has been proposed. GridSim aids in the mapping of user tasks to grid resources. Several task scheduling algorithms have been simulated using GridSim since its introduction48,49,50,51,52,53,54,55.
The Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) is a method used for multi-criteria decision analysis. It was initially introduced in Refs.56,57,58. A-TOPSIS, presented in Ref.59, aims to compare the performance of different algorithms based on mean and standard deviations. This technique calculates the best and worst algorithms based on user-defined parameters. Another method, D-TOPSIS, is presented in Ref.60 and is more effective in representing uncertain information compared to other group decision support systems based on the classical TOPSIS method. TOPSIS fuzzy61 is a multi-objective decision-making tool used to find a scheduling algorithm that can minimize response time and maximize throughput. In Ref.62, the authors propose a method that combines the Heterogeneous Earliest Finish Time (HEFT) algorithm with the TOPSIS method to solve multi-objective problems. Thus, TOPSIS is a valuable decision-making technique because it provides a systematic and structured approach to evaluate and rank alternatives based on multiple criteria, helping end users to make well-justified choices in complex decision scenarios.
System model
Task model
The task scheduling framework consists of a task graph, a task scheduler and a grid network. A task graph is an input to a task scheduler and is defined as a Weighted Directed Acyclic Graph (WDAG) \(WTG=(T, E)\). where T is set of tasks and E set of edges which describes the dependency between tasks. The weight \(W(T_i)\) is assigned to task \(T_i\) represents the size of a \(i^{\text {th}}\) task and is expressed as Million Instructions (MI).
Grid model
Grid network consists of set of grid nodes G = \(\{G_1, G_2, G_3 ,...,G_m\}\) and they are interconnected by high speed network. Each grid node contains p number of heterogeneous processing elements \(G_i\) = \(\{r_{i1}, r_{i2}, r_{i3},...,r_{ip}\}\) and these processing elements are internally connected by a high-speed communication network. Processing speed / CPU_speed of each processor is represented in terms of Million Instructions Per Second (MIPS). Each computational grid contains a local scheduler, The function of the local scheduler is to manage the execution of a task on a grid resource given by the task scheduler. The local scheduler is also responsible for collecting information about computational resources periodically and communicating with the task scheduler.
Proposed multi-layer architecture.
Simulation model
GridSim66
We have employed a Java-based discrete-event toolkit called GridSim to simulate our multi-objective task scheduling framework. This versatile toolkit offers a comprehensive suite of features for modelling and simulating resources and network connectivity, accommodating various capabilities and configurations. Among its capabilities are primitives for composing applications, information services for resource discovery, and interfaces for task allocation to resources and managing their execution. These capabilities enable us to simulate resource brokers or grid schedulers, facilitating the evaluation of scheduling algorithms’ performance. It’s worth noting that GridSim does not prescribe any specific application model, but in our proposed framework, we have adopted a Directed Acyclic Graph (DAG) as the application model. Within the GridSim environment, individual tasks can exhibit differing processing times and input file sizes. To represent these tasks and their requirements, we utilize Gridlet objects. Each Gridlet encapsulates comprehensive information related to a job, including execution management details such as job length (measured in MIPS), disk I/O operations, input and output file sizes, and the job’s originator. In the context of GridSim, a Processing Element (PE) stands as the smallest computing unit, configurable with varying capacities denoted in Million Instructions per Second (MIPS). Multiple PEs can be combined to construct a machine, and in a similar fashion, machines can be aggregated to form a grid. Grids can allocate Gridlets in either a time-sharing mode (common in single-processor Grids) or a space-sharing mode (typical for multi-processor Grids).
Existing GridSim architecture
Proposed multi-layer architecture and abstractions are shown in Fig. 1. The layered structure of this system begins with the foundational run-time machinery, known as the JVM (Java Virtual Machine). This JVM is versatile, catering to both single and multiprocessor systems, including clusters. Moving up to the second layer, we encounter a fundamental discrete-event infrastructure that relies on the interfaces offered by the first layer. This infrastructure is actualized through SimJava, a well-regarded Java library for discrete event simulation. The third layer delves into the simulation of essential grid entities, encompassing resources and information services, among others. Here, the GridSim toolkit employs the discrete event services provided by the underlying infrastructure to simulate these core resource entities. Ascending to the fourth layer, our attention turns to the simulation of resource aggregators, often referred to as grid resource brokers or schedulers. Finally, the fifth and topmost layer is dedicated to application and resource modelling across various scenarios. It harnesses the services furnished by the two lower-level layers to evaluate scheduling strategies, resource management policies, heuristics, and algorithms.
Life cycle of a GridSim simulation
Prior to commencing a simulation, we establish the resource entities (including PEs, Machines, and Grids) that will be available throughout the simulation. Upon GridSim’s initiation, these resource entities autonomously enroll themselves with the Grid Information Service (GIS) entity by dispatching relevant events.
Furthermore, at the onset of the simulation, a user initiates the process by submitting their job to a Resource Broker. The resource broker plays a pivotal role in the simulation, encompassing several responsibilities. It first employs information services to identify accessible resources for the user. Subsequently, it performs task-to-resource mapping (scheduling), orchestrates the staging of application components and data for processing (deployment), initiates job execution, and ultimately aggregates the results. Beyond these tasks, the resource broker also takes on the crucial role of monitoring and tracking the progress of application execution.
Our resource broker implementation
All the application models we have explored rely on task inter-dependencies, which are precisely defined using Directed Acyclic Graphs (DAGs). Regrettably, GridSim does not inherently accommodate the execution of tasks that are constrained by these inter-dependencies. In response to this limitation, our Resource Broker implementation extends support for such scenarios by ensuring that the order of task execution adheres to the specified dependency constraints. Our Resource Broker defines a versatile task Scheduler interface, offering seamless integration with various schedulers. This interface serves as a plug-and-play mechanism, enabling the utilization of multiple schedulers introduced in our work (GS, GCPS, GEPS, GNFS), all of which adhere to this common interface. Furthermore, our task scheduling framework introduces an innovative concept called task fragmentation, allowing tasks to be divided for execution across multiple computing resources. To facilitate this, our resource broker incorporates a Gridlet Fragmentation Service. When a gridlet is scheduled to run on more than one Processing Element, it is initially fragmented into multiple smaller virtual gridlets. These virtual gridlets are then individually executed by the allocated Processing Elements. Upon their completion, the Gridlet Fragmentation Service reunites them into the original single gridlet. Another novel concept introduced by our task scheduling framework involves partial dependencies among tasks. However, GridSim does not inherently enable the Resource Broker to monitor task progress during execution. To address this, we have implemented a pinger service within the Resource Broker and individual Processing Elements. This pinger service allows the Broker to stay informed about a gridlet’s execution progress, enabling it to schedule child tasks once a parent task has reached a predefined threshold percentage of execution, as dictated by the parent-child dependency.
Lastly, we have enhanced the Resource Broker with the capability to gather performance statistics, including Turnaround Time, Resource Utilization, Execution Price, and Communication Price. These statistics provide valuable insights into the system’s performance.
Formulation of multi-objective optimization for task scheduling
We propose task scheduling problem as a multi-objective optimization problem with a goal to minimize TAT, execution price, communication price and maximize grid utilization for precedence constrained task graphs is represented as argmin(TAT, EP,CP, \(-GU\)).
The objective function for TAT is defined and formulated as shown in Eq. (1).
where \({X_{ij_{k}}}={\left\{ \begin{array}{ll} 1, &{}\quad \text {if the task} {T_{i}} \text {is scheduled on the } jth \text { grid} \\ &{}\quad \text {on its } kth \text { resource } \\ 0, &{}\quad \text {otherwise}. \end{array}\right. }\)
\(\tau _{{ij}_{k}}=\) Execution time of Task \(T_i\) on k’th resource of grid j
Grid Utilization is formulated in Eq. (2).
Task execution price and communication price is defined and formulated in Eqs. (3) and (4) respectively. Rest of the paper used price and cost interchangeably.
Where
\({\tau _{ij}}={\sum }_{k=1} ^{p[j]} {X_{ijk}}*{\tau _{ijk}}\)
and
\({M_{i}}={\sum }_{j=1} ^{m} X_{ij}\)
where \({X_{ij}}={\left\{ \begin{array}{ll} 1, &{} \text {if the task }{T_{i}} \text {is scheduled on} \\ &{} \text {on any machine of Grid} G_j \\ 0, &{} \text {otherwise}. \end{array}\right. }\)
Proposed task scheduling algorithm
Proposed Multi-Objective task scheduling algorithm is described in algorithm 2. Algorithm generates an optimized schedule sequence (task-id, [grid-ID, machine-ID], execution start-time and end-time) according to multiple objectives (TAT, EC, CC and RU).
Input to the algorithm is number of tasks(n), task dependency graph (weighted adjacency matrix WTG[1, ..., n][1, ..., n]), task lengths (\(W_T[1,..., n]\)), number of grids(m), number of machines p[1, ..., m] in each grid, processing capacity of each grid in terms of MIPS (\(W_G[1,..., m])\), and the user’s objective optimization criteria (See 2 for choices). The algorithm’s output is the optimized task schedule sequence (step 1 and 2). Step 3 generates all possible combinatorial subsets of Grid-Machines that a task can be allocated onto, depending on the user’s objective optimization criteria, as so: If the user criteria is GS then this step generates all possible subsets of grid-machines sets. If the user criteria is GCPS then it generates combinatorial sets of grid machines with all the machines in each set belonging to the same grid. If the user criteria is GEPS then it generates combinatorial sets of grid-machines which offer the lowest task execution price (other Grid-Machines are ignored). Similarly, if the user criteria is GNFS then it generates singleton sets of all the individual grid-machines.
The algorithm then executes in a loop (from Step 7) until all the tasks have been scheduled. On every iteration of the loop, the algorithm first identifies (in Step 8) tasks whose parent task dependency constraints have been met and are thus available for scheduling. Step 4 then uses function (5) to select the best task and Grid-Machine combination for scheduling. Steps 11 to 13 append this Task-Grid-Machine allocation to the schedule sequence, and update the information about available Grid Machines and unscheduled tasks. Finally, Steps 14, 15 enter into a blocking wait until one or more Grid-Machines are available, after which, the algorithm enters into another iteration of the Step 7 loop.
Multi-objective task scheduler.
Generic single-objective task scheduler.
Generate processing element combinations.
Function to determine the preference to schedule a task on a set of GridMachines
Demonstration of the proposed task scheduling algorithm
To enhance comprehension of the proposed algorithm 2, we’ll illustrate its functionality through an example, using concise input parameters. This demonstration will cover four distinct user objective types (GS, GEPS, GCPS, GNFS).
Consider an application with workload characterized by a task graph comprising four tasks, each task contains 60 million instructions (MI). This task graph is represented as a Directed Acyclic Graph (DAG), as shown in Fig. 2a. Similarly, a grid network, depicted in Fig. 2b, comprises two grids: \(G_1\) housing Grid-Machine \(G_1M_1\) and \(G_2\) hosting Grid-Machines \(G_2M_1\) and \(G_2M_2\). Each Grid-Machine possesses a processing capacity of 2 million instructions per second (MIPS). These specifications in Table 1, serve as the inputs for Algorithm 2. In the following subsections, we illustrate the iterations executed by the proposed scheduling algorithm and the corresponding helper functions for each distinct objectiveType.
A typical scenario for a proposed scheduling algorithm demonstration.
Objective type: greedy scheduler
Function \(f_g()\) (described in Table 2) generates 7 possible combinations of Grid-Machine subsets to allocate tasks for the Greedy Scheduler objectiveType, as illustrated in Table 3.
Function \(f_s()\) (described in Eq. (5)) computes a preference matrix for scheduling each task on each of the generated Grid-Machine subsets, as shown in Table 4. Then, Algorithm 2 computes the schedule sequence of task allocations onto Grid-Machines, as shown in Table 5.
Objective type: greedy communication price scheduler
Function \(f_g()\) (described in Table 2) generates 4 possible combination of Grid-Machine subsets to allocate tasks for a Greedy Scheduler objectiveType, as illustrated in Table 6. Function \(f_s()\) (described in Eq. (5)) computes a preference matrix for scheduling each task on each of the generated Grid-Machine subsets, as shown in Table 7. Then, Algorithm 2 computes the schedule sequence of task allocations onto Grid-Machines, as depicted in Table 8.
Objective type: greedy no fragmentation scheduler
Function \(f_g()\) (described in Table 2) generates 3 possible combination of Grid-Machine subsets to allocate tasks for the Greedy Scheduler objectiveType, as illustrated in Table 9. Function \(f_s()\) (described in Eq. (5)) computes a preference matrix for scheduling each task on each of the generated Grid-Machine subsets, as shown in Table 10. Then, Algorithm 2 computes the schedule sequence of task allocations onto Grid-Machines, as shown in Table 11.
Objective type: greedy execution price scheduler
Function \(f_g()\) (described in Table 2) generates 4 possible combination of Grid-Machine subsets to allocate tasks for the Greedy Scheduler objectiveType, as illustrated in Table 12. Function \(f_s()\) (described in Eq. (5)) computes a preference matrix to schedule a task on each of the generated Grid-Machine subsets, as shown in Table 13. Then, Algorithm 2 computes the schedule sequence of task allocations onto Grid-Machines, as shown in Table 14.
Results and discussion
Simulation setup
The proposed multi objective task scheduling framework is simulated using GridSim. Simulation is carried out on three types of task graphs : standard task graphs, random task graphs and scientific task graphs on ubuntu operating system with AMD Ryzen 5 processor.
The framework includes five distinct task schedulers, each designed to optimize different target objectives:
1. Greedy scheduler: Prioritizes minimizing turnaround time, communication cost, and execution cost while maximizing grid utilization. 2. Greedy Communication Cost scheduler: Focused on minimizing communication cost by distributing tasks across computing resources within a single Grid. 3. Greedy Execution Cost scheduler: Aims to minimize execution cost by scheduling each task on the most suitable subset of computing resources based on their cost-to-performance ratio. 4. Greedy No Fragmentation scheduler: Aims to schedule tasks on individual computing resources, resulting in zero task fragmentation. 5. Random scheduler: Schedules tasks on a random subset of computing resources.
Table 15 explicates the notations used in the mathematical models and algorithms. Table 16 delineates the symbols representing various scheduling algorithms, while Table 17 furnishes a catalogue of scientific application graphs used in the current study.
The proposed task scheduling algorithm is evaluated using standard, random and scientific task graphs.
Standard task graphs
Our earlier research, as presented in63, demonstrated theorems for standard unit size task graphs on a homogeneous grid network for turnaround time. Similarly, in64, we stated theorems for grid utilization. In this article, we have formulated mathematical models for homogeneous standard-weighted task graphs on a homogeneous grid network for both fragmented and non-fragmented versions of the task graphs. These formulations are defined in Tables 18 and 19 respectively.
TAT obtained from the proposed algorithm is tabulated in Table 20. The result describes both theoretical and simulated results for various standard task graphs (with fragmentation and without fragmentation) for a given number of tasks, grids, and processing elements. Here each task contains a uniform number of instructions (\(W_{Ti}=20000\) MI) and homogeneous processing elements ( \(W_{GR}=500\) MIPS) in each grid. Computed TAT is on par with our mathematical formulations. From the results, it is evident that as number of tasks increases, TAT also increases. Similarly, The computed values of turnaround time, execution cost, communication cost, and resource utilization using proposed schedulers for pipeline, star, ternary, independent and fully connected task graphs with varying number of task nodes and a given number of grid resources are tabulated in Tables 21, 22 and 23 respectively. From these results, it has been found that the greedy scheduler successfully optimizes for the fastest turnaround time along with grid utilisation, but the trade-off is that the communication cost is high. However, the greedy communication cost scheduler with a slightly slower TAT successfully incurs the lowest communication cost. In the absence of task fragmentation, a greedy scheduler achieves optimal grid utilization while incurring zero communication costs. Additionally, it’s worth noting that the execution cost remains consistent across different task schedulers when standard graphs are processed on a homogeneous grid network. As the nature of the graphs becomes increasingly independent (such as star graphs or independent graphs), most schedulers yield similar turnaround times due to the reduced dependency constraints. The Random scheduler, inherently achieves TAT, Resource Utilization, and Communication cost in between the extremes achieved by the other schedulers. Another interesting observation is that greedy scheduler achieves maximum resource utilization and minimum turnaround time, albeit by incurring the highest communication and execution costs.
Random task graphs
Random task graphs with diverse levels of connectivity (0%, 25%, 50%, 75%, and 100%) is generated by using algorithm-264. The outcomes of our proposed algorithm, encompassing TAT, resource utilization, execution cost, and communication cost, are depicted in Fig. 3 through Fig. 4. From these results, we can conclude that the turnaround time increases due to the increase in the number of tasks and also the increase in task dependency. This is shown in Figs. 5, 6, 7 and 8. Also when tasks are scheduled without fragmentation TAT increases as compared to tasks with fragmentation.
Random task graph with 0% connectivity - TAT and resource utilization.
Random task graph with 100% connectivity - TAT and execution cost.
Random task graph with 25% connectivity - TAT and resource utilization.
Random task graph with 50% connectivity - TAT and resource utilization.
Random task graph with 75% connectivity - TAT and resource utilization.
Random task graph with 100% connectivity - TAT and resource utilization.
Resource utilization decreases when scheduling a random task graph with a higher degree of dependency without fragmentation (as seen in Figs. 5, 6, 7, and 8), in contrast to when tasks are fragmented. Additionally, it’s noteworthy that all schedulers perform optimization for turnaround time and resource utilization when there is no inter dependency among the tasks, as illustrated in Fig. 3.
As the inter dependency between tasks within a task graph increases (with connectivity’s of 0% as shown in Fig. 9, 25% connectivity as shown in Fig. 10, 50% in Fig. 11, 75% in Fig. 12, and 100% in Fig. 13), it becomes evident that the greedy scheduler achieves the lowest Turnaround Time (TAT). However, this comes at the cost of higher communication expenses due to the fragmentation of tasks. Conversely, a greedy scheduler without task fragmentation incurs zero communication costs in all cases, effectively eliminating this expense from the scheduling process.
Random task graph with 0% connectivity - TAT and communication cost.
Random task graph with 25% connectivity - TAT and Commutation Cost.
Random task graph with 50% connectivity - TAT and communication cost.
Random task graph with 75% connectivity - TAT and communication cost.
Random task graph with 100% connectivity - TAT and communication cost.
Figures 4, 14, 15, 16 and 17 shows that the greedy execution cost scheduler incurs the least execution cost. The computed values of turnaround time, execution cost, communication cost, and resource utilization using proposed schedulers for random task graphs with 25%, 50%, 75% and 100% dependency with varying number of task nodes and a given number of grid resources are tabulated in Tables 24, 25 and 26 respectively.
Random task graph with 0% connectivity - TAT and execution cost.
Random task graph with 25% connectivity - TAT and execution cost.
Random task graph with 50% connectivity - TAT and execution cost.
Random task graph with 75% connectivity - TAT and execution cost.
Scientific task graphs
The performance of the proposed algorithm is also evaluated by using scientific graphs such as Montage, CyberShake, LIGO etc. Here all workflows are generated by Pegasus Workflow Generator65. Results shown in Figs. 18, 19, 20, 21 and 22 demonstrates the performance of proposed algorithm.
Scientific task graphs with resource utilization and communication cost.
Scientific task graphs with resource utilization and execution cost.
Scientific task graphs with resource utilization and TAT.
Scientific task graphs with resource utilization and communication cost.
Scientific task graphs with TAT and execution cost.
Our observation reveals that across all application task graphs, the greedy scheduler consistently generates schedules with the most optimal TAT and resource utilization. However, it’s important to note that this optimization is achieved at the expense of incurring the highest communication and execution costs compared to the schedules generated by the other schedulers.
A consistent trend that emerges across all schedulers is the inverse relationship between resource utilization and the extent of parallel execution of tasks, which is dictated by the inter-dependency constraints among tasks. For example, in the case of the Gaussian Elimination and Montage scientific application graphs, where tasks exhibit a high degree of inter-dependency, the scheduling sequences result in the lowest resource utilization. This highlights the influence of task inter-dependency on resource allocation and utilization in the scheduling process.
Similarly, computed values of turnaround time, execution cost, communication cost, and resource utilization using proposed schedulers for different scientific task graphs is tabulated in Table 27.
Formulation of the multi-objective-decision-making problem
The generic multi-attribute-decision-making (MADM) problem
Scheduling tasks in a grid network can be conceptualized as a MADM problem. In the context of MADM, the goal is to assess and prioritize various alternative solutions denoted as \(A_i(i = 1, 2, 3, \dots , I)\), taking into account specific criteria. These criteria, represented as \(C_j(j = 1, 2, 3, \dots , J)\), encapsulate the factors that play a role in influencing the ranking of the alternative solutions within the set \(A_i\).
Each alternative solution, denoted as \(A_i\), undergoes an evaluation against each individual criterion, represented by \(C_j\). This evaluation process produces a performance rating matrix \(X = (x_{ij})_{(I \times J)}\).
The user is tasked with specifying a set of weights, denoted as \(W = w_j(j = 1, 2, \dots , J)\), which serve as indicators of the user’s individual preferences for each criterion, \(C_j\).
Modeling task scheduling as an MADM problem
We model task scheduling problem as an MADM problem by:
-
1.
Considering the schedule sequence output by each scheduler as the set of alternative solutions i.e. \(A = \{ a | a \subset \{GS, GCCS, GECS, GNFS\} \}\).
-
2.
Considering the performance metrics of a schedule sequence as the set of criteria i.e. \(C = \{c | c \subset \{TAT, RU, CC, EC\}\}\).
-
3.
Computing the performance rating of each scheduler (GS, GCCS, GECS, GNFS) against every criteria (TAT, RU, CC, EC).
i.e.
$$\begin{aligned} X = \begin{array}{*{20}c} GS \\ GCCS \\ GECS \\ GNFS \\ \end{array} \mathop {\left( {\begin{array}{*{20}l} y_{11} &{} x_{12}&{} x_{13}&{} x_{14}\\ x_{21}&{} x_{22}&{} x_{23}&{} x_{24}\\ x_{31}&{} x_{32}&{} x_{33}&{} x_{34}\\ x_{41} &{} x_{42} &{} x_{43} &{} x_{44} \\ \end{array} } \right) } \limits ^{{\begin{array}{*{20}l} &{} TAT &{} RU &{} CC &{} EC \\ \end{array} }} \end{aligned}$$ -
4.
Collecting a user’s preferences for each criterion involves ranking these criteria in descending order of importance. Weights are then allocated using a Geometric Progression, with greater weights being assigned to criteria ranked higher in importance by the user.
Solving the MADM problem
The task scheduling MADM problem is addressed using a well-regarded technique within the MADM field known as TOPSIS. TOPSIS operates on the principle that the optimal solution is the one closest to the positive-ideal solution while simultaneously being the farthest from the negative-ideal solution. Alternatives are ranked by computing an overall index based on their proximity to these ideal solutions.
The TOPSIS method comprises a series of steps, as follows:
-
1.
Normalize the performance rating matrix.
i.e. \(y_{ij} = \frac{x_{ij}}{\sqrt{ \sum _{i=1}^{I} x_{ij}^2 }}\)
\(Y = \begin{bmatrix} y_{11} &{} y_{12} &{} \dots &{} y_{1J} \\ y_{21} &{} y_{22} &{} \dots &{} y_{2J} \\ \dots &{} \dots &{} \dots &{} \dots \\ y_{I1} &{} y_{I2} &{} \dots &{} y_{IJ} \end{bmatrix}\)
-
2.
Determine the weighted, normalized performance rating matrix.
i.e.
\(V = \begin{bmatrix} y_{11} &{} v_{12} &{} \dots &{} v_{1J} \\ v_{21} &{} v_{22} &{} \dots &{} v_{2J} \\ \dots &{} \dots &{} \dots &{} \dots \\ v_{I1} &{} v_{I2} &{} \dots &{} v_{IJ} \end{bmatrix}\)
Where \(v_{ij} = W_j * y_{ij}; (i = 1, 2, \dots , I; j = 1, 2, \dots , J)\)
-
3.
Compute the positive and negative ideal solutions, \(A^+\) and \(A^-\), respectively.
\(A^+ = [v_1^+, v_2^+, \dots , v_J^+]\) \(A^+ = [v_1^-, v_2^-, \dots , v_J^-]\)
where,
\(v_j^+ = {\left\{ \begin{array}{ll} max_{i=1}^{I}(v_{ij})\,\,\,\, \text {if }\,\,\,\, j \text { is a benefit attribute}, min_{i=1}^{I}(v_{ij})\,\, \text {if }\,\,\,\, j\,\,\,\, \text { is a cost attribute} \end{array}\right. }\)
\(v_j^- = {\left\{ \begin{array}{ll} min_{i=1}^{I}(v_{ij})\,\,\,\, \text {if }\,\, j \,\,\,\,\text { is a benefit attribute}, max_{i=1}^{I}(v_{ij})\,\, \text {if } \,\,\,\,j\,\,\,\, \text { is a cost attribute} \end{array}\right. }\)
-
4.
Calculate the Euclidean distance from the positive and negative ideal solutions.
\(S_i^+ = \sqrt{ \sum _{j=1}^j (v_{ij} - v_{j}^+)^2 }\)
\(S_i^- = \sqrt{ \sum _{j=1}^j (v_{ij} - v_{j}^-)^2 }\)
-
5.
Calculate the closeness of each alternative solution to the ideal solution. \(V_i = \frac{S_i^-}{S_i^- + S_i^+}\)
-
6.
Determining the rank order of all alternatives on the basis of their relative closeness to the ideal solutions. The larger the \(V_i\) is, the better the alternative solution \(A_i\) is. The best alternative solution is the one with the largest closeness to the ideal solution.
TOPSIS results and discussion
To rank the task schedule sequences produced by various schedulers, the TOPSIS method is employed. This method optimizes the selection of schedules according to the user’s prioritized objectives, which include Turnaround Time, Resource Utilization, Communication Price, and Execution Price, in terms of their desirability. Tables 28, 29, and 30 presents the result of the TOPSIS algorithm when applied to standard, random, and scientific task graphs, respectively. We explore different possible priority orders that users may assign to each criterion. Notably, we find a consistent ranking pattern for schedule sequences across all types of graphs, including Standard, Random, and Scientific graphs, which encompass Fully Connected, Pipeline, Star, Ternary, and Independent graph categories. Additionally, this ranking consistency persists even when the number of tasks varies (40, 121, 364, and 1039).
Weightage types 1, 2, 3, 4, as well as 7, 8, 9, and 10, exemplify situations where the user places the highest importance on turnaround time and resource utilization as criteria, while assigning less significance to communication cost and execution cost. In these scenarios, TOPSIS consistently ranks the greedy scheduler as the top solution. The second-best alternative solution is the greedy communication cost scheduler, which outperforms the other schedulers in terms of TAT and resource utilization.
However, in cases corresponding to weightage types 5, 6, 10, and 11, where the user’s preference primarily focuses on achieving an optimal communication cost, TOPSIS identifies the schedule generated by the greedy communication scheduler as the best solution. This scheduler minimizes communication costs to zero while maintaining TAT and resource utilization levels that are nearly on par with those achieved by the greedy scheduler. In this context, the output schedule sequence of the greedy scheduler is ranked last by TOPSIS, as it incurs the highest communication cost, contradicting the user’s prioritization of criteria desirability.
Conclusion and future work
In this paper, we presented a multi-objective task scheduling framework for scheduling different types of workflows on computational grids. The main objective of our proposed framework is to minimize the overall execution cost, including application turnaround time and communication cost, while maximizing grid utilization. The proposed scheduling framework is integrated with GridSim and validated through experiments conducted on weighted standard task graphs, weighted random task graphs, and scientific task graphs. Furthermore, we envisaged a multi-criteria decision method called Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) to rank the output of the scheduling sequence based on different objective functions and the requirements of both users and service providers.
As part of future work, we plan to design a multi-objective task scheduling framework based on Large Language Models (LLMs) and compare the performance with NSGA-II in a computational cloud computing environment.
Data availibility
The data that supports the findings of this study are available from the corresponding author on request.
References
Casanova, H. & Dongarra, J. Network enabled solvers for scientific computing using the NetSolve system. In Proc. of 3rd International Conference on Algorithms and Architectures for Parallel Processing, Melbourne, VIC, Australia, pp. 17-33 (1998).
Goux, J.P., Kulkarni, S., Linderoth, J. & Yoder, M. An enabling framework for master_worker applications on the computational grid. In 9th IEEE Int. Symposium on High Performance Distributed Computing, HPDC’00 (2000).
Chervenak, A., Foster, I., Kesselman, C., Salisbury, C. & Tuecke, S. The data grid: Toward an architecture for the distributed management and analysis of large scientific datasets. J. Netw. Comput. Appl. 23, 187–200 (2000).
Beynon, M. D., Sussman, A., Catalyurek, U., Kurc, T. & Saltz, J. Performance optimization for data intensive grid applications. In Proc. Third Annual International Workshop on Active Middleware Services, USA, 97–105 (2001).
Linderoth, L. & Wright, S. J. Decomposition algorithms for stochastic programming on a computational grid. Comput. Optim. Appl. 24, 207–250 (2003).
Newman, H. B., Ellisman, M. H. & Orcutt, J. A. Data-intensive e-Science frontier research. Commun. ACM 46(11), 68–77 (2003).
Buyya, R., Abramson, D. & Venugopal, S. The grid economy. Proc. IEEE 93(3), 698–714 (2005).
Paniagua, C., Xhafa, F., Caballé, S. & Daradoumis, T. A parallel grid-based implementation for real time processing of event log data in collaborative applications. In Parallel and Distributed Processing Techniques, PDPT2005, Las Vegas, USA, pp. 1177–1183 (2005).
Arbona, A. et al. A service-oriented grid infrastructure for biomedical data and compute services. IEEE Trans. NanoBiosci. 6(2), 136–141 (2007).
Alonso, J. M. et al. A grid computing-based approach for the acceleration of simulations in cardiology. IEEE Trans. Inf. Technol. Biomed. 12(2), 138–144 (2008).
Mishra, Manoj Kumar, Patel, Yashwant Singh, Rout, Yajnaseni & Mund, G.B. A survey on scheduling heuristics in grid computing environment, I.J. Modern Education and Computer Science, pp. 57-83 (2014).
Tsai, C. & Rodrigues, J. Meta heuristic scheduling for cloud: A survey. IEEE Syst. J. 8(1), 279–291 (2014).
Zhou, Zhou & Zhigang, Hu. Task scheduling algorithm based on greedy strategy in cloud computing. Open Cybern. Syst. J. 8, 111–114 (2014).
Kong, X., Lin, C., Jiang, Y., Yan, W. & Chu, X. Efficient dynamic task scheduling in virtualized data centers with fuzzy prediction. J. Netw. Comput. Appl. 34(4), 1068–1077 (2011).
Sun, W. et al. A game theoretic resource allocation model based on extended second price sealed auction in grid computing. J. Comput. 7(1), 65–75 (2012).
Grover, R. & Chabbra, A. Bio-inspired optimization techniques for job scheduling in grid computing. In 2016 IEEE International Conference on Recent Trends in Electronics, Information & Communication Technology (RTEICT), pp. 1902-1906 (2016).
Bagchi, T. P. The nondominated sorting genetic algorithm: NSGA. In Multiobjective Scheduling by Genetic Algorithms (ed. Bagchi, T. P.) (Springer, 1999).
Deb, K., Pratap, A., Agarwal, S. & Meyarivan, T. A fast and elitist multiobjective genetic algorithm: NSGA-II. IEEE Trans. Evolut. Comput. 6(2), 182–197 (2002).
Coello Coello, C. A. & Lechuga, M. S. MOPSO: a proposal for multiple objective particle swarm optimization Proceedings of the 2002 Congress on Evolutionary Computation. CEC’02 (Cat. No.02TH8600), Honolulu, HI, USA, pp. 1051-1056 (2002).
Li, H. and Landa-Silva, D., An Adaptive Evolutionary Multi-Objective Approach Based on Simulated Annealing, Evolutionary Computation, pp. 561-595, (2011).
Lopez-Ibanez, M. & Stutzle, T. The automatic design of multiobjective ant colony optimization algorithms. IEEE Trans. Evolut. Comput. 16(6), 861–875 (2012).
Zhou, Aimin, Bo-Yang, Qu., Li, Hui & Zhao, Shi-Zheng. Multiobjective evolutionary algorithms: A survey of the state of the art. Swarm Evolut. Comput. 1(1), 32–49 (2011).
Yang, S. et al. A grid-based evolutionary algorithm for many-objective optimization. IEEE Trans. Evolut. Comput. 17(5), 721–736 (2013).
Zuo, L., Shu, L., Dong, S., Zhu, C. & Hara, T. A multi-objective optimization scheduling method based on the ant colony algorithm in cloud computing. IEEE Access 3, 2687–2699 (2015).
Wang, H., Jin, Y. & Yao, X. Diversity assessment in many-objective optimization. IEEE Trans. Cybern. 47(6), 1510–1522 (2017).
Tian, Y., Cheng, R., Zhang, X. & Jin, Y. PlatEMO: A MATLAB platform for evolutionary multi-objective optimization. IEEE Comput. Intell. Mag. 12(4), 73–87 (2017).
Lin, Q. et al. Particle swarm optimization with a balanceable fitness estimation for many-objective optimization problems. IEEE Trans. Evol. Comput. 22(1), 32–46 (2018).
Sadhukhan, Arindam, & Sivasubramani, S. Multi-objective load scheduling in a smart grid environment. In 20th National Power Systems Conference (NPSC), IEEE (2018).
Singh, J. & Tiwari, R. Multi-Objective Optimal Scheduling of Electric Vehicles in Distribution System, 20th National Power Systems Conference (NPSC), 1–6 (2018).
Lin, Q. et al. A clustering-based evolutionary algorithm for many-objective optimization problems. IEEE Trans. Evol. Comput. 23(3), 391–405 (2019).
Leiva, J., Pardo, R. C. & Aguado, J. Data analytics-based multi-objective particle swarm optimization for determination of congestion thresholds in lv networks. Energies 12(7), 1295 (2019).
Yuping, L. Optimization of multi-objective virtual machine based on ant colony intelligent algorithm. Int. J. Perform. Eng. 15(9), 2494 (2019).
Grewal, S. K. & Mangla, N. Deadline and Cost Optimization based Task Scheduling (DCOTS) in Cloud Computing Environment,4th International Conference on Intelligent Engineering and Management (ICIEM), London, United Kingdom, pp. 1-6 (2023).
Cui, Z., Zhao, T., Wu, L., Qin, A. K. & Li, J. Multi-objective cloud task scheduling optimization based on evolutionary multi-factor algorithm. IEEE Trans. Cloud Comput. 11(4), 3685–3699 (2023).
Shrichandran, G., Tinnaluri, V. S. N., Murugan, J. S., Meeradevi, T., Dwivedi, V. K. & Christal Mary, S. S. Hybrid Competitive Swarm Optimization Algorithm Based Scheduling in the Cloud Computing Environment. In 5th International Conference on Inventive Research in Computing Applications (ICIRCA), Coimbatore, India, pp. 1013-1018 (2023).
Zhang, H. & Jia, R. Application of chaotic cat swarm optimization in cloud computing multi objective task scheduling. IEEE Access 11, 95443–95454 (2023).
Lipsa, S., Dash, R. K., Ivković, N. & Cengiz, K. Task scheduling in cloud computing: A priority-based heuristic approach. IEEE Access 11, 27111–27126 (2023).
Lou, J. et al. Cost-effective scheduling for dependent tasks with tight deadline constraints in mobile edge computing. IEEE Trans. Mobile Comput. 22(10), 5829–5845 (2023).
Ajinkya Wagaskar, K. & Chowdhary, G. V. Optimal Resource Search in Grid Computing as a Multi-Objective Problem with Particle Swarm Technique. In International Conference for Emerging Technology (INCET), Belgaum, India, pp. 1-6 (2020).
Alsadie, D. TSMGWO: Optimizing task schedule using multi-objectives grey wolf optimizer for cloud data centers. IEEE Access 9, 37707–37725 (2021).
Ni, L., Sun, X., Li, X. & Zhang, J. Gcwoas2: Multiobjective task scheduling strategy based on gaussian cloud-whale optimization in cloud computing. Comput. Intell. Neurosci. 2021, 1–17 (2021).
Abualigah, L. & Diabat, A. A novel hybrid antlion optimization algorithm for multiobjective task scheduling problems in cloud computing environments. Clust. Comput. 24(1), 205–223 (2021).
Dutta, Debashis. Subhabrata rath job scheduling on computational grids using multi-objective fuzzy particle swarm optimization. Soft Comput. Theor. Appl. 1380, 333–3347 (2022).
Kaur, K., Garg, S., Aujla, G. S., Kumar, N. & Zomaya, A. Y. A multi-objective optimization scheme for job scheduling in sustainable cloud data centers. IEEE Trans. Cloud Comput. 10(1), 172–186 (2022).
Akbar, M. I. et al. A novel hybrid optimization-based algorithm for the single and multi-objective achievement with optimal DG allocations in distribution networks’. IEEE Access 10, 25669–25687 (2022).
Moazeni, A., Khorsand, R. & Ramezanpour, M. dynamic resource allocation using an adaptive multi-objective teaching-learning based optimization algorithm in cloud. IEEE Access 11, 23407–23419 (2023).
Reddy, B. P. V. & Reddy, K. G. A multi-objective based scheduling framework for effective resource utilization in cloud computing. IEEE Access 11, 37178–37193 (2023).
Dakkak, O., Suki, A., Arif, M. & Shahrudin, A. N. A critical analysis of simulators in grid. J. Teknol. 77(4), 111–117. https://doi.org/10.11113/jt.v77.6050 (2015).
Wu, R., Wu, M., Mi, X. & An, Q. Task Scheduling Algorithm Based on Triangle Module in Grid Computing. In 8th International Conference on Wireless Communications, Networking and Mobile Computing, 2012, pp. 1-4 (2012).
Patel, D. K. & Tripathy, C. R. An efficient load balancing mechanism with cost estimation on GridSim. Int. Conf. Inf. Technol. (ICIT) 2016, 75–80 (2016).
Eng, K., Muhammed, A., Mohamed, M. A. & Hasan, S. Incorporating the range-based method into GridSim for modeling task and resource heterogeneity. IEEE Access 5, 19457–19462 (2017).
Nukarapu, D., Tang, B., Wang, L. & Lu, S. Data replication in data intensive scientific applications with [32]performance guarantee. IEEE Trans. Parallel Distrib. Syst. 22(8), 1299–1306 (2011).
Haider, S. & Nazir, B. Dynamic and adaptive fault tolerant scheduling with QoS consideration in computational grid. IEEE Access 5, 7853–7873 (2017).
Patel, D. K. & Tripathy, C. R. An Effective Selection Method for Scheduling of Gridlets among Heterogeneous Resources with Load Balancing on GridSim. In 2017 3rd International Conference on Computational Intelligence and Networks (CINE), pp. 68-72 (2017).
Sheikh, S., Shahid, M. & Nagaraju, A. “A novel dynamic task scheduling strategy for computational grid. In 2017 International Conference on Intelligent Communication and Computational Techniques (ICCT), 2017, pp. 102-107 (2017).
Hwang, C. L. & Yoon, K. Multiple Attribute Decision Making: Methods and Applications (Springer-Verlag, 1981).
Yoon, K. A reconciliation among discrete compromise situations. J. Oper. Res. Soc. 38(3), 277–286 (1987).
Hwang, C. L., Lai, Y. J. & Liu, T. Y. A new approach for multiple objective decision making. Comput. Oper. Res. 20(8), 889–899 (1993).
Krohling, R. A. & Pacheco, A. G. C. A-TOPSIS - An approach based on TOPSIS for ranking evolutionary algorithms. Procedia Comput. Sci. 55, 308–317 (2015).
Fei, Liguo, Yong, Hu., Xiao, Fuyuan, Chen, Luyuan & Deng, Yong. Modified TOPSIS method based on numbers and its applications in human resources selection. Math. Probl. Eng. 2016(3), 1–14 (2016).
Shirvani, M. H., Amirsoleimani, N., Salimpour, S. & Azab, A. Multi-criteria task scheduling in distributed systems based on fuzzy TOPSIS. In IEEE 30th Canadian Conference on Electrical and Computer Engineering (CCECE), pp. 1-4 (2017).
Liu, L., Fan, Q. & Buyya, R. A deadline-constrained multi-objective task scheduling algorithm in mobile cloud environments. IEEE Access 6, 52982–52996 (2018).
Srinivas, D.B., Hegde, S. N., Rajan, M. A. & Krishnappa, H. K. A Novel Task Scheduling Scheme for Computational Grids - Greedy Approach. In 2018 IEEE 32nd International Conference on Advanced Information Networking and Applications (AINA), 2018, pp. 1026-1033 (2018).
Srinivas, D. B., Hegde, Sujay N., Rajan, M. A. & Krishnappa, H. K. An efficient greedy task scheduling algorithm for heterogeneous inter-dependent tasks on computational grids. Int. J. Grid Util. Comput. 11(5), 587–601 (2020).
Pegasus workflow generator: https://confluence.pegasus.isi.edu.
Buyya, Rajkumar & Murshed, Manzur. Gridsim: A toolkit for the modeling and simulation of distributed resource management and scheduling for grid computing. Concurr. Comput. Pract. Exp. 14(13–15), 1175–1220 (2002).
Acknowledgements
This research was supported by Basic Science Research Program through the National Research Foundation of Korea(NRF) funded by the Ministry of Education(No.2021R1F1A1055408).
Author information
Authors and Affiliations
Contributions
Sujay N. Hegde plays role of conceived and designed the experiments, analyzed and interpreted the data, and wrote the paper. D B Srinivas plays role of conceived and designed the experiments, contributed reagents, materials, analysis tools or data, wrote the paper, and supervised the project. M A Rajan plays role of performed the experiments, analyzed and interpreted the data, and contributed reagents, materials, analysis tools or data. Sita Rani plays role of analyzed and interpreted the data, contributed reagents, materials, analysis tools or data, and wrote the paper. Aman Kataria plays role of conceived and designed the experiments, performed the experiments, and wrote the paper. Hong Min plays role of conceived and designed the experiments, contributed reagents, materials, analysis tools or data, wrote the paper, supervised the project, and funding.
Corresponding authors
Ethics declarations
Competing interests
The authors declare no competing interests.
Additional information
Publisher's note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Rights and permissions
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article’s Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article’s Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.
About this article
Cite this article
Hegde, S.N., Srinivas, D.B., Rajan, M.A. et al. Multi-objective and multi constrained task scheduling framework for computational grids. Sci Rep 14, 6521 (2024). https://doi.org/10.1038/s41598-024-56957-8
Received:
Accepted:
Published:
DOI: https://doi.org/10.1038/s41598-024-56957-8
Keywords
Comments
By submitting a comment you agree to abide by our Terms and Community Guidelines. If you find something abusive or that does not comply with our terms or guidelines please flag it as inappropriate.
