Multi-Core Integration of Sporadic Events in Time-Triggered Systems

We assume a platform composed of $N_c$ identical unit-speed processors. The system utilization is at most $N_c$ since this is a necessary condition for the schedulability of real-time tasks [3]. A time-triggered (TT) task dispatcher is executing TT tasks according to a static schedule table that is generated offline. Idle slots within the TT schedule can be used by ET tasks, which are scheduled at runtime by a $2^{nd}$-level preemptive global fixed-priority scheduler. We consider non-parallel tasks, i.e., ET and TT tasks can only execute on a single core at the same time. We denote the sets of TT and ET tasks by ${𝒯}^{TT}$ and ${𝒯}^{ET}$, respectively. Each TT or ET task ${\tau }_i$ is characterized by the tuple $(C_i,T_i,D_i)$, where $C_i$ denotes the worst-case execution time and $D_i$ denotes the relative deadline. For TT tasks, $T_i$ represents the task period, whereas for ET tasks, we consider a sporadic task model in which $T_i$ specifies the minimum inter-arrival time (MIT). Both TT and ET tasks are assumed to have constrained deadlines, i.e., $D_i\le T_i$.

The system has a microtick $\mu t$, which is the smallest granularity for scheduling decisions and is usually given by the limits of the hardware and underlying OS. We use discrete time where any time value used for scheduling is a non-negative integer [27]. Similar to [19, 35, 31], the scheduling timeline for TT tasks can be divided into equal segments by the macrotick $mt$ (also called slot length) [35, 31], which is a multiple of the microtick $\mu t$. We use the macrotick ratio $\eta =\frac{mt}{\mu t}$ to define the set of slots $[t\cdot \eta ,(t+1)\cdot \eta )$ of a static TT schedule $\sigma$, with each slot (of duration $\eta$) being either idle (i.e., can run an ET task) or executing a TT task. The choice of macrotick involves a trade-off between schedulability, system overhead, and schedule synthesis runtime. TT slots are scaled to macrotick to reduce the synthesis search space, whereas ET tasks require microtick granularity to accurately model fine-grained arrival, preemption, and migration behavior. A macrotick equal to the microtick ($\text{mt}=\mu t$) offers optimal granularity for placing TT slots but can lead to high system overhead and a more complex offline schedule synthesis. In contrast, a higher macrotick reduces the number of TT slots, lowering scheduling overhead, but limits placement options. The choice of macrotick rests with the system designer. We assume that $\forall {\tau }_i$, $D_i,C_i,T_i$ are correctly scaled to a multiple of the $\mu t$ for ET tasks, and to a multiple of the $mt$ for TT tasks. Idle slots within the TT schedule can be used by ET tasks, which are scheduled at runtime by a $2^{nd}$-level preemptive global fixed-priority scheduler, with a granularity $\mu t$. Each schedule $\sigma$ repeats after the schedule cycle (hyperperiod) $HP$, which is a common multiple of the TT task periods (c.f. Sect. 3.3).

In the case of a global scheduling dispatcher, we consider that ET tasks can be migrated at any time, and TT tasks can only be migrated at the start of a TT slot. In the case of fully partitioned multi-core scheduling, both TT and ET tasks are pre-assigned to a core and cannot migrate, even between jobs.

We introduce several notations from [19] to improve readability. For any task ${\tau }_i$, we denote its priority by $p(i)$ and its utilization by $U_i=\frac{C_i}{T_i}$. The total utilization of all TT tasks is given by $U^{TT}={\sum }_{{\tau }_i\in {𝒯}^{TT}}{U}_i$, while the total utilization of all ET tasks is denoted by $U^{ET}={\sum }_{{\tau }_i\in {𝒯}^{ET}}{U}_i$. Following the same notation, we define $C^{TT}={\sum }_{{\tau }_i\in {𝒯}^{TT}}{C}_i$ as the total computation time of all TT tasks. At runtime, as illustrated in Figure 1(a), the dispatcher selects one ready task with the highest priority. All TT tasks are assigned the same priority, which is the highest in the system. ET tasks have lower priority than TT tasks and are ordered according to their relative priorities: if ${\tau }_i$ has higher priority than ${\tau }_j$, i.e., $p(i)>p(j)$, then $i>j$. We further assume that each ET task has a distinct priority, namely $p(i)\ne p(j)$ for all $i\ne j$.

RTA was originally introduced in [34] for constrained-deadline task systems. Here, we use the description from [26]. RTA uses the notion of the level-$k$ busy period, defined as the longest continuous interval during which tasks with priority higher than or equal to that of some task ${\tau }_k$ execute until the active job of ${\tau }_k$ completes. In existing multi-core analyses, the level-$k$ busy period of a task ${\tau }_k$ consists of three components: 1) the body, which captures the contribution of all jobs whose release times and deadlines both lie within the level-$k$ busy period; 2) the carry-in contribution, which accounts for at most one job released before the start of the level-$k$ busy period; and 3) the contribution of at most one job released within the level-$k$ busy period whose deadline occurs after the end of that period. The workload $W_k$ of a task ${\tau }_k$ over a given busy period is the total execution time accumulated by that task within the period. The interference $I_k$ represents the portion of the workload $W_k$ that can actually interfere with ${\tau }_k$, that is, the part that may prevent ${\tau }_k$ from executing. We use $W_k^{NC}({\tau }_i,x)$ and $I_k^{NC}({\tau }_i,x)$ to denote, respectively, the workload and interference bounds over an interval of length $x$ when ${\tau }_i$ has no carry-in jobs. Similarly, $W_k^{CI}({\tau }_i,x)$ and $I_k^{CI}({\tau }_i,x)$ denote the corresponding workload and interference bounds over an interval of length $x$ when ${\tau }_i$ has carry-in jobs.

In [27, 26] (with processor capacity $1$ and unique priority $p(k)$ for each ${\tau }_k$) the total interference on one job of task ${\tau }_k$ is:

where $𝒵\subseteq 𝒯\times 𝒯$ denotes the set of all partitions of the higher-priority task set $𝒯>k$ into the subsets ${𝒯}^{NC}$ and ${𝒯}^{CI}$, such that ${𝒯}^{NC}\cup {𝒯}^{CI}=𝒯>k$, ${𝒯}^{NC}\cap {𝒯}^{CI}=\mathrm{\varnothing }$, and $\left|{𝒯}^{CI}\right|\le N_c-1$. Maximizing over $𝒵$ allows ${\mathrm{\Omega }}_k(x)$ to capture the worst-case total interference under the condition that at most $N_c-1$ tasks have carry-in jobs, while all remaining tasks have no carry-in. Thus, ${\mathrm{\Omega }}_k(x)$, which can be computed in linear time, represents the maximum interference generated by higher-priority tasks on a job of ${\tau }_k$ during a level-$k$ busy period of length $x$. The interferences and workloads are:
$I_k^{NC}({\tau }_i,x)$ $={\left[\min (W_k^{NC}({\tau }_i,x),x-C_k+1)\right]}^{+},$ $I_k^{CI}({\tau }_i,x)$ $={\left[\min (W_k^{CI}({\tau }_i,x),x-C_k+1)\right]}^{+},$ $W_k^{NC}({\tau }_i,x)$ $=\lfloor {\displaystyle \frac{x}{T_i}}\rfloor \cdot C_i+\min (xmod{T}_i,C_i)\text{, }{W}_k^{CI}({\tau }_i,x)=\lfloor {\displaystyle \frac{{\left[x-C_i\right]}^{+}}{T_i}}\rfloor \cdot C_i+C_i+\alpha ,$ with $\alpha ={\left[\min ({[x-C_i]}^{+}mod{T}_i-(T_i-R_i),C_i-1)\right]}^{+}$ and $R_i$ the worst-case response time of ${\tau }_i$. Using the above, the following RTA was proposed in [27] for constrained deadlines:

The searches return “unschedulable” as soon as $x>T_k$, since $D_k\le T_k$.

RTC [63] is a framework used to calculate the worst-case response-time (WCRT) of real-time tasks (e.g. [59]). The WCRT of ${\tau }_i\in 𝒯$ is based on the distance between a curve representing the arrival of requests and a curve representing the service offered. The WCRT is detailed in Theorem 5 and illustrated in Figure 1(b). We refer the reader to [19, 63, 48] for a more complete and detailed description of Real-Time Calculus.

An arrival curve denotes the maximum number of requests (which may be in terms of cycles, time units, etc) arriving during an interval $]s,e]$.

These curves denote the processing power (which may be in terms of processor cycles, time units, etc.) available to $𝒯$ from the resource during an interval ]s,e].

This curve denotes the minimum processing power that will be used by $𝒯$ during a backlogged interval ]s,e].

Theorem 5 is not used in multi-core systems. However, the proof in [36] Section 1.4, Theorem 1.4.2 (Delay Bound), shows that they depend solely on the mathematical definition of the curves detailed in Definitions 2 and 4 and so they can be applied to a multi-core system. The challenge of using this theorem in multi-core systems is to compute accurate arrival curves and service curves for the given tasks and dispatchers.

Since we will do a per-task analysis, we must model an arrival curve for each task ${\tau }_i$ and the service offered by the multi-core system to each task ${\tau }_i$.

If task ${\tau }_i$ releases jobs with execution cost $C_i\in {ℝ}^{+}$ according to a period, or minimum inter-arrival time, $T_i\in {ℝ}^{+}$, then it can be represented by a staircase arrival curve $\alpha :{ℝ}^{+}\to {ℝ}^{+}$, where $\alpha (0)=0$ and $\alpha (t)=C_i\cdot \lceil t/T_i\rceil$ for $t>0$ [9]. Alternatively, it can be upper-bounded by the more pessimistic linear arrival curve ${\alpha }_{r,b}:{ℝ}^{+}\to {ℝ}^{+}$, defined by ${\alpha }_{r,b}(0)=0$ and ${\alpha }_{r,b}(t)=rt+b$ for $t>0$, with $r=\frac{C_i}{T_i}$ and $b=C_i$ [11]. Within a given schedule slot, a task executes at a constant rate $R$, corresponding to one unit of computation per unit of time, after an initial delay, or latency, $L$. This latency may result from blocking caused, for example, by higher-priority tasks. Such behavior corresponds to a rate-latency service [11], which is modeled by the function ${\beta }_{R,L}:t\mapsto R\cdot {\left[t-L\right]}^{+}$.

Integrating ET and TT tasks has been studied in a holistic approach [51, 52, 50], which uses a greedy method to evaluate TT and ET schedulability. However, this approach is limited to single-core nodes with strictly periodic and non-preemptive TT slots, as well as periodic ET tasks with bounded jitter. In contrast, our method is designed for global multi-core scheduling, supporting a more flexible preemptive, non-strictly-periodic TT task model and sporadic ET tasks. Meroni et al. [47] present simple (SPoll) and advanced polling (Adv Polling) for integrating ET and TT tasks in partitioned multi-core systems. SPoll assigns a polling server to each ET task by oversampling the period to ensure ET schedulability. Adv Polling leverages hierarchical analysis [1, 57, 58, 54] to decouple TT schedule synthesis from ET analysis, using a genetic algorithm to solve the allocation problem. Our method addresses the global scheduling of TT and ET tasks without fixed task allocation.

In multi-core systems, the “critical instant” concept from single-core schedulability analysis does not always hold, and scheduling can exhibit timing anomalies. This makes determining the true worst-case behavior in multi-core systems significantly more challenging than in single-core systems [28]. Several works [42, 32, 56, 8, 38] address multi-core hierarchical scheduling. Resource abstraction models such as the Multi-processor Periodic Resource (MPR) model for virtual clustering [56] and the Bounded-Delay Multipartition (BDM) [42] interface, enable compositional analysis by encapsulating components behind abstract resource interfaces which can be beneficial for integrating TT and ET tasks. However, when used in this context, both TT and ET tasks are encapsulated behind abstract resource interfaces. The initial work in [38] provides a coarse interface (bandwidth only) that is not expressive enough to be able to capture fine-grained TT burstiness. The MPR model specifies a collective budget $\mathrm{\Theta }$ provided every period $\mathrm{\Pi }$ with a bounded concurrency $m$. The BDM interface [42] balances total bandwidth ${\beta }_m$ and maximum delay $\mathrm{\Delta }$ for admission control and allocation. When TT tasks are modeled as higher-priority supply, the resulting analysis must conservatively account for their potential parallel execution, which can lead to pessimism for predominantly sequential TT workloads and does not explicitly exploit restricted migration patterns or statically synthesized TT schedules. Moreover, such approaches may be too coarse for tight TT and ET integration. They cannot express fine-grained TT bursts, cannot synthesize TT schedules that explicitly respect ET deadlines, and cannot capture the strong coupling between offline TT synthesis and online ET scheduling that we address. We compare directly to BDM, because, as shown in [42] (Section IV-A), it provides a compositional multiprocessor resource abstraction that remains well-defined without strong synchronization assumptions, unlike MPR. Moreover, BDM is most similar to our BLC envelope definition, i.e., they are symmetric since BDM defines a lower bound on supply while BLC defines an upper bound on demand/interference. In the experiment section (c.f. Section 4.2.4) we show that our method dominates BDM across all evaluated scenarios both in terms of schedulability and runtime.

We build upon [19] where an RTC approach is introduced that expresses a constraint for the TT task schedule (a maximal affine envelope), which ensures sporadic ET task deadlines and models this envelope as a burst limiting constraint (BLC), which can be integrated into any existing TT schedule algorithm. It is shown in [19] that the method outperforms all previous approaches in terms of schedulability and runtime, including Holistic scheduling [51, 52, 50], SPoll [47], Adv Polling [47], and Slot Shifting [23, 30, 29, 31]. However, the work in [19] mainly focuses on the single-core case and only handles multi-core in a fully partitioned variant. The RTC theory used in [19] cannot be applied to global scheduling, and the BLC is only defined for a single core, its proof is based on hypotheses of strict partitioning. In this paper, we extend not only the RTC and RTA theory but also the approach from [19] to be able to handle a global scheduling approach for multi-core systems.

Finally, extending RTC to multi-core systems was studied in [39], where a pseudo-polynomial-time algorithm for testing response times of task jobs was proposed. However, [39] only considered ET tasks.

In [19], two methods (called B3LF and LMminB3LF, c.f. Figure 2) are presented to compute TT schedules that not only ensure the schedulability of TT tasks but also fulfill the ET deadline constraints. Both methods from [19] share the same two key functions: 1) they compute a schedule enforcing a Burst Limiting Constraint (BLC) [19], using a modified Least Laxity First (LLF) scheduler [40]; and 2) perform a schedulability analysis, based on a formal timing analysis using RTC, of the ET tasks.

The BLC shapes the TT schedule to ensure the TT cumulative computation time remains below an affine envelope $t\mapsto r^{TT}\cdot t+b^{TT}$, with $r^{TT}$ the cumulative rate of the TT tasks, $U_{TT}$. Depending on the method, the value of $b^{TT}$ is computed differently.

In the case of B3LF (c.f. Figure 2), a binary search is used to compute a maximum TT burst $b_{max,ET}^{TT}$, i.e., the maximum impact that the TT tasks may have on the ET tasks, such that the ET tasks still fulfill their deadlines. Then a schedule enforcing a BLC parameterized with $b^{TT}=b_{max,ET}^{TT}$ is generated. In the case of LMminB3LF (c.f. Figure 2), a binary search is used to vary the possible $b^{TT}$ used to parameterize the BLC, to find the minimum $b_{min,TT}^{TT}$ such that a TT schedule can be generated. Hence, the final TT schedule is computed to have the least impact on ET tasks. Then, using this $b_{min,TT}^{TT}$, the RTC analysis is run to check ET schedulability. If this is not the case, the system is not schedulable.

In the single-core and fully-partitioned multi-core results from [19], LMminB3LF has a similar schedulability to B3LF, with a loss of a few percent in some cases due to different binary searches. However, LMminB3LF offers interesting optimization to maximize schedule re-utilization. In the event of modifications to ET tasks (TT tasks remain unchanged), only the schedulability analysis needs to be run to determine if the generated TT schedule is still valid. In the next section, we will extend both methods to global multi-core systems.

Analyzing the schedulability of an ET task ${\tau }_i$ often implies calculating the busy-period for any time interval [5, 4, 27], i.e., the maximum interval during which ${\tau }_i$ cannot be executed. In this paper, we show how to extend the busy-period computation to integrate the shaping of the TT schedule.

We have shown that the workload of higher priority tasks used in RTA and RTC depends on the shaping function ${\alpha }_{fp}^{TT}(t)=U^{TT}\cdot t+b^{TT}$, the affine envelope the schedule must enforce before the fixed-priority online scheduler. The rate of the affine function is always $r^{TT}=U^{TT}$, the value of $b^{TT}$ depends on the method, B3LF or LMminB3LF (c.f. Section 2.5).

In the next part, we analyze the Burst Limiting Constraint to demonstrate how to parametrize it to shape the TT task workload accurately. The proofs are based on the RTC framework, but could be done using another formalism.

According to Definition 2, an arrival curve $A_{fp}^{TT}$ is defined by: $\forall s\le e$, $R(e)-R(s)\le A_{fp}^{TT}(e-s)$. It means that any curve ${\alpha }_{fp}^{TT}(e-s),$ such that $A_{fp}^{TT}(e-s)\le {\alpha }_{fp}^{TT}(e-s),\forall s\le e$ is also a TT arrival curve.

Similar to [19], the schedule is the output of the modified LLF scheduler, which itself depends on the BLC. Thus ${\alpha }_{fp}^{TT}$ is limited by a maximum service curve of the B3LF ${\gamma }_{b3lf}^{TT}(t)$, which is the minimum of maximum service curves of the BLC ${\gamma }_{blc}^{TT}(t)$ and mLLF ${\gamma }_{mllf}^{TT}(t)$:

So, a TT arrival curve in the online fixed-priority scheduler, $A_{fp}^{TT}(t)$, is constrained by: $A_{fp}^{TT}(t)\le \min ({\gamma }_{blc}^{TT}(t),{\gamma }_{mllf}^{TT}(t)).$ We know from [19] that the lower bound of the maximum service offered by the LLF scheduler is ${\gamma }_{mllf}^{TT}(t)=N_c\cdot t$, which cannot be used to enforce an affine envelope, as this is the maximum service the multi-core system can offer.

Additionally, since $A_{fp}^{TT}(t)\le {\gamma }_{blc}^{TT}(t)$ and due to Definition 2, ${\gamma }_{blc}^{TT}$ is an arrival curve for TT tasks. By setting the BLC such that ${\gamma }_{blc}^{TT}={\alpha }_{fp}^{TT}(t)=U^{TT}\cdot t+b^{TT}$, we will be able to create a schedule enforcing the desired TT burst $b^{TT}$.

Therefore, we must first extend the definition of the BLC from [19] to multi-core systems and define the corresponding ${\gamma }_{blc}^{TT}(t)$. Then we must find the correct parameters for the BLC, i.e., its maximum level $L_M$ and its rate $I^{idle}$.

We now present the maximum service curve offered to TT tasks by the generalized BLC, which we will use afterwards to parameterize the affine envelop $U^{TT}\cdot t+b^{TT}$.

The proposed method can be applied to any TT schedule generation method. The TT synthesis algorithm only needs to be able to keep track of the budget and remove the tasks not fulfilling the BLC from consideration until the budget is sufficient again. There are many options for generating TT schedules based on the definition and requirements of TT tasks (e.g., [49, 45, 17]). Any of these algorithms can be adapted to include our BLC constraint and also fulfill ET task deadlines. In this paper, we adapt an LLF-based TT schedule generator. Least Laxity First(LLF) [40] is an online algorithm that uses the current task laxity to assign dynamic priorities to task jobs. LLF has good performance on multi-core systems [37] and is well-suited to track the BLC budget consumption and replenishment at any instant on the discrete timeline [19]. Simulating LLF, or other online algorithms like EDF, to generate TT schedules has been introduced before [16, 44]. However, any work-conserving algorithm will not result in the schedulability of TT tasks and the fulfillment of the BLC, since sometimes it may be necessary to insert idle times even though there are TT tasks with execution time left in order to have the full burst later. For a more in-depth explanation, we refer the reader to the counterexample and detailed description in Figure 4 in [19].

The B3LF is detailed through two algorithms which are inspired by and largely follow the algorithms from [19]. Algorithm 1 presents the TT schedule generation under the BLC. The schedule must be valid for any time interval: it is generated for a hyperperiod and must be valid under the BLC indefinitely. It means that the budget variation during the time interval must be positive or null: the budget at the end of the hyperperiod $bd{g}_{\sigma }(HP)$ must be greater or equal to the budget $bd{g}_{\sigma }(0)$ at the start of HP so that the budget always remains greater than or equal to $0$. Algorithm 2 shows how to incorporate the BLC into a modified LLF for multi-core.

In Algorithm 1, following an approach similar to [19], we first verify the two sufficient conditions in lines 3 and 9. This verification is performed using our mLLF scheduler through the function mLLF($initia{l}_{b}udget,{𝒯}^{TT},HP,L_M,I^{TT},I^{idle}$), which generates a schedule based on the specified initial budget. If these conditions are not satisfied, the mLLF scheduler is executed with different initial-budget values, as shown in line 13, starting from an initial budget equal to the budget at $HP$. To reduce the search space we use a similar method as in [19] where we select (line 14) the new initial budget as a multiple of $\eta \cdot I^{TT}$ (and not directly $bd{g}_{\sigma }(HP)$) since this has a large performance boost without sacrificing too much schedulability (c.f. [19]). Similar to [19], Algorithm 1 finishes when a solution $\sigma$ is found (i.e., $bd{g}_{\sigma }(0)$ $\le$ $bd{g}_{\sigma }(HP)$), or when the final budget reaches the minimum final budget possible, $bd{g}_{\sigma }(HP)\le \min \mathrm{\_}budget(HP)$. The function of the final budget $\sigma \mapsto bd{g}_{\sigma }(HP)$ is strictly decreasing from one iteration to the next when no solution is found, which ensures the algorithm always finishes.

Algorithm 2 details a multi-core LLF enforcing the BLC. Over all time slots $t$ of the hyperperiod, firstly, for each TT task, we check if a deadline has been missed, then we update the remaining duration of the task and update the deadline, if necessary. Finally, the laxity of the TT task is computed. Secondly, we assign the slots for each $t$ on each core. After each assignment, the budget is updated before the assignment on the next core. Hence, the BLC is always fulfilled on all cores $\forall t$. Additionally, in the function returning the valid task with the least laxity, i.e., the LL function, see line 11, we check $\sigma$ and select only a task that has not been assigned to a core at the current time $t$. In Algorithm 2, contrary to the single-core algorithm (i.e., Algorithm 2 [19]), as idle slots can be scheduled at each time $t$ at the same time TT slots are scheduled on other cores, we found no advantage in varying the idle task laxity. Its laxity is set to $HP$, to be used if no other task is available and fulfilling the BLC.

We use the real-world automotive use-case from [19], featuring a $6$ core platform. There are $120$ tasks with periods $\{5,10,20,40,80\}ms$, a distribution of $\{9.166\%,26.66\%,12.5\%,19.166\%,32.508\%\}$ and total system utilization of $3.08$. In the original use-case, all tasks were defined as time-triggered and were pre-assigned to the $6$ cores. In [19], the TT tasks are changed to ET when the task’s laxity (i.e., $T_i-C_i$) is bigger than $100$ macroticks, hence converting $73$ tasks from the original TT type to be ET. For each resulting ET task ${\tau }_i$ the priority is computed as $p(i)=max(0,(6-\lfloor (T_i-C_i)/100\rfloor )\cdot 100)$. TT tasks with laxity under $100$ macroticks are kept of type TT, with priority set to $700$. Then, each ET task priority is increased until each ET task has a unique priority. We used $mt=250\mu s$ and $\mu t=1\mu s$ and so $\eta =250$.

All assessed methods successfully computed schedules for all $6$ cores. The runtimes are as follows: $171$ ms for RTA Global B3LF, $204$ ms for RTA Global LMminB3LF, $471$ s RTC Global B3LF, $539$ s for RTC Global LMminB3LF, $20$ ms for Fully-Partitioned B3LF, $56$ ms for Fully-Partitioned LMminB3LF, $241$ ms for Fully-Partitioned Adv Polling. Unsurprisingly, we can see that RTA is much faster (over 2000 times) than RTC. This is because RTC must calculate each point of the minimum service curve and the arrival curve, whereas RTA converges much faster with the fixed-point search.

We created synthetic test cases that align to the macrotick, period distribution, and period values of the real-world use-case. We set the macrotick to $250\mu s$ and periods are $\{5,10,20,40,80\}ms$ respecting a distribution of $\{9.166\%,26.66\%,12.5\%,19.166\%,32.5\%\}$.

For each synthetic test set, we generate $10$ TT and $10$ ET tasks per core. This gives us a total of $120$ tasks when considering the 6-cores use-case, which is the number of cores and tasks in the real-world use case. We study constrained deadlines for ET tasks, with $\forall {\tau }_i\in {𝒯}^{ET},D_i\in [C_i,T_i]$. TT tasks have implicit deadlines, i.e., $\forall {\tau }_i\in {𝒯}^{TT},D_i=T_i$. For each case, we generate $1200$ individual test sets per tuple ($U^{TT}$,$U^{ET}$), with $U^{TT}$ and $U^{ET}$ varying in {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7} and such that $U^{TT}+U^{ET}\le 0.9$. For each tuple ($U^{TT}$,$U^{ET}$), these $1200$ test sets are merged depending on the number of cores (e.g., for the 6-core use-case, we obtain $200$ merged sets for each tuple).