Hybrid Energy-Aware Ranking and Optimization

Abstract

The increase in delay-sensitive application tasks requires heterogeneous edge clusters to maintain low online latency and energy efficiency without relying on rigid scheduling policies. To address this, we propose HERO (Hybrid Energy-aware Ranking and Optimization), a lightweight collaborative scheduling framework. HERO utilizes a perturbation-based communication-aware multi-layer perceptron (MLP) predictor to quantify global time sensitivity and discover latent time slack in non-critical paths. A hybrid budget mechanism then converts this slack into customized DVFS decisions. These decisions are based on the inherent computational load and topological criticality to optimize energy consumption. A communication-aware hole-filling strategy dynamically recovers sporadic idle times fragmented by heterogeneous communication overhead. Extensive simulations were conducted across varying DAG depths, parallelism levels, and system utilizations. Compared to state-of-the-art algorithms (NSGA-II, SSA, TOM, and DPMC), HERO reduced the completion time by an average of 10.89% under high-density topologies, and achieved up to 4.04% energy savings across varying task depths.

1. Introduction

Multi-access Edge Computing (MEC) has emerged as a critical infrastructure for latency-sensitive applications in the 5G/6G and IoT era [1,2]. To process complex Deep Neural Network (DNN) inferences, edge computing is shifting towards multi-node heterogeneous clusters that collaborate via task offloading [3,4]. However, edge servers exhibit significant differences in computing capabilities and face strict battery capacity or Thermal Design Power (TDP) constraints [5,6]. Achieving the joint optimization of millisecond-level real-time response (makespan) and total system energy consumption in such heterogeneous and dynamic environments has become a highly challenging NP-hard bi-objective scheduling problem [7,8].

To tackle this problem, edge computational workloads are typically modeled as complex Directed Acyclic Graphs (DAGs) to capture fine-grained dependencies and strict millisecond-level deadlines. Although academia has proposed various advanced DAG scheduling strategies, severe challenges remain in resource-constrained and highly dynamic edge environments. First, evolutionary algorithms, such as NSGA-II [1], rely on heavy iterative searches. Consequently, they incur excessively high online scheduling latency. Second, existing deep reinforcement learning-based algorithms (such as SSA-DAG) [9,10,11] often exhibit a “performance-heavy, energy-light” tendency, lacking proactive energy budget planning. More crucially, they typically treat edge weights as static features. This makes it difficult to capture the condition-triggered characteristics of communication overheads in heterogeneous clusters. As a result, they fail to accurately identify the true system bottlenecks. Finally, dedicated algorithms based on specific structures or mixed criticality (such as TOM and DPMC) [12,13,14] usually adopt pessimistic resource reservation or rigid slack allocation strategies. They ignore differences in the intrinsic computational workloads of individual tasks. Therefore, they are highly prone to over-scaling the frequency of heavy-workload tasks on non-critical paths, thereby creating new system bottlenecks.

To address the aforementioned pain points, this paper proposes a lightweight and efficient collaborative scheduling framework: HERO (Hybrid Energy-aware Ranking and Optimization). This framework constructs a “perception–decision–compensation” closed-loop optimization system, aiming to break the limitations of traditional static heuristic and greedy learning strategies. The main contributions of this paper are summarized as follows:

• Establishment of a Communication-Aware Sensitivity Quantification Model: We propose a perturbation-based mechanism to quantify the marginal effect of task execution fluctuations on the global makespan, accurately stripping away pseudo-critical paths.
• Hybrid Budget Allocation: We design a multi-factor energy arbitration mechanism that balances critical path progression with the resource needs of heavy-load tasks on non-critical paths.
• Time Fragment Recovery Mechanism: We introduce an aggressive hole-filling strategy to reclaim discrete idle time slots induced by heterogeneous communication overheads.
• Performance Validation: Extensive experiments on a diverse testbed (Raspberry Pi 4, Jetson Orin Nano, and Xeon D) demonstrate that HERO reduced the completion time by an average of 10.89% under high-density topologies, and achieved up to 4.04% energy savings across varying task depths.

The remainder of this paper is organized as follows. Section 2 reviews the related work. Section 3 formalizes the system and communication models, alongside the bi-objective optimization problem. Section 4 elaborates on the detailed design of the proposed HERO framework. Section 5 presents the experimental setup, comparative results, and performance evaluation. Finally, Section 6 concludes the paper.

2. Related Work

Directed Acyclic Graph (DAG) task scheduling and offloading in heterogeneous edge environments is a relatively classical NP-hard problem. As summarized in

Table 1. Comprehensive Feature Comparison of Existing Task Scheduling Strategies and the Proposed HERO Framework.

Category	Ref. & Method	Optimization Objectives	Energy Strategy	Communication Overhead Handling
Heuristic &Evolutionary Algorithms	Li et al. [1]	Makespan, Energy	Standard DVFS	Static transmission assumption
	Jiang et al. [7]	Energy, Delay	DVFS auto-adjustment	Partially considered
	Zhang et al. [12]	Performance, Service Quality	Dynamic DVFS	Not strictly prioritized
	Liu et al. [15]	Reliability, Energy	Standard DVFS	Redundancy-based
	Biswas et al. [8]	Reliability, Energy	Fast DVFS switching	Static bounds
	Zhang et al. [16]	Makespan, Fault-tolerance	None (Re-execution)	Unpredictable failure status
	Taghinezhad-Niar [5]	Cost, Energy, Deadline	Energy-constrained	Edge-cloud congestion modeled
DRL & Intelligent Scheduling	Drag-JDEC [9]	Makespan, QoS	None	GNN feature extraction
	Cao et al. [3]	Makespan	None	GAT-based dependency
	Sun et al. [17]	DAG Width, Deadline	None	Edge generation representation
	Song et al. [18]	Energy, Makespan	Transmit power & CPU freq.	Attention-based feature
	GA-DRL [19]	Makespan, Timeliness	None	Topology two-way aggregation
	DVTP [11]	Makespan	None	Spatiotemporal representation
	Ding et al. [20]	Latency, Energy	Charging time trade-off	Dynamic environment-aware
	LACHESIS [10]	Completion time	None	Topological perception
Structure-Aware & Specific Strategies	Zhao et al. [21]	Execution time	None	Wireless interference
	LOU [22]	Latency, Cost	Strict Constraints	Dependency-aware
	Zhou et al. [2]	Latency, Energy, Gain	End-device frequency	Soft cooperation (Data sharing)
	He et al. [6]	Makespan, Queue stability	None	Cross-slot queue (Lyapunov)
	Gao et al. [13]	Makespan	None	Pre-calculated node priority
	Wang et al. [14]	Worst-case latency	None	1-Opt Local Search path
	DoSRA [4]	Efficiency, Delay	None	Decentralized provision
	OPSA [23]	Processor utilization	None	Parallelism limitation
Proposed	HERO (Ours)	Makespan, Energy	Preventive-bottleneck budget	Aggressive hole-filling strategy

, existing solutions can generally be divided into three categories: heuristic and evolutionary algorithms, deep learning-based intelligent scheduling, and structure-aware specific offloading strategies.

2.1. Heuristic and Evolutionary Algorithms

Due to the heterogeneity of edge environments, multi-objective evolutionary and heuristic algorithms are widely adopted to address the trade-offs between latency, energy consumption, and system reliability [1,5,7,8,12,15,16]. While these methods excel in finding Pareto-optimal solutions or ensuring fault tolerance, they face severe challenges in real-time edge collaboration scenarios. Algorithms represented by NSGA-II rely on heavy population iteration and mutation processes, resulting in scheduling delays that are too high to meet the millisecond-level response requirements of intelligent edge services. Furthermore, their energy optimization methods often employ rigid strategies, allocating energy budgets solely based on time margins while ignoring intrinsic computational workload differences, which easily creates new system bottlenecks.

2.2. Intelligent Scheduling Based on Deep Reinforcement Learning

Schedulers based on Deep Reinforcement Learning (DRL) have become a research hotspot due to their environmental adaptability. Recent advancements frequently combine DRL with Graph Neural Networks (GNNs) or Transformers to capture complex DAG dependencies and optimize offloading decisions in highly dynamic environments [3,9,10,11,17,18,19,20].

While DRL methods perform well in finding high-quality solutions, deploying them on resource-constrained edge nodes remains challenging. The high-dimensional state encoding required by complex GNNs or Transformers introduces unacceptable millisecond-level inference latency for lightweight edge tasks. Additionally, as detailed in Table 1, existing DRL schedulers predominantly prioritize performance over energy consumption, lacking an active energy budget mechanism and often neglecting the critical impact of heterogeneous communication overheads on feature extraction.

2.3. Structure-Aware and Specific Offloading Strategies

Structure-aware and specific offloading strategies simplify the scheduling problem by exploiting DAG structural characteristics or predefined rules, such as service caching, 1-Opt local search, or decentralized game theory [2,4,6,13,14,21,22,23].

Although effective in specific use cases, these strategies lack generality. Chain-based optimizations make strong assumptions about the DAG’s shape, making it difficult to handle highly irregular edge workflows. Moreover, unlike the aggressive gap-filling strategy proposed in our HERO framework, these structured methods often struggle to flexibly recycle discrete idle time slots caused by heterogeneous communication, resulting in limited overall resource utilization.

3. System Model and Problem Description

To facilitate a clear understanding of the mathematical models presented in this section, the primary notations used throughout this paper are summarized in the table in the Abbreviations.

To provide a rigorous mathematical abstraction for the task scheduling problem in an edge collaborative environment, this section first defines an application model based on a DAG to depict the complex dependencies and heterogeneous computational workloads among tasks. Subsequently, the heterogeneous edge cluster architecture and communication model are constructed to quantify the heterogeneous transmission overhead incurred by cross-node collaboration. Furthermore, considering the resource-constrained nature of edge devices, a power and energy consumption model based on DVFS is introduced. Finally, building upon the aforementioned models, the joint optimization of latency and energy consumption is formulated as a constrained bi-objective optimization problem.

3.1. Application Model

We model the dependency-driven task flow—specifically the deep learning inference pipeline in an edge computing environment—as a DAG, as illustrated in Figure 1, and defined as

$$G=(\mathcal{V},E)$$

(1)

The vertex set $\mathcal{V}=\{v_1,v_2,\dots ,v_n\}$ represents the computational tasks, where each task $v_i$ has a computational load $w_i$. The set of directed edges E denotes task dependencies. A directed edge $e_{i,j}=(v_i,v_j)\in E$ indicates that $v_j$ cannot start until $v_i$ completes, involving a data transmission volume $d_{i,j}$ over a network with bandwidth B.

To quantitatively characterize the divergent requirements for computational resources and communication bandwidth across various DAG applications, we define the Communication-to-Computation Ratio (CCR) as the ratio of the average communication cost ${\overline{T}}_{\mathrm{comm}}$ to the average computational cost ${\overline{T}}_{\mathrm{comp}}$ of the entire graph:

$$\mathrm{CCR}={\displaystyle \frac{\frac{1}{\left|E\right|}{\sum }_{(v_i,v_j)\in E}\frac{d_{i,j}}{\overline{B}}}{\frac{1}{\left|\mathcal{V}\right|}{\sum }_{v_i\in \mathcal{V}}{\overline{t}}_i}}$$

(2)

where the numerator represents the average data transfer time across all dependency edges given the average bandwidth $\overline{B}$ within the heterogeneous edge cluster; the denominator represents the average execution time of all tasks. Due to system heterogeneity and Dynamic Voltage and Frequency Scaling (DVFS) capabilities, the execution time of task $v_i$ is not constant. Therefore, we define ${\overline{t}}_i$ as the expected execution time of task $v_i$ across all available physical configurations in the cluster $\mathcal{P}$:

$${\overline{t}}_i={\displaystyle \frac{1}{{\sum }_{p_k\in \mathcal{P}}\left|{\mathcal{F}}_k\right|}}\sum _{p_k\in \mathcal{P}}\sum _{f\in {\mathcal{F}}_k}{\displaystyle \frac{w_i}{s_k·f}}$$

(3)

In this formula, ${\mathcal{F}}_k$ is the set of available frequencies supported by server $p_k$, and $s_k$ is its architectural performance coefficient.

For any task $v_i$, we define $\mathrm{Pred}\left(v_i\right)$ as its set of direct predecessors and $\mathrm{Succ}\left(v_i\right)$ as its set of direct successors. To simplify the model, we assume G has a unique entry task $v_{\mathrm{entry}}$ and a unique exit task $v_{\mathrm{exit}}$. For practical workflows with multiple entries or exits, this can be unified by adding virtual nodes with zero computational load and zero communication overhead.

3.2. Architecture and Communication Model

We model the edge computing cluster as a set of M heterogeneous edge servers, denoted by $\mathcal{P}=\{p_1,p_2,\dots ,p_M\}$. Due to the diverse hardware architectures (CPU, GPU, or specialized accelerators) of the edge servers, significant disparities exist in their efficiency when processing the same task. In practical implementation, this cluster typically operates under a master–worker paradigm: one resource-sufficient node is designated as the master controller to maintain cluster state and handle scheduling logic, while the remaining heterogeneous devices act as worker nodes to execute dispatched tasks. For any task $v_i\in \mathcal{V}$, if it is assigned to processor $p_k\in \mathcal{P}$ and executed at a frequency $f_{i,k}$, its execution time $t_{i,k}$ is expressed as

$$t_{i,k}={\displaystyle \frac{w_i}{s_k·f_{i,k}}}$$

(4)

where $w_i$ represents the computational workload of the task, and $s_k$ denotes the architectural performance coefficient of server $p_k$, reflecting the processor’s Instructions Per Cycle (IPC) throughput per unit frequency.

Communication Cost Model: The communication overhead between tasks is determined by the data transmission volume and network bandwidth. Let B denote the average transmission bandwidth within the edge cluster. For a dependency edge $e_{i,j}$, if task $v_i$ is assigned to server $p_m$ and task $v_j$ is assigned to server $p_n$, the communication time $c_{i,j}$ is defined as

$$c_{i,j}=\left\{\begin{array}{cc}0,\hfill & \mathrm{if}m=n\hfill \\ {\displaystyle \frac{d_{i,j}}{B}},\hfill & \mathrm{if}m\ne n\hfill \end{array}\right.$$

(5)

When parent and child tasks are scheduled on the same processor, data is exchanged via shared memory; thus, the communication overhead is considered to be zero.

3.3. Power and Energy Consumption Model

To support energy-efficiency optimization, we assume that each edge server supports Dynamic Voltage and Frequency Scaling (DVFS) technology.

DVFS Frequency Set: For each server $p_k$, the processor supports a set of discrete voltage–frequency pairs. The available frequency set for $p_k$ is defined as ${\mathcal{F}}_k=\{f_{k,1},f_{k,2},\dots ,f_{k,\max }\}$, where $f_{k,\max }$ is the maximum clock frequency of the processor.

Following widely adopted dynamic voltage and frequency scaling (DVFS) power models, the instantaneous power $P_k\left(f\right)$ of edge server $p_k$ operating at frequency f is modeled according to the well-known Cubic Law:

$$P_k\left(f\right)=P_k^{\mathrm{stat}}+{\xi }_k·f^3$$

(6)

where $P_k^{\mathrm{stat}}$ is the static baseline power, and ${\xi }_k$ is a hardware-specific constant reflecting the processor’s capacitive characteristics.

The total system energy consumption $E_{\mathrm{total}}$ is the sum of the energy consumed during task execution and the energy consumed during idle periods. For task $v_i$ running on server $p_k$ at frequency $f_{i,k}$, its execution energy is defined as

$$E_i^{\mathrm{exec}}=P_k\left(f_{i,k}\right)\times t_{i,k}=\left(P_k^{\mathrm{stat}}+{\xi }_k·f_{i,k}^3\right)\times {\displaystyle \frac{w_i}{s_k·f_{i,k}}}$$

(7)

The objective function for the total energy consumption of the entire edge cluster during the scheduling cycle is

$$\mathrm{Minimize}:E_{\mathrm{total}}=\sum _{v_i\in \mathcal{V}}{E}_i^{\mathrm{exec}}+\sum _{p_k\in \mathcal{P}}{P}_k^{\mathrm{stat}}\times T_{\mathrm{idle},k}$$

(8)

where $T_{\mathrm{idle},k}$ is the idle wait time of server $p_k$.

3.4. Formal Problem Description

The scheduling of DAG tasks in a heterogeneous edge environment is formulated as finding an optimal mapping of tasks to processors, determining their execution sequence, and allocating operating frequencies. For any task $v_i$ assigned to processor $p_k$, its timing constraints are governed by the completion status of its predecessors and the resource availability of the assigned processor.

Following standard task scheduling semantics, the Data Ready Time (DRT), Earliest Start Time (EST), and Earliest Finish Time (EFT) for a task $v_i$ on processor $p_k$ are calculated recursively:

$$\mathrm{DRT}(v_i,p_k)=\underset{v_j\in \mathrm{Pred}\left(v_i\right)}{max}\{\mathrm{AFT}\left(v_j\right)+c_{j,i}\}$$

(9)

$$\mathrm{EST}(v_i,p_k)=max\left(\mathrm{Avail}\left(p_k\right),\mathrm{DRT}(v_i,p_k)\right)$$

(10)

$$\mathrm{EFT}(v_i,p_k)=\mathrm{EST}(v_i,p_k)+t_{i,k}$$

(11)

where $\mathrm{AFT}\left(v_j\right)$ denotes the actual finish time of predecessor $v_j$, and $\mathrm{Avail}\left(p_k\right)$ is the earliest time at which $p_k$ becomes ready to execute a new task.

The primary objective of this study is to address a bi-objective optimization problem: minimizing the application makespan while simultaneously reducing total system energy consumption.

The makespan minimization aims to minimize the completion time of the entire application, which is determined by the actual finish time of the exit task $v_{\mathrm{exit}}$:

$$min{T}_{\mathrm{makespan}}=\mathrm{AFT}\left(v_{\mathrm{exit}}\right)$$

(12)

The total energy minimization aims to minimize the total energy consumption, which includes the dynamic execution energy of all tasks and the static energy consumed during idle periods:

$$min{E}_{\mathrm{total}}=\sum _{v_i\in \mathcal{V}}{E}_i^{\mathrm{exec}}+\sum _{p_k\in \mathcal{P}}{P}_k^{\mathrm{stat}}\times T_{\mathrm{idle},k}$$

(13)

Given a DAG G and a heterogeneous cluster $\mathcal{P}$, the goal is to identify an optimal scheduling strategy $\mathcal{S}=(\mathcal{M},\mathcal{O},\mathcal{F})$—where $\mathcal{M}$ is the task-to-processor mapping, $\mathcal{O}$ is the execution order, and $\mathcal{F}$ is the frequency allocation—that minimizes the objective vector:

$$\underset{\mathcal{S}}{min}\mathcal{J}\left(\mathcal{S}\right)=\left(T_{\mathrm{makespan}}\left(\mathcal{S}\right),E_{\mathrm{total}}\left(\mathcal{S}\right)\right)$$

(14)

4. HERO Framework Design

This chapter will elaborate on the design details of the HERO framework. The framework comprises two core phases: communication-aware priority learning and bottleneck-aware resource allocation.

4.1. Framework Overview

As shown in Figure 2 and Algorithm 1, HERO establishes a closed-loop identify–utilize–reclaim cascade process. In the identification phase, an MLP predictor is used to unravel complex dependencies and isolate exploitable time redundancy. In the utilization phase, we exploit this time redundancy through a hybrid budgeting mechanism. This mechanism converts non-critical time slack into energy efficiency via DVFS. This conversion leads to scheduling fragmentation. Finally, the reclaim phase acts as a compensator by employing a hole-filling strategy. This strategy recovers these fragmented gaps for small tasks, thereby maximizing resource density through compute–communication overlap.

From an implementation perspective, to ensure strict online real-time performance, the deep-enhanced MLP predictor is trained offline. During the online phase, the master controller only performs an $O\left(1\right)$ lightweight forward inference, strictly bounding the decision-making overhead to the microsecond level. The master then dispatches the parsed subtasks and specific DVFS frequency commands to designated worker nodes via lightweight remote procedure calls (e.g., gRPC), fully bridging the theoretical algorithm with practical edge orchestration.

Algorithm 1: HERO: Hybrid Energy-aware Ranking and Optimization

4.2. Task Ranking Based on Enhanced MLP

To extract nonlinear scheduling features from high-dimensional heterogeneous DAGs with low inference latency, HERO employs a Deep Enhanced Multilayer Perceptron (MLP).

4.2.1. DAG Feature Extraction

For each task $v_i$ in the DAG, we extract an 11-dimensional feature vector $x_i$, as detailed in

Table 2. The 11-dimensional feature vector for task representation.

Feature Categories	Feature Name	Specific Meaning
Computation & Communication	$w_i$	The task’s own computational load
	${\mathrm{Comm}}_{\max }$	Maximum data transfer weight of all output edges of the task
Static Priority Features	${\mathrm{Rank}}_{\mathrm{up}}$	Distance from the task to the exit node
	${\mathrm{Rank}}_{\mathrm{down}}$	Distance from task to the entry node
	${\mathrm{Level}}_{\mathrm{topo}}$	Task level depth in the DAG topological sorting
Graph Structure & Path	$d_{\mathrm{in}}$	In-degree of the task node
	$d_{\mathrm{out}}$	Out-degree of the task node
	$d_{\mathrm{tot}}$	Total degree of the task node
	$d_{\mathrm{diff}}$	The difference between in-degree and out-degree
	$T_{\mathrm{path}}$	Execution time of the critical path passing through the node
	$N_{\mathrm{path}}$	Number of paths from entry node to exit node passing through the node

. By encoding macro-level path criticality (e.g., $Ran{k}_{\mathrm{up}}$, $T_{\mathrm{path}}$) and micro-level topological attributes (e.g., $d_{\mathrm{in}}$, $Leve{l}_{\mathrm{topo}}$) into a unified linear vector space, this feature set effectively captures the topological integrity of the DAG.

4.2.2. Perturbation-Based Sensitivity Generation

In learning-based DAG scheduling research, obtaining high-quality supervision signals is a key bottleneck for model performance. Existing imitation learning methods typically use static priority sequences generated by heuristic algorithms (such as HEFT) as training labels. This approach has the limitation of locking the upper limit of model performance. To overcome this limitation, HERO proposes a perturbation-based sensitivity analysis mechanism. The model learns the global time sensitivity of each task—the extent to which local execution fluctuations of that task will degrade the completion time of the entire system.

We define a sensitivity label $y_i$ for task $v_i$ as the marginal effect of load variation on global completion time. As shown in Figure 3, for each instance G in the training set, the label generation process includes the following three standardized steps:

First, using a standard list scheduling algorithm (the HEFT algorithm is used in this paper) to schedule DAG G under the target heterogeneous cluster configuration, a baseline scheduling scheme $S_{\mathrm{base}}$ and its corresponding baseline completion time $T_{\mathrm{base}}$ are obtained:

$$T_{\mathrm{base}}=\mathrm{Schedule}(G,\mathrm{HEFT})$$

(15)

Then, for each task $v_i\in \mathcal{V}$ in the DAG, a perturbed instance $G_i^{\prime }$ is constructed. In $G_i^{\prime }$, we increase the worst-case execution time $w_i$ of task $v_i$ by a significant perturbation factor $\delta$ (in the experimental setup, $\delta =w_i$, i.e., simulating a doubling of the load):

$$w_i^{\prime }=w_i+\delta ,w_j^{\prime }=w_j(\forall j\ne i)$$

(16)

Subsequently, $G_i^{\prime }$ is re-evaluated using the same scheduling algorithm to obtain the perturbed completion time $T_i^{\prime }$.

Finally, the absolute impact of the delay of task $v_i$ on the system is $\Delta T_i=T_i^{\prime }-T_{\mathrm{base}}$. To eliminate the dimensional differences caused by different DAG sizes, we define the final training label $y_i$ as the normalized marginal deterioration rate:

$$y_i={\displaystyle \frac{T_i^{\prime }-T_{\mathrm{base}}}{T_{\mathrm{base}}}}$$

(17)

If $y_i>0$, it indicates that the task is in some form of bottleneck state, and the larger the value, the greater its impact on the system completion time. If $y_i\approx 0$, it indicates that the disturbance of the task is absorbed by the system’s parallel gaps or communication latency.

Through this mechanism, HERO’s MLP predictor learns the global time sensitivity of each task, enabling HERO to dynamically identify hidden bottlenecks masked by traditional static CCR metrics during the inference phase.

4.2.3. Model Design and Optimization Strategies

To address the challenges of high-dimensional non-linearity and sparsity inherent in DAG task scheduling features, we designed a deep funnel-like feature extraction network coupled with a robust training mechanism:

Funnel-like Network Architecture: To capture the implicit coupling among topological features (e.g., $Ran{k}_{\mathrm{up}}$ and communication overhead), we construct a five-layer descending network. Specifically, a funnel-shaped information bottleneck structure is utilized. Combined with batch normalization and ReLU activation functions in the first three layers, it can effectively filter out noise and distill high-level abstract features. A decaying Dropout strategy ($0.15\to 0.1\to 0.05$) is adopted to prevent structural overfitting while maintaining the stability of deep semantic representations.

Dynamic Optimization and Training Strategy: The model uses the Mean Squared Error (MSE) loss function to heavily penalize prediction deviations, forcing it to quickly lock onto key path nodes. The AdamW optimizer is selected to enhance generalization ability. We also integrate a ReduceLROnPlateau learning rate scheduler (halving the learning rate if validation loss stagnates for five consecutive epochs) and an early stopping mechanism (training stops if there is no improvement for 15 consecutive epochs).

4.2.4. Model Performance Analysis

To ensure the robustness of our model, we constructed a comprehensive dataset containing 100,000 DAG task samples. This dataset is randomly divided into a training set, validation set, and test set in a 90:5:5 ratio. As shown in Figure 4a, the training loss and validation loss converge rapidly and stabilize after approximately 30 epochs. The slight gap between the two curves indicates that no significant overfitting has occurred, demonstrating the effectiveness of batch normalization and the Dropout mechanism. Figure 4b shows the comparison between actual sensitivity and predicted values on the test set. The randomly selected 5000 data points are evenly distributed around the $y=x$ diagonal, indicating that the MLP can accurately predict the potential impact of tasks in heterogeneous environments.

We selected four classic regression models (linear regression, decision tree, random forest, XGBoost) to verify the necessity of deep learning, and conducted an ablation study (2-layer, 5-layer, and 12-layer MLPs) to justify the architectural depth of HERO-MLP. All models were trained on the same 11-dimensional features and evaluated using MSE, MAE, $R^2$, inference latency, and parameter count.

As shown in

Table 3. Model performance comparison against classic baselines.

Model	MSE	MAE	${\mathbf{R}}^2$
Linear Regression	0.018663	0.075654	0.1786
Decision Tree	0.017255	0.070981	0.2406
Random Forest	0.010575	0.055387	0.5346
XGBoost	0.010004	0.054553	0.5597

and

Table 4. Ablation study of MLP architectures on prediction accuracy and computational overhead.

Architecture	MSE	${\mathbf{R}}^2$	Latency (μs)	Parameters
Shallow-MLP (2-layer)	0.006224	0.690191	43.53	1537
HERO-MLP (5-layer)	0.005880	0.707295	199.09	50,049
Deep-MLP (12-layer)	0.006106	0.696074	254.53	2,638,849

, classic models fail to capture the complex non-linear relationships, with the best ensemble method (XGBoost) only reaching an $R^2$ of 0.5597. In the neural network ablation study, the five-layer HERO-MLP achieves the highest prediction accuracy ($R^2=0.707295$, MSE = 0.005880). Compared to a shallow two-layer MLP (limited feature extraction, $R^2=0.690191$) and a 12-layer MLP (where performance marginalization occurs due to increased complexity, $R^2=0.696074$), the five-layer HERO-MLP strikes the optimal balance. It delivers superior accuracy while maintaining an ultra-low inference latency (199.09 μs) and a compact parameter size (50,049), which is crucial for real-time edge scheduling.

4.2.5. Analysis of Key Node Identification Capability

To investigate the actual performance of the MLP in scheduling decisions, we designed a stress test to observe its ability to identify key nodes. Traditional heuristic list scheduling algorithms (such as the $Ran{k}_{\mathrm{u}}$ strategy in HEFT) primarily rely on static Communication-to-Computation Ratio (CCR) to construct task priorities. To verify whether the MLP predictor in the HERO framework truly learns a global bottleneck awareness capability beyond simple data memorization, we conducted a targeted evaluation.

The experiment was deployed in a heterogeneous computing environment containing two types of computing nodes: high-performance cores ($p_0$) with processing speed $s_k=6.0$, simulating the master computing node in an edge cluster, and medium-performance cores ($p_1$) with processing speed $s_k=2.0$, simulating auxiliary computing nodes or low-power cores.

To simulate stress load scenarios, we constructed a set of synthetic DAG datasets with bimodal distribution characteristics. This dataset contains two types of tasks with opposing properties:

• Computationally intensive isolated tasks (Type-C): High computational load with low communication overhead, representing potential “computational bottlenecks.”
• Communication-intensive coupled tasks (Type-D): Low computational load but requiring significant data transfer, representing “communication bottlenecks.”

Experimental results reveal the fundamental difference in scheduling decision logic between the benchmark algorithm ($Ran{k}_{\mathrm{u}}$) and the MLP, as shown in Figure 5. Faced with the substantial communication overhead generated by Type-D tasks, the $Ran{k}_{\mathrm{u}}$ algorithm schedules all such tasks to the high-performance core $p_0$ to eliminate cross-node data transmission latency. This locally greedy strategy leads to scarce $p_0$ resources being occupied by a large number of low-computation-value tasks. Consequently, when Type-C tasks—which truly determine the global completion time—arrive, they are relegated to the low-speed core $p_1$, ultimately deteriorating the total makespan.

In contrast, the MLP predictor, by learning global time sensitivity, successfully identifies that although Type-C tasks lack explicit communication constraints, their heavy computational burden constitutes the global critical path. Therefore, HERO assigns Type-C tasks a higher scheduling priority, allowing them to preempt the computational resources of $p_0$.

As shown in Figure 6, across test cases with different graph depths and parallelism, HERO’s normalized makespan consistently outperforms the benchmark. Particularly in deep graph structures (Depth $>8$), HERO’s average normalized makespan is 0.8468, achieving a performance improvement of approximately 15.3%; in high-concurrency scenarios (Layers $>8$), the average normalized makespan is 0.8479, an improvement of 15.2%. These results demonstrate that HERO possesses global bottleneck identification capabilities that surpass local greedy strategies, validating the model’s generalization effectiveness in extremely heterogeneous environments.

4.2.6. Model Interpretability and Microbehavior Analysis

Based on the importance analysis of permutation features, we verified the effectiveness of the HERO feature set and the nonlinear learning capability of deep MLPs (as shown in Figure 7). Experimental results show that computational load ($w_i$) and communication overhead ($Com{m}_{\max }$) have an absolutely dominant contribution to prediction accuracy, confirming the importance of communication overhead in cross-node data transmission in heterogeneous edge environments. Meanwhile, the model has high weights on the number of paths ($N_{\mathrm{path}}$) and the exit distance ($Ran{k}_{\mathrm{up}}$), indicating that it has successfully learned a strategy of prioritizing scheduling topology intersections and key nodes in long chains.

4.3. Hybrid Budget Allocation

After determining the task scheduling order, HERO introduces a dynamic hybrid budget mechanism to address the trade-off between energy consumption and performance. Unlike traditional methods that allocate resources solely based on static load, this mechanism combines topology importance and computational volume for global budget planning and introduces runtime energy recovery strategies.

4.3.1. Task Energy Consumption Boundary and Global Energy Margin Definition

Before allocating resources, it is necessary to first define the energy consumption boundaries of each task and the entire task flow within the current heterogeneous edge cluster.

For any task $v_i\in \mathcal{V}$, considering that it can be executed on any processor $p_k\in \mathcal{P}$ at any frequency $f_{k,j}\in {\mathcal{F}}_k$, we can pre-calculate the upper and lower bounds of the task’s energy consumption.

Minimum execution energy consumption: $E_{\min }^{\left(i\right)}$ represents the lowest energy consumption value that task $v_i$ can achieve among all possible combinations of processors and frequencies:

$$E_{\min }^{\left(i\right)}=\underset{p_k\in \mathcal{P},f_{k,j}\in {\mathcal{F}}_k}{min}\left\{P_k\left(f_{k,j}\right)\times {\displaystyle \frac{w_i}{s_k·f_{k,j}}}\right\}$$

(18)

Maximum execution energy consumption: $E_{\max }^{\left(i\right)}$ represents the highest energy consumption that task $v_i$ may generate at the highest performance configuration:

$$E_{\max }^{\left(i\right)}=\underset{p_k\in \mathcal{P},f_{k,j}\in {\mathcal{F}}_k}{max}\left\{P_k\left(f_{k,j}\right)\times {\displaystyle \frac{w_i}{s_k·f_{k,j}}}\right\}$$

(19)

System minimum energy consumption: $E_{\mathrm{sys}}^{\min }$ is the minimum energy required to complete the entire application, which is the total energy required when all tasks are executed at their respective most energy-efficient configurations:

$$E_{\mathrm{sys}}^{\min }=\sum _{v_i\in \mathcal{V}}{E}_{\min }^{\left(i\right)}$$

(20)

System peak energy consumption: $E_{\mathrm{sys}}^{\max }$ is the upper limit of energy consumption when pursuing maximum performance:

$$E_{\mathrm{sys}}^{\max }=\sum _{v_i\in \mathcal{V}}{E}_{\max }^{\left(i\right)}$$

(21)

Energy Constraints and Global Margin: To balance performance and energy consumption, the system sets a total energy consumption constraint $E_{\mathrm{constraint}}$. This constraint must lie within the system’s physically feasible region, satisfying

$$E_{\mathrm{constraint}}=\gamma E_{\mathrm{sys}}^{\max }+(1-\gamma )E_{\mathrm{sys}}^{\min }$$

(22)

Under this constraint, we define the global energy reserve $E_{\mathrm{slack}}^{\mathrm{global}}$ as the additional energy pool that the system can use for higher performance beyond meeting the minimum operating requirements:

$$E_{\mathrm{slack}}^{\mathrm{global}}=E_{\mathrm{constraint}}-E_{\mathrm{sys}}^{\min }$$

(23)

4.3.2. Two-Factor Mixed Weight Definition

To allocate energy margin more scientifically, we no longer rely solely on computational cost, but instead define a hybrid importance score $S_i$. This score combines the task’s topological criticality and relative workload:

$$S_i=\theta ·{\displaystyle \frac{Rank\left(v_i\right)}{Ran{k}_{\max }}}+(1-\theta )·{\displaystyle \frac{w_i}{W_{\max }}}$$

(24)

Topological criticality ($\mathrm{Rank}\left(v_i\right)$): Reflects the task’s position on the critical path of the DAG (based on $Ran{k}_{\mathrm{up}}+Ran{k}_{\mathrm{down}}$). Relative workload ($w_i$): Reflects the size of the task itself. $\theta$ is a balancing factor used to adjust the weights of the two.

4.3.3. Initial Budget Allocation

Based on the mixed score, the global margin $E_{\mathrm{slack}}^{\mathrm{global}}$ is proportionally allocated to each task to form the initial budget $E_{\mathrm{budget}}^{\left(i\right)}$:

$$E_{\mathrm{budget}}^{\left(i\right)}=E_{\min }^{\left(i\right)}+{\displaystyle \frac{S_i}{{\sum }_{v_j\in \mathcal{V}}{S}_j}}·E_{\mathrm{slack}}^{\mathrm{global}}$$

(25)

During online scheduling, HERO employs a dynamic budget reclamation strategy. The accumulated surplus $E_{\mathrm{saved}}^{\left(t\right)}$ is defined as the sum of unused budgets from previously scheduled tasks. The actual available dynamic upper limit $E_{\mathrm{limit}}^{\left(i\right)}$ for the current task $v_i$ is

$$E_{\mathrm{limit}}^{\left(i\right)}=E_{\mathrm{budget}}^{\left(i\right)}+E_{\mathrm{saved}}^{\left(t\right)}$$

(26)

The scheduler selects the highest frequency, $f_{i,k}^{*}$, on the chosen processor $p_k$, which meets the dynamic upper limit:

$$f_{i,k}^{*}=max\left\{f\in {\mathcal{F}}_k\mid E_{i,k}\left(f\right)\le E_{\mathrm{limit}}^{\left(i\right)}\right\}$$

(27)

After the task is executed, update the accumulated balance:

$$E_{\mathrm{saved}}^{(t+1)}\leftarrow E_{\mathrm{saved}}^{\left(t\right)}+\left(E_{\mathrm{budget}}^{\left(i\right)}-E_{\mathrm{actual}}^{\left(i\right)}\right)$$

(28)

4.3.4. Effectiveness of the Hybrid Budgeting Mechanism

To further explore the effectiveness of HERO’s proposed two-factor hybrid weighting mechanism, we designed a set of controlled variable experiments. The experiments aim to demonstrate a core issue: under identical energy consumption constraints, HERO’s hybrid strategy outperforms single-dimensional allocation strategies.

We categorized HERO’s budget allocation module into three baseline strategies and compared their completion times (makespan) under the same total energy consumption constraint ($E_{\mathrm{constraint}}$ with $\gamma =0.9$):

• Rank-Only: Allocation of budget based solely on the task’s position on the critical path, with a balance factor $\theta =1.0$.
• Workload-Only: Allocation of budget based solely on the task’s base energy consumption (i.e., computational load), with $\theta =0.0$.
• Hybrid (Ours): HERO’s default configuration ($\theta =0.85$), considering both topological criticality and relative workload.

Figure 8 shows the performance comparison of the three strategies across 10 groups of DAG instances. Experimental data reveals that Rank-Only can easily lead to resource starvation for heavily loaded tasks on non-critical paths, causing new cascading blockages due to excessive frequency reduction, while Workload-Only ignores global dependencies, wasting budget on non-critical tasks with high slack, resulting in insufficient acceleration of critical nodes. In contrast, HERO’s hybrid mechanism successfully balances topological criticality and computational volume. Experiments show that, under the same energy consumption, HERO’s completion time is improved by 8% and 2% respectively compared to the aforementioned single strategies, demonstrating that jointly considering topology and load is key to achieving energy-efficient scheduling in heterogeneous environments.

4.4. Processor Selection Based on Hole-Filling Strategy

4.4.1. Hole-Filling Strategy

To overcome the resource fragmentation problem caused by heterogeneous communication latency, HERO introduces a hole-filling strategy to actively reclaim idle time slices on the processors.

Define the m-th idle time slice as the interval ${\mathrm{Slot}}_m=[t_{\mathrm{end}}^{\left(m\right)},t_{\mathrm{start}}^{(m+1)}]$. For task $v_i$ to be safely inserted into ${\mathrm{Slot}}_m$, the following timing constraints must be met:

$$min\left(t_{\mathrm{start}}^{(m+1)},{\mathrm{Deadline}}_i\right)-max\left(t_{\mathrm{end}}^{\left(m\right)},{\mathrm{DRT}}_{i,k}\right)\ge {\displaystyle \frac{w_i}{s_k·f_{i,k}^{*}}}$$

(29)

Based on the hole-filling strategy, the earliest start time (EST) of the task is the earliest time among all feasible slots:

$${\mathrm{EST}}_{i,k}=\underset{m}{min}\left\{max\left(t_{\mathrm{end}}^{\left(m\right)},{\mathrm{DRT}}_{i,k}\right)\mid {\mathrm{Slot}}_m\mathrm{is}\mathrm{feasible}\right\}$$

(30)

4.4.2. Verify the Effectiveness of the Hole-Filling Strategy

To demonstrate the effectiveness of reclaiming fragmented idle time in heterogeneous edge clusters, we designed a controlled ablation experiment with the task mapping strategy as the sole independent variable. All other scheduling components remained completely consistent in both schemes.

Baseline Scheme: This strategy strictly follows the tail-append principle. For any task $v_i$ assigned to processor $p_j$, its earliest start time (EST) is restricted to no earlier than the processor’s current available time $\mathrm{Avail}\left(p_j\right)$, i.e., the completion time of the last scheduled task:

$$\mathrm{EST}(v_i,p_j)=max\left(\mathrm{Avail}\left(p_j\right),\mathrm{DRT}(v_i,p_j)\right)$$

(31)

The experimental results are shown in Figure 9. The results demonstrate that the hole-filling strategy achieves synergistic optimization of latency and energy consumption. In terms of execution efficiency, this strategy effectively compresses the system’s critical path by dynamically filling tasks into fragmented time, resulting in an average completion time reduction of 6.96%. Regarding energy efficiency, compared to the static power waste caused by processor idling in the traditional Append-Only mode, the hole-filling strategy achieves energy savings of up to 9.46% by eliminating invalid waiting periods.

5. Experiments

To fully verify the effectiveness of the HERO framework in heterogeneous edge computing environments, we built a high-fidelity simulation platform based on Python 3.8.20 programming and conducted extensive comparative experiments with four mainstream scheduling algorithms in the current academic community.

5.1. Experimental Setup

5.1.1. Task Generation

To evaluate the performance of the scheduling algorithm in different application scenarios, we use a parameter-controlled random DAG generator to construct a diverse benchmark set. This generation model strictly follows the mathematical formulations below:

Topology generation employs a hierarchical generation method to construct the DAG structure, fundamentally guaranteeing the acyclic property. We divide the vertex set $\mathcal{V}$ into L disjoint hierarchical subsets:

$$\mathcal{V}=\bigcup _{k=1}^L{\mathcal{V}}_k,{\mathcal{V}}_a\cap {\mathcal{V}}_b=Ø,\forall a\ne b$$

(32)

Graph depth: The number of layers L follows a uniform distribution $L\sim U[L_{\min },L_{\max }]$, reflecting the serial length of the task flow. Graph width: The parallelism (number of nodes) of each layer $|{\mathcal{V}}_k|$ follows a distribution $|{\mathcal{V}}_k|\sim U[P_{\min },P_{\max }]$. Connection constraint: For any edge $(v_i,v_j)\in E$, if $v_i\in {\mathcal{V}}_a$ and $v_j\in {\mathcal{V}}_b$, then the hierarchical constraint $a<b$ must be satisfied.

For computational load generation, we employ the UUnifast algorithm. This algorithm performs uniform sampling within a simplex space defined by the total system utilization $U_{\mathrm{sys}}$, generating a set of unbiased utilization vectors $u=\{u_1,u_2,\dots ,u_n\}$ that satisfy the following conditions:

$$\sum _{i=1}^n{u}_i=U_{\mathrm{sys}},0<u_i<1$$

(33)

Subsequently, the computational load $w_i$ of task $v_i$ is jointly determined by its allocated utilization $u_i$ and task period $T_i$ ($w_i\propto u_i·T_i$), ensuring the statistical uniformity of the load distribution.

To cover diverse application characteristics, we introduce CCR as a control parameter. The average computational load of the graph is calculated as

$$\overline{w}={\displaystyle \frac{1}{n}}\sum _{i=1}^n{w}_i$$

(34)

The data transfer volume $d_{i,j}$ of edge $e_{i,j}$ is generated based on the following random process:

$$d_{i,j}=\overline{w}\times \mathrm{CCR}\times \delta ,\delta \sim U[0.8,1.2]$$

(35)

Here, $\delta$ is a random perturbation factor used to simulate the random fluctuations in communication overhead between different tasks in a real environment.

5.1.2. Simulation Platform and Tools

The proposed HERO framework is implemented in Python 3; specifically, the communication-aware predictor of HERO uses the PyTorch 2.4.1+cu118 framework for offline training and forward inference. Data aggregation and visualization are handled by the Pandas 2.0.3 and Seaborn 0.13.2 libraries. Furthermore, to ensure computational efficiency, the NSGA-II benchmark was independently implemented in C++ and dynamically invoked by the Python-based main scheduler during the simulation.

To construct a representative modern heterogeneous edge environment, we employ three distinct types of processors: Raspberry Pi 4 (Raspberry Pi Foundation, Cambridge, UK), Jetson Orin Nano (NVIDIA Corporation, Santa Clara, CA, USA), and Intel Xeon D (Intel Corporation, Santa Clara, CA, USA). Their corresponding frequencies (f) and power consumption profiles (P) across different levels are detailed in

Table 5. Processor configurations.

Level	Normalized Freq	Raspberry Pi 4		Jetson Orin Nano		Xeon D
		$\mathit{f}$(MHz)	$\mathit{P}$(mW)	$\mathit{f}$(MHz)	$\mathit{P}$(mW)	$\mathit{f}$(MHz)	$\mathit{P}$(mW)
1	0.2	300	2500	302	5000	600	20,000
2	0.4	600	3200	605	7000	1200	28,000
3	0.6	900	4200	907	10,000	1800	38,000
4	0.8	1200	5500	1209	15,000	2400	50,000
5	1.0	1500	7000	1512	25,000	3000	65,000

. For systematic comparison and frequency scaling analysis, the processor frequencies are normalized across five discrete levels with a step size of 0.2. The cluster consists of three heterogeneous nodes, and the static leakage power of each processor is set to 10% of its peak dynamic power at the maximum frequency level (1.0).

To ensure the objectivity and reproducibility of the benchmark set, during the topology generation phase, the average connection probability of our DAG is set to 0.3, and the basic computational load of tasks is randomly sampled between 10 and 3000. The Communication-to-Computation Ratio (CCR) was dynamically sampled between a wide range of $[0.5,3.0]$. The energy budget factor $\gamma$ is empirically set to 0.85 (i.e., $E_{\mathrm{constraint}}=0.85\times E_{\mathrm{sys}}^{\max }+0.15\times E_{\mathrm{sys}}^{\min }$) during the resource allocation phase.

5.1.3. Evaluation Metrics

To quantitatively evaluate the performance of the proposed HERO framework and baseline algorithms, we employ two primary absolute metrics defined in Section 3.4: Makespan ($T_{\mathrm{makespan}}$) and Total Energy Consumption ($E_{\mathrm{total}}$). Furthermore, to clearly illustrate the relative advantages of HERO, we define the Performance Improvement Ratio (PIR) for both latency and energy. Let $M_{\mathrm{base}}$ denote the metric value (Makespan or Energy) obtained by the benchmark algorithm, and $M_{\mathrm{HERO}}$ denote the corresponding value obtained by HERO. The improvement percentage is calculated as

$$\mathrm{PIR}={\displaystyle \frac{M_{\mathrm{base}}-M_{\mathrm{HERO}}}{M_{\mathrm{base}}}}\times 100\%$$

(36)

A positive PIR indicates that HERO outperforms the baseline algorithm, while a negative value indicates performance degradation. In our multi-trial experiments, all reported results are the arithmetic mean of multiple random instances to eliminate statistical outliers.

5.2. Comparison with Benchmark Algorithms

To comprehensively evaluate the performance boundaries of the HERO framework, we selected four state-of-the-art (SOTA) algorithms with significant representative scheduling strategies as benchmarks:

• NSGA-II: A classic Pareto-optimal multi-objective evolutionary algorithm. Theoretically, NSGA-II can approach the global optimum within an infinite search time. This experiment adapted NSGA-II to a scale-adaptive constraint. We set the population size as a linear function of the number of tasks and limited the maximum number of iterations to three times the number of tasks.
• DPMC: A heuristic algorithm for mixed-criticality systems that distinguishes between high- and low-criticality tasks. It employs a relatively conservative frequency reservation strategy to ensure the deadlines of high-priority tasks.
• SSA: A structure-aware scheduling algorithm based on MLP. Its core lies in using neural networks to learn node importance and introducing a dual-queue mechanism to reserve resources for high-priority tasks waiting for predecessor tasks to complete, in order to optimize task completion time.
• TOM: An algorithm based on time-triggered and chain-structure optimization. It performs excellently in merging linear task chains to reduce synchronization overhead.

5.3. Experimental Results

5.3.1. Impact of Task Size (Number of Layers) on Performance

Figure 10 shows algorithm performance as DAG depth M increases from 8 to 13 (with fixed width $N=15$).

HERO achieves the fastest completion time across all depths. Without fine-grained communication awareness, SSA-DAG lags behind HERO by 28.89% on average (peaking at 32.85% at $M=12$). DPMC’s rigid resource reservations similarly cause a 15.46% scheduling delay.

Regarding energy trade-offs, NSGA-II and DPMC save 9.58% and 3.29% energy, respectively, but severely sacrifice real-time performance (lagging 12.29% and 15.46% in makespan). Meanwhile, SSA-DAG and TOM consume more energy (4.04% and 1.92%) while remaining slower. Ultimately, HERO’s hybrid budgeting secures the best completion time without excessive energy waste.

5.3.2. Impact of Task Parallelism (Width) on Performance

Figure 11 shows the performance trends of various algorithms under different levels of parallelism. We fixed the DAG task depth at $M=10$, and the average number of parallel nodes per layer N varied from 10 to 30.

HERO maintained the fastest completion time in all tests. SSA-DAG’s completion time was on average 22.51% slower than HERO. The TOM algorithm, due to insufficient adaptability to complex mesh dependencies, was on average 9.13% slower. DPMC’s static rule-based reservation mechanism struggles to adapt to dynamic concurrent workloads, resulting in performance fluctuations with an average lag of 13.19%.

In terms of energy optimization, DPMC and NSGA-II saved 3.52% and 7.71% of energy on average compared to HERO, respectively. NSGA-II achieved this by sacrificing 6.39% of critical time performance, with the worst-case performance degradation reaching 7.78%. Moreover, NSGA-II relies on heavy population iterations (requiring minutes), whereas HERO completes inference in microseconds using neural network forward propagation.

5.3.3. Impact of Graph Density (Connection Probability)

Figure 12 illustrates algorithm performance across varying graph densities. We adjusted the connection probability C from 0.1 (highly sparse) to 0.7 (highly dense), with fixed depth $M=12$, width $N=15$, and task utilization $U=2.5$.

Increasing graph density exponentially exacerbates communication bottlenecks and synchronization barriers. HERO consistently achieves the lowest makespan across all densities. In highly dense scenarios ($C\ge 0.5$), algorithms lacking fine-grained communication awareness struggle to resolve complex mesh dependencies: SSA-DAG and TOM lag behind HERO by an average of 10.89% and 5.36%, respectively.

Conversely, HERO’s deep-enhanced MLP explicitly incorporates maximum communication overhead ($Com{m}_{\max }$) to accurately identify true critical paths amidst massive data transfer delays. While DPMC and NSGA-II exhibit energy-saving tendencies under dense topologies (saving 3.67% and 10.54% on average, respectively), they severely compromise real-time performance, with makespans lagging behind HERO by 8.24% and 4.53%.

5.3.4. System Load Stress Test

Figure 13 shows the performance of various scheduling algorithms as the system task utilization (U) increases from $U=1.0$ to overload ($U=3.0$). We keep the other parameters fixed at $M=12$, $N=15$.

For DPMC, as the load increases, its completion time delay expands significantly, rising from 19.75% under light load to 19.97% under heavy load ($U=3.0$), indicating severe underutilization of resources. SSA-DAG has an average completion time delay of 40.90%. This illustrates the limitation of relying solely on structural features without fine-grained communication awareness in high-density computing scenarios. NSGA-II sacrifices 14.66% of execution speed to achieve 12.18% energy savings. Across all tests, HERO maintains its absolute lead in completion time.

6. Conclusions and Future Work

In this paper, we proposed the lightweight HERO framework to resolve the bi-objective scheduling challenges of delay-sensitive DAG tasks in heterogeneous edge clusters. Rather than reiterating the algorithmic design, our extensive evaluations directly demonstrate the framework’s practical superiority. Notably, when compared to the representative learning-based baseline (SSA-DAG), HERO achieves an average $10.89\%$ reduction in makespan under high-density topologies, and saves up to $4.04\%$ of system energy across varying task depths. For resource-constrained edge devices, this continuous energy margin is highly significant, as it cumulatively extends battery lifespan and prevents hardware thermal throttling during sustained workloads. It pushes energy optimization to the extreme without introducing new system bottlenecks, all while strictly maintaining the ultra-low, microsecond-level scheduling latency crucial for real-time edge intelligence. Building upon these promising quantitative results, our future research will focus on three main avenues: (1) adapting the framework for dynamic, online environments (e.g., vehicular networks) with unpredictable task generation and topologies; (2) integrating lightweight fault-tolerance mechanisms to ensure high reliability against transient edge node failures; and (3) advancing to hardware-in-the-loop deployments on actual microcontrollers and embedded IoT sensor nodes to assess real-world physical overhead and end-to-end adaptability outside of simulated environments.