arXiv:2604.09202v1 [cs.LG] 10 Apr 2026
On the Role of DAG topology in Energy-Aware Cloud Scheduling : A GNN-Based Deep Reinforcement Learning Approach ANAS HATTAY, CEA, List, Université Paris-Saclay, France FRED NGOLE MBOULA, CEA, List, Université Paris-Saclay, France ERIC GASCARD, Université Grenoble Alpes, CNRS, Grenoble INP, G-SCOP, France ZAKARIA YAHOUNI, Université Grenoble Alpes, CNRS, Grenoble INP, G-SCOP, France Cloud providers must assign heterogeneous compute resources to workflow DAGs while balancing competing objectives such as completion time, cost, and energy consumption. In this work, we study a singleworkflow, queue-free scheduling setting and consider a graph neural network (GNN)–based deep reinforcement learning scheduler designed to minimize workflow completion time and energy usage. We identify specific out-of-distribution (OOD) conditions under which GNN-based deep reinforcement learning schedulers fail, and provide a principled explanation of why these failures occur. Through controlled OOD evaluations, we demonstrate that performance degradation stems from structural mismatches between training and deployment environments, which disrupt message passing and undermine policy generalization. Our analysis exposes fundamental limitations of current GNN-based schedulers and highlights the need for more robust representations to ensure reliable scheduling performance under distribution shifts. Additional Key Words and Phrases: Cloud Computing, Resource Allocation, Deep Reinforcement Learning, Robustness, Interpretability, Job Scheduling, Graph Neural Networks
1
Introduction
1.1
Context
Over the past few years, artificial intelligence and large language models have pushed cloud systems much harder than before. According to [24], the energy used by data centers keeps growing because of heavier AI training and inference workloads. This means even small improvements in how cloud resources are allocated can save a noticeable amount of time and electricity. Figure 1 shows the setting. A workflow is a directed acyclic graph. Nodes are tasks. Edges are data or control dependencies. Some stages expose wide parallelism. Others form long serial chains. Authors’ Contact Information: Anas Hattay, [email protected], CEA, List, Université Paris-Saclay, Palaiseau, France; Fred Ngole Mboula, [email protected], CEA, List, Université Paris-Saclay, Palaiseau, France; Eric Gascard, [email protected], Université Grenoble Alpes, CNRS, Grenoble INP, G-SCOP, Grenoble, France; Zakaria Yahouni, [email protected], Université Grenoble Alpes, CNRS, Grenoble INP, G-SCOP, Grenoble, France. Manuscript submitted to ACM 1
At the same time, machines in a cloud are heterogeneous. Some machines finish tasks faster but draw more power. Others are slower but use less. The scheduler decides, at each step, which ready task should run on which machine. Each assignment changes the makespan and the total energy used. This problem has drawn steady research interest. Energy-aware scheduling appeared in HPC and cloud literature well before the recent AI boom. Early work used DVFS to trade performance for power [34, 49]. Recent surveys report steady activity: Multiple systematic reviews published indicate sustained research activity in this domain [1, 44]. Machine learning-based cluster management has demonstrated measurable impact, reducing data center energy consumption by up to 15% in Google’s production deployments [18]. Amazon and Microsoft have explored complementary approaches through right-sizing and spot market mechanisms to reduce both operational costs and resource waste [10, 38]. Modern AI workflows add new dimensions to this problem. They mix layers that are very wide with chains that are very long. And they run on machines with big differences in speed and power use. Old scheduling rules assume the workflow shape stays the same and machines are predictable. When that is not true, performance can drop fast. Because of this, researchers are looking at more advanced schedulers that can adapt. But the problem is we do not know if these learned policies still work when the workflow or machines change. We will go over the current approaches next and then introduce the gap that motivated our study. 1.2
Related Work
Many workflow applications are naturally written as directed acyclic graphs (DAGs) of tasks with different resource needs and complex dependencies ([13], [35]). Scheduling these DAGs on pools of virtual machines with different speeds and power use is a classic problem in distributed systems and high performance computing ([29]). This problem is NP hard in general. Foundational work by Pinedo [32] and the notation of Graham et al. [19] provide the standard formal basis for makespan minimization under precedence and machine heterogeneity. 1.2.1 Classical Topology Aware DAG Scheduling. A large body of work models applications as weighted DAGs, where nodes are tasks and edges capture precedence and communication constraints on heterogeneous processors. The Heterogeneous Earliest Finish Time (HEFT) and Critical Path on a Processor (CPOP) list schedulers of Topcuoglu et al. [43] are central references. They rank tasks with path based metrics and map them to heterogeneous processors to reduce makespan. HEFT uses an upward rank that approximates remaining critical path length, then schedules tasks on the processor with the earliest finish time. This exploits DAG depth, fan out, and communication
Fig. 1. Overview of the workflow scheduling problem in a heterogeneous cloud. The scheduler receives a DAG with ready tasks and a set of machines with different speed and power. It must decide which task runs on which machine, and each choice changes both completion time and energy.
along paths. CPOP identifies a global critical path and assigns its tasks to a single processor to reduce inter processor communication. Many variants build on this topology aware idea while adding new objectives such as energy or reliability. Energy aware DAG schedulers on heterogeneous and embedded platforms often use critical path and level based slack to decide which tasks can safely be slowed down or consolidated while still meeting deadlines [23]. In these works, DAG topology is not only a feasibility constraint. It is a direct signal for making decisions. Parallelism per level, critical path length, and slack structure strongly influence task priorities and mapping choices. In cloud and distributed environments, workflow systems such as Pegasus [14] and simulators such as CloudSim [8] have established DAGs as the standard abstraction for scientific workflows. Energy aware scheduling has been widely studied in this setting. For example, Beloglazov and Buyya [3] show how power heterogeneity and job topology together shape good placement policies. Many real world workloads are also multi objective. Schedulers must trade off makespan, cost, energy, and sometimes reliability ([6], [11]). Classical heuristics are usually tuned around a single dominant objective. When new metrics are added, they often need extensive manual retuning and may not transfer well across workloads [6]. Meta heuristic methods can explore richer trade
offs but are often too slow for real time scheduling in dynamic clouds, since they rely on iterative search ([11]). 1.2.2 Deep Reinforcement Learning for Resource Scheduling. These limitations have motivated a shift toward learning based schedulers. Deep reinforcement learning (deep RL ), first introduced by Sutton et al. [40], offers a way to learn scheduling policies directly from experience without manually encoding rules for every scenario. Early work by Mao et al. [27] showed that deep RL agents could learn to pack tasks and allocate resources in cluster settings, outperforming hand tuned heuristics on job completion time. The idea is to frame scheduling as a sequential decision problem. An agent observes system state, selects actions such as which task to schedule or which machine to use, and receives rewards based on performance metrics like makespan or resource use. This approach has several advantages. First, the policy can adapt to patterns in the workload without explicit feature engineering. Second, it can handle multi objective trade offs by shaping the reward function. Third, once trained, the policy can make decisions quickly, which is useful in online settings. Several studies have confirmed that deep RL schedulers can match or beat classical heuristics in controlled environments ([47], [27]). But early deep RL schedulers often treated system state as a flat feature vector. This does not capture the relational structure of workflows or resource topologies. This is where graph neural networks come in. 1.2.3 Graph Neural Networks for Structured Scheduling. Graph neural networks provide a natural way to encode relational structure. In scheduling, both workflows (task dependencies) and resource topologies (machine connectivity or hierarchy) are naturally represented as graphs. GNNs use message passing to let each node aggregate information from its neighbors. This means the learned representation can respect the structure of the problem. Decima was one of the first systems to combine GNNs with RL for cluster scheduling [28]. It models each data processing job as a DAG of stages. A GNN embeds this DAG along with per stage features such as remaining work and resource demand. The RL policy then uses these embeddings to decide which stage to schedule and how many executors to assign. Message passing over the DAG lets the model implicitly capture properties like depth, critical paths, and fan in or fan out. Experiments showed that this topology aware policy reduced average job completion time compared to topology agnostic baselines and classical heuristics. Follow up work extended this idea to other scheduling domains. Park et al. [31] used GNNs to embed both job DAGs and cluster topology for multi resource scheduling. Others applied similar architectures to workflow scheduling in cloud and edge environments, where tasks have precedence constraints and machines have different speeds or power profiles. In most cases, the
GNN based approach improved performance over flat feature representations. These results suggest that exploiting the graph structure provides richer relational information, allowing the policy to generalize more robustly across scenarios. 1.2.4 Generalization and Robustness Challenges. Despite these successes, most studies evaluate learned policies primarily on the same types of workflows and host configurations seen during training. They show that GNN based RL can work well in specific settings, but they rarely ask how robust these policies are when the workflow structure or resource characteristics change. For example, what happens when a policy trained on shallow parallel workflows is tested on deep sequential workflows? Or when a policy trained on homogeneous machines is deployed on heterogeneous hardware with conflicting speed and power trade offs? This concern is grounded in known limitations of graph neural networks under distribution shift. Wu et al. [45] showed at ICLR 2022 that distribution shifts hit GNNs particularly hard because of how nodes connect to each other. When the graph topology changes, the whole representation can break down. This matters for workflow scheduling. A policy trained on one type of DAG may face very different graphs at deployment. Depth can change. Width can change. Branching can change. This motivates a systematic first step: characterize the distribution shift in our setting. We must precisely define and measure how deployment DAGs differ from those seen during training, and then determine how to address it. 1.3
Positioning of Our Work
This paper identifies specific out-of-distribution conditions that cause GNN-based deep RL schedulers to fail, and explains why these failures occur. We build on two key observations. First, Gu et al. [20] showed that real workflows from production systems (millions of DAGs from Alibaba batch jobs) cluster into a few structural types. Second, recent RL-based schedulers using GNNs to embed DAGs have shown strong performance on some benchmarks ([28], [31]), but their robustness across structural types remains unclear. An empirical pattern is reported in [21]. When a deep RL scheduler is compared with classical heuristics across many workflow instances, it does not simply dominate or fail everywhere. It performs very well on some workflows and host settings and quite poorly on others. Sometimes it is even worse than basic list scheduling rules. With closer examination, we observed that these failures are not random. They concentrate in specific combinations of workflow topology and host heterogeneity. This suggests that learned schedulers have implicit structural domains where they behave coherently and domains where their behavior degrades. Epistemologically, we follow a Popper style view of scientific progress [33]. We are less interested in showing more positive cases for a learned policy and more interested in subjecting it to tests
that might break it. We treat the learned policy as a provisional theory about how topology and heterogeneity shape scheduling decisions. We then expose that theory to workflow topologies and host regimes in which it should fail if it is narrow or brittle. The goal is not only to show that the agent can work somewhere, but to reveal what it has actually learned when the surrounding conditions change. To study this in a controlled way, we define two simple workflow families. wide DAGs are shallow with high parallelism. Long Critical Path (LongCP) DAGs have deep dependency chains and little parallel slack. On the resource side, we consider four queue free host regimes that isolate different aspects of heterogeneity: Homogeneous Speed (HS), Homogeneous Power (HP), Heterogeneous Aligned (AL), and Heterogeneous Non Aligned (NA). Each regime creates a different trade off between makespan and active energy. As a result, each regime gives a different incentive for using or ignoring parallelism. We then train a GNN based actor critic deep RL scheduler on these environments. We use separate agents specialized to wide workflows and to LongCP workflows. We do not evaluate these agents only on the distributions they were trained on. Instead, we systematically probe cross topology and cross regime generalization. For example, we run a wide trained agent on LongCP workflows, a LongCP trained agent on wide workflows, and we test all agents across all four host regimes. This work therefore investigates how DAG topology and host heterogeneity together shape the behavior and generalization of an RL based scheduler with joint energy and makespan objectives in a queue free, single workflow cloud setting. Research Questions. This setup lets us ask two main questions: • Q1: How do DAG topology (wide vs. long critical path) and host speed/power configurations jointly influence learned policy priorities under mixed energy-makespan objectives? Do these factors induce systematic biases in scheduling strategies despite identical objectives? • Q2: How does cross-topology generalization vary across host configurations (AL, NA, HS, HP)? When do wide specialists outperform LongCP specialists (and vice versa), and what explains these performance gaps? Contributions. By answering these questions, we make the following contributions: • A controlled decomposition of the problem space. We separate the effects of workflow topology and host heterogeneity by defining two contrasting DAG families (wide and LongCP) and four host regimes (HS, HP, AL, NA) that each capture a different dimension of heterogeneity.
• Systematic cross topology and cross regime evaluation. We train GNN based deep RL schedulers specialized to wide workflow and to LongCP workflows. We then test all agents across all topology and regime combinations using wide and LongCP test workflows per configuration. • An interpretability focused analysis of generalization domains. We show that the combined structure of workflow and host naturally divides the problem into domains where a given policy behaves consistently and domains where its generalization breaks down. In the following sections, we first formalize the problem and objectives (Section 2), then describe our benchmark and GNN based scheduler (Section 3), and finally evaluate and explain its behavior across workflow topologies and host regimes (Section 4). 2 2.1
Problem Setup Problem Formulation
We adopt the Markov Decision Process (MDP) formulation from Chandrasiri and Meedeniya [9] for workflow scheduling on virtualized clusters, with modifications to support concurrent task execution on multi-core VMs. While we retain the same state space, action space, and transition dynamics, we extend the makespan and active energy calculations to account for overlapping tasks running on a single VM and fractional CPU utilization when computing energy consumption and VM resource liberation times. We model workflow scheduling as a finite-horizon MDP MDP = (S, A, P, R, 𝛾), with state space S, action space A, transition kernel P, reward function R, and discount factor 𝛾. Decisions occur at epochs 𝑘 = 0, . . . , 𝐾 until all tasks complete. 2.1.1 System Model. Let G = (V, E) be a workflow DAG with tasks 𝑖 ∈ V and precedence edges (𝑝 → 𝑖) ∈ E. Each task has: (i) computational size 𝐿𝑖 , representing the total amount of processing required to complete the task (e.g., MI), (ii) resource demand vector d𝑖 = (cpu𝑖 , mem𝑖 ), cpu mem (iii) compatibility set C𝑖 ⊆ M of admissible VMs. Each VM 𝑚 ∈ M has capacity c𝑚 = (𝐶𝑚 , 𝐶𝑚 ), peak idle processing speed 𝑠𝑚 (e.g., MIPS), and power parameters (𝑃𝑚 , 𝑃𝑚 ). 2.1.2 Decision Epochs and Clock. Let 𝜏𝑘 denote the simulation clock at decision epoch 𝑘. Decisions occur when the agent assigns a ready task. Between decisions, the environment advances 𝜏 according to scheduled start/finish events implied by previous assignments.
2.1.3
State Space S. A state 𝑠𝑘 ∈ S summarizes all information needed for optimal control: 𝑠𝑘 = (𝜏𝑘 ; {task status𝑖 ∈ {not_ready, ready, running, done}}𝑖 ∈ V ; {parent_ready𝑖 = max 𝑐 𝑝 }𝑖 ∈ V ; 𝑝 ∈Pa(𝑖 )
{assignment𝑖 ∈ C𝑖 ∪ {∅}}𝑖 ∈ V ; {start𝑖 , 𝑐𝑖 }𝑖 ∈ V ; {VM residual capacities and active allocations over [𝜏𝑘 , ∞)}𝑚∈ M ; peak
idle {(𝑃𝑚 , 𝑃𝑚 )}𝑚∈ M ;
{C𝑖 }𝑖 ∈ V ). • Pa(𝑖) denotes the set of parent tasks of task 𝑖 in the workflow DAG. • 𝑐 𝑝 is the completion time of parent task 𝑝. • start𝑖 and 𝑐𝑖 are the planned start and completion times of task 𝑖. • VM residual capacities and active allocations are tracked for each VM 𝑚 ∈ M over future time. idle, 𝑃 peak ) are the power parameters of VM 𝑚. • (𝑃𝑚 𝑚 • C𝑖 ⊆ M is the set of VMs compatible with task 𝑖. The ready set at 𝜏𝑘 is R𝑘 = {𝑖 : task status𝑖 = ready}. 2.1.4
Action Space A. An action selects a task–VM pair: 𝑎𝑘 = (𝑖, 𝑚) ∈ F (𝑠𝑘 ) ⊆ V × M,
where the feasible set enforces precedence, compatibility, and capacity: n o F (𝑠𝑘 ) = (𝑖, 𝑚) : 𝑖 ∈ R𝑘 , 𝑚 ∈ C𝑖 , d𝑖 ⪯ residual_capacity𝑚 (𝑡) for some 𝑡 ≥ parent_ready𝑖 . Operationally, assigning (𝑖, 𝑚) schedules task 𝑖 on VM 𝑚 at its earliest feasible start time 𝑠𝑖 = min{𝑡 ≥ parent_ready𝑖 : d𝑖 ⪯ residual_capacity𝑚 (𝑡)}, and updates VM 𝑚’s capacity timeline, with completion time 𝑐 𝑖 = 𝑠𝑖 +
𝐿𝑖 , 𝑠𝑚
where 𝑠𝑚 is the processing speed of VM 𝑚.
. In contrast to [9], which assumes one task per VM at a time, our formulation allows multiple tasks to execute concurrently on VM 𝑚 as long as the aggregate resource demands satisfy Í Í cpu mem for all 𝑡. Action masking enforces F (𝑠 ). 𝑘 𝑗 ∈𝐴𝑚 (𝑡 ) cpu 𝑗 ≤ 𝐶𝑚 and 𝑗 ∈𝐴𝑚 (𝑡 ) mem 𝑗 ≤ 𝐶𝑚
2.1.5 Transition Kernel P. Given a state 𝑠𝑘 and an action 𝑎𝑘 = (𝑖, 𝑚), the environment deterministically transitions to 𝑠𝑘+1 by performing the following updates: (i) task 𝑖’s (start𝑖 , 𝑐𝑖 , status𝑖 ), (ii) VM 𝑚’s allocation timeline, (iii) descendants’ readiness when all parents are completed: task status 𝑗 ← ready if ∀𝑝 ∈ Pa( 𝑗) : task status𝑝 = done and 𝜏 ≥ max𝑝 ∈Pa( 𝑗 ) 𝑐 𝑝 , (iv) simulation clock to the next decision epoch 𝜏𝑘+1 , i.e., the earliest time when a task becomes ready. 2.1.6 Reward R with Concurrency-Aware Heuristics. Designing informative intermediate rewards for workflow scheduling is challenging due to delayed objectives : makespan and total energy consumption. To enable effective credit assignment during learning, we define per-step rewards based on regret reductions relative to concurrency-aware heuristic estimates that approximate the remaining cost-to-go. Heuristic Estimates. At each state 𝑠, we compute two greedy estimates: • Makespan estimate 𝑇b(𝑠): Earliest completion time obtained by greedily scheduling remaining tasks using an earliest-completion-time (ECT) policy. • Active energy estimate 𝐸b(𝑠): Minimum active energy consumption for remaining tasks, accounting for fractional CPU utilization and concurrent execution. Both heuristics simulate a feasible completion of the workflow by: (1) Building per-VM event timelines from already-scheduled tasks, where each event (𝑡, Δmem, Δcores ) tracks resource changes at time 𝑡. 𝑖 (2) For each unscheduled task 𝑖, finding the earliest feasible start time 𝑡 ≥ 𝑡 ready on each compatible VM 𝑚 ∈ C𝑖 when: mem used_mem𝑚 (𝑡) + mem𝑖 ≤ 𝐶𝑚
and
cpu
used_cores𝑚 (𝑡) + cpu𝑖 ≤ 𝐶𝑚
(3) Selecting the VM that minimizes completion time (for makespan) or energy consumption (for energy). For the energy heuristic, power on VM 𝑚 at time 𝑡 is modeled as: ∑︁ 1 © ª 𝑈𝑚 (𝑡) = min1, cpu cpu 𝑗 ® 𝐶𝑚 𝑗 ∈𝐴 (𝑡 ) 𝑚 « ¬ where 𝐴𝑚 (𝑡) is the set of tasks active on VM 𝑚 at time 𝑡, and 𝑈𝑚 (𝑡) ∈ [0, 1] is the fractional CPU utilization. This fractional CPU model extends Chandrasiri and Meedeniya [9] work by accounting for the aggregate core usage of all concurrent tasks, enabling accurate energy estimation when multiple tasks overlap on multi-core VMs. Energy is integrated piecewise-constant over segments bounded by task start/completion events. peak
idle 𝑃𝑚 (𝑡) = 𝑃𝑚 + (𝑃𝑚
idle − 𝑃𝑚 ) · 𝑈𝑚 (𝑡),
Regret-Based Reward. At each decision epoch 𝑘, after action 𝑎𝑘 transitions 𝑠𝑘 → 𝑠𝑘+1 , we compute normalized regret reductions: Δ𝑅𝑘mk = −
𝑇b(𝑠𝑘+1 ) − 𝑇b(𝑠𝑘 ) , max(𝑇b(𝑠𝑘+1 ), 𝜀)
Δ𝑅𝑘en = −
𝐸b(𝑠𝑘+1 ) − 𝐸b(𝑠𝑘 ) max(𝐸b(𝑠𝑘+1 ), 𝜀)
where 𝜀 > 0 is a small constant. A positive value indicates the action reduced the estimated cost-to-go. The combined reward is: 𝑟𝑘 = 𝑤𝑇 · Δ𝑅𝑘mk + 𝑤 𝐸 · Δ𝑅𝑘en where (𝑤𝑇 , 𝑤 𝐸 ) are tunable weights that scalarize the multi-objective problem. Objective. We optimize a stationary policy 𝜋𝜃 (𝑎 | 𝑠) to maximize the expected discounted return "𝐾 # ∑︁ 𝐽 (𝜋𝜃 ) = E𝜋𝜃 ,P 𝛾 𝑘 𝑟𝑘 , 𝑘=0
where P denotes the environment transition dynamics, 𝑟𝑘 is the reward at decision step 𝑘, and 𝐾 is the episode horizon corresponding to the total number of scheduling decisions until termination. We typically set 𝛾 ≈ 1 for episodic scheduling problems. At episode termination, the final makespan 𝑇mk = max𝑖 𝑐𝑖 and the total energy consumption ∑︁ ∫ 𝑇mk 𝐸 tot = 𝑃𝑚 (𝑡) 𝑑𝑡 𝑚∈ M
0
are computed for evaluation, where 𝑃𝑚 (𝑡) denotes the instantaneous power consumption of machine 𝑚 at time 𝑡. 2.1.7 Constraints and Termination. Feasibility is enforced by F (𝑠𝑘 ): (i) precedence constraints via readiness, (ii) per-VM resource capacities (CPU cores and memory) over time with concurrent task support, (iii) task–VM compatibility. The episode terminates when all tasks are completed. 2.2
Workflow Topology and Host Regime Decomposition
To understand the problem complexity, we first examine what makes one job different from another at a structural level. Since jobs consist of multiple interdependent tasks, their dependency structure determines how many tasks can be ready in parallel and how scheduling decisions propagate through time. Let 𝐺 = (𝑉 , 𝐸) be a DAG with task work {𝐿𝑖 }𝑖 ∈𝑉 . We denote: Í • total work 𝑊 = 𝑖 ∈𝑉 𝐿𝑖 , Í • critical-path length 𝐿CP = max𝜋 ∈paths(𝐺 ) 𝑖 ∈𝜋 𝐿𝑖 , • depth 𝐷 and level widths |level(ℓ)| from a standard levelization of the DAG.
A useful scalar summary of intrinsic parallelism is Φ =
𝑊 . 𝐿CP
Intuitively, 𝐿CP is the amount of work that must be done sequentially, while 𝑊 is the total work. Large Φ indicates ample exploitable parallelism; Φ close to 1 indicates a nearly sequential job. We focus on two representative topologies: • Long Critical Path (LongCP). Deep dependency chains (𝐷 large) with small width, so Φ is close to 1–few. Ready sets are typically small and concentrated near occasional side branches. • wide DAG. Shallow depth (𝐷 small) with large level widths, so Φ ≫ 1. Ready sets are large and bursty at wide layers, and many task–VM assignments are simultaneously feasible. wide DAG
Long Critical Path DAG
Fig. 2. Schematic comparison of a wide DAG (left, shallow with many parallel branches) and a Long-CP DAG (right, deep dependency chain with limited side-branch concurrency).
Figure 3 shows how workflow structure changes the scheduling problem. wide DAGs create a rugged landscape with shallow valleys everywhere. When many tasks are ready at once, there are countless ways to assign them to VMs. A small change in the assignment can cause energy consumption to jump around unpredictably. LongCP DAGs produce a different landscape entirely. Fewer valleys, but deeper ones. The critical path constrains most decisions because dependency chains force a specific order. There’s little room to explore alternatives. The main freedom is placing short side branches, which creates a few isolated basins instead of a chaotic surface. With these distinctions, we address Q1 and Q2 through four host-configuration regimes (AL, NA, HS, HP) in our queue-free setting. Queue-Free Regime. Across all four regimes we assume a queue-free, single-workflow environment. A cluster of 𝑉 virtual machines (VMs) executes a single DAG workflow. Time is continuous and tasks are non-migratable once assigned to a VM.
Fig. 3. Fitness landscape of the scheduling search space. We exhaustively enumerate all feasible action sequences for a small scenario and project them onto a 2D plane using a Hilbert curve. The Z-axis shows energy consumption (lower is better). Left: LongCP DAG. Right: wide DAG .
The dataset generator enforces queue-freedom: for each DAG we scale task memory and CPU requirements so that the peak-width layer fits within aggregate cluster capacity. If Lmax is the peak layer, ∑︁ 𝑖 ∈ Lmax
req_mem𝑖 ≤
𝑉 ∑︁ 𝑣=1
mem𝑣 ,
∑︁ 𝑖 ∈ Lmax
req_cores𝑖 ≤
𝑉 ∑︁
cores𝑣 .
𝑣=1
Thus, whenever a task becomes ready, there exists a feasible placement that does not violate capacity. The four regimes below differ only in how VM speed and power are parameterized. Homogeneous-Speed Regime (HS). In the homogeneous-speed regime, all VMs process work at the same rate 𝑠 (e.g., MIPS). If a task 𝑖 has computational length 𝐿𝑖 (in MI), its processing time is 𝜏𝑖 = 𝐿𝑖 /𝑠, independent of which VM executes it. Because speeds are identical and the instance is queue-free, any non-pathological schedule that keeps critical-path tasks busy attains the same makespan 𝑇 ★ = 𝐿CP /𝑠, where 𝐿CP is the critical-path length of the DAG. Makespan is determined by DAG topology, not by VM assignment choices. We focus on power-heterogeneous but speed-homogeneous hosts. At approximately fixed makespan, the only remaining degree of freedom is which VMs are active and for how long. This means the policy can only shape active energy by controlling VM power profiles. Homogeneous-Power Regime (HP). In the homogeneous-power regime, all VMs share the same ∫ active power 𝑃 act but differ in speed 𝑠 (𝑣). Active energy is approximated as 𝐸 ≈ 𝑃 act 𝑑𝑡. For
a fixed task workload, this makes energy largely insensitive to speed (ignoring second-order utilization effects), while makespan still depends on 𝑠 (𝑣) through 𝜏 = 𝐿/𝑠 (𝑣). The effective objective becomes primarily time-dominated: faster machines shorten makespan, but active energy remains approximately unchanged across VM choices since 𝑃 act is constant. This reduces the multi-objective problem to a single-objective problem focused on minimizing completion time. Heterogeneous Aligned Regime (AL). In the heterogeneous aligned regime, speed and energy efficiency move in the same direction. Faster machines are also more power efficient for the same amount of work. Formally, for two VMs 𝑣 1 and 𝑣 2 with speeds 𝑠 (𝑣 1 ) < 𝑠 (𝑣 2 ), the faster VM has lower energy. Moving a task to a faster VM therefore tends to reduce both completion time and total energy, so the two objectives are mostly aligned. Heterogeneous Non Aligned Regime (NA). In the heterogeneous non aligned regime, we break this link between speed and efficiency. Some VMs are fast but energy hungry, while others are slow but energy cheap. In other words, higher speed does not imply lower energy per unit work, and in some cases it can be strictly worse. This creates real conflicts between local choices. A faster VM may reduce completion time but increase total energy, while a slower and more efficient VM may save energy at the cost of longer makespan. The trade off surface becomes non monotone, with several locally attractive choices depending on the exact speed and power pairing. 3
Model Architecture
Our scheduler is a deep actor–critic architecture built around a shared graph neural network (GNN) backbone that embeds both workflow tasks and virtual machines (VMs). Figure 5 summarizes the deep reinforcement learning architecture used throughout this work. We follow the standard actor–critic decomposition : an actor (policy network) outputs a stochastic policy 𝜋𝜃 (𝑎 | 𝑠) over scheduling actions, while a critic (value network) estimates the state value 𝑉𝜙 (𝑠) and is used as a learned baseline to reduce the variance of the policy-gradient estimator ([26, 30, 37]). Both heads share the same Graph Isomorphism Network (GIN) backbone so that policy and value are learned from a common structural representation of the workflow and VM pool. Input representation. At each decision step the environment provides a structured observation encoding the current workflow DAG and the VM pool. Tasks are represented by: (i) scheduled/ready flags, (ii) remaining work and completion time, (iii) CPU and memory requirements. VMs are represented by: (i) completion times and current utilization, (ii) speed, core count and available cores, (iii) memory capacity and free memory, (iv) host idle and peak power. Compatibility edges
Fig. 4. Speed–power host regimes. Illustration of the four queue-free host regimes studied in this paper. Homogeneous-Speed: all VMs share the same processing speed but differ in power, isolating energy trade-offs at fixed makespan. Homogeneous-Power: all VMs share the same active power but differ in speed, isolating time trade-offs. Heterogeneous Aligned: speed and power are monotonically aligned, inducing an intuitive Pareto frontier between makespan and active energy. Heterogeneous Non-Aligned: speed and power are not aligned, creating counter-intuitive trade-offs and stronger generalization challenges for learned schedulers.
Fig. 5. Overview of the proposed GIN-based actor–critic scheduler architecture.
link tasks to VMs on which they can run, and dependency edges encode the workflow DAG (parent–child relations). The resulting structure forms a bipartite-plus-dependency graph with heterogeneous node types and two distinct edge families. Task and VM encoders. We map raw task and VM features into a common latent space using two separate multi-layer perceptrons (MLPs). The task encoder consumes a 6-dimensional feature vector and outputs a 𝑑-dimensional embedding. The VM encoder consumes a 12-dimensional feature vector and outputs an embedding in the same space. Both encoders use batch normalization and ReLU nonlinearities, followed by a final linear projection. The encoders are shared between actor and critic. GIN backbone. We concatenate the encoded task and VM nodes into a single set and process them using a three-layer Graph Isomorphism Network (GIN) ([46]) with hidden dimension ℎ. The edges capture both task–VM compatibility links and task–task dependency links. Each GIN layer performs neighborhood aggregation followed by an MLP update, producing type-agnostic node embeddings that capture both the workflow structure and the VM context. A global mean-pooling operation over all nodes is then applied to compute a graph embedding, providing a compact summary of the current scheduling state. Actor head. The actor network uses the learned node and graph embeddings to evaluate possible scheduling decisions. For each task that can run on a given VM, we build an edge embedding by combining the embeddings of the task node, the VM node, and the overall graph representation. This combined vector is passed through a small multilayer perceptron (the edge scorer) that outputs a single numerical score. All scores are then arranged into a task×VM matrix, where invalid entries that corresponds to tasks that are not ready, already scheduled, or incompatible are masked out. After flattening the remaining entries, a softmax function converts the scores into a probability distribution over all valid (task, VM) pairs. The agent’s policy 𝜋𝜃 (𝑎 | 𝑠) is defined by sampling or selecting the highest-scoring action from this distribution. Critic head. The critic shares the same GIN backbone and encoders but operates only on the global graph embedding. A two-layer MLP maps the graph embedding to a scalar value estimate 𝑉𝜙 (𝑠), representing the expected return from the current state under the policy. Training. Actor and critic parameters are jointly optimized with a policy-gradient algorithm using the mixed objective described in Section 2.1.6. The actor receives policy-gradient updates based on advantage estimates that combine makespan and active-energy, while the critic is trained with a regression loss toward bootstrapped returns. Gradients flow through the encoders and GIN
backbone, so the resulting node, edge, and graph embeddings become specialized for topologyaware scheduling decisions across the host regimes described in the next section. 4
Experimental Methodology, Results and Analysis
This section shows the experiments and results that really answer Q1 (how DAG topology and host setups affect scheduling choices) and Q2 (how well policies work across different topologies). 4.1
Experimental Methodology
We conduct experiments using the two workflow families (wide and LongCP) and four host regimes (HS, HP, AL, NA) defined in Section 2.2. For each topology class, we define disjoint training and evaluation seed sets to generate independent workflow instances. 4.1.1 Training Setup. We train the GNN-based actor–critic agent described in Section 3 using standard on-policy policy gradients with advantage estimation. Episodes and environment dynamics. Each episode executes a complete workflow from source tasks to sink completion. The environment implements the transition kernel P from Section 2.1, simulating task execution, updating readiness based on DAG dependencies, and integrating power over time. Reward formulation. We use the mixed objective from Section 2.1.6: 𝑟𝑘 = 𝑤𝑇 · Δ𝑅𝑘mk + 𝑤 𝐸 · Δ𝑅𝑘en with per-decision incremental improvements in makespan and energy. Coefficients (𝑤𝑇 , 𝑤 𝐸 ) are fixed as (1,1) within experiments. Training distributions. For each host regime, we train two specialist policies: (1) wide-only: episodes contain only 10 wide workflows. (2) LongCP-only: episodes contain only 10 LongCP workflows. Training hyperparameters. All agents use the same PPO configuration: 2,000,000 total timesteps with 10 parallel environments, batch size 2560 (256 steps per environment), 4 minibatches, 4 update epochs per batch, learning rate 2.5 × 10−4 , GAE with 𝛾 = 0.99 and 𝜆 = 0.95, and clip coefficient 0.2. 4.1.2
Evaluation Protocol.
In-distribution and cross-topology evaluations. For each trained agent, we evaluate under all combinations of: • training topology: wide-only vs. LongCP-only.,
• test topology: wide vs. LongCP, • host regime: HS, HP, AL, NA. This produces in-distribution conditions (e.g., wide-trained agent on wide workflows) as well as cross-topology conditions (e.g., wide-trained agent on LongCP workflows), under each host regime. Metrics. For every configuration we report: • average makespan per workflow. • average active energy per workflow; • the empirical Pareto relationship between energy and makespan across different agents and baselines. 4.2
Results and Analysis
4.2.1 Results. Table 1 summarizes cross-domain performance of the wide and LongCP heterogeneous specialists across the HS, HP, AL, and NA host configurations. Homogeneous-Speed (HS) All VMs have the same speed, so makespan is driven by DAG topology and keeping the critical path busy. Both specialists match makespan on their evaluation domains (2.08 on LongCP, 0.70 on wide). The wide specialist uses less active energy in both domains (51.00 vs 52.87 on LongCP, 57.11 vs 58.92 on wide). This means the wide specialist wins on energy while maintaining the same makespan, even when tested on LongCP configurations where it was never trained. The reason is that training on wide parallel structures teaches the agent to spread work efficiently across VMs with different power profiles. Homogeneous-Power (HP) All VMs share the same power, but speeds vary from 160 to 800 GIPS. Energy becomes timedriven. The LongCP specialist is faster on both domains (3.48 vs 3.62 on LongCP, 1.26 vs 1.27 on wide). Energy is essentially tied on LongCP (21.76 vs 21.76) and on wide (24.33 vs 24.34). This happens because training on long dependency chains teaches the agent to prioritize critical path optimization and assign important tasks to faster VMs. When power is fixed, this speed-aware scheduling becomes the dominant factor for both makespan and energy. The wide specialist, trained on more parallel structures, learns a more exploratory policy that spreads work broadly but misses the structured prioritization that matters when speed varies.
Heterogeneous Aligned (AL) Speed and power are aligned: faster VMs are more energy-efficient. Using the same speed distribution as HP and NA, the wide specialist dominates on both time and energy in both domains: LongCP eval 4.05 vs 4.07 makespan and 50.91 vs 51.58 energy, wide eval 1.37 vs 1.39 makespan and 56.98 vs 58.31 energy. When speed aligns with efficiency, the wide policy’s tendency to keep more work on faster machines helps both makespan and energy.
Heterogeneous Non-Aligned (NA) Fast VMs are power-hungry and slow VMs are efficient. Using the same speed distribution, a real tradeoff appears. On LongCP eval, LongCP is faster (3.04 vs 3.14) while wide uses less energy (50.87 vs 52.34). On wide eval, LongCP is slightly faster (1.17 vs 1.18) and higher energy (58.45 vs 56.72).
Table 1. Cross-domain evaluation of heterogeneous agents across host configurations. Best results for each evaluation domain within a host configuration are in bold. Makespan
Active Energy
HS host configuration HS LongCP LongCP HS wide LongCP HS LongCP wide HS wide wide
2.08 2.08 0.70 0.70
52.87 51.00 58.92 57.11
HP host configuration HP LongCP LongCP HP wide LongCP HP LongCP wide HP wide wide
3.48 3.62 1.26 1.27
21.76 21.76 24.34 24.34
AL host configuration AL LongCP LongCP AL wide LongCP AL LongCP wide AL wide wide
4.07 4.05 1.39 1.37
51.58 50.91 58.31 56.98
NA host configuration NA LongCP LongCP NA wide LongCP NA LongCP wide NA wide wide
3.04 3.14 1.17 1.18
52.34 50.87 58.45 56.72
Host cfg
Method
Eval Domain
Figure 6 confirms the headline trade-offs: the LongCP specialist tends to dominate the lowmakespan region, while the wide specialist tends to dominate the low-energy region. This mirrors the averages and shows the biases across the whole distribution.
Fig. 6. Empirical attainment functions (EAFs) over 100 test jobs for the wide and LongCP specialists on the wide configuration (top) and the LongCP configuration (bottom). Each panel shows the distribution of the trade-off between normalized makespan (x-axis) and normalized active energy (y-axis), with color indicating the attainment level 𝛼 and black contours marking 𝛼 ∈ {0.5, 0.75, 0.9}.
The diagnostic referenced earlier now appears in Figure 7. Panel (a) (AL, Long-CP) shows near-perfect coupling (𝑟 =0.993): makespan and active energy move almost linearly together. Panel (b) (AL, wide) remains strongly coupled (𝑟 =0.953), though with a slightly wider band. Now , under NA, the link weakens: panel (c) (NA, Long-CP) shows only moderate correlation with substantial spread (𝑟 =0.493), while panel (d) (NA, wide) is stronger but still looser than AL (𝑟 =0.823) and exhibits more variance at lower makespans. AL creates a strong link between time and energy, so improving one usually improves the other. NA loosens this connection, especially for Long CP workflows, allowing real trade offs between time and energy. This pattern also shows up in the EAFs: under NA, different specialists dominate different parts of the frontier, rather than a single agent leading everywhere
Fig. 7. Correlation between makespan and active energy across Pareto checkpoints for AL (top row) and NA (bottom row), with LongCP and wide specialists.
Fig. 8. Panels: a) Active energy, case NA; b) Active energy, case AL; c) Makespan, case NA; d) Makespan, case AL.
These patterns raise a natural question: why do two agents trained with the same mixed objective end up with such different preferences over time and energy? The answer lies in how DAG topology shapes which states the agent visits during training. Let 𝜋 be a policy over observations 𝑠 (task requirements and readiness, VM utilization, energy rate features), and let 𝑑𝜋 (𝑠) denote its state occupancy measure. Both agents are trained with the same mixed objective described in Section 2.1: 𝐽 (𝜋) = 𝛼 E[𝐸 active ] + 𝛽 E[Makespan],
𝛼, 𝛽 > 0,
but they visit different parts of the state space because of their training DAGs. Figure 9 shows how this works. The x-axis shows a parallelism index (normalized ready tasks per level / DAG width) and the y-axis shows an energy intensity index (aggregate active power rate while busy).
Fig. 9. State visitation under a fixed mixed objective and non-aligned speed–power. (a) Conceptual state-space diagram with anti-aligned red (makespan) and blue (energy) descent directions, plus an inset showing non-aligned host speed–power. (b) Long Critical Path (LongCP) training: KDE contours and rollouts concentrate in high-parallelism regions. (c) wide DAG training: visitation shifts toward lowerparallelism states.
Crucially, both agents optimize the same 𝐽 (𝜋). The difference is that DAG topology changes which states are reachable and frequently visited. Long critical paths (Panel 9b) compress the feasible manifold toward low parallelism, so 𝑑𝜋 places more mass in low-parallelism regions where energy-reducing choices matter. wide DAGs (Panel 9c) expand the feasible trajectory set T (DAG, hosts) in parallel directions, so 𝑑𝜋 shifts toward high-parallelism states where timereducing choices are available. Structure rotates which parts of the trade-off surface are accessible during training.
Figure 8 provides additional evidence by showing how the learned value landscapes change with actor parameters during training. In the aligned case (AL), both makespan and energy gradients point in similar directions because faster VMs also consume less power. In the non-aligned case (NA), the optimal regions for makespan and active energy need not coincide: improving one does not necessarily improve the other, and the two objectives can favor different parts of parameter space. This reflects the different biases learned from different 𝑑𝜋 (𝑠) patterns. This explains the cross-evaluation results in Table 1. When the LongCP specialist is tested on wide configurations, it still tries to minimize makespan. When the wide specialist is tested on LongCP configurations, it still tries to minimize energy because that’s what it learned to prioritize when it had choices. Neither strategy is wrong, they just learned different priorities from different training distributions. The DAG topology during training fundamentally shapes which features the policy learns to care about, even when the objective function stays the same. Policy gradients are weighted by 𝑑𝜋 (𝑠), so topology and host regime determine which features and transitions are emphasized during learning. This is the regime where domain-specific training matters most: choosing the right specialist depends on whether the deployment prioritizes time or energy. 5
Conclusion
The challenge of efficiently scheduling complex, dependency-driven workflows in modern cloud environments requires balancing completion time (makespan) against energy consumption. Deep Reinforcement Learning (deep RL) schedulers with Graph Neural Network (GNN) backbones are a promising alternative to classical heuristics, but their robustness and generalization across workflow structures and hardware regimes remain open questions. In this work, we addressed this by constructing a controlled benchmark that factorizes the problem into two contrasting DAG topologies : wide Parallel and Long Critical Path (LongCP) , and four host regimes: Homogeneous Speed (HS), Homogeneous Power (HP), Aligned (AL), and Non-Aligned (NA). By training specialized agents and subjecting them to systematic cross-topology and cross-regime evaluation, we have successfully answered the two research questions posed in Section 1 and made several key contributions to the understanding of learned cloud scheduling: Our study shows that DAG topology and host regime shape what deep RL schedulers actually learn to prioritize, even under the same energy–makespan objective. With homogeneous speed (HS), makespan is the same across specialists on each domain, and the wide specialist consistently uses less active energy while matching time. With homogeneous power (HP), the LongCP specialist is faster on both domains. In the aligned regime (AL), where faster machines are also more efficient, the wide specialist wins on both makespan and energy across both domains. In the non-aligned regime (NA), a real tradeoff appears: LongCP achieves better makespan while wide achieves lower
energy. In brief, there is no single best specialist. Each policy acts like a regime-specific heuristic: LongCP pushes time down via critical-path focus, wide reduces energy by distributing work, and the preferred choice depends on the deployment’s speed–power correlation. This structural and regime dependence matters for production. A single agent will not cover all workflows and hardware. Different combinations call for different strategies. LongCP works well when power is uniform or aligned with speed because it focuses on the critical path. wide saves energy when power favors spreading work because it uses parallelism and load distribution. Knowing which structures and power relations each specialist exploits helps predict performance and pick the right policy. It also guides data curation for a larger agent by telling us which jobs to include so the training mix matches the target regimes. This opens clear next steps. We should identify which graph features and hardware traits the agents attend to using attribution on actions or embeddings. This will improve interpretability and help predict transfer. We should also test domain agnostic training such as meta learning or domain randomization that pushes the agent to learn features that hold across topologies and host regimes, aiming for a single robust policy that adapts at run time. Finally, our study only looked at a single workflow with no queue. Real systems are more complex. They run many workflows at once and must deal with contention and priorities. Extending this analysis to a queue based setting is essential. In that case, DAG topology, system load, and hardware heterogeneity will interact in new ways. A critical-path policy may behave differently when multiple long chains compete for the same fast machines. A parallelism-aware policy may struggle when the queue is deep and spreading work increases wait times, or excel when speed heterogeneity allows better load balancing. The results here show why both topology and hardware regime matter and provide a solid foundation for studying these more realistic scenarios. Understanding how learned scheduling strategies depend on workflow topology and power-speed correlations is the first step toward building robust, topology-aware and regime-aware systems that can handle the full complexity of production cloud environments.
References [1] Karan Ajmera and T. K. Tewari. 2024. A systematic literature review on contemporary and future trends in virtual machine scheduling techniques in cloud and multi-access computing. Frontiers in Computer Science 6 (2024). doi:10.3389/fcomp.2024.1288552 [2] Hamid Arabnejad and Jorge G. Barbosa. 2014. List Scheduling Algorithm for Heterogeneous Systems by an Optimistic Cost Table. IEEE Transactions on Parallel and Distributed Systems 25, 3 (2014), 682–694. [3] Anton Beloglazov and Rajkumar Buyya. 2012. Optimal Online Deterministic Algorithms and Adaptive Heuristics for Energy and Performance Efficient Dynamic Consolidation of Virtual Machines in Cloud Data Centers. Concurrency and Computation (2012).
[4] Anton Beloglazov and Rajkumar Buyya. 2012. Optimal online deterministic algorithms and adaptive heuristics for energy and performance efficient dynamic consolidation of virtual machines in cloud data centers. Concurrency and Computation (2012). [5] Yoshua Bengio and Yann LeCun. 2007. Scaling Learning Algorithms Towards AI. In Large Scale Kernel Machines. MIT Press. [6] Luiz Fernando Bittencourt and Edmundo Roberto Mauro Madeira. 2018. HCOC: A cost optimization algorithm for workflow scheduling in hybrid clouds. IEEE Transactions on Cloud Computing 6, 3 (2018), 649–662. [7] Shaileshh Bojja, Hongzi Mao, Malte Schwarzkopf, and Mohammad Alizadeh. 2019. Learning Graph-based Cluster Scheduling Algorithms. ACM SIGCOMM Computer Communication Review (2019). [8] Rodrigo Calheiros et al. 2011. CloudSim: A toolkit for modeling and simulation of cloud computing environments. Software: Practice and Experience (2011). [9] Sunera Chandrasiri and Dulani Meedeniya. 2025. Energy-efficient dynamic workflow scheduling in cloud environments using deep learning. Sensors 25, 5 (2025), 1428. [10] Eli Cortez, Anand Bonde, Alexandre Muzio, Mark Russinovich, Marcus Fontoura, and Ricardo Bianchini. 2017. Resource Central: Understanding and Predicting Workloads for Improved Resource Management in Large Cloud Platforms. In Proceedings of the 26th Symposium on Operating Systems Principles. 153–167. [11] Daniel G. da Silva and Luiz Fernando Bittencourt. 2017. Learning-based workflow scheduling in cloud computing: A survey. Journal of Cloud Computing 6, 1 (2017), 1–20. [12] Rafael Ferreira da Silva, Henri Casanova, Mats Rynge, Karan Vahi, Ewa Deelman, et al. 2020. A Community Framework for Enabling Scientific Workflow Research and Development. arXiv preprint arXiv:2009.00250 (2020). https://arxiv.org/abs/2009.00250 [13] Ewa Deelman, Dennis Gannon, Matthew Shields, and Ian Taylor. 2009. Workflows and e-Science: An overview of workflow system features and capabilities. Future Generation Computer Systems 25, 5 (2009), 528–540. [14] Ewa Deelman, Karan Vahi, Gideon Juve, Mats Rynge, Scott Callaghan, Philip J. Maechling, Rajiv Mayani, Weiwei Chen, Rafael Ferreira da Silva, Miron Livny, et al. 2015. Pegasus, a Workflow Management System for Science. Future Generation Computer Systems 46 (2015), 17–35. doi:10.1016/j.future.2014.10.008 [15] Juan J. Durillo and Radu Prodan. 2014. Multi-objective Workflow Scheduling in Amazon EC2. In Cluster Computing, Vol. 17. 169–189. [from the Wiley survey] 2023)]EnergyWorkflowSurvey2023 [Authors from the Wiley survey]. 2023. A survey on energyefficient workflow scheduling algorithms in cloud computing environment. Software: Practice and Experience (2023). doi:10.1002/spe.3292 [17] Ian Goodfellow, Yoshua Bengio, Aaron Courville, and Yoshua Bengio. 2016. Deep learning. Vol. 1. MIT Press. [18] Google. 2016. Machine Learning Applications for Data Center Optimization. Technical Report. Google. https: //deepmind.google/discover/blog/deepmind-ai-reduces-google-data-centre-cooling-bill-by-40/ DeepMind AI Reduces Google Data Centre Cooling Bill by 40%. [19] R. L. Graham et al. 1979. Optimization and Approximation in Deterministic Sequencing and Scheduling: a Survey. Annals of Discrete Mathematics (1979). [20] Zhaochen Gu, Sihai Tang, Beilei Jiang, Song Huang, Qiang Guan, and Song Fu. 2021. Characterizing Job-Task Dependency in Cloud Workloads Using Graph Learning. In 2021 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW). 288–297. doi:10.1109/IPDPSW52791.2021.00052 [21] Anas Hattay, Fred Ngole Mboula, Eric Gascard, and Zakaria Yahouni. 2024. Evaluating energy-aware cloud task scheduling techniques: A comprehensive dialectical approach. In 2024 IEEE/ACM 17th International Conference on
Utility and Cloud Computing (UCC). IEEE, 109–118. [22] Geoffrey E. Hinton, Simon Osindero, and Yee Whye Teh. 2006. A Fast Learning Algorithm for Deep Belief Nets. Neural Computation 18 (2006), 1527–1554. [23] Biao Hu, Xincheng Yang, and Mingguo Zhao. 2023. Online energy-efficient scheduling of DAG tasks on heterogeneous embedded platforms. Journal of Systems Architecture 140 (2023), 102894. [24] International Energy Agency. 2025. Data Centres and Data Transmission Networks. Technical Report. IEA. https://www.iea.org/energy-system/buildings/data-centres-and-data-transmission-networks [25] Thomas N. Kipf and Max Welling. 2017. Semi-Supervised Classification with Graph Convolutional Networks. In ICLR. [26] Vijay R. Konda and John N. Tsitsiklis. 1999. Actor-Critic Algorithms. In Advances in Neural Information Processing Systems, Vol. 12. [27] Hongzi Mao, Mohammad Alizadeh, Ishai Menache, and Srikanth Kandula. 2016. Resource management with deep reinforcement learning. In Proceedings of the 15th ACM Workshop on Hot Topics in Networks. 50–56. [28] Hongzi Mao, Malte Schwarzkopf, Shaileshh Bojja Venkatakrishnan, Zili Meng, and Mohammad Alizadeh. 2019. Learning Scheduling Algorithms for Data Processing Clusters. In ACM SIGCOMM. 270–288. [29] Mingwei Mao and Marty Humphrey. 2012. A survey of dynamic resource management in cloud computing. IEEE Communications Surveys & Tutorials 14, 4 (2012), 1101–1117. [30] Volodymyr Mnih, Adrià Puigdomènech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. 2016. Asynchronous Methods for Deep Reinforcement Learning. In Proceedings of the 33rd International Conference on Machine Learning (ICML, Vol. 48). 1928–1937. [31] Junyoung Park, Jaehyeong Chun, Sang Hun Kim, Youngkook Kim, and Jinkyoo Park. 2021. Learning to schedule job-shop problems: representation and policy learning using graph neural network and reinforcement learning. International journal of production research 59, 11 (2021), 3360–3377. [32] Michael Pinedo. 2012. Scheduling: Theory, Algorithms, and Systems. Springer. [33] Karl Popper. 2005. The logic of scientific discovery. Routledge. [34] Barry Rountree, David K. Lownenthal, Bronis R. de Supinski, Martin Schulz, Vincent W. Freeh, and Tyler Bletsch. 2009. Adagio: Making DVS Practical for Complex HPC Applications. ACM International Conference on Supercomputing (2009), 460–469. [35] Rizos Sakellariou, Henan Zhao, and Ewa Deelman. 2010. Mapping workflows on grid resources: Experiments with the montage workflow. In Grids, P2P and services computing. Springer, 119–132. [36] John Schulman et al. 2016. High-Dimensional Continuous Control Using Generalized Advantage Estimation. In ICLR. [37] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. 2017. Proximal Policy Optimization Algorithms. arXiv preprint arXiv:1707.06347 (2017). [38] Mohammad Shahrad, Rodrigo Fonseca, Íñigo Goiri, Gohar Chaudhry, Paul Batum, Jason Cooke, Eduardo Laureano, Colby Tresness, Mark Russinovich, and Ricardo Bianchini. 2020. Serverless in the Wild: Characterizing and Optimizing the Serverless Workload at a Large Cloud Provider. In 2020 USENIX Annual Technical Conference. 205–218. [39] S&P Global Commodity Insights. 2025. Global data center power demand to double by 2030 on AI. https: //www.spglobal.com/energy/. Accessed: 2025-12-10. [40] Richard S Sutton, Andrew G Barto, et al. 1998. Reinforcement learning: An introduction. Vol. 1. MIT press Cambridge.
[41] Ian J Taylor, Ewa Deelman, Dennis B Gannon, and Matthew Shields. 2014. Workflows for e-Science: Scientific Workflows for Grids. Springer. [42] Huangshi Tian, Yunchuan Zheng, and Wei Wang. 2019. Characterizing and Synthesizing Task Dependencies of Data-Parallel Jobs in Alibaba Cloud. In Proceedings of the ACM Symposium on Cloud Computing (SoCC). doi:10. 1145/3357223.3362710 [43] Haluk Topcuoglu, Salim Hariri, and Min-You Wu. 2002. Performance-Effective and Low-Complexity Task Scheduling for Heterogeneous Computing. IEEE Transactions on Parallel and Distributed Systems 13, 3 (2002), 260–274. [44] Laurens Versluis and Alexandru Iosup. 2020. A Survey and Annotated Bibliography of Workflow Scheduling in Computing Infrastructures: Community, Keyword, and Article Reviews. arXiv preprint arXiv:2004.10077 (2020). [45] Qitian Wu, Hengrui Zhang, Junchi Yan, and David Wipf. 2022. Handling Distribution Shifts on Graphs: An Invariance Perspective. In International Conference on Learning Representations (ICLR). [46] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. 2019. How Powerful are Graph Neural Networks?. In International Conference on Learning Representations (ICLR). [47] Kaixiang Zhang, Wenbo Li, Kai Zhang, Zenglin Li, and Zhaohui Qin. 2021. DeepJS: Job-shop scheduling with deep reinforcement learning. IEEE Transactions on Industrial Informatics 17, 3 (2021), 2083–2093. [48] Eckart Zitzler, Lothar Thiele, Marco Laumanns, Carlos M Fonseca, and Viviane Grunert da Fonseca. 2003. Performance assessment of multiobjective optimizers: An analysis and review. IEEE Transactions on Evolutionary Computation 7, 2 (2003), 117–132. [49] Zhiling Zong, Adam Manzanares, Xiaojun Ruan, and Xiao Qin. 2007. EAD and PEBD: Two Energy-Aware Duplication Scheduling Algorithms for Parallel Tasks on Homogeneous Clusters. 56, 12 (2007), 1661–1675.