HiGAT-AC: Hierarchical Graph Attention with Actor-Critic for Scalable Multi-Objective Workflow Scheduling

Abstract

As scientific workflows grow more complex and green computing becomes a priority, efficient multi-objective scheduling is essential to optimize makespan, cost, and energy consumption for large task graphs. However, existing methods often suffer from scalability bottlenecks and insufficient modeling of task dependencies, leading to degraded performance on large-scale workflows. This paper proposes HiGAT-AC, a framework that combines a hierarchical graph attention network with actor-critic reinforcement learning for scalable workflow scheduling in heterogeneous systems. HiGAT-AC splits large workflows into subgraphs via spectral clustering and uses a three-level hierarchy to capture local task dependencies, coordinate inter-subgraph information, and conduct global resource allocation. The actor-critic model employs Chebyshev scalarization to balance the three conflicting objectives. Experimental results show that HiGAT-AC achieves competitive composite scores across workflow scales from 500 to 1000 tasks, with scores reaching 0.954 on 500-task workflows and 1.000 on 1000-task workflows, while remaining stable above 0.70 across all scales. Compared with traditional and representative learning-based methods, HiGAT-AC exhibits favorable overall performance and relatively stable scalability on large task graphs, providing a promising solution for scientific workflow scheduling that balances performance and sustainability.

1. Introduction

With the rapid development of scientific computing and data-intensive applications in computational biology, climate modeling, and high-energy physics, scientific workflow scheduling has become increasingly complex. As scientific research advances, workflows in genomics, climate science, and particle physics have grown more complex, some consisting of thousands of interdependent tasks. These workflows require coordination across heterogeneous resources and distributed computing systems, creating major scheduling challenges.

Scientific workflows face several inherent scheduling challenges. Strict task dependencies lead to fixed execution sequences, while resource heterogeneity means tasks may require specific hardware or memory configurations. Data transfer between tasks also creates large overheads that reduce performance, and dynamic resource availability in heterogeneous computing systems causes uncertain resource competition. Together, these factors form a highly dynamic optimization problem with continuously changing environmental states, making it difficult for traditional scheduling methods to respond effectively.

Despite extensive research on workflow scheduling, critical limitations remain unresolved in existing methods. Most heuristic strategies such as HEFT and CPOP rely on static priority rules and lack adaptability to dynamic resource states. Meta-heuristic algorithms including Genetic Algorithms and particle swarm optimization tend to suffer from excessive computational costs and slow convergence on large-scale workflows. While reinforcement learning methods provide better adaptability, they typically ignore the topological structure of DAGs or rely on flat graph models that suffer from scalability bottlenecks when handling large task graphs. Even graph-based methods often compute attention over all node pairs, leading to unaffordable complexity and poor scalability in real-world large-scale scenarios.

To address these unresolved limitations, we propose HiGAT-AC (hierarchical graph attention with actor-critic), a novel framework that combines hierarchical graph attention networks with actor-critic reinforcement learning for scalable multi-objective workflow scheduling. Our approach employs a three-level architecture that partitions large workflows into manageable subgraphs using spectral clustering, implements sparse graph attention within each subgraph to capture local dependencies, and coordinates decisions through lightweight inter-subgraph communication. The actor-critic learning framework incorporates Chebyshev scalarization to balance makespan, cost, and energy consumption objectives.

Evaluations demonstrate that HiGAT-AC shows competitive performance against traditional scheduling methods and representative learning-based approaches. Compared with baseline methods, our model achieves competitive or improved performance in makespan, cost, and energy consumption for 1000-task workflows, while maintaining favorable scalability as workflow size increases. The hierarchical design helps alleviate the dimensional explosion problem in conventional graph-based learning methods, making our approach potentially suitable for large-scale scientific computing scenarios.

The key contributions of this paper include:

• We propose a hierarchical graph attention architecture that enables scalable and efficient processing of large-scale workflow graphs through subgraph partitioning and sparse attention mechanisms.
• We develop a multi-objective actor-critic learning framework with Chebyshev scalarization that effectively balances performance, cost, and energy considerations.
• Extensive experimental results indicate that our approach achieves competitive or superior performance and scalability compared with baseline methods.

The remainder of this paper is organized as follows: Section 2 reviews related work in workflow scheduling and learning-based scheduling approaches. Section 3 describes our system model and problem formulation. Section 4 details the HiGAT-AC architecture. Section 5 analyzes experimental results and comparisons with baseline methods. Finally, Section 6 concludes the paper and discusses future research directions.

2. Related Work

Workflow scheduling in distributed computing environments has been extensively studied, with research evolving from traditional heuristic methods to advanced learning-based approaches.

2.1. Conventional Methods for Workflow Scheduling

Traditional workflow scheduling methods primarily rely on heuristic and meta-heuristic strategies, which have laid the foundation for task-resource assignment in distributed systems. Heuristic algorithms, such as the Heterogeneous Earliest Finish Time (HEFT) and Critical Path On a Processor (CPOP) [1,2], are widely adopted for their computational efficiency and clear priority-driven logic. HEFT calculates task priorities based on upward rank values and assigns tasks to resources that minimize the earliest finish time, making it a benchmark for evaluating scheduling performance [3,4,5,6]. However, these methods lack adaptability to dynamic environments, as their decision rules are static and dependent on prior knowledge of task and resource characteristics.

Meta-heuristic algorithms, including Non-dominated Sorting Genetic Algorithm II(NSGA-II) [7], particle swarm optimization (PSO) [8], BAT algorithm [9], and Artificial Bee Colony Algorithm (HABC) [10,11], address some limitations of heuristics by exploring larger solution spaces. Nevertheless, both heuristic and meta-heuristic methods fail to incorporate real-time environmental feedback, limiting their effectiveness in heterogeneous and dynamic computing environments.

2.2. Reinforcement Learning Methods for Workflow Scheduling

The emergence of reinforcement learning has enabled adaptive scheduling by leveraging trial-and-error learning from environmental interactions.

2.2.1. Value-Based Reinforcement Learning Methods

(1)

Q-Learning: As a classic tabular reinforcement learning method, it learns the long-term value of state-action pairs by iteratively updating Q-values and is suitable for scheduling problems with finite state and action spaces. Researchers have applied Q-learning in various scheduling frameworks, such as dynamically selecting heuristic rules within hyper-heuristics [12], enabling adaptive resource scaling in cloud environments [13]. It has also been used for task clustering optimization, where agents autonomously learn to balance exploration and exploitation [14]. Furthermore, multi-agent Q-learning frameworks have been developed to enable parallel task exploration and collaborative resource matching, aiming to maximize global rewards [15,16]. Some studies have also integrated Q-learning with heuristic algorithms like HEFT, combining the adaptability of reinforcement learning with the efficiency of heuristics to improve scheduling performance [17,18].

(2)

Deep Q-Network (DQN) [19]: DQN uses a deep neural network to approximate the Q-value function, incorporating experience replay and target networks to enhance training stability, making it suitable for complex state spaces in workflow scheduling. Several studies have enhanced DQN by incorporating environmental constraints like data center temperature [20] or combining it with multi-objective evolutionary algorithms to optimize task sequences and push solutions toward the Pareto front [21]. Advanced architectures such as Transformers have been integrated with DQN to handle long-range dependencies in large-scale tasks [4].

(3)

Double Deep Q-Network (DDQN) [22]: DDQN addresses the overestimation bias in DQN by decoupling action selection from value evaluation using two separate networks. This method has been applied to fault-tolerant workflow scheduling, where it adaptively selects between replication and resubmission strategies based on execution scenarios [23]. Enhancements such as integrating pointer networks and diversity-sensitive modules have also been proposed to improve multi-objective scheduling performance [24].

2.2.2. Policy-Based Reinforcement Learning Methods

(1)

Actor-Critic (AC) [25]: The AC framework employs a dual-network architecture that jointly handles policy generation and value evaluation, making it well-suited for dynamic and multi-objective scheduling problems. To address dynamic VM performance variations in cloud environments, [26] proposes RLWS, an actor-critic-based method that models workflow scheduling as a Markov Decision Process and employs an extended pointer network to learn optimized rescheduling policies that minimize makespan.

(2)

Asynchronous Advantage Actor-Critic (A3C) [27]: A3C enhances training efficiency and stability through asynchronous parallel learning across multiple agents. A3C has been combined with heuristic rules and temporal fusion networks to achieve scale-adaptive, multi-objective optimization and autonomously discover scheduling heuristics [28,29].

(3)

Proximal Policy Optimization (PPO) [30]: PPO stabilizes policy updates by clipping the objective function, preventing drastic policy changes while maintaining efficiency. It has been integrated with pre-training and fine-tuning mechanisms for multi-agent scheduling in dynamic cloud environments [31]. PPO has also been combined with Transformers and self-critic mechanisms to balance multi-objective trade-offs [32] and applied to microservice workflow scheduling with considerations for cognitive cost [33].

Nevertheless, despite the considerable progress of existing reinforcement learning methods, they still face certain common constraints in practical workflow scheduling. Most approaches tend to adopt simple network structures that cannot fully capture the topological dependencies and task-resource relationships in complex workflows. In addition, many solutions focus on single-objective optimization and offer limited support for balanced trade-offs among makespan, cost, and energy consumption. Furthermore, the decision-making process of such models is usually less interpretable, which brings challenges to practical deployment and parameter tuning. Therefore, there remains a practical demand for a more expressive, scalable, and interpretable scheduling approach to better adapt to complex heterogeneous computing environments.

2.2.3. Graph Neural Network Enhanced RL Methods

Graph neural networks (GNN) serve as powerful representation learning modules for modeling task dependencies, resource topologies, and structural relationships in workflow scheduling, rather than standalone reinforcement learning algorithms. In recent years, GNNs have been widely integrated with RL frameworks to improve scheduling performance. Raith et al. proposed a heterogeneous GNN model to predict host power consumption for energy-aware container scheduling, achieving measurable energy savings while preserving application performance [34]. Zhou et al. integrated an anisotropic GNN-derived heatmap with Monte Carlo Tree Search to guide scheduling decisions, improving solution quality and scalability on medium-scale workflows [35]. Sharma and Kunkel presented GrapheonRL, a GNN–reinforcement learning framework embedded in Snakemake that delivers near-optimal makespan with linear scalability for large-scale HPC workflows [36]. Hattay et al. further analyzed topology-induced distribution shifts and revealed that GNN-based RL schedulers suffer from performance degradation when test DAG topologies differ significantly from training ones [37]. Despite these advances, existing GNN-RL methods typically rely on shallow or flat graph encoders, focus mainly on makespan or single-target optimization, and provide limited guidance for balancing performance and green computing goals. In contrast, this work introduces a hierarchical graph attention-based actor-critic approach with explicit multi-objective trade-off tuning and structured interpretability to address these limitations.

In this study, we adopt the actor-critic framework because it is well suited for dynamic workflow scheduling. Its dual-network structure can evaluate state values and optimize action policies at the same time, making it effective in dynamic environments with varying resource performance. This framework is also flexible when combined with specialized neural networks to handle structured scheduling decisions. Thus, the actor-critic method balances adaptability to dynamic environments and fine-grained policy optimization, which matches the goals of this work.

3. System Model

This section establishes the foundational system model and formal problem definition for workflow scheduling in heterogeneous computing environments.

3.1. Workflow and Task Model

3.1.1. Directed Acyclic Graph Representation

Scientific workflows are formally modeled as directed acyclic graphs (DAG) to capture their inherent computational dependencies and data flow patterns. A workflow DAG is defined as $\mathrm{G}=(\mathrm{T},\mathrm{E})$, where $\mathrm{T}=\{t_1,t_2,\dots ,t_n\}$ represents the set of computational tasks, and $\mathrm{E}\in \mathrm{T}\times \mathrm{T}$ denotes the set of directed edges representing precedence constraints and data dependencies between tasks. For example, as shown in Figure 1, Task 2 (14.7 h) must be completed before its dependent tasks can begin execution. Each task $t_i$ is characterized by its computational requirements, estimated execution time, and resource type preferences. The DAG structure inherently prevents cyclic dependencies, ensuring that workflows can be executed to completion without deadlocks.

3.1.2. Task Characteristics and Constraints

Workflow tasks exhibit heterogeneous characteristics and impose specific constraints on scheduling decisions. The notation of the task is shown in

Table 1. Notation of task.

Symbol	Definition	Example/Value
$\mathrm{G}=(\mathrm{T},\mathrm{E})$	Workflow DAG with tasks and edges	-
$t_i$	Individual computational task	-
$\mathrm{w}\left(t_i\right)$	Expected execution time of task $t_i$	14.7 h
$\overline{w\left(t_i\right)}$	The average execution time of task $t_i$ on all computing resources	15.6 h
$\mathrm{r}\left(t_i\right)$	Resource type requirement	CPU, GPU, DCU, FPGA…
$\mathrm{p}\mathrm{r}\mathrm{e}\mathrm{d}\left(t_j\right)$	Set of predecessor tasks of $t_j$	-
$\mathrm{s}\mathrm{u}\mathrm{c}\mathrm{c}\left(t_j\right)$	Set of successor tasks of $t_j$	-
$c_{ij}$	Data transfer time between $t_i$ and $t_j$	200 s

. Each task $t_i$ has associated metadata including its expected execution time $\mathrm{w}\left(t_i\right)$ , resource type requirement $\mathrm{r}\left(t_i\right)$ , and data dependencies $\mathrm{D}\left(t_i\right)$ with predecessor and successor tasks. The resource distribution in the provided example (57% CPU tasks, 14% GPU tasks, 14% DCU tasks, 14% FPGA tasks) shows the different characteristics of scientific workflows, where different computational stages require specialized hardware accelerators. Additionally, tasks are subject to precedence constraints: $t_j$ cannot start execution until all its predecessor tasks $\mathrm{p}\mathrm{r}\mathrm{e}\mathrm{d}\left(t_j\right)$ have completed and their output data has been transferred. Resource constraints further limit task assignment because each task can only be scheduled on resources that meet its computational needs.

3.2. Heterogeneous Computing Resource Model

The execution environment for scientific workflows consists of heterogeneous computing resources organized in a distributed architecture. Each resource is characterized by distinct computational capabilities, energy profiles, and cost structures. The notation of the resource is shown in

Table 2. Notation of resources.

Symbol	Definition	Example/Value
$\mathrm{M}=\{m_1,m_2,\dots ,m_k\}$	Set of available computing nodes	-
${Type(m}_k)$	Resource type of $m_k$	{CPU, GPU, FPGA, DCU…}
$\mathrm{C}\mathrm{S}\left(m_k\right)$	Compute Speed of $m_k$	1.5
$\mathrm{P}\mathrm{r}\mathrm{i}\mathrm{c}\mathrm{e}\left(m_k\right)$	Cost per time unit of $m_k$	0.1
$P_k\left(U_k\right)$	Utilization-power function of $m_k$	-
${PUE}_k$	Power Usage Effectiveness of the data center where $m_k$ is located	1.2
$\mathrm{T}(m_i,m_j)$	Transfer speed between $m_i$ and $m_j$	500 MB/s
$\mathrm{T}\mathrm{E}\mathrm{T}\left(\mathrm{G}\right)$	Total execution time of workflow G	10 h

. The resource pool includes multiple resource types: CPU, GPU, FPGA, DCU, etc. Each resource $m_k$ is defined by three key attributes: Compute Speed (CS) representing relative processing capability (normalized to a 1–10 scale), Price indicating cost per unit time of usage, and Power representing energy consumption in watts. Resources of the same type exhibit correlated performance–cost–energy relationships, where higher compute speeds generally correspond to higher prices and power consumption, though with ±20% random variation to reflect real-world market conditions. Inter-resource communication is modeled through a transfer speed matrix $\mathrm{T}$ that defines data transmission rates between all resource pairs in MB/s.

3.3. Multi-Objective Optimization Formulation

3.3.1. Primary Optimization Objectives

This research addresses the multi-objective optimization problem in workflow scheduling, where three conflicting objectives must be simultaneously optimized: makespan (total execution time), economic cost, and energy consumption. The optimization aims to find scheduling solutions that provide optimal trade-offs among these three dimensions, particularly important in computing environments where both performance efficiency and sustainability are critical considerations.

(1)

Makespan Minimization

The makespan represents the total completion time of the workflow, calculated as the difference between the finish time of the last task and the start time of the first task. This objective seeks to minimize the overall execution time:

$$\mathrm{M}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{m}\mathrm{i}\mathrm{z}\mathrm{e}:\mathrm{ }\mathrm{m}\mathrm{a}\mathrm{k}\mathrm{e}\mathrm{s}\mathrm{p}\mathrm{a}\mathrm{n}=\underset{t_i\in T}{\max }ACT\left(t_i\right)-\underset{t_i\in T}{\min }AST\left(t_i\right)$$

(1)

where T is the set of all workflow tasks, $AST\left(t_i\right)$  is the actual start time of task $t_i$  and $ACT\left(t_i\right)$  is the actual completion time of task $t_i$ .

(2)

Economic Cost Minimization

The economic cost objective minimizes the total monetary expense of executing the workflow on computational resources. Each resource $m_k$  has a price per time unit $\mathrm{P}\mathrm{r}\mathrm{i}\mathrm{c}\mathrm{e}\left(m_k\right)$, and the total cost accumulates as each task executes on its assigned resource:

$$\mathrm{M}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{m}\mathrm{i}\mathrm{z}\mathrm{e}:\mathrm{c}\mathrm{o}\mathrm{s}\mathrm{t}={\sum }_{t_i\in T}\mathrm{P}\mathrm{r}\mathrm{i}\mathrm{c}\mathrm{e}\left(m_k\right(t_i\left)\right)\times \mathrm{ }\mathrm{w}(t_i)$$

(2)

where $m_k\left(t_i\right)$  is the resource assigned to task $t_i$.

(3)

Energy Consumption Minimization

Service providers must account not only for server energy consumption but also for the power usage of supporting infrastructure, such as cooling and lighting systems. To accurately estimate the total energy consumption, this research adopts the Power Usage Effectiveness (PUE) metric. The energy consumption of task $t_i$  executed on computing node $P_k$ is calculated as follows:

$$\mathrm{M}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{m}\mathrm{i}\mathrm{z}\mathrm{e}:\mathrm{e}\mathrm{n}\mathrm{e}\mathrm{r}\mathrm{g}\mathrm{y}={\sum }_{t_i\in T}{P}_k\left(U_k\right)\times w(t_i)\times {PUE}_k$$

(3)

where $P_k\left(U_k\right)$ denotes the utilization-power function of $m_k$, with $U_k$ representing its resource utilization. ${PUE}_k$ refers to the Power Usage Effectiveness of the data center where $m_k$ is located, and $w\left(t_i\right)$ is the execution time.

3.3.2. Chebyshev Scalarization for Multi-Objective Optimization

The Chebyshev scalarization approach is a widely used method in multi-objective optimization that transforms multiple, often conflicting objectives into a single scalar objective through a weighted min-max formulation. Mathematically, given objectives $f_1,f_2,\dots ,f_n$ with corresponding weights $w_1,w_2,\dots ,w_n>0$, the scalarized objective is defined as:

$$L={max}_i\{w_i\times {\displaystyle \frac{|f_i\left(x\right)-f_i^{*}|}{f_i^{max}-f_i^{min}}}\}$$

(4)

where $f_i^{*}$  denotes the ideal value of the i-th objective, and normalization by ($f_i^{max}-f_i^{min}$) ensures all objectives are scaled to a comparable range.

This formulation is particularly effective because it minimizes the maximum weighted deviation from the ideal values across all objectives. By focusing on the worst-performing objective at any given solution, it inherently promotes balanced trade-offs rather than allowing any single objective to dominate the optimization process. Unlike simple weighted-sum methods, which may fail to find solutions on non-convex parts of the Pareto front, Chebyshev scalarization guarantees Pareto-optimal solutions for any positive weight combination, enabling decision-makers to explore different regions of the Pareto front by adjusting weight preferences according to specific operational priorities.

In practice, this scalarization is efficient because it converts multi-objective problems into single-objective ones that standard optimization algorithms can solve. For the proposed reinforcement learning framework, this transformation ensures that the reward signal remains well-defined and stable during training.

To ensure the rationality and realism of the constructed resource model, all hardware-related parameter settings in this study refer to publicly available configurations of real heterogeneous computing clusters. The computational performance, power consumption characteristics, and data transmission bandwidth of each resource node are set within the common value range of practical cloud and HPC platforms. Although the experiments are conducted on a simulated scheduling platform, the resource parameter settings follow real-world physical constraints, which enhance the model applicability and ensure that the experimental results are representative of real heterogeneous scheduling scenarios.

4. Methodology

This section presents a scalable multi-objective workflow scheduling method called HiGAT-AC, which combines hierarchical graph attention and actor-critic reinforcement learning. As illustrated in Figure 2, the framework integrates hierarchical graph attention with actor-critic reinforcement learning for scalable multi-objective workflow scheduling.

(1)

Workflow Representation with GAT: The input workflow DAG is processed through a hierarchical graph attention network that captures task dependencies via spectral clustering-based graph partitioning, intra-subgraph sparse attention, inter-subgraph lightweight coordination, and global resource allocation.

(2)

Environment Modeling: The heterogeneous computing environment consists of computing nodes with varying computational capabilities, energy profiles, and cost structures, interconnected by network infrastructure that models data transfer speeds between resources.

(3)

State Formulation: At each scheduling step, the state $s_t$  encodes workflow progress, resource availability, and task characteristics enhanced with HEFT priorities. The transition tuple $(s_t,a_t,r_t,s_{t+1})$  forms the basis for experience replay and learning.

(4)

Agent Architecture: The actor-critic agent employs a dual-network structure. The actor network learns a policy that maps states to action probabilities for resource allocation. The critic network estimates the state-value function V(s), representing expected cumulative reward. The advantage function $\mathrm{A}\mathrm{d}\mathrm{v}=\mathrm{Q}(\mathrm{s},\mathrm{ }\mathrm{a})-\mathrm{V}\left(\mathrm{s}\right)$ quantifies the relative benefit of taking action $\mathrm{a}$ compared to the average action, guiding policy updates.

(5)

Chebyshev-based Multi-Objective Reward: The reward function incorporates Chebyshev scalarization combined with linear weighted summation to balance three conflicting objectives—makespan minimization, economic cost reduction, and energy efficiency optimization.

The decision-making process of HiGAT-AC follows a structured multi-step reasoning pipeline. The hierarchical graph attention network first processes the workflow DAG at multiple granularities, learning sparse attention weights at the intra-subgraph level to prioritize tasks critical to local computation paths and identifying cross-partition dependencies at the inter-subgraph level that may bottleneck global progress, thereby capturing both fine-grained and coarse-grained task relationships to inform scheduling priorities. At each scheduling step, the state vector $s_t$  integrates workflow progress, real-time resource availability, and task characteristics enhanced with HEFT priorities. The critic network evaluates the long-term value of each possible state, while the actor network maps this context-aware representation to concrete scheduling actions. Guided by the Chebyshev scalarized reward function, the agent avoids over-optimizing a single objective and instead learns to make balanced trade-offs. For instance, it may select a slightly slower but more energy-efficient resource to maintain balanced performance across makespan, cost, and energy consumption. The advantage function further refines this process by quantifying how much better the chosen action is than the average policy, ensuring that policy updates consistently move the model toward more balanced and optimal scheduling decisions. By combining dependency-aware attention, context-rich state representation, and multi-objective reinforcement learning, HiGAT-AC does not merely generate schedules; it actively reasons about which tasks to prioritize, which resources to select, and how to balance conflicting goals at each step.

4.1. Hierarchical Graph Attention Architecture

As illustrated in Figure 3, the HiGAT-AC architecture integrates graph partitioning, a hierarchical processing pipeline, and sparse graph attention to enable scalable and efficient large-scale workflow scheduling. The detailed procedure is presented in Algorithm 1.

Algorithm 1. HiGAT-AC scheduling procedure

Require: DAG G, Resources M, Task features, Subgraph dependency matrix Ensure: Optimal task-resource assignment 1: // Partition DAG into $K_{sub}$ subgraphs 2: Partition G into $K_{sub}$ subgraphs via spectral clustering 3: Ensure critical path tasks stay in one subgraph 4: // Local feature learning 5: for each subgraph $S_i$ do 6:   Extract node features 7:   Apply Sparse GAT (top-10 neighbors only) 8:   Generate subgraph embedding $h_i$ via pooling 9: end for 10: // Cross-subgraph fusion 11: Build subgraph dependency graph 12: Input {$h_1, \dots , h_{K_{sub}}$} to cross-subgraph GAT 13: Output fused representations H 14: // State & policy update 15: Encode system state $s_t$ 16: Concatenate s and H → global feature f 17: Actor: f → softmax → resource probabilities 18: Critic: f → state value $V(s_t$) 19: Update policy via policy gradient + MSE + entropy regularization 20: Return argmax(action probabilities)

4.1.1. Graph Partitioning Strategy

The scalability of graph neural networks in large-scale workflow scheduling depends on effectively breaking large workflow graphs into smaller, computable parts. HiGAT-AC uses spectral clustering to divide the workflow DAG. It first builds a similarity matrix that reflects task connections and dependencies. Then it uses normalized cuts to split the DAG into subgraphs. Adaptive thresholds keep critical paths complete in each subgraph to preserve execution logic. For irregular workflows, a dynamic rebalancing mechanism adjusts task distribution across subgraphs to balance load and reduce communication costs. This partitioning turns the difficult scalability problem into a manageable hierarchical optimization task.

4.1.2. Three-Level Processing Hierarchy

HiGAT-AC’s main innovation is its three-layer structure that simplifies workflow processing at different levels. At the bottom layer, Subgraph Processors use local attention to learn task dependencies inside each subgraph. Subgraph representatives are key task nodes that represent each subgraph and connect different subgraphs. These processors turn task features into compact subgraph embeddings that capture local structure. At the middle layer, a light communication network connects these subgraph representatives. It fuses information across subgraphs, finds global workflow patterns, and removes unimportant local noise. At the top layer, a global coordinator combines subgraph representations with overall system state information. This hierarchical design reduces data complexity and avoids the curse of dimensionality, while keeping important scheduling information. The three layers work bottom-up for feature extraction and top-down for decision-making. This bidirectional information flow ensures both good local decisions and consistent global scheduling.

4.1.3. Sparse Graph Attention Mechanism

Traditional Graph Attention Network (GAT) is too computationally expensive for large workflows because it needs to compute attention between every pair of nodes. Our sparse attention mechanism only lets each task node focus on its K most important neighbors. It uses a learnable scoring function to choose these neighbors based on task dependency, time, resource fit, and data transfer needs. Attention weights are calculated with a modified additive function and LeakyReLU, then only the top-K connections are kept. In this setting, each of the N nodes computes attention weights only for its K selected neighbors, leading to a total of N × K operations. Thus, the overall time complexity is reduced from O($N^2$) to O(N·K), which significantly lowers the computational overhead, especially for large-scale workflows where K remains much smaller than N. We also use multi-head attention with orthogonal initialization to learn different task relationships. The sparse structure changes during training, so the model can learn which task connections are most important for scheduling. With edge dropout for regularization, this adaptive sparse attention works well on many different workflow structures.

4.2. Actor-Critic Reinforcement Learning Framework

4.2.1. State Representation Design with HEFT-Informed Prioritization

In reinforcement learning for workflow scheduling, state design has to consider both current resource availability and each task’s importance in the dependency graph, so we add Heterogeneous Earliest Finish Time (HEFT) priorities directly into our state representation to give the agent useful heuristics that speed up training and improve scheduling results. HEFT calculates task priorities using upward rank, which considers task computation needs and data dependencies across the workflow, and integrating it has three main benefits: it provides an efficient and useful guide for early training, ensures tasks on critical paths get enough attention, and transfers knowledge from traditional scheduling methods to the deep reinforcement learning model.

The HEFT priority calculation employs a recursive upward rank formulation defined as:

$${rank}_{up}\left(t_i\right)=\overline{w\left(t_i\right)}+\underset{t_j\in \mathit{succ}\left(t_i\right)}{\max }[c_{ij}+{rank}_{up}(t_j\left)\right]$$

(5)

where $\overline{w\left(t_i\right)}$ represents the average execution time of task $t_i$ across all compatible resources, $c_{ij}$ denotes the average communication cost between tasks $t_i$ and $t_j$, and $\mathrm{s}\mathrm{u}\mathrm{c}\mathrm{c}\left(t_i\right)$ is the set of immediate successor tasks of $t_i$.

Tasks are then sorted in descending order of their ${rank}_{up}$ values, with higher ranks indicating greater scheduling priority. In our implementation, we normalize these priorities to the [0, 1] range to ensure compatibility with other state features:

$$P_{norm}\left(t_i\right)={\displaystyle \frac{{rank}_{up}\left(t_i\right)-\mathrm{m}\mathrm{i}\mathrm{n}\left({rank}_{up}\right)}{\max \left({rank}_{up}\right)-\mathrm{m}\mathrm{i}\mathrm{n}\left({rank}_{up}\right)}}$$

(6)

This normalized priority $P_{norm}\left(t_i\right)$ is embedded as a dedicated feature within our state vector, serving as an informative prior that complements the learned representations from the hierarchical graph attention mechanism. The combined state representation therefore encompasses three synergistic information streams: HEFT-based structural importance capturing global workflow criticality, resource-centric availability metrics detailing current system conditions, and task-specific characteristics including computational requirements and dependency constraints. This multi-faceted encoding enables the learning algorithm to balance immediate resource optimization against long-term workflow progression, with HEFT priorities providing particularly valuable guidance for early scheduling decisions that have cascading effects on overall workflow makespan. The state representation dynamically adjusts its dimensionality based on the number of ready tasks, employing zero-padding and masking mechanisms to handle variable-length inputs while maintaining fixed-dimensional processing within neural network layers. This adaptive representation ensures that the learning algorithm focuses computational resources on currently relevant information while retaining access to broader contextual knowledge.

4.2.2. Action Space and Policy Network

The action space of HiGAT-AC is formally defined as a discrete space, where each action corresponds to assigning one workflow task to a candidate computational resource within the heterogeneous resource pool. The dimension of the action space equals the total number of available heterogeneous resources.

The policy network takes hierarchical graph features as input and outputs a probability distribution over all feasible resource assignment actions. Residual connections and adaptive gating modules are adopted to enhance feature propagation and stabilize training. The softmax layer generates normalized assignment probabilities, considering both immediate scheduling reward and long-term cumulative performance. Entropy regularization is further introduced to balance exploration and exploitation: it maintains adequate randomness in the early training stage and gradually converges to a stable deterministic scheduling policy in later iterations.

4.2.3. Value Network and Advantage Estimation

The value estimation component of our framework provides the crucial learning signal that guides policy improvement toward long-term optimality. The value network, architecturally similar to but independent from the policy network, learns to predict the expected cumulative return from any given state under the current policy. This network receives the same state representation as the policy network but processes it through separate parameters to avoid confounding the objectives of value estimation and action selection. We employ Generalized Advantage Estimation (GAE) with λ-return blending to compute advantage values that balance bias–variance trade-offs in credit assignment. The advantage estimates capture the relative value of specific actions compared to the expected value of following the current policy, providing precisely targeted learning signals that accelerate convergence and improve final performance. The value network is trained using temporal difference learning with a clipped objective function that prevents destructive updates during periods of high variance in reward signals. This dual-network architecture, with separate but complementary learning objectives, creates a stable learning foundation that supports effective exploration of the complex, high-dimensional scheduling solution space.

4.2.4. Multi-Objective Reward Design

The reward function serves as the critical learning signal that guides the policy network toward optimal scheduling decisions in the complex multi-objective optimization landscape. Our reward effectively balances the competing objectives of makespan minimization, economic cost reduction, and energy efficiency optimization. The foundation of our approach lies in deviation-based normalization, where each objective’s performance is evaluated relative to its theoretical optimal value, providing a consistent and interpretable metric across objectives with different units and scales.

The deviation metrics for the three primary objectives are computed as:

$${makespan}_{dev}=(tota{l}_{makespan}-optima{l}_{makespan})/optima{l}_{makespan}$$

(7)

$$cos{t}_{dev}=(tota{l}_{cost}-optima{l}_{cost})/optima{l}_{cost}$$

(8)

$$energ{y}_{dev}=(tota{l}_{energy}-optim{al}_{energy})/optima{l}_{energy}$$

(9)

where ${optimal}_{makespan}$ ${optimal}_{cost}$ and ${optimal}_{energy}$ are defined as the best possible single-objective performance achievable for the given workflow and resource set, under idealized scheduling conditions. Specifically, ${optimal}_{makespan}$ is obtained by solving a single-objective scheduling problem to minimize makespan, ${optimal}_{cost}$ is obtained by solving a single-objective scheduling problem to minimize execution cost and ${optimal}_{energy}$ is obtained by solving a single-objective scheduling problem to minimize energy consumption. These values serve as normalized baselines to measure the relative deviation of multi-objective solutions. They represent practically achievable performance under the given system constraints, rather than strict theoretical lower bounds, ensuring fair and consistent scaling across different objectives. These baseline values ensure fair comparison across objectives and provide meaningful scaling that reflects actual improvement potential rather than absolute performance metrics.

To achieve effective multi-objective optimization, we implement a hybrid Chebyshev-linear aggregation approach:

$$chebyshe{v}_{term}=\mathrm{m}\mathrm{a}\mathrm{x}({ch}_t\times {makespan}_{dev},{ch}_c\times cos{t}_{dev},{ch}_e\times energ{y}_{dev})$$

(10)

$$su{m}_{term}={ch}_m\times {makespan}_{dev}+{ch}_c\times cos{t}_{dev}+{ch}_e\times energ{y}_{dev})$$

(11)

The Chebyshev term (${chebyshev}_{term}$) ensures Pareto optimality by focusing on the worst-performing objective, preventing solutions where dramatic improvement in one dimension comes at unacceptable deterioration in others. This component guarantees that the optimization process maintains balanced progress across all objectives. The weighting parameters ${ch}_m$, ${ch}_c$ and ${ch}_e$ are user-configurable coefficients that reflect the relative importance of each objective, where ${ch}_m+{ch}_c+{ch}_e=1$ and ${ch}_i>0$ for all i. Adjusting these weights directly shapes the characteristics of the final schedule. When assigning a larger weight to ${ch}_m$, the model places higher priority on computational performance, tending to allocate high-performance resources to reduce overall makespan. Increasing ${ch}_c$ and ${ch}_e$ shifts the optimization tendency toward green and economical scheduling, prompting the algorithm to prefer low-cost and energy-efficient resources to lower system overhead. By tuning the three weighting coefficients reasonably, users can flexibly balance performance-oriented scheduling and green computing demands, which provides clear practical guidance for model configuration under different application priorities.

The total deviation metric combines these two components:

$$tota{l}_{dev}=chebyshe{v}_{term}+ϵ\times su{m}_{term}$$

(12)

where $ϵ$ is a small scaling factor that controls the relative influence of the linear term. This combination ensures that the primary optimization driver remains the Chebyshev component, maintaining Pareto optimality, while the linear term provides fine-grained guidance for incremental improvements.

The reward computation then converts the deviation metric into a positive reinforcement signal:

$$bas{e}_{reward}=\alpha \times (1-tota{l}_{dev})$$

(13)

$$reward=clip[bas{e}_{reward},L,\mathrm{ }U]$$

(14)

where $\alpha$ is a scaling factor and [L, U] are clipping bounds that stabilize training by preventing extreme reward values. These hyperparameters can be adjusted for different workflow scales and optimization objectives.

This reward function has several key advantages: it is scale-invariant, ensures Pareto optimality using the Chebyshev term, supports stable exploration with linear guidance, and remains stable during training due to bounded reward values. It allows the agent to balance makespan, cost, and energy efficiency effectively. The model learns solutions that match user preferences and works reliably across different workflows and resource settings.

5. Experiment

This section presents a comprehensive evaluation of the proposed HiGAT-AC method through a series of systematic experiments.

5.1. Experimental Dataset

To fully evaluate HiGAT-AC, we use a synthetic workflow dataset produced by our own DAG generator. The generator allows us to adjust parameters such as the number of tasks, graph density, resource heterogeneity, and communication–computation ratio. This lets us test the scheduling algorithm’s scalability and stability under different settings. We build workflows that imitate real structures. Tasks have different resource requirements (CPU/GPU/DCU/FPGA…), and their execution times follow realistic distributions used in high-performance computing.

5.2. Baseline Algorithm

To validate HiGAT-AC’s effectiveness, we conduct comparative experiments under various configurations. We compare it with three established baselines: the classical heuristic HEFT, the standard reinforcement learning method actor-critic, and a GA (Genetic Algorithm)-based scheduling approach.

Heterogeneous Earliest Finish Time (HEFT): HEFT is a classical heuristic scheduling algorithm that assigns task priorities based on upward rank calculation and schedules each task to the resource that minimizes its earliest finish time. It is widely recognized for its efficiency in handling heterogeneous environments and provides a solid baseline for makespan-oriented workflow scheduling.

Actor-Critic: AC is a fundamental reinforcement learning architecture that combines a policy network for action selection and a value network for state evaluation. In workflow scheduling, AC-based methods learn to map workflow states to resource assignments through trial and error, aiming to optimize cumulative rewards. This baseline represents a standard learning-driven approach without explicit hierarchical or multi-objective enhancements.

Genetic Algorithm (GA): GA is a classic evolutionary computation algorithm inspired by the natural selection and genetic variation mechanisms in biological evolution. It encodes scheduling solutions into “chromosomes” (e.g., task-resource assignment sequences) and iteratively evolves the population through core operations including selection, crossover, and mutation. In workflow scheduling, GA evaluates the fitness of each candidate solution based on predefined objectives (e.g., makespan, resource utilization), selects high-performance solutions for reproduction, generates new candidate solutions via crossover of parental genes, and introduces random variations through mutation to explore the solution space. As a population-based stochastic optimization method, GA does not rely on gradient information or explicit state evaluation networks and is renowned for its strong global search capability and robustness in solving complex combinatorial optimization problems.

Proximal Policy Optimization (PPO): PPO is a state-of-the-art reinforcement learning algorithm that achieves a reliable balance between exploration and exploitation by constraining policy updates within a small, stable range to avoid large, destructive gradient steps. Built on the actor-critic framework, PPO uses a clipped surrogate objective function to iteratively optimize policy and value networks, making it more stable, sample-efficient, and robust than traditional policy gradient methods. In workflow scheduling, PPO learns to assign tasks to heterogeneous resources by interacting with scheduling environments, optimizing long-term cumulative rewards related to makespan, resource utilization, or cost. As a widely adopted and practical reinforcement learning baseline, PPO effectively handles complex decision-making processes in dynamic scheduling scenarios and provides strong performance for sequential resource allocation tasks.

Graph Neural Networks (GNNs): GNN is a class of deep learning models designed to learn representations from graph-structured data by propagating and aggregating features across connected nodes and edges. Given that workflow applications are naturally modeled as directed acyclic graphs (DAGs) with task dependencies, GNNs excel at capturing topological structures, task dependencies, and resource relationships in scheduling problems. By embedding local and global graph information into low-dimensional feature vectors, GNNs enable effective feature extraction and structural understanding for scheduling decision models. When integrated with reinforcement learning or heuristic policies, GNN-based scheduling methods significantly improve the ability to model complex dependencies, leading to better task-resource assignments and enhanced performance in makespan optimization and resource efficiency.

5.3. Experimental Setup

The key hyperparameters of HiGAT-AC are configured as follows: For the sparse GAT architecture, the dropout rate is set to 0.1, the negative slope of LeakyReLU (alpha) is 0.2, each node attends to a maximum of 10 neighbors, and multi-head attention uses 4 heads with hidden/output dimensions of 16/8 for subgraph-level GAT layers. Spectral clustering for graph partitioning adopts 25 target subgraphs, with subgraph size constrained between 30 and 50 tasks. For the actor-critic framework, the learning rates for actor and critic networks are both 5 × 10⁻⁴, the reward discount factor (gamma) is 0.99, the epsilon-greedy exploration strategy initializes at 1.0, decays by 0.9995 per step, and bottoms out at 0.4. Entropy regularization (coefficient = 0.1) is applied to encourage exploration, with L2 weight decay (1 × 10⁻⁵) and gradient clipping (max norm = 0.5) to stabilize training. The state encoder uses a 3-layer MLP (64 → 32 → 8), and the global coordinator leverages a 2-layer MLP (128 → 128) to fuse subgraph embeddings and state information.

5.4. Results and Analysis

To validate the effectiveness of the proposed HiGAT-AC algorithm in achieving balanced optimization across multiple objectives, we introduce a comprehensive evaluation metric based on normalized weighted scoring. This metric synthesizes performance across all three optimization dimensions—makespan, cost, and energy consumption—into a single composite score, reflecting a specific user-defined preference (e.g., weights of 0.4, 0.3, and 0.3, respectively). The calculation proceeds in two steps: first, each objective value is normalized to a [0, 1] range relative to the best and worst performers among all baselines, with a score of 1 is assigned to the optimal value for that objective; second, the composite score is computed as the weighted sum of these normalized values. A higher composite score indicates superior overall performance in holistic multi-objective optimization under the given preference weights. The aforementioned steps can be formalized by the following equations:

$$N_i={\displaystyle \frac{M_{max}-M_i}{M_{max}-M_{min}}}$$

(15)

$$S_i=w_t\times N_i^{time}+w_c\times N_i^{cost}+w_e\times N_i^{energy}$$

(16)

where $M_{max}$ and $M_{min}$ are the maximum and minimum values, respectively, observed for that metric among all algorithms. $w_t$, $w_c$ and $w_e$ are the predefined weights.

5.4.1. Comprehensive Evaluation

We conduct comparative experiments on large-scale synthetic workflows with task counts ranging from 500 to 1000, comparing the proposed HiGAT-AC with the five aforementioned baseline algorithms.

As shown in

Table 3. Composite scores for synthetic workflows.

	HEFT	AC	GA	PPO	GNN	HiGAT-AC
500	0.257	0.57	0.705	0.391	0.596	0.954
600	0.663	0.768	0.806	0.839	0.01	0.838
700	0.294	0.309	0.45	0.531	0.539	0.704
800	0.177	0.275	0.487	0.497	0.612	0.933
900	0.08	0.256	0.439	0.562	0.53	0.845
1000	0.116	0.335	0.481	0.363	0.265	1.0

, the proposed HiGAT-AC method achieves consistently high composite scores across most workflow scales from 500 to 1000 tasks and shows competitive performance compared with baseline methods including HEFT, AC, GA, PPO, and GNN.

Note on composite score calculation: The composite score is computed via min-max normalization, where $M_{max}$ and $M_{min}$ are determined by the range of performance values of all methods included in the same table. For this main comparison table, normalization is performed against all baseline methods (HEFT, AC, GA, PPO, GNN) plus HiGAT-AC.

Compared with the baselines, HiGAT-AC demonstrates clear advantages across multiple dimensions. Traditional heuristics such as HEFT rely on static priority rules and fail to adapt to dynamic resource conditions, leading to the lowest composite scores in most cases. Evolutionary algorithms like GA achieve moderate performance but suffer from high computational overhead and unstable convergence. Standard reinforcement learning methods, including AC and PPO, lack explicit modeling of task dependencies, resulting in suboptimal scheduling decisions for complex DAG structures. Flat GNNs capture partial topological information but use full-attention mechanisms that ignore hierarchical task structures, limiting their scalability in large-scale scenarios. In contrast, HiGAT-AC leverages hierarchical graph attention to capture both local task dependencies and global structural patterns, combined with multi-objective scalarization to balance makespan, cost, and energy consumption. This combination enables the method to maintain stable and competitive comprehensive performance under the given weighting strategy, achieving particularly strong results on 500-task and 1000-task workflows, which indicates its reliable optimization ability across different scales.

HiGAT-AC also exhibits strong scalability in large-scale scenarios. As the number of tasks increases, most baseline methods show significant performance degradation due to their limited ability to handle complex dependencies and dynamic resource states. HiGAT-AC, however, remains relatively stable across all tested scales, maintaining composite scores above 0.70 in all cases. This stability stems directly from its design: the hierarchical subgraph processing reduces the complexity of dependency modeling, while the sparse attention mechanism focuses computational resources on critical dependencies, allowing the model to scale efficiently without sacrificing performance.

Finally, HiGAT-AC consistently achieves a better balance among multiple objectives. Instead of over-optimizing a single metric, HiGAT-AC maintains reasonable performance across makespan, cost, and energy, leading to more balanced and practical scheduling results. The composite score results confirm that HiGAT-AC outperforms traditional heuristics, standard reinforcement learning methods, and flat graph neural networks in multi-objective optimization. The hierarchical structure improves scalability, while the actor-critic framework with multi-objective scalarization contributes to stable and robust performance. These results demonstrate the effectiveness and potential of HiGAT-AC for large-scale scientific workflow scheduling.

5.4.2. Ablation Study

To rigorously validate the effectiveness of each core component in HiGAT-AC, we conduct a series of ablation experiments. Analyzing the source of performance improvements is important for complex models with multiple new mechanisms, as it helps avoid redundancy and verify that each module is necessary. In this work, we focus on analyzing the hierarchical graph attention network and the Chebyshev scalarization-based reward function to evaluate their individual effects on multi-objective scheduling performance.

We design two ablated variants of our full model:

• HiGAT-AC (w/o GAT): This variant replaces the hierarchical graph attention network with a standard multi-layer perceptron for state encoding. It retains the actor-critic framework and the Chebyshev-based multi-objective reward to isolate the effectiveness of the graph attention mechanism in capturing complex task dependencies.
• HiGAT-AC (w/o Chebyshev): This variant removes the Chebyshev scalarization from the reward function, relying solely on a linear weighted sum of the normalized makespan, cost, and energy deviations. The hierarchical graph attention architecture is kept intact to evaluate the contribution of the Chebyshev method in achieving balanced optimization.

Table 4. Composite score of ablation study.

	HiGAT-AC (w/o GAT)	HiGAT-AC (w/o Chebyshev)	HiGAT-AC
500	0.183	0.35	1
600	0.329	0.38	0.7
700	0.413	0.418	0.7
800	0.363	0.442	0.64
900	0.3	0.269	0.845
1000	0.071	0.168	1

presents the results of the ablation study conducted on synthetic workflows with scales from 500 to 1000 tasks, aiming to verify the contribution of each core component in the HiGAT-AC framework.

Note on composite score calculation: For the ablation study table, normalization is performed only among the three variants (HiGAT-AC, HiGAT-AC w/o GAT, and HiGAT-AC w/o Chebyshev). Since the set of methods included differs from the main comparison table, the composite scores for HiGAT-AC are naturally different, even though its raw performance values are identical.

The complete HiGAT-AC model consistently achieves the highest composite scores across all workflow scales, demonstrating the synergistic effect of its integrated components. For workflows with 500 and 1000 tasks, HiGAT-AC attains a perfect score of 1, indicating that the full model achieves the optimal balance of makespan, cost, and energy consumption under the current weighting strategy. For other workflow scales, the complete model also significantly outperforms both ablated versions, confirming that neither the graph attention mechanism nor the Chebyshev scalarization alone can replicate the performance of the integrated framework.

In contrast, removing either component leads to clear and interpretable performance degradation. HiGAT-AC (w/o GAT) suffers the most severe performance drop, with its composite score plummeting to 0.071 at the 1000-task scale. This sharp decline is directly attributable to the removal of the hierarchical graph attention mechanism, which is responsible for modeling complex task dependencies and inter-subgraph relationships. Without it, the model can no longer identify critical scheduling paths or allocate resources based on structural information, resulting in poor scalability and suboptimal decisions in large-scale scenarios.

HiGAT-AC (w/o Chebyshev) also exhibits inferior performance compared to the full model, particularly at larger scales, with a score of only 0.168 for the 1000-task workflow. This confirms the critical role of Chebyshev scalarization in balancing conflicting scheduling objectives. Without this mechanism, the agent tends to prioritize a single metric (e.g., makespan) at the expense of others (e.g., energy or cost), leading to imbalanced solutions and reduced robustness across different workflow scales.

These ablation results validate the necessity of each core component in HiGAT-AC. The graph attention mechanism provides structured dependency modeling, while the Chebyshev scalarization ensures balanced multi-objective optimization. Their integration produces a synergistic effect that significantly enhances the model’s multi-objective optimization capability, scalability, and robustness.

5.4.3. Training Time

To further evaluate the practical efficiency of HiGAT-AC, we compare the training time of HiGAT-AC with that of baseline algorithms across different workflow scales, as shown in

Table 5. Training times in seconds.

	HEFT	AC	GA	PPO	GNN	HiGAT-AC
500	2.7	0.18	413.76	0.97	2.55	44.65
600	2.58	1.65	600.83	1.25	3.88	58.59
700	3.45	1.9	821.83	1.73	5.61	81.52
800	5.11	2.82	1048.83	2.06	7.6	92.37
900	6.6	3.35	1359.4	2.32	9.86	131.42
1000	10.44	3.56	1896.62	2.91	14.03	147.08

.

Compared with the GA method, which requires a large amount of computation time, HiGAT-AC shows significantly lower time complexity. Even for the largest 1000-task workflow, the training time remains within 147.08 s, which is much shorter than that of population-based optimization methods. This suggests that the hierarchical graph attention and actor-critic framework can learn scheduling policies with relatively acceptable computational overhead. Although heuristic methods (HEFT) and simple reinforcement learning methods (AC, PPO) have faster execution times, they lack the multi-objective optimization capability of HiGAT-AC. The training time of HiGAT-AC increases gradually with workflow size, showing relatively stable scalability, which is acceptable for most practical scheduling scenarios. Compared with the standard GNN method, HiGAT-AC requires more training time due to its three-level attention structure. However, this moderate increase in computational cost is accompanied by improved multi-objective scheduling performance. Overall, the results indicate that HiGAT-AC achieves a reasonable balance between solution quality and computational efficiency and provides a feasible option for heterogeneous workflow scheduling.

6. Conclusions and Future Work

This paper presented HiGAT-AC, a hierarchical graph attention network integrated with actor-critic reinforcement learning for scalable multi-objective workflow scheduling in heterogeneous computing environments. The proposed framework addresses the key challenges of scalability in large-scale workflows and multi-objective trade-offs among conflicting metrics through three main innovations: (1) a spectral clustering-based graph partitioning strategy that decomposes large workflows into semantically coherent subgraphs, enabling efficient hierarchical processing; (2) a three-level graph attention architecture with sparse attention mechanisms that reduce computational complexity while preserving critical dependency information; and (3) a multi-objective actor-critic learning framework that employs Chebyshev scalarization combined with linear aggregation to balance makespan, cost, and energy consumption.

Extensive experimental results show that HiGAT-AC achieves competitive and favorable composite scores across workflow scales from 500 to 1000 tasks. In particular, HiGAT-AC achieves composite scores of 0.954 for 500-task workflows and 1.000 for 1000-task workflows and maintains scores above 0.70 across all tested scales. Compared with traditional heuristic algorithms and representative learning-based scheduling methods, HiGAT-AC exhibits better overall performance in balancing makespan, cost, and energy consumption. HiGAT-AC also shows relatively stable and favorable scalability as the workflow scale increases, indicating its potential for large-scale scientific workflow scheduling in heterogeneous environments.

The current study is subject to two main limitations that should be acknowledged. First, all experiments are conducted using synthetic workflow datasets, which provide controlled conditions to evaluate scalability and multi-objective performance. However, conclusions drawn from synthetic data may not fully generalize to real-world scientific workflows with more complex dynamics and heterogeneous characteristics. Second, due to the high computational overhead training of the proposed hierarchical model and baseline methods, experiments are currently performed under fixed random seeds, without formal statistical analysis such as variance, standard deviation, or significance testing across multiple runs. While the results consistently show the relative performance advantage of HiGAT-AC, further statistical validation is needed to confirm the stability and reliability of the observed improvements.

Future work will focus on addressing these limitations. We plan to validate the proposed HiGAT-AC on real-world workflow traces collected from heterogeneous computing clusters to better assess their practical applicability. Additionally, we will conduct repeated experiments with different random seeds to provide a comprehensive statistical analysis of the results. We will also further optimize the training strategies of the hierarchical graph attention network to improve both scheduling accuracy and training efficiency and incorporate real-time factors such as network latency fluctuations and unexpected node failures into the model to enhance its adaptability and robustness in evolving computing environments.