Optimizing Federated Scheduling for Real-Time DAG Tasks via Node-Level Parallelization

Abstract

Real-time task scheduling in multi-core systems is a crucial research area, especially for parallel task scheduling, where the Directed Acyclic Graph (DAG) model is commonly used to represent task dependencies. However, existing research shows that resource utilization and schedulability rates for DAG task set scheduling remain relatively low. Meanwhile, some studies have identified that certain parallel task nodes exhibit “parallelization freedom,” allowing them to be decomposed into sub-threads that can execute concurrently. This presents a promising opportunity for improving task schedulability. Building on this, we propose an approach that optimizes both node parallelization and processor core allocation under federated scheduling. Simulation experiments demonstrate that by parallelizing nodes, we can significantly reduce the number of cores required for each task and increase the percentage of task sets being schedulable.

1. Introduction

Multi-core processors are widely employed in real-time systems, significantly enhancing application execution efficiency. DAGs serve as a representation of the complexity and parallelism of an application. Each node in the DAG is referred to as a subtask of the DAG task. The DAG task model is a universal framework in parallel task scheduling that effectively illustrates the temporal constraints between subtasks and provides an abstract structure describing the fundamental nature of most practical parallel tasks. A crucial characteristic of a DAG is its “longest path” (or critical path), which is the sequence of dependent subtasks whose total execution time is the longest; this path determines the minimum possible execution time for the entire DAG task.

DAG tasks are widely used in industrial applications. For example, a leading open-source autonomous driving framework can easily incorporate over 20 tightly integrated modules solely for the perception stack. This complex program model is described by a DAG. Due to this intricate structure and intensive computational demands, extensive system-wide optimization is required to ensure stable real-time execution [1]. The advantage of a DAG structure lies in its ability to clearly represent task dependencies, ensuring tasks are executed in a certain order and with the conditions of predecessor and successor tasks, thereby reducing resource conflicts and execution delays. By parallelizing the nodes within a DAG, these applications can significantly improve processing efficiency and real-time performance. For example, in autonomous driving, parallel processing of multiple subtasks within the perception module can accelerate data processing, reduce latency, and ensure real-time responsiveness.

The development of parallel frameworks such as OpenCL [2] and OpenMP [3] has enabled the parallelization of subtasks within DAG tasks into multiple versions under computing resource constraints, a concept referred to as “parallelization freedom”. This term describes the flexibility to execute a given task using a variable number of parallel threads; for instance, a task can be run on one, two, or more cores, which in turn affects its execution time and resource requirements. For example, an object detection program using the Euclidean clustering algorithm can be executed with an optimal number of threads. However, due to the parallelization overhead, this increases the total execution time of the task. Therefore, we can maximize system schedulability while meeting real-time and parallelization constraints by carefully selecting an appropriate “parallelization option” for each task, meaning that each task is parallelized with the optimal number of threads.

Research on parallelization has garnered attention due to the potential for maximizing task schedulability through a reasonable selection of the parallelization options. For instance, in the context of multi-threaded task models, parallelization freedom was applied to a fluid scheduling algorithm [4,5]. Parallelization freedom has also been applied in global Fixed Priority (FP) [6] and global Earliest Deadline First (EDF) [7,8] scheduling algorithms. Specifically for DAG parallel task models, Cho et al. [1] employed global EDF to handle the issue of DAG node parallelization and analyzed how appropriate parallelization can better meet the conditions for schedulability analysis under global EDF scheduling. The article in [1] also presented the relation between the total execution time of DAG nodes after parallelization and the parallelization overhead. Recently, different types of scheduling algorithms have been proposed for parallel real-time tasks modeled as DAG, among which federated scheduling [9] has shown its superiority in real-time performance. However, to our knowledge, no solution has been proposed for parallelizing the DAG task model under federated scheduling. Therefore, this paper proposes a parallelization algorithm under federated scheduling.

In federated scheduling [9], each high-density task (with the ratio of the worst-case execution time to the deadline greater than 1) is executed on dedicated processors, while all low-density tasks (with the ratio of the worst-case execution time to the deadline less than or equal to 1) are executed on the remaining processors. However, federated scheduling can lead to a significant waste of resources. Parallelization overhead will increase the number of cores allocated to high-density tasks. We use state-of-the-art federated scheduling based on long paths to further improve the task schedulability [10]. By analyzing the method of allocating cores to high-density tasks presented in [10], we find that assigning reasonable parallelization options to the nodes on the longest path of the high-density DAG tasks can also reduce the number of cores allocated to high-density tasks, thereby reducing resource waste. The impact of parallelization overhead is also present. Leveraging these characteristics, we develop a federated scheduling parallelization algorithm based on long paths.

Our algorithm applies to scenarios in which a node’s parallelization changes the longest path in a DAG task. Meanwhile, we experimentally verify the order of the nodes’ parallelization, and based on this order, we select the node on the longest path that can maximize the schedulability.

This paper is organized as follows: Section 2 introduces related work. Section 3 formally defines the structure of a DAG task and explains the problem. Section 4 introduces federated scheduling based on Graham’s bound algorithm for sporadic DAG tasks and the federated scheduling algorithm based on long paths. The extension of DAG task parallelism is then considered under these two federated scheduling algorithms, and an analysis is presented of the formula for the allocation of core numbers in high-density DAG tasks parallelized under the federated scheduling algorithm based on long paths. Section 5 proposes the algorithm for allocating parallelization options for DAG tasks and validates the order of nodes’ parallelization. Subsequently, Section 6 reports our experimental results. Section 7 summarizes the entire paper.

2. Related Work

The research presented in this paper is based on federated scheduling. Significant research has been conducted on this topic in recent years. For example, a semi-federated scheduling algorithm based on the federated scheduling algorithm was proposed in [11]. A new reservation-based joint scheduling method was proposed in [12] for federated scheduling of DAG tasks, and it was then used to schedule fragmented DAG tasks with arbitrary deadlines. A virtual federated scheduling algorithm for DAG tasks with constrained deadlines was proposed in [13]. Another federated scheduling algorithm based on long paths was proposed in [10].

The aforementioned research does not consider parallelization freedom. Parallelization freedom is allowed in modern parallel programming frameworks (such as OpenCL and OpenMP). Recently, Cho et al. [6,7] adopted the BCL schedulability analysis method in global FP and global EDF, respectively, for a multi-threading task model to allocate the optimal parallelization options to the tasks. In global fluid scheduling, Kwon et al. [4] proposed using parallelization for a multi-segment task model to determine and constrain the parallelization options for each segment and their respective deadlines. They utilized the relation between individual segment deadlines and the overall deadline to improve the schedulability. In subsequent fluid scheduling research, four controllable variables have been identified: parallelization options, artificial deadlines, offsets, and artificial cycles. A method was proposed to balance the density of the entire task system and the execution time of each task by adjusting these four parameters. By controlling the deadlines of the task through parallelization and subsequently controlling the offset of the next task, the method aims to minimize the cumulative density of the tasks after parallelization and ensure that each task is completed before its deadline, thereby enhancing the task schedulability [5]. Lastly, while the previously presented research on the DAG task model does not consider parallelization, Cho et al. [1] used EDF and BCL analyzable scheduling conditions in a study of the DAG task model to propose a node parallelization option algorithm.

It can be seen from the above review that research on federated scheduling of the DAG model and on parallelization freedom under scheduling algorithms has achieved some results. Federated scheduling shows superiority in real-time performance, and reasonable parallelization options can also increase the task schedulability. However, the existing studies have not investigated parallelization algorithms for DAG tasks under federated scheduling. It has been shown that the task schedulability conditions affected by DAG node parallelization can be further improved through reasonable parallelization [1]. Additionally, the latest research on federated scheduling based on long paths has been presented by [10], who applied DAG node parallelization to the latest federated scheduling results, assigning parallelization options to high-density DAG task nodes. This approach reduces the total length of long paths, balances the impact of parallelization overhead, and subsequently reduces the waste resources caused by high-density tasks. As a result, it significantly improves the schedulability of the system.

3. System Model and Problem Description

We consider a DAG task set $\Gamma$ composed of n sporadic DAG tasks $\{{\tau }_1,{\tau }_2,\dots ,{\tau }_n\}$, scheduled on M identical processors.

A DAG task is represented by a triplet, ${\tau }_k=\left\{G,D,T\right\}$, where D denotes the relative deadline and T denotes the period, i.e., the minimum interval between the release times of two consecutive tasks of ${\tau }_k$. A DAG task G is represented by $G=(V,E)$, where V is a collection of $n_k$ nodes, denoted by $V=\left\{v_1,v_2,\dots ,v_{n_k}\right\}$, and E is the set of directed edges between these nodes. An edge $(v_i,v_k)\in E$ represents the precedence relation between $v_i$ and $v_k$, signifying that $v_k$ may only begin execution after $v_i$ has finished. In this case, $v_i$ is the predecessor of $v_k$, and conversely, $v_k$ is the successor of $v_i$. A vertex $v\in V$ represents a workload that is characterized by its worst-case execution time (WCET) $c\left(v\right)$. A node without a predecessor node is called a source node, and a node without a successor node is called a sink node. A node is eligible for execution only if all of its predecessor tasks have been completed.

Considering the parallelization freedom of the nodes, each node can be parallelized into an ideal number of threads. In the example in Figure 1, node $v_1$ can select any value between 1 and $O_{max}$ as its parallelization option, where $O_{max}$ denotes the maximum resources available for the DAG task. In this case, selecting 2 as the node’s parallelization option, i.e., $O_1=2$, means that node $v_1$ is parallelized into two sibling threads with the same priorities, release times, and deadlines. These sibling threads are denoted by $v_1\left(2\right)=\left\{v_1^1\left(2\right),v_1^2\left(2\right)\right\}$. From this, we generalize a more common expression for sibling threads, parallelizing node $v_i$ into $O_i$ threads, resulting in

$$v_i\left(O_i\right)=\left\{v_i^1\left(O_i\right),v_i^2\left(O_i\right),\dots v_i^{O_i}\left(O_i\right)\right\}$$

where $v_i^l\left(O_i\right)$ denotes the lth sibling thread. The WCET for the node’s sub-threads is denoted by $e\left(v_i^l\left(O_i\right)\right)$. This paper assumes that, after parallelization, each thread of a task has an identical execution time. This assumption is motivated by the widespread adoption of load-balancing strategies in modern parallel programming frameworks such as OpenCL and OpenMP, where tasks are divided into threads with equal workloads to maximize parallel efficiency. Furthermore, this assumption has been adopted in the field of real-time multi-core scheduling research [5], where scheduling analysis and optimization also build models of scheduling density and timing bounds based on this premise. The total computation time for the $O_i$ sibling threads is denoted by $c\left(v_i\left(O_i\right)\right)={\sum }_{l=1}^{O_i}e\left(v_i^l\left(O_i\right)\right)$. Due to the presence of parallelization overhead, the total computation of all sibling threads will increase with an increase in the parallelization option.

Now, let us consider the definition of path length and the total WCET for DAG tasks with parallelization freedom. A path is defined as a sequence of nodes starting from a source node and ending at its receiving node, with each consecutive pair of nodes connected by an edge. For example, in Figure 1, $\left\{v_1,v_3,v_5\right\}$ is one possible path within G. The path of a DAG with parallelization freedom is denoted by $\lambda$. The length of $\lambda$ is defined by

$$len\left(\lambda \right)=\sum _{v_i\in \lambda }e\left(v_i^1\left(O_i\right)\right)$$

This is the sum of the WCETs of the longest threads for all nodes on the path. The longest path of ${\tau }_k$ is represented by ${\lambda }^{*}$, and G represents the actual structure of the DAG, including nodes and directed edges. The length of the longest path ${\lambda }^{*}$ in the DAG can be defined as follows:

$$len\left(G\right)=len\left({\lambda }^{*}\right)=\underset{\lambda \in G}{max}len\left(\lambda \right)$$

The threads that constitute this path are referred to as the longest threads. However, as the threads of the DAG task nodes change, the path may change with variations in the execution time of the threads, and the longest threads may also change depending on changes in the parallelization. After parallelization, the total execution time of all threads in G is referred to as the volume of G:

$$vol\left(G\right)=\sum _{v_i\in V}c\left(v_i\left(O_i\right)\right)$$

We employ a federated scheduling algorithm to schedule n DAG tasks, where the scheduling cost is considered negligible or is included in the WCET. The problem is defined as follows.

• Problem Definition: For high-density tasks within a task set, our problem is to identify parallelization options for the nodes on the longest path to minimize the number of cores allocated to this high-density task. However, as DAG task node parallelization progresses, the longest thread path may also change. We aim to design a strategy that allocates parallelization options for nodes on the changing longest path, thereby minimizing the number of cores allocated to the high-density task and enhancing the federated scheduling.

4. Extension of Federated Scheduling for DAG Tasks with Parallelization Freedom

In this section, we will review federated scheduling. In the first subsection, we start with a review of federated scheduling based on Graham’s bound, followed by an introduction to the response time bounds for DAG tasks under federated scheduling with long paths, and the method for allocating the number of cores with high-density DAG tasks. In the second subsection, we first derive the condition for reducing the number of cores allocated to high-density DAG tasks with parallelization freedom under federated scheduling based on Graham’s bound. Subsequently, we derive the condition for reducing the number of cores allocated to high-density DAG tasks with parallelization freedom under federated scheduling based on long paths and provide a formula for core allocation. The main notations used in this paper are shown in

Table 1. Notations used in the paper.

Notation	Description
$c\left(v\right)$	the WCET of vertex v
$O_i$	the parallelization option for the $v_i$ node
$len\left(\lambda \right)$	the length of path $\lambda$
$len\left(G\right)$	the length of the longest path of DAG G
$vol\left(G\right)$	the volume of G
${\left({\lambda }_i\right)}_0^k$	a generalized path list
$\stackrel{\_}{k}+1$	the number of all generalized paths in G
C	the total WCET for all nodes within G
L	the length of the longest path of G
D	the relative deadline of G
T	the period of G
$v_i\left(O_i\right)$	the $v_i$ after parallelizing node $v_i$ into $O_i$ threads
$v_i^l\left(O_i\right)$	the lth sibling thread of $v_i\left(O_i\right)$
$e\left(v_i^l\left(O_i\right)\right)$	the WCET of $v_i^l\left(O_i\right)$
m	the number of cores for high-density DAG
${\sum }_{i=0}^{p_a}len\left({\lambda }_i\right)$	the sum of the lengths of the first $p_a$+1 paths in a DAG
$m\left(p_a\right)$	the number of cores is calculated by Formula (4)
	using the first $p_a$+1 paths
$c\left(v_i\left(O_i\right)\right)$	the total WCET for all threads within the $v_i\left(O_i\right)$
${\sum }_{i=0}^{p_a}{L}_i$	the sum of the lengths of the first $p_a$+1 paths in a DAG
Z	${\sum }_{i=1}^{p_a}{L}_i$
$Ocur$	the list of parallelization options for DAG nodes
$Opre$	the temporary node’s list of parallelization options
${\tau }_k\left(Ocur\right)$	the DAG task with $Ocur$
${\tau }_k\left(Opre\right)$	the DAG task with $Opre$
y	the formula inside the ceiling function
	in Formula (1) or (4)
$y^{\prime }$	the value of y after the next parallel step in a DAG
$C^{\prime }$	the value of C after the next parallel step in a DAG
$L^{\prime }$	the value of L after the next parallel step in a DAG
$Z^{\prime }$	the value of Z after the next parallel step in a DAG
${\sum }_{i=0}^{p_a}{L}_i\left(Ocur\right)$	the sum of the lengths of the first $p_a$+1 paths
	in the DAG task with $Ocur$
$C\left(Ocur\right)$	the total WCET for all nodes within the DAG
	with the list of parallelization options
$L\left(Ocur\right)$	the length of the longest path of DAG
	with the list of parallelization options
x	the current parallelization option for a node
$\alpha$	parallelization overhead
b	the execution time per thread for node
$\Delta L$	the change in the longest path of a DAG
Y	the transformed expression for y

.

4.1. Overview of Federated Scheduling Based on Graham’s Bound and Long Paths

We first review the method of federated scheduling [9]. Upon the arrival of a DAG, we classify the tasks into high-density tasks (C greater than D) and low-density tasks (C less than or equal to D). This paper focuses on high-density tasks (with the assumption that D is equal to its period T). To each task in the set of high-density tasks, we allocate a dedicated number of cores for its execution. Each high-density task ${\tau }_k$ can be executed independently on m processors, where m can be determined using the following formula:

$$m=⌈{\displaystyle \frac{C-L}{D-L}}⌉$$

(1)

Low-density tasks are treated and executed as though they are sequential tasks and any multiprocessor scheduling algorithm, such as partitioned EDF or global EDF, can be employed for them. Formula (1) ensures that any greedy parallel scheduler can be used to schedule the high-density DAG tasks; a greedy scheduler is one that never leaves cores idle when nodes in the DAG task are ready for execution. However, a significant portion of the processor’s resources is wasted during the execution of task ${\tau }_k$. Next, we introduce the response time bounds for DAG tasks under federated scheduling based on long paths and the method for allocating cores to high-density DAG tasks.

The response time bound for a DAG with federated scheduling based on long paths is

$$R\le len\left(G\right)+{\displaystyle \frac{vol\left(G\right)-{\sum }_{i=0}^{k}len\left({\lambda }_i\right)}{m-k}}$$

(2)

After the list of generalized paths is given, the response time of the DAG can be written as

$$R\le \underset{p_a\in \left[0,k\right]}{min}\left\{len\left(G\right)+{\displaystyle \frac{vol\left(G\right)-{\sum }_{i=0}^{p_a}len\left({\lambda }_i\right)}{m-p_a}}\right\}$$

(3)

We now introduce the concept of a generalized path. The subtasks in a generalized path cannot be executed at the same unit time in any execution sequence. That is to say, the nodes on the generalized path have precedence constraints, and so does the path. All nodes in the path have a predecessor or a successor, so the generalized path evolves from the path; that is, the generalized path skips some vertices in the path so as to satisfy the constraint relationships of any previous and subsequent executions. For example, in Figure 1, $\left\{v_1,v_3,v_5\right\}$ is both a path and a generalized path, while $\left\{v_1,v_5\right\}$ is a generalized path but not a traditional path. Algorithm 1 describes how to generate a generalized path for a DAG task. Algorithm 1 is adapted from Reference [14]; however, we have made minor modifications to its details to align with the context of this study.

In Algorithm 1, $\overline{k}+1$ denotes the number of all generalized paths in the DAG, and $\overline{k}$ denotes the index of the last generalized path. The value of k in Formula (3) cannot exceed $min(\overline{k},m-1)$, where k is chosen from $[0,min(\overline{k},m-1)]$ to compute Formula (3). In Algorithm 1, $res(G,\lambda )$ (the residual graph) retains the same structure as G, but with the WCETs of nodes on $\lambda$ set to zero. Let $G^{\prime }=G$ (line 1); when $vol\left(G^{\prime }\right)\ne 0$, the loop is entered (lines 2–6). In each iteration, the longest path of $res(G,\lambda )$ is selected; then, the WCETs of the nodes on this path are set to zero, and $G^{\prime }$ is updated. The loop continues until the condition $vol\left(G^{\prime }\right)=0$ is satisfied. Therefore, $vol\left(G\right)={\sum }_{i=0}^{\overline{k}}len\left({\lambda }_i\right)$. Then, from Formula (3), the number of dedicated cores for the high-density DAG tasks can be derived as follows:

$$\begin{array}{c}\hfill \left\{\begin{array}{c}m\left(p_a\right)=\left\{\begin{array}{cc}⌈{\displaystyle \frac{C-{\sum }_{i=0}^{p_a}{L}_i}{D-L}}⌉+p_a& p_a<\stackrel{\_}{k}\wedge D>L\\ \stackrel{\_}{k}+1& p_a=\stackrel{\_}{k}\end{array}\right.\\ m=\underset{p_a\in [0,\stackrel{\_}{k}]}{min}\left\{m\left(p_a\right)\right\}\end{array}\right.\end{array}$$

(4)

in which $\overline{k}+1$ denotes the total number of generalized paths in a DAG task; it is necessary to calculate this total according to Algorithm 1. Based on the variations in the value of $p_a$ in Formula (4), we can compute the number of cores required for different values of $p_a$. We then select the case with the minimum number of cores and record the corresponding value of $p_a$, representing the required maximum generalized path index, where $p_a+1$ denotes the number of generalized paths required to compute the minimum number of cores via Formula (4). Through this analysis, multiple generalized paths can be used to determine the dedicated number of cores required for a high-density DAG task in federated scheduling, as well as the necessary number of generalized paths.

Algorithm 1 Computing_Generalized_Path_List(G) [14]

Input: $G=(V,E)$ Output: ${\left({\lambda }_i\right)}_0^{\stackrel{\_}{k}}$ 1: $G^{\prime }\leftarrow G$; $i\leftarrow 0$; $\stackrel{\_}{k}\leftarrow -1$; ${\left({\lambda }_i\right)}_0^{\stackrel{\_}{k}}\leftarrow${} 2: while  $vol\left(G^{\prime }\right)\ne 0$ do 3:    ${\lambda }_i$ ← the longest path of $G^{\prime }$ 4:    $\stackrel{\_}{k}\leftarrow \stackrel{\_}{k}+1$ 5:    ${\left({\lambda }_i\right)}_0^{\stackrel{\_}{k}}$ ← ${\left({\lambda }_i\right)}_0^{\stackrel{\_}{k}}\cup {\lambda }_i$ 6:    ${\lambda }_i$ ← ${\lambda }_i$∖{$v\in {\lambda }_i|c\left(v\right)$ of $G^{\prime }$ is 0 } 7:    $G^{\prime }\leftarrow res(G^{\prime },{\lambda }_i)$; $i\leftarrow i+1$ 8: end while 9: return  ${\left({\lambda }_i\right)}_0^{\stackrel{\_}{k}}$

4.2. Extension of Federated Scheduling Based on Graham’s Bound and Long Paths with Parallelization Freedom

We first derive the condition for decreasing the number of cores in high-density DAG task assignments with parallelization freedom under federated scheduling based on Graham’s bound. By distributing the number of cores through Formula (1), we understand that L denotes the length of the longest path, and C denotes the total WCET. To reduce the number of cores allocated to ${\tau }_k$, it is evident from the formula that only L and C can be altered, with D being unchangeable. Due to parallelization overhead, splitting nodes on the longest path will increase C. However, if the parallelization overhead is sufficiently small, it can decrease the length of the longest thread L. This leads to two cases:  

• Case 1: In this case, nodes on the longest path are split, and the longest path remains unchanged. Since the nodes along the path are parallelized, the longest thread is reduced; hence, the total length of this path is shorter than before the parallelization.  
• Case 2: In this case, nodes on the longest path are split, leading to a change in the longest path. However, since the length of this new path is shorter than the length of the previous the longest path, the length of the longest path is reduced.

For instance, as shown in Figure 2, the longest path before parallelization is $\left\{v_1,v_2,v_5\right\}$. Assume a parallelization overhead of 0.2, and split $v_2$ into two threads. Consider the parallelization overhead $\alpha ={\displaystyle \frac{c\left(v_i(O_i+1)\right)-c\left(v_i\left(O_i\right)\right)}{c\left(v_i\left(O_i\right)\right)}}$. According to the concept introduced in [1], the parallelization overhead is defined as the ratio between the difference in the total WCETs before and after parallelization and the WCET before parallelization. The WCET after node parallelization is calculated according to the method described in [1], resulting in $c\left(v_2(O_i+1)\right)=(1+\alpha )c\left(v_2\left(O_i\right)\right)$, where $\alpha$ denotes the parallelization overhead. Therefore, the WCET becomes $c\left(v_2\left(2\right)\right)=(1+0.2)\times c\left(v_2\right)=6$, where $c\left(v_2\right)=5$. The longest thread becomes $\left\{v_1,v_2^1,v_5\right\}$, which aligns with Case 1.

To focus on the core impact of the node parallelization sequence on scheduling performance, this paper models the parallelization overhead coefficient $\alpha$ as a fixed value derived from a pessimistic estimation. While this simplified treatment does not capture the full dynamic characteristics of $\alpha$ in real-world systems, it provides a clear baseline for theoretical analysis and algorithm design. It is important to note that, despite this simplification, the experimental data in Section 6 robustly demonstrate that the proposed algorithm still achieves a significant schedulability improvement under the assumption of a fixed $\alpha$. Looking forward, constructing a generalized model that treats $\alpha$ as a stochastic variable or a function of the degree of parallelism to more accurately reflect system behavior represents a highly valuable direction for future work.

Based on the aforementioned analysis, it is necessary to parallelize the nodes on the longest path to reduce the length of the longest thread, L. Subsequently, we will discuss the impact of changes in L and C, after parallelization, on the changes in the number of cores. To analyze the trend of the change in Formula (1), we omit the ceiling function part of this formula. The new formula is as follows:

$$y={\displaystyle \frac{C-L}{D-L}}$$

(5)

When C increases, it is evident that y will also increase, leading to a tendency for m to also increase. Below, we illustrate the impact of a decrease in L on y.

Lemma 1. 

When C is greater than D, a decrease in L will lead to a tendency for m to decrease. The proof is as follows:

Proof. 

Taking the derivative of Formula (5) with respect to L, we obtain

$${\displaystyle \frac{dy}{dL}}={\displaystyle \frac{-(D-L)+C-L}{{(D-L)}^2}}={\displaystyle \frac{C-D}{{(D-L)}^2}}$$

For high-density tasks where $C>D$, the aforementioned expression is greater than zero, and y increases monotonically with L. Therefore, as L decreases, y also decreases, indicating a tendency for m to decrease too. C and L have opposite effects on y.    □

Lemma 2 illustrates the condition under which y decreases after node parallelization, which is the condition for a decreasing trend in m.

Lemma 2. 

After parallelization, if ${\tau }_k$ satisfies Formula (6), then y decreases.

$${\displaystyle \frac{(C^{\prime }-C)}{(L-L^{\prime })}}<{\displaystyle \frac{(C-D)}{(D-L)}}$$

(6)

Proof. 

Let C become $C^{\prime }$ and L become $L^{\prime }$ after the next parallelization step:

$$y^{\prime }={\displaystyle \frac{C^{\prime }-L^{\prime }}{D-L^{\prime }}},y={\displaystyle \frac{C-L}{D-L}}$$

Let $y^{\prime }<y$. Consequently, we have

$$\begin{array}{cc}& {\displaystyle \frac{C^{\prime }-L^{\prime }}{D-L^{\prime }}}<{\displaystyle \frac{C-L}{D-L}}(C>D,D>L)\hfill \\ \Rightarrow & (C^{\prime }-L^{\prime })(D-L)<(D-L^{\prime })(C-L)\hfill \\ \Rightarrow & C^{\prime }\times D-C^{\prime }\times L-D\times L^{\prime }+L\times L^{\prime }<\hfill \\ & C\times D-C\times L^{\prime }-L\times D+L\times L^{\prime }\hfill \\ \Rightarrow & C^{\prime }\times D-C^{\prime }\times L-D\times L^{\prime }<\hfill \\ & C\times D-C\times L^{\prime }-L\times D\hfill \\ \Rightarrow & (C^{\prime }-C)D+D(L-L^{\prime })<C^{\prime }\times L-C\times L^{\prime }\hfill \\ \Rightarrow & (C^{\prime }-C)D+D(L-L^{\prime })<\hfill \\ & C^{\prime }\times L-C\times L^{\prime }+C\times L-C\times L\hfill \\ \Rightarrow & (C^{\prime }-C)D+D(L-L^{\prime })<(C^{\prime }-C)L+C(L-L^{\prime })\hfill \\ \Rightarrow & (C^{\prime }-C)(D-L)<(C-D)(L-L^{\prime })\hfill \end{array}$$

This yields

$${\displaystyle \frac{(C^{\prime }-C)}{(L-L^{\prime })}}<{\displaystyle \frac{(C-D)}{(D-L)}}$$

   □

According to Lemma 2, if we aim to ensure a decreasing trend in the number of cores after node parallelization, the parameters before and after parallelization need to satisfy Formula (6). For instance, as shown in Figure 2a, before parallelization, the required number of cores calculated using Formula (1) is $⌈{\displaystyle \frac{14-9}{11-9}}⌉=3$. Figure 2b depicts the graph after parallelizing node $v_2$, with a parallelization overhead of 0.2. The required number of cores, calculated using Formula (1), is $⌈{\displaystyle \frac{15-7}{11-7}}⌉=2$. At this point, ${\displaystyle \frac{15-14}{9-7}}<{\displaystyle \frac{14-11}{11-9}}$ satisfies Formula (6).

Next, we introduce the extension of federated scheduling based on long paths with parallelization freedom. Formula (4) gives the number of cores allocated to high-density DAG task cores under federated scheduling based on long paths. In this case, each DAG node is considered to be single-threaded, and what we need to consider is the case with parallelization freedom.

Similarly, we select nodes on the longest path for parallel execution. Through parallelization freedom, each node can be parallelized into the ideal number of threads. As mentioned in Section 4.1, we understand that it is crucial to find an effective parallelization strategy to minimize the number of cores calculated by Formula (4). It is clear that after identifying all generalized paths in the DAG, one must use Formula (4) to find the number of generalized paths that minimizes the value of m. It is not necessarily true that an increase in the number of generalized paths will lead to a decrease in the required number of cores. Here, we assume that the minimum number of cores for a DAG is achieved with $p_a+1$ paths. Our algorithm is applicable in situations where $p_a=k$, which will be discussed later. For the sake of analysis, let us define

$$m=⌈{\displaystyle \frac{C-{\sum }_{i=0}^{p_a}{L}_i}{D-L}}⌉+p_a$$

In the analysis provided by Section 4.1, it is necessary to identify parameters that can vary with node parallelization to facilitate a decreasing trend in the value of m. The values of $p_a$ and D are fixed. Unlike the analysis in Section 4.1, aside from the total WCET of the DAG denoted by C and the longest path length denoted by L, which change with node parallelization, ${\sum }_{i=1}^{p_a}{L}_i$ may also vary as nodes are parallelized. By eliminating the ceiling function and $p_a$ from the expression $m=⌈{\displaystyle \frac{C-{\sum }_{i=0}^{p_a}{L}_i}{D-L}}⌉+p_a$, we can analyze the trend in changes to the formula as follows:

$$y={\displaystyle \frac{C-L-{\sum }_{i=1}^{p_a}{L}_i}{D-L}}$$

(7)

To analyze Formula (7), it should be observed that y exhibits a decreasing trend as ${\sum }_{i=1}^{p_a}{L}_i$ increases. To illustrate the changes in ${\sum }_{i=1}^{p_a}{L}_i$, we will consider three cases. Prior to the analysis, we set $p_a$ to 2 to facilitate the examination, thereby indicating that under three generalized paths, m is minimized.  

• Case 1: After the node on the longest path is parallelized, the longest path becomes the second longest, and the second longest path becomes the longest. The third path remains unchanged. In this case, L and ${\sum }_{i=1}^{p_a}{L}_i$ both decrease.
• Case 2: After the node on the longest path is parallelized, the nodes of the longest path remain unchanged, while the lengths of the other two paths are replaced by the sub-threads of the nodes parallel to the longest path. As a result, L decreases and ${\sum }_{i=1}^{p_a}{L}_i$ increases.
• Case 3: After the node on the longest path is parallelized, the nodes of the longest path remain unchanged, and the nodes of the other two paths also remain unchanged. In this case, L decreases and ${\sum }_{i=1}^{p_a}{L}_i$ remains unchanged.  

The selection of the node parallelization order will be explained in Section 5.2.

Based on the analysis of the aforementioned three cases, we can see that ${\sum }_{i=1}^{p_a}{L}_i$ may increase or decrease depending on the relations between the lengths of the three paths. Importantly, this change is independent of the selection of the nodes for parallelization.

Let ${\sum }_{i=1}^{p_a}{L}_i=Z$. Then, Formula (7) becomes

$$y={\displaystyle \frac{C-L-Z}{D-L}}$$

(8)

Through Formula (8), we can see that after node parallelization, the monotonic increase in C continuously impedes the decrease in y, yet Z may either increase or decrease. An increase in Z is conducive to a decrease in y. To illustrate this, suppose $C=12$, $L=5$, $Z=4$, $D=10$, and then from Formula (8), $y=3/5$. After parallelization, suppose $C^{\prime }=12.5$, $L^{\prime }=4$, $Z^{\prime }=5$, and $D^{\prime }=10$. Then, from Formula (8), $y^{\prime }=7/12$, showing that $y^{\prime }$ is less than y. Therefore, it is necessary to identify conditions under which $y^{\prime }<y$, and based on Lemma 2, Lemma 3 is derived.

Lemma 3. 

After parallelization, y decreases when ${\tau }_k$ satisfies Formula (9).

$${\displaystyle \frac{(C^{\prime }-Z^{\prime }-C+Z)}{(L-L^{\prime })}}<{\displaystyle \frac{(C-D)}{(D-L)}}$$

(9)

Proof. 

Following the next parallelization step, C changes to $C^{\prime }$, L changes to $L^{\prime }$, and Z changes to $Z^{\prime }$; hence,

$$\begin{array}{c}\hfill y^{\prime }={\displaystyle \frac{C^{\prime }-L^{\prime }-Z^{\prime }}{D-L^{\prime }}},y={\displaystyle \frac{C-L-Z}{D-L}}\end{array}$$

Let $y^{\prime }<y$:

$$\begin{array}{cc}& {\displaystyle \frac{C^{\prime }-L^{\prime }-Z^{\prime }}{D-L}}<{\displaystyle \frac{C-L-Z}{D-L}}(C>D,D>L)\hfill \\ \Rightarrow & (C^{\prime }-Z^{\prime }-L^{\prime })(D-L)<(D-L^{\prime })(C-L-Z)\hfill \\ \Rightarrow & (C^{\prime }-Z^{\prime })\times D-(C^{\prime }-Z^{\prime })\times L-D\times L^{\prime }<\hfill \\ & (C-Z)\times D-(C-Z)\times L^{\prime }-L\times D\hfill \\ \Rightarrow & (C^{\prime }-Z^{\prime }-C+Z)D+D(L-L^{\prime })<\hfill \\ & (C^{\prime }-Z^{\prime })\times L-(C-Z)\times L^{\prime }\hfill \\ \Rightarrow & (C^{\prime }-Z^{\prime }-C+Z)D+D(L-L^{\prime })<\hfill \\ & (C^{\prime }-Z^{\prime })\times L-(C-Z)\times L^{\prime }+\hfill \\ & (C-Z)\times L-(C-Z)\times L\hfill \\ \Rightarrow & (C^{\prime }-Z^{\prime }-C+Z)D+D(L-L^{\prime })<\hfill \\ & (C^{\prime }-Z^{\prime }-C+Z)L+(C-Z)(L-L^{\prime })\hfill \\ \Rightarrow & (C^{\prime }-Z^{\prime }-C+Z)(D-L)<(L-L^{\prime })(C-Z-D)\hfill \end{array}$$

This yields

$$\begin{array}{c}\hfill {\displaystyle \frac{(C^{\prime }-Z^{\prime }-C+Z)}{(L-L^{\prime })}}<{\displaystyle \frac{(C-D)}{(D-L)}}\end{array}$$

   □

According to Lemma 3, to ensure that the number of cores decreases after the parallelization of the nodes, the parameters before and after the parallelization need to satisfy Formula (9). For instance, as shown in Figure 2a, without parallelization and calculated according to Formula (4), the resulting $p_a$ is 1. This means that for two generalized paths, the number of required cores m is minimized, and m is $⌈{\displaystyle \frac{14-9-3}{11-9}}⌉+1=2$. At this point, Formula (7) computes y as 1. Figure 2b presents the graph after the parallelization of node $v_2$, with a parallelization overhead of 0.2. According to Formula (7), $y^{\prime }$ is calculated as 1.25. However, this time, ${\displaystyle \frac{15-3-14+3}{9-7}}={\displaystyle \frac{1}{2}}>{\displaystyle \frac{14-3-11}{11-9}}=0$ does not satisfy Formula (9). The selection of nodes on the longest path for parallelization will be introduced in Section 4.

Following the above analysis, let the list of parallelization options for DAG nodes be denoted as $Ocur$. The formula for calculating the number of cores after parallelization is derived as Formula (10):

$$m=⌈{\displaystyle \frac{C\left(Ocur\right)-{\sum }_{i=0}^{p_a}{L}_i\left(Ocur\right)}{D-L\left(Ocur\right)}}⌉+p_a$$

(10)

If $p_a$ calculated according to Formula (4) is equal to $\stackrel{\_}{k}$, encompassing all nodes in the DAG, that is, when the number of generalized paths is $\stackrel{\_}{k}+1$, the number of cores calculated by Formula (4) is minimized. Then, $C-{\sum }_{i=0}^{p_a}{L}_i$ = 0. Since the number of paths increases after parallelization, which is the case where $C\left(Ocur\right)-{\sum }_{i=0}^{p_a}{L}_i\left(Ocur\right)$ = 0 does not occur, then Formula (10) is also applicable.

5. Parallelization Algorithm

In this section, we will introduce our parallelization algorithm, followed by a discussion of the node selection algorithm, and conclude with an analysis of the algorithm’s time complexity.

5.1. Parallelization Algorithm

Based on the above theoretical analysis, we will now introduce the parallelization algorithm under federated scheduling based on long paths. The vertices that should be parallelized are those located on the longest path in the DAG task, as this has the most significant impact. After vertex parallelization, the longest path of the vertex is likely to change. Therefore, our algorithm selects the node on the newly longest path after parallelization to parallelize at each iteration. All nodes start running in single-threaded mode, with the algorithm progressively adding parallelization options.

Assuming there is a task ${\tau }_k$ that includes $n_k$ nodes within its structure, we use $Ocur$ to denote the list of parallelization options for the task nodes, leading to the following expression:

$$Ocur=\left(O_1,O_2,\dots ,O_{n_k}\right)$$

Here, $O_i$ denotes the parallelization options for the $v_i$ node, and $\Theta$ encompasses the set of parallelization options for nodes across the entire task set. A task begins its parallelization with all nodes set to $Ocur=\left(1,1,\dots ,1\right)$. It is important to note that in $Ocur=\left(O_1,O_2,\dots ,O_{n_k}\right)$, the maximum limit for each node’s option is determined by the number of currently calculated available cores. For example, if the currently calculated number of available cores is 4, then each element in $Ocur=\left(O_1,O_2,\dots ,O_{n_k}\right)$ is limited to a maximum of 4. A potential issue is illustrated by the following example: Suppose $O_2=4$, and the number of dedicated cores for a DAG as calculated based on $Ocur$ is 3; then, the maximum limit would be 3, making $O_2=4$ infeasible. However, if $O_2$ were not equal to 4, the number of cores calculated would not be 3, leading to a contradiction. Our algorithm calculates the number of cores after parallelization without contradictions, as demonstrated below.

In the task set $\Gamma$, let the set of high-density tasks be denoted by ${\Gamma }_h$, and $M_h$ denote the total number of cores allocated for high-density tasks. ${\tau }_k$ is a task within ${\Gamma }_h$. We use $Ar{r}_{dex}$ to denote the list of indices of the nodes of the longest path in the DAG. For example, if the longest path is $\left\{v_1,v_2,v_3\right\}$, then $Ar{r}_{dex}$ is $\left\{0,1,2\right\}$. Algorithm 2 demonstrates our parallelization algorithm, which allocates node parallelization options for high-density tasks. It determines the list of node parallelization options for all tasks in the task set, as well as the number of dedicated cores allocated after parallelizing the high-density task set. Initially, $Ocur$ of ${\tau }_k$ is initialized (lines 1–3). Using Algorithm 1, we identify all generalized paths for the current ${\tau }_k$, and then calculate the number of dedicated cores m and the required number of long paths $p_a+1$ based on Formula (4) (line 5). Parallelization is considered for task ${\tau }_k$ only if the calculated number of cores m is greater than 2 (lines 6–7). This is because if m is 1, there is no need for parallelization. If $m=2$, parallelization would either leave m unchanged or reduce it to 1. If reduced to 1, the maximum parallelization limit becomes 1, contradicting the fact that each node in ${\tau }_k$ has a parallelization option of 2. Thus, for $m=2$, there is no need for parallelization; m is directly added to M (line 35). Within lines 8–30, the for loop is initiated, with each iteration subject to a limitation that starts from 2 and iterates up to the initially calculated core count. Under each limitation, we parallelize to obtain the minimum value of m that is not less than the limitation. Eventually, the minimum m across all limitations is selected, and m is updated; then, the current $Ocur$ is updated and set equal to the temporary node’s list of parallelization options, $Opre$ (lines 26–28). Under a certain limitation, $Ar{r}_{dex}$ is initialized. According to Node_Selection (Algorithm 3), the node indexed by $dex$ is to be parallelized, and the temporary node parallelization option list $Opre$ is selected (lines 9–11). Subsequently, a while loop is entered (lines 12–29), where we determine the minimum number of cores m and the list of parallelization options $Ocur$ under the current parallelization constraint. Initially, $Ar{r}_{dex}$ is updated (line 13), and then, using Algorithm 1, all generalized paths of ${\tau }_k\left(Opre\right)$ are obtained, along with the lengths of the first $p_a+1$ generalized paths (line 13). If $Ocu{r}_{dex}$ (the $dex+1^{th}$ element of $Ocur$) reaches the current $O_{limit}$, the value of $dex$ is updated using Node_Selection (Algorithm 3). If $dex$ changes, then $Opr{e}_{dex}=Opr{e}_{dex}+1$; otherwise, the loop exits. If not, the value of $dex$ is updated using Node_Selection (Algorithm 3), and $Opr{e}_{dex}=Opr{e}_{dex}+1$ (lines 14–23). Subsequently, all the generalized paths of ${\tau }_k\left(Opre\right)$ are calculated using Algorithm 1, and the lengths of the first $p_a+1$ paths are computed to determine the new number of cores (line 24). If the new number of cores is computed to be less than m and greater than or equal to $O_{limit}$, then m and $Ocur$ can be updated (lines 25–27). At this point, the number of parallelization options is less than or equal to $O_{limit}$, and the calculated number of cores is greater than or equal to $O_{limit}$, thereby resolving the aforementioned contradiction. Finally, the list $\Theta$ containing the parallelization options for all tasks in the task set and the number of cores $M_h$ for the high-density tasks is returned.

The pseudocode is illustrated using Figure 1. According to [5], after task parallelization, the execution time for all threads is considered equal. According to [1], assuming the parallelization overhead to be $\alpha$, the total execution time for a node is $c\left(v_i\left(O_i+1\right)\right)=(1+\alpha )c\left(v_i\left(O_i\right)\right)$. Assuming $\alpha =0.2$, we first use Formula (4) to calculate $p_a=1$, $m=3$. Entering the loop (lines 8–30), $O_{limit}$ is set within the closed range of 2 to 3. First, $O_{limit}=2$. According to Algorithm 3, a node is selected from the longest path $\left\{v_1,v_2,v_5\right\}$. After the parallelization of node $v_1$, we have $C=15.6$, $L=7.8$, and ${\sum }_{i=1}^{p_a}{L}_i=4.8$. Therefore, using Formula (7), we calculate ${\displaystyle \frac{15.6-7.8-4.8}{11-7.8}}=0.94$. For node $v_2$ after parallelization, $C=16$, $L=7$, and ${\sum }_{i=1}^{p_a}{L}_i=3$. Using Formula (7), we calculate ${\displaystyle \frac{16-7-3}{11-7}}=1.50$. After the parallelization of node $v_5$, we have $C=15.2$, $L=8.6$, and ${\sum }_{i=1}^{p_a}{L}_i=3.6$. Using Formula (7), we calculate ${\displaystyle \frac{15.2-8.6-3.6}{11-8.6}}=1.25$. The result corresponding to $v_1$ is the smallest, indicating that the initial node index $dex=0$, which corresponds to node $v_1$ in Figure 1, should be selected. This node is then parallelized into two threads, with each thread having an execution time of 1.8. At this point, the required $m_{cur}=⌈{\displaystyle \frac{15.6-7.8-4.8}{11-7.8}}⌉+1=2$, and since $m_{cur}$ meets the condition on line 26, $m=2$ and $Ocur=[2,1,1,1,1]$. After parallelizing $v_1$, the new longest path in the DAG becomes $\left\{v_1^1,v_2,v_5\right\}$, and the $Ar{r}_{dex}$ is $\left\{0,1,4\right\}$ (line 13), at which point $Opre\left[0\right]=2$ meets the current limit requirement (line 14). Based on Algorithm 3 for re-selecting the node indices, with parallelizing $v_2$ based on $v_1$ being parallelized, the parameters are $C=16.6$, $L=5.8$, and  ${\sum }_{i=1}^{p_a}{L}_i=4.8$. According to Formula (7), this results in ${\displaystyle \frac{16.6-5.8-4.8}{11-5.8}}=1.154$. With parallelizing $v_5$ based on $v_1$ being parallelized, the parameters are $C=15.8$, $L=7.4$, and ${\sum }_{i=1}^{p_a}{L}_i=5.4$. According to Formula (7), this results in ${\displaystyle \frac{15.8-7.4-5.4}{11-7.4}}=0.833$. Since the result for $v_5$ is smaller, node $v_5$ is selected, at which point $dex=4$. The required $m_{cur}$ is calculated as $⌈{\displaystyle \frac{15.8-7.4-5.4}{11-7.4}}⌉+1=2$, which does not satisfy the condition on line 26; thus, the while loop continues. After parallelizing $v_1$ and $v_5$, the new longest path in the DAG is $\left\{v_1^1,v_2,v_5^1\right\}$, and the $Ar{r}_{dex}$ is $\left\{0,1,4\right\}$ (line 13). At this point, $Opre\left[4\right]=2$ meets the current limit requirement (line 14), which only allows the selection of node $v_2$ (line 15), setting $dex=1$. The required $m_{cur}=⌈{\displaystyle \frac{16.8-5.4-5.4}{11-5.4}}⌉+1=3$ does not satisfy the condition on line 26; thus, the while loop continues. However, since all nodes on the longest path have reached $O_{limit}$, the loop exits. Within the loop where $O_{limit}=2$, m is updated to 2, and $Ocur=[2,1,1,1,1]$. The value of $O_{limit}$ is then updated to 3, and the loop continues iteratively updating the smallest value of m and the current $Ocur$ until all limits have been explored. The final value of m is the new number of cores allocated to high-density tasks after parallelization. If m is equal to the number of cores allocated without parallelization, then parallelization is not necessary for this high-density task (lines 31–32).

5.2. Node Selection Method

This section will introduce the parallel order of nodes on the longest path of the DAG, that is, how to select the node on the longest path for parallel processing. We first analyze the federated scheduling method based on Graham’s bounds. Let $Ocur=\left(O_1,O_2,\dots ,O_{n_k}\right)$ denote the parallel paths of the DAG task nodes, where each element denotes the parallelization option for the corresponding indexed node. For a task’s longest path, the choice of which node to parallelize can minimize the newly calculated number of cores after parallelization. To illustrate this, suppose all nodes have a parallelization option of 1 before parallelization, as shown in Figure 2. We choose nodes $v_2$ and $v_5$, which have the maximum and minimum execution times, respectively, for parallel execution. Before parallelization, both nodes have a parallelization option of 1. After parallelization, $v_2$ remains on the longest thread with a parallelization overhead of 0.2, and the result, as shown in Figure 2b, is that the longest path length is $L\left(Ocur\right)=7$ and $C\left(Ocur\right)=15$. The calculation using the formula ${\displaystyle \frac{15-14}{9-7}}=0.5<{\displaystyle \frac{14-11}{11-9}}=1.5$ and satisfies Formula (6). Using Formula (5), we calculate $y_1={\displaystyle \frac{15-7}{11-7}}=2<y={\displaystyle \frac{14-9}{11-9}}=2.5$. Similarly, after parallelization, $v_5$ remains on the longest thread, and the result, as shown in Figure 2c, shows that the longest path length is $L\left(Ocur\right)=8.6$ and $C\left(Ocur\right)=14.2$. The calculation using the formula ${\displaystyle \frac{14.2-14}{9-8.6}}=0.5<{\displaystyle \frac{14-11}{11-9}}=1.5$ and satisfies Formula (6). Using Formula (5), we calculate $y_2={\displaystyle \frac{14.2-8.6}{11-8.6}}=2.3<y={\displaystyle \frac{14-9}{11-9}}=2.5$.

Following the above analysis, where $y_2>y_1$, we observe that $y_1$ produces a better effect. Furthermore, the results from using Formula (6) remain unchanged when parallelizing $v_2$ or $v_5$, under the supposition that the initial parallelization options for $v_2$ and $v_5$ are both 1. This raises the question of whether the conclusion drawn from the above analysis still holds if the initial parallelization options for both are equal, but for values other than 1. Suppose the initial parallelization options for both are x, with the total WCET and the longest path length for the DAG task denoted by C and L, respectively. Assuming idealized parallelism, where the total WCET is evenly distributed across each thread, suppose the parallelization option is x for $v_2$ with each thread’s WCET being 5 and is x for $v_5$ with each thread’s WCET being 1. The parallelization overhead is $\alpha$. After increasing the parallelization option for $v_2$ by 1, considering the impact of the parallelization overhead on the WCET for a DAG node, the WCET of the DAG before and after parallelization changes from $5x(1+\alpha )$ to $5x$. After parallelization, the execution time per thread becomes ${\displaystyle \frac{5x(1+\alpha )}{x+1}}$. Therefore, the length of the longest path is reduced by $5-{\displaystyle \frac{5x(1+\alpha )}{x+1}}$. The result of the left-hand side of Formula (6) is as follows:

$${\displaystyle \frac{5x(1+\alpha )-5x}{5-\frac{5x(1+\alpha )}{x+1}}}={\displaystyle \frac{x\alpha (x+1)}{1-x\alpha }}$$

After increasing the parallelization option for $v_5$ by 1, the calculation using Formula (6) would be as follows:

$${\displaystyle \frac{x(1+\alpha )-x}{1-\frac{x(1-\alpha )}{x+1}}}={\displaystyle \frac{x\alpha (x+1)}{1-x\alpha }}$$

It can then be seen that the initial parallelization options for $v_2$ and $v_5$ are equivalent and can be set to any arbitrary value, leading to consistent outcomes from using Formula (6).

Consequently, if the initial parallelization options for $v_2$ and $v_5$ are equivalent and can be set to any arbitrary value, and if the longest path remains unchanged, one might question whether $y_1$ can still yield improved outcomes. We introduce Lemma 4 to address this question.

Lemma 4. 

When the parallelization options for two nodes are equal (but an arbitrary value), selecting the node with a longer execution time does not necessarily result in a greater reduction in the number of cores required.

Proof. 

Let the total WCET and the longest path length of the DAG task be denoted by C and L, respectively, with an absolute deadline of D. Suppose the longest path length is reduced by $\Delta L$ due to node parallelization. Based on the aforementioned evidence, parallel processing of any nodes with identical parallelization options results in the same values being obtained from Formula (6). Formula (6) gives the ratio of the change in the DAG’s total WCET to the change in the longest path length. Let this ratio be z. Then, the total WCET increases by $\Delta L$z. Therefore, Formula (5) can be rewritten as follows:

$$Y={\displaystyle \frac{C-L+\Delta Lz+\Delta L}{D-L+\Delta L}}$$

(11)

Taking the derivative of Formula (11) with respect to $\Delta L$ yields

$$Y^{\prime }={\displaystyle \frac{z(D-L)+D-C}{{(D-L+\Delta L)}^2}}<{\displaystyle \frac{C-D+D-C}{{(D-L+\Delta L)}^2}}=0$$

Therefore, Y increases as $\Delta L$ decreases: the larger $\Delta L$ is, the smaller Y becomes. Let the current parallelization option for a node be x, and the execution time per thread for this node be b. The parallelization overhead is $\alpha$. After increasing the parallelization option by 1, the execution time per thread becomes

$${\displaystyle \frac{bx(1+\alpha )}{x+1}}$$

(12)

Thus, the change in the longest path length $\Delta L$ is

$$b-{\displaystyle \frac{bx(1+\alpha )}{x+1}}$$

(13)

Taking the derivative of Formula (13) with respect to b yields

$${\displaystyle \frac{1-x\alpha }{x+1}}$$

(14)

Formula (14) is not strictly greater than 0, indicating that Formula (13) does not strictly increase with respect to b. Therefore, it is not necessarily true that a larger single-thread execution time results in a greater reduction in the longest path length. The current parallelization option of the node also plays a crucial role. Hence, choosing a node with a longer execution time does not necessarily lead to a significant decrease in the computed number of cores.    □

Lemma 4 informs us that selecting nodes with longer execution times does not necessarily lead to a larger decrease in the required number of cores: the current parallelization option of the node must also be considered. Moreover, parallelizing the node with a longer thread time increases the likelihood of altering the longest path. The above analysis is based on the assumption that the longest path remains unchanged. If selecting the node with a longer thread time for parallelization results in a change to the longest path, this could lead to a relatively smaller variation in the longest path length. However, choosing the node with a shorter thread time is still not advisable. Assuming that the current parallelization options are identical for the node with a shorter thread time and the node with a longer thread time, when the longest path remains unchanged after parallelization, the impact of the node with a shorter thread time is not as significant as that of the node with a longer thread time.

The analysis presented above is based on federated scheduling using Graham’s bound. Considering the federated scheduling based on long paths, it is necessary to consider additional paths. When parallelizing nodes on the longest path, those with larger thread times are more likely to affect the probability of changing the longest path, and the decreasing trend in the calculated number of cores is not necessarily more significant. The sum of other required paths may increase, decrease, or remain unchanged. Nodes with shorter thread times can reduce the likelihood of changes to the longest path. By analyzing the monotonicity of Formula (13), it can be concluded that when the longest path remains unchanged, with a certain parallelization overhead and within a certain bound of parallelization options, selecting nodes with shorter thread times can lead to a greater reduction in the number of cores. Therefore, the impact of selecting nodes with either shorter or longer thread times is uncertain. Therefore, we employ five different node selection algorithms to determine the best choice:

• Select the node that minimizes the outcome of Formula (7), as shown in Algorithm 3.
• Based on Algorithm 3, the selection criteria have been modified so that a node is selected only if it meets the condition of Formula (9). Subsequently, select the node that minimizes the result of Formula (7).
• If the current node’s option does not reach the limit, the node index remains unchanged; otherwise, select a node according to its topological order in the longest path.
• In the longest path, select the node with the longest single-thread execution time among the nodes where the parallelization option has not reached its limit.
• In the longest path, among the nodes where the parallelization option has not reached its limit, select the node with the shortest single-thread execution time.

Algorithm 2 Parallelization_Algorithm(${\Gamma }_{high}$)

Input: the high-density task sets: ${\Gamma }_{high}$ Output: parallelization option combination: $\Theta$, the number of cores required for high-density tasks: $M_h$ 1: for each ${\tau }_k\in {\Gamma }_{high}$ do 2:    $Ocur=[1,1,\dots ,1]$ 3: end for 4: for each ${\tau }_k\in {\Gamma }_{high}$ do 5:    $p_a$, m ← Formula (4) 6:    if $m>2$ then 7:      $m_{min}$ ← m 8:      for $O_{limit}\in [2,m_{min}]$ do 9:         Update $Ar{r}_{dex}$ 10:         $Opre=[1,1,\dots ,1]$ 11:         $dex$ ← Node_Selection ($dex$, $Opre$, $O_{limit}$, $Ar{r}_{dex}$) 12:         while True do 13:           Update $Ar{r}_{dex}$, Use Algorithm 1 to get the generalized path after node parallelization 14:           if $Opre\left[dex\right]=O_{limit}$ then 15:              x ← $dex$, $dex$ ← Node_Selection ($dex$, $Opre$, $O_{limit}$, $Ar{r}_{dex}$) 16:              if $dex=x$ then 17:                break 18:              else 19:                $Opre\left[dex\right]=Opre\left[dex\right]+1$ 20:              end if 21:           else 22:              $dex$ ← Node_Selection ($dex$, $Opre$, $O_{limit}$, $Ar{r}_{dex}$), $Opre\left[dex\right]$=$Opre\left[dex\right]+1$ 23:           end if 24:           Use Algorithm 1 to get the parallel generalized path 25:           $m_{cur}$ ← Formula (10), y ← Formula (7) 26:           if $m_{cur}<m$ and $m_{cur}>=O_{limit}$ and $y>0$ then 27:              m ← $m_{cur}$, $Ocur$ ← $Opre$ 28:           end if 29:         end while 30:      end for 31:      if $m_{min}=m$ then 32:         $Ocur=[1,1,\dots ,1]$ 33:      end if 34:    end if 35:    $\Theta \leftarrow \Theta \cup Ocur$, $M_h\leftarrow M_h+m$ 36: end for 37: return $\Theta$, $M_h$

We denote the above five selection algorithms as N-S-Min, N-S-Condition-Min, N-S-Topology, N-S-Descend, and N-S-Ascend. We compared their acceptance ratio differences on a 16-core system. We conducted experiments with parallelization overheads of 0.1, 0.2, and 0.4. Figure 3 displays the scheduling results for these selection methods. From the results in Figure 3, it can be seen that the first selection method achieves the best scheduling outcome in the majority of cases. Furthermore, as the parallelization overhead increases, the acceptance ratios for the first two selection methods tend to converge. However, the acceptance ratio for the first selection method remains slightly higher. This first method aligns with the characteristics of a greedy algorithm. Therefore, we choose Algorithm 3 for node selection in each iteration.

Algorithm 3 Node_Selection($dex$, $Opre$, $O_{limit}$, $Ar{r}_{dex}$)

Input: $dex$, $Opre$, $O_{limit}$, $Ar{r}_{dex}$ Output: $dex$ 1: initialize $y_{min}\leftarrow \infty$ 2: for i in $Ar{r}_{dex}$ do 3:    $Opt$ ← Copy($Opre$) 4:    if $Opt\left[i\right]$≠$O_{limit}$ then 5:      $Opt\left[i\right]$←$Opt\left[i\right]+1$ 6:      Use Algorithm 1 to get      the parallel generalized path 7:      y ← Formula (7) 8:      if $y<y_{min}$ and $y>0$ then 9:         $y_{min}\leftarrow y$; $dex\leftarrow i$ 10:      end if 11:    end if 12: end for 13: return  $dex$

5.3. Time Complexity of Algorithm

This section will introduce the time complexity of Algorithm 2. The outermost loop conducts a one-way search on the tasks (lines 4–36). For n high-density tasks, each high-density task has $n_k$ nodes, and the number of cores dedicated to each task is denoted by $m_k$. The inner loop iterates from 2 to $m_k$ (lines 8–30). However, not all tasks can be parallelized, so the time complexity at this point is less than $O(n·m_k)$. Under the constraint $d_k\in [2,m_k]$, after entering the while loop (lines 12–29), the number of nodes in the longest path is less than $n_k$, so the time complexity of Algorithm 3 is less than $O\left(n_k\right)$. The maximum parallelization limit for the nodes is $d_k$. Not every node needs to be parallelized, nor can every node be parallelized to the maximum limit. Therefore, the time complexity of the while loop is less than $O(d_k·n_k^2)$. Therefore, the overall upper bound of the time complexity for Algorithm 2 is $O(d_k·n_k^2·n·m_k)$.

6. Experimental Results

In this section, we provide a comprehensive evaluation of the proposed algorithm. Initially, in the first segment, we conduct a comparative analysis between our parallelization strategy and alternative parallelization methods in terms of scheduling performance for an identical task set. Following this, in the second segment, we compare our algorithm with existing algorithms in real-time scheduling to determine its effectiveness and performance.

6.1. Compared to Other Parallel Methods

We generate a DAG task set with the following parameter settings for each DAG task ${\tau }_k=(G,D,T)$: (1) The number of nodes, $n_k$, is randomly determined, within the range of 3 to 10. (2) Implicit deadlines are considered, where $D=T$, and D is calculated by $\beta (C-L)+L$, with L denoting the length of the longest path, C denoting the volume of the DAG, and $\beta$ being a parameter. According to Formula (1), the maximum number of cores required for a task is ${\displaystyle \frac{1}{\beta }}$. The number of cores dedicated to high-density tasks is set between 2 and 40, so $\beta$ is assumed to lie within the range of 0.025 to 0.5. (3) The WCET for each node in ${\tau }_k$ is selected from the range of 200 to 900. (4) Based on [1], the parallelization overhead is $\alpha$, and the total execution time of the nodes is given by $c\left(v_i\left(O_i+1\right)\right)=(1+\alpha )c\left(v_i\left(O_i\right)\right)$. (5) According to [5], after parallelizing the node of a DAG task, the execution time for all threads is assumed equal, i.e., $e\left(v_i^1\left(O_i\right)\right)=e\left(v_i^2\left(O_i\right)\right),\dots ,e\left(v_i^{O_i}\left(O_i\right)\right)$. (6) Each node within ${\tau }_k$ is connected with a probability of $p_r=0.3$, forming a set of edges E.

To ensure the reproducibility of our simulation study, we generated synthetic DAG task sets with the following principled parameter choices:

• The number of nodes per DAG, $n_k$, was uniformly sampled between 3 and 10 to reflect typical parallel task complexity.
• Node WCETs were drawn from $[200,900]$ to model heterogeneous computational loads.
• Implicit deadlines were set as $D=T=\beta (C-L)+L$, where $\beta \in [0.025,0.5]$ controls task density and core allocation bounds.
• Edge connectivity probability $p_r=0.3$ was chosen to balance sparsity and dependency richness.
• Parallelization overhead $\alpha$ was varied as 0.1, 0.2, and 0.4 to assess robustness under different overhead regimes.

These settings align with common practices in the real-time systems literature and allow for systematic evaluation of schedulability under controlled yet realistic conditions.

To construct a task set, we first initialize an empty task set, denoted by $\Gamma$. Using the above method, a DAG task is generated and added to $\Gamma$. The necessary condition for the schedulability of the task set is checked as follows: ${\sum }_{{\tau }_k\in \Gamma }vol\left({\tau }_k\right)/T<m$. If this condition is satisfied, $\Gamma$ becomes a valid task set; otherwise, it is re-established.

Following the described method for generating task sets, we created 2000 task sets for the experimental testing. We compare the acceptance ratio differences of the following four parallel approaches on a 16-core system:

• Ours: Parallelization according to Algorithm 2, denoted as Federate-Parallel.
• Single: Tasks are not parallelized and run in a single thread, denoted as Federate-Single.
• Max: Tasks are parallelized to the maximum extent possible within constraints, denoted as Federate-Max.
• Random: For each task node, the limit on parallelization is randomly selected, and then the parallelization options are randomly chosen within the limit, denoted as Federate-Random.

In our experiment, we set the parallelization overhead to 0.1, 0.2, and 0.4, respectively, and Figure 4a–c display the experimental results. The task set utilization is represented on the x-axis, while the acceptance ratio of the task set is represented on the y-axis. Thus, each data point on the graph represents the ratio of schedulable task sets with the same utilization to the total number of generated task sets. The results demonstrate that the acceptance ratio of our parallelization method significantly surpasses that of the other methods. As the parallelization overhead increases, the effectiveness of “Max” and “Random” decreases due to the larger execution times for individual threads in parallel, making it more challenging to satisfy Formula (9). Because no threads are parallelized in “Single”, the acceptance ratio is not affected.

Figure 4a shows that, under the condition of low parallelization overhead, the results of “Max” are superior to those of “Random”. Figure 4b,c show that although both “Max” and “Random” are affected by an increase in the parallelization overhead, “Max” is more severely affected. This is because, under the condition of high parallelization overhead, “Max” results in significantly longer total execution times for a node’s threads, with individual thread execution times exceeding those of other methods, thereby greatly affecting its results. When the parallelization overhead reaches a certain level, the results of “Ours” also decline. However, “Ours” still maintains an advantage in scheduling performance, demonstrating strong resilience to the impact of parallelization overhead. However, its performance gradually approaches that of “Single.” This trend is consistent with the findings reported in [1]. When the parallelization overhead increases, for some task sets, the benefit of critical path reduction achieved through node parallelization diminishes significantly compared to the “Single” method. Consequently, the acceptance ratios of these two methods in the graph become increasingly similar as the parallelization overhead grows.

6.2. Compared with Other Scheduling Algorithms

In this section, we will use the task generation method proposed in the previous section to compare our parallel algorithm with other state-of-the-art real-time parallel task scheduling algorithms. The experimental comparison includes the following advanced scheduling algorithms:

• A global DM scheduling algorithm based on the TDTA strategy, denoted as TDTA-DM [15].
• An improved virtual federated scheduling algorithm, denoted as Virtual-Federate [13].
• A federated scheduling algorithm based on decomposition, denoted as Federate-Decompose [16].
• A gang reservation scheduling algorithm based on federated scheduling, denoted as Gang-Reservation [17].
• An ordinary reservation scheduling algorithm based on federated scheduling, denoted as Ordinary-Reservation [17].
• A parallel algorithm based on the global EDF scheduling algorithm, denoted as EDF-Parallel [1].
• A fluid scheduling algorithm for implicit deadlines, denoted as Fluid-Implicit [18].
• A basic federated scheduling algorithm, denoted as Federate-Li [9].
• A federated scheduling algorithm based on the long path, denoted as Federate-Path [14].

We conduct experiments with parallelization overhead set to 0.1 and 0.2 under 8-core, 16-core, and 32-core conditions to investigate the acceptance ratios of the different task set-normalized utilizations. The experimental results are depicted in Figure 5a–f. The acceptance rate of task sets under our proposed Federate-Parallel algorithm consistently matches or slightly exceeds that of the state-of-the-art Federate-Path algorithm [14] under most task utilization levels and core configurations. This limited yet stable performance improvement stems primarily from our node-level parallelization strategy, which further optimizes core allocation efficiency for high-density tasks. It should be noted that the Federate-Path algorithm itself already tightly bounds response times using long-path techniques, and its scheduling performance is already near the upper limit of such methods. Therefore, the room for further compressing the schedulability boundary on top of such an efficient baseline is inherently limited. The value of our work lies in demonstrating that, even under constraints close to the theoretical boundary, the introduction of node-level parallelization freedom can still exhibit additional system schedulability within an already high-performance scheduling framework. Moreover, as the number of cores increases, the proportion of high-density tasks also rises. Our algorithm effectively reduces the number of cores allocated to high-density tasks, leading to a slight increase in the acceptance ratio as the number of cores of the system increases. In contrast, other algorithms experience a slight decrease in the acceptance ratio as the number of system cores increases. However, as the parallelization overhead increases, as shown in Figure 5b,e, there is a slight decline in the performance of our algorithm.

7. Conclusions

This paper presents a method for parallelizing DAG task nodes using federated scheduling. It also analyzes the parallelization sequence of nodes on the longest path of a DAG task. This algorithm applies DAG node parallelization to federated scheduling based on long paths, addressing issues related to any changes in the longest path and changes in the maximum parallelization limit for DAG nodes, thereby further enhancing the schedulability of tasks. We conducted experiments to evaluate the effectiveness of our algorithm. Firstly, we compared our parallelization algorithm with other parallelization algorithms. The implementation results demonstrate that our method outperforms the others when the parallelization overhead is not particularly high. Secondly, we compared our algorithm with other real-time scheduling algorithms. The implementation results indicate that our algorithm achieves better schedulability compared to other algorithms to a certain extent.

While the proposed algorithm demonstrates significant improvements in schedulability under the considered model, we acknowledge three primary limitations that outline directions for future research.

First, our algorithm assumes that all sub-threads of a parallelized node have identical execution times. This assumption is grounded in the load-balancing strategies commonly employed in modern parallel programming frameworks such as OpenMP and OpenCL, and has been widely adopted in real-time scheduling research. However, in practice, thread execution times may vary due to data dependencies, memory access patterns, cache behaviors, or contention for hardware resources. Such variations could lead to deviations in the estimation of the longest path length L and the total workload C, thereby affecting the accuracy of core allocation. Future work could consider introducing an uncertainty model for execution times or incorporating runtime monitoring mechanisms to enhance the algorithm’s robustness.

Second, our algorithm and its theoretical analysis are developed within the context of identical (homogeneous) multi-core processors. However, modern embedded and high-performance systems increasingly leverage heterogeneous processor architectures (e.g., big.LITTLE, CPU-GPU systems). In such environments, the execution time of a parallel thread can vary significantly depending on the type of core it is allocated to. Our current method, which relies on a single WCET value per thread, does not account for this variability. The core allocation strategy in federated scheduling would also need to be re-evaluated to handle the complex trade-offs between core performance and power consumption. Extending the proposed parallelization algorithm to heterogeneous platforms presents a core challenge and critical step: the algorithm must be capable of characterizing and adapting to the variations in execution time across different types of processing cores. To achieve this, it is essential to establish a multiple-version WCET model to enable effective extension of the algorithm.

Third, our model assumes a fixed parallelization overhead ratio for all nodes. In practice, this overhead may not be constant and could vary with the number of threads, the specific node’s computational characteristics, or the system’s current contention level. This variable overhead could affect the optimality of the node selection and parallelization option allocation determined by our algorithm. The condition for reducing core count (as defined in Lemma 3) might be violated under variable overhead scenarios, potentially leading to suboptimal decisions. Future work will involve refining the algorithm to be robust against such variable overheads, perhaps by adopting a more adaptive or worst-case overhead estimation model.

A highly promising research direction involves extending the deterministic model of this work into stochastic environments to more accurately characterize system behavior. Specifically, building upon the work of Li et al. [19] on federated scheduling for stochastic parallel tasks, the DAG task model presented in this paper can be extended to stochastic DAG tasks, where the execution time of each node and the critical path length L are modeled as random variables. The hard real-time scheduling objective would then be relaxed to “ensuring bounded expected delay” or “meeting probabilistic timing constraints.” Under this stochastic framework, analyzing the response time distribution of tasks becomes crucial. For this purpose, the method introduced by Kocian and Chessa [20] can be adopted, which treats the DAG as a synchronous dataflow graph and utilizes their generalized rejection sampling Monte Carlo technique to efficiently estimate the probability of tasks meeting their deadlines. This approach provides system designers with performance metrics that are richer and more practical than WCET. Ultimately, this framework can be further extended to accommodate dynamic parallelization overhead, transforming the fixed coefficient $\alpha$ into a function of the degree of parallelism or a stochastic process. This would establish a unified and comprehensive stochastic performance prediction model, aiming to maximize resource utilization and system throughput while guaranteeing soft real-time performance.