Schedulability analysis of dynamic priority real-time systems with contention

In multicore scheduling of hard real-time systems, there is a significant source of unpredictability due to the interference caused by the sharing of hardware resources. This paper deals with the schedulability analysis of multicore systems where the interference caused by the sharing of hardware resources is taken into account. We rely on a task model where this interference is integrated in a general way, without depending on a specific type of hardware resource. There are similar approaches but they consider fixed priorities. The schedulability analysis is provided for dynamic priorities assuming constrained deadlines and based on the demand bound function. We propose two techniques, one more pessimistic than the other but with a lower computational cost. We evaluate the two proposals for different task allocators in terms of the increased estimated utilization. The results show that both bounds are valid for ensuring schedulability although, as expected, one is tighter than the other. The evaluation also serves to compare allocators to see which one produces less interference.


Introduction
The use of multicore in embedded systems is already widespread. In critical realtime systems, ensuring the temporal requirements of multicore systems is much more complicated than in single-processor systems. Not only because there is one more dimension (the number of processors) but also because the execution of tasks no longer depends not only on their own computational time, but also on the hardware resources shared between processors. This sharing means interference between processors, so that there are additional delays in the execution of tasks because these resources may be being used by other tasks on other processors. Some works have identified the main sources of interference in multicore systems such as in [11,16,21]. Three main sources of interferences are identified: cache, memory bus and main memory. In a multicore platform with a shared memory model, the data in the cache must be kept coherent. To prohibit access to stale data, additional bus transactions are required. This increases indeterminism. In general, the main memory comprises multiple components such as ranks, banks, and buses that cause unpredictability due to its non-deterministic access time.
The study of such systems, in particular the analysis of interference, has been the focus of attention in recent years in the real-time systems community. Many works have focused on calculating this interference at a low level for each type of shared hardware resource. The idea is to add this estimated interference to the task model, either directly by adding it to the Worst Case Execution Time (WCET), or by adding it to the schedulability test. The advantage is that this estimation is very close to the real interference values. The problem is that this analysis is only valid for that type of hardware resource.
Another approach is to consider a more general task model, not directly linked to the type of shared hardware resource and therefore independent of it. This solution is the only one possible when the hardware vendor does not provide detailed information about the shared resource behaviour. The advantages and disadvantages are obvious: the model does not depend on the specific type of hardware, but by not modelling interference in detail, the temporal analysis is more pessimistic.
The recent work [1] proposes a general task model that considers the contention of the previous mentioned hardware shared resources. They also propose an allocation algorithm to minimize the interference due to contention of shared hardware resources. Nevertheless, their work lacks a schedulability test and assumes an implicit deadline task model for both fixed and dynamic priorities.

Contribution
This paper proposes a schedulability test for multicore real-time systems. We extend the model in [1] to consider constrained task deadlines. In particular, authors propose two contention-aware demand bound functions with different levels of pessimism. The novelty of the contribution is the consideration of dynamic priority scheduling in a model that considers interference due to shared hardware resources and constrained deadlines. We use a general model that can be used with different types of shared hardware resources in contrast with other works that assume a very specific kind of resource. Other works assume only fixed priorities or the interference is only valid for a specific type of shared resource.
This work is organized as follows: The main contributions in the related research area are presented in Sect. 2. Section 3 presents the system model for constraineddeadline systems. Section 4 reviews the classical schedulability analysis for multicore systems with dynamic priorities. Then, we propose two upper bounds to the dbf based on the classical analysis with their corresponding schedulability tests. The experimental evaluation in Sect. 5 demonstrates the acceptance of our schedulability tests. It also compares the different allocation techniques in terms of degree of approximation between the proposed algorithms in terms of utilisation and the actual utilisation.

Related works
There has been a trend towards using multicore platforms due to their high computing performance. From the key results in the field in 2006, there is a lot of research about real-time multicore systems. Some of the main surveys in the area are [14,16,17,25,26].
This work is focused on hard real-time systems, in which the non-compliance of temporal constraints could have dramatic consequences. Therefore, partitioned scheduling is considered in these systems, as migration of tasks between cores is not allowed. Then, the problem of scheduling in a multicore hard real-time system involves a first phase of task to cores allocation and a second phase of independent scheduling of each core.
However, in multicores, the schedulability analysis does not only consider the WCET of each task but also the interference produced when tasks are executing in parallel on other cores and access to the shared hardware resource. This way, the timing correctness of the hard real-time system becomes more complicated. In [25] it is presented a survey about timing verification techniques for multi-core real-time systems until 2018.
In order to integrate the effects of the interference in the schedulability analysis, each task is characterized by its WCET (running in isolation) and the effect of the contention of the shared resource in the response time of the task. Many works consider a single shared resource: memory bus [10,23], scratchpad memories and DRAM [19,22,34], etc. For example, [19] focus on the analysis of memory contention delays in heterogeneous commercial-off-the-shelf (COTS) MPSoC platforms, where their goal is to derive a safe bound on these delays suffered by any critical task in a mixed-criticality system executing on these platforms upon accessing the off-chip DRAM.
However, other works consider multiple shared resources in the contention, which is on the scope of this work. Among the most relevant works of interference contending for multiple resources, [2] presented a Multicore Response Time Analysis (MRTA) framework, that provides a general approach to timing verification for multicore 1 3 systems. They omit the notion of WCET and instead directly target the calculation of task response times through execution traces. They start from a given mapping of tasks to cores and assume fixed-priority preemptive scheduling. Other works as [12] or [30] come from the MRTA framework.
In [20], a schedulability test and response time analysis for constrained-deadline systems is proposed. They analyse the amount of time for shared resource accesses and the maximum number of access segments, which is out of the scope of this work. They also assume fixed priorities. [7] propose a conservative modeling technique of shared resource contention supporting dependent tasks, in contrast to our work, that considers independent tasks. They also assume fixed-priority scheduling. Another work that considers fixed priority scheduling is [3]. This work presents a task model for tasks with co-runner-dependent execution times that generalizes the notion of interference-sensitive WCET (isWCET). Their model considers constrained-deadline sporadic task sets and a fixed priority scheduling. Here, tasks are represented by a sequence of segments, each of which has execution requirements and co-runner slowdown factors with respect to sets of other segments that could execute in parallel with it.
In [1], the interference due to contention is added to the temporal model. Instead of adding it to the WCET, they propose a scheduling algorithm that computes the exact value of interference and an allocator that tries to reduce this total interference. This model considers implicit deadlines in the system and both fixed or dynamic priorities can be used. However, they do not propose any schedulability test to ensure the system's feasibility.
In [18], a partitioned scheduling that considers interference while making partition and scheduling decisions is presented. They present a mixed integer linear programming model to obtain the optimal solution but with a high computation cost and also they propose approximation algorithms. They only consider implicit deadline models. This paper differentiates between isolated WCET and the WCET with interference and overhead. They define an Inter-Task interference matrix, in which each element of the matrix is the interference utilisation between two tasks, considering the inflated WCET when two tasks run together. This work is similar to [1] but in [1] a general model is considered, valid for any type of shared hardware resource while in [18] only interference due to cache sharing is considered.
A similar work is presented in [15]. They define the Multicore Resource Stress and Sensitivity (MRSS) task model that characterises how much stress each task places on resources and its sensitivity to such resource stress. This work also considers a general model to cope with different hardware resources but only fixed priority scheduling policies are considered. The task-to-cores allocation is known a priori.
In this work, we proceed under the assumption of the task model in [1] (as fixed and dynamic priorities can be used) with an extension to a constrained-deadline model and we propose two schedulability tests for dynamic priorities.

Problem definition and task model
This task model is similar to the one presented in [1]. The only difference is the introduction of the parameter D in the temporal model since in this case we will assume that deadlines are less than or equal to periods. We suppose a multicore system with m cores ( M 0 , M 1 , M 2 , ..., M m−1 ) where a synchronous task set of n independent tasks should be allocated to these cores. Each task i is represented by the tuple: where C i is the WCET, D i is the relative deadline, T i is the period and I i is the interference. We assume constrained deadlines, so D i ≤ T i . Tasks can be periodic or sporadic.
The term I i is the time the task takes to access shared hardware resources. A typical case is the operation of reading and writing in memory. Although I i is part of C i , during the time the task is accessing the shared resource, other tasks on other cores will be delayed if they try to access the same resource. So this interference time is defined independently of C i , as will be used to represent the delay caused to other tasks. A detailed description of this parameter can be found in [1].
When we refer to M i , we mean the core in which i is allocated. Moreover, we will define as M k the subset of tasks in that belong to the core M k . Therefore, The hyperperiod of the task set, H, is the smallest interval of time after which the periodic patterns of all the tasks are repeated, and it is calculated as the least common multiple of the task periods. The utilisation of a task i is calculated as the relation between the computation time and the period, . The utilisation of a core M k is the sum of the utilisation of all tasks that belong to this core: The total utilisation of the system is the sum of the utilisation of all cores: . We define A i as the number of activations that i has throughout H, A i = H∕T i . We will also need the following definitions: A task is defined as a receiving task when it accesses shared hardware resources and suffers an increase in its computation time due to the interference produced by other tasks allocated to other cores.

Definition 2 [1]
A task is defined as a broadcasting task when it accesses shared hardware resources and provokes an increase in computation time in other tasks allocated to other cores due to contention.
If I i = 0 , i is neither broadcasting nor receiving task. If I i > 0 , i will be a broadcasting and receiving task if there is at least one task j in other core whose I j > 0. Figure 1 represents the scheduling of a system when interference is considered. In the example, there is a set of three tasks allocated to a platform with two cores. Tasks 0 and 1 are allocated to core 0 and 2 , to core 1. As I 0 = 0 is neither broadcasting nor receiving task, so it only executes its WCET. As I 1 , I 2 > 0 and are allocated to different cores, both are broadcasting and receiving tasks. When they coincide in execution, the interference appears as extra units of execution due to accesses to shared hardware resources (depicted as rectangles with diagonal lines). Note that interference is not caused in all activations, only when two or more broadcasting tasks in different cores are executing.

Interference-aware schedulability analysis for dynamic priorities
There are two phases in order to obtain the schedulability plan of a partitioned multicore system: First, tasks are allocated to cores and then, each core schedules its tasks. Migration is not allowed, since the context of our problem is highly critical real-time systems. Then, once the allocation is performed, the scheduling can be solved as a multiple monocore scheduling problem.
In this section, first we present a well-known dynamic-priority schedulability analysis for constrained deadline task models and then we extend the study to consider the effect of the interference.

Earliest deadline first schedulability analysis
Dynamic priority-based schedulers do not assign an initial priority to the tasks but at runtime. Earliest Deadline First (EDF) in [24] is an optimal scheduling algorithm for dynamic priorities. EDF assigns the highest priority to the task with the earliest absolute deadline, which is a ⋅ T i + D i for the a th activation in a periodic task i .
With constrained deadlines task models, the demand bound function, dbf , determines the schedulability of the system. It is a positive and increasing function that only increases in scheduling points i.e., when a deadline arrives. For Schedulability analysis of dynamic priority real-time systems… partitioned scheduling, this function is calculated for each core so if a task set is allocated to m cores, the system is characterised by m demand bound functions.
Definition 3 [4] The maximum cumulative execution time requested by a set of synchronous tasks M k over any interval of length t is: Therefore, the task set M k is schedulable by EDF if and only if [5]: However, studying the demand bound function over all the hyperperiod H is a tedious process. Some schedulability tests as in [6] reduce the time interval in which the schedulability condition must be satisfied. In 1996, [31,33] derived another upper bound for the time interval which guarantees the schedulability of the task set. This interval is called the synchronous busy period. It is a processor busy period in which all tasks are released simultaneously at the beginning of the processor busy period and ends by the first processor idle period. Its length is the maximum of any possible busy period in any schedule. The length of this interval is calculated by an iterative process [31,33] Then, the schedulability condition is defined as: where L b is the length of the synchronous busy period of the task set.

Interference-aware schedulability analysis for EDF
In this section, we propose a demand bound function that considers the interference so we can provide a schedulability test.
Let us start with the following task set, = [ 0 , 1 ] with 0 = (2, 4, 5, 1) and 1 = (4, 5, 6, 1) , allocated to a dual-core platform. 0 is allocated to core M 0 , and 1 , to M 1 . Figure 2 shows the demand bound function for each core, according to Eq. 2. Note that this function only considers the execution times of the task set of each core and not the received interference.
In order to derive a demand bound function with interference considerations, some definitions need to be introduced.

Definition 4 Let ����� ⃗
v j→i be the activation pattern from a broadcasting task j to a receiving task i .
The meaning of this array is the number of activations of j that fall within an activation a of j . Note that this is an array that later we will use to represent the interference that a broadcasting task j can cause to a receiving task i . In this way, ����� ⃗ v j→i [a] coincides with the maximum overlapping between j and i in its a th activation, etc. The length of this array coincides with the number of activations of i .
The following example shows graphically how the array ����� ⃗ v j→i is characterised. Let us suppose a system with two tasks, � = [ � 0 , � 1 ] with � 0 = (1, 2, 3, 1) and � 1 = (1, 6, 7, 1) , allocated to a dual-core platform. ′ 0 is allocated to core M 0 , and ′ 1 , to M 1 . For the sake of simplicity, computation times and deadlines are not depicted. As seen in Fig. 3 3,3]. Note that in the scheduling, not all activations receive the same interference from other tasks. As showed in Fig. 1, this will depend on whether the tasks coincide in execution. In the next theorem, we are going to provide an expression to calculate ����� ⃗ v j→i and we will demonstrate that this is the maximum number of activations of the broadcasting task j that fall within each activation of i .

Theorem 2
The maximum number of activations of the broadcasting task j that fall within a th activation of i is: being Proof Let us assume that exists t 1 so that t 1 = ⋅ T j and aT i ≤ t 1 < (a + 1)T i .
In this case: and then g(t 1 ) = 1. Therefore, g(t) is equal to 1 only when the broadcasting task j is released in the interval [aT i + 1, (a + 1)T i ) . Evaluating g(t) all over the previous interval we get the number of activations that fall within activation a of i .
It is not possible for the sum of g(t) to be greater than this number of activations, so we can say that the maximum number of activations falling within the interval is correctly calculated with Eq. 4. ◻ Note that if i is not a receiving task, ����� ⃗ v j→i [a] = 0 ∀j, a. Listing 1 shows the pseudo-code (python-like) to calculate ����� ⃗ v j→i .
In the next sections, we will use vector ����� ⃗ v j→i to obtain a demand bound function that incorporates the interference. We will present two proposals, one more pessimistic than the other but with a lower computational cost.

A first approximation
In order to deduce a demand bound function that contemplates the interference, a first approximation is to consider that all the activations of the receiving task i receive the maximum possible interference from the broadcasting task j . From the definition of ����� ⃗ v j→i array, this maximum interference is calculated as: Then, the execution time of a receiving task will be defined as the sum of its own computation time and the worst-case interference received by the broadcasting tasks allocated in other cores.
Note that if i is not a receiving task, ����� ⃗ v j→i [a] = 0 ∀j, a and then C � i = C i .
represents the maximum number of activations of j that fall within an activation of i , the maximum of this array multiplied by the interference factor I j is the maximum interference that i can receive from j . There is no possibility for a task to receive more interference than max a ����� ⃗ v j→i [a] ⋅ I j in activation a so if by adding this value to the demand function the system is schedulable, no deadline will be lost in the execution. ◻ By adding this maximum value to C i , we are considering that the maximum interference occurs in all activations. On the one hand, introducing the same maximum value of interference in all activations makes the system still periodic. Then, the schedulability test must be satisfied in the synchronous busy period and not in the hyperperiod and only in the scheduling points. On the other hand, previous definition is very pessimistic as not all the activations of the receiving task receive its maximum value of interference. This is only a first approximation in order to provide a simple schedulability test. As ����� ⃗ v j→i [a] ⋅ I j exactly provides the maximum possible interference received from j at each activation a of i , next section presents a more accurate (less pessimistic) definition of the demand bound function.

A more accurate definition
In this section, let us present a schedulability test using the exact definition of the activation pattern array, ����� ⃗ v j→i . We will estimate an upper bound of the interference received with this array and we will include it, not in the computacion time but in the demand bound function.

Definition 6
The less pessimistic demand bound function of a task set allocated to a core M k considering the interference is: Proof It is easy to see that: {To simplify the notation, let us define max 0≤a≤A i −1 ����� ⃗ v j→i [a] as maxV.} Developing both sides of the equation: In both sides of the previous equation there are exactly ∀a , each term on the right side is equal or greater than each term on the left side. Therefore:

◻
The second term in Eq. 10 includes the upper bound of the total interference received by i . It is calculated as the number of interferences that all the tasks allocated in other cores provoke to all activations of i released until time t. If i is neither receiving nor broadcasting, the second term of this equation will be equal to 0 (as ����� ⃗ v j→i [a] = 0 ∀j, a ). If j is not broadcasting, I j = 0 and also ����� ⃗ v j→i [a] = 0. This is an upper bound in the sense that the ����� ⃗ v j→i [a] array is maximum, as demonstrated in Theorem 2.
However, when interference is considered throughout the ����� ⃗ v j→i [a] array, the maximum cumulative execution time requested by the tasks may happen indifferently at any time during all the hyperperiod making the demand not periodic. With the following counterexample, we will show that studying the schedulability of the system in the synchronous busy period is not a valid approach.

Counterexample for dynamic priorities
Let us consider the task set defined in the beginning of Sect. 4.2, = [ 0 , 1 ] with 0 = (2, 4, 5, 1) and 1 = (4, 5, 6, 1) , allocated to a dual-core platform. 0 is allocated to core M 0 , and 1 , to M 1 . Once tasks are allocated to cores, EDF algorithm schedules tasks in each core. The actual execution of the task set is shown in Fig. 4. From [31], proving that dbf M k (t) ≤ t during the first busy period is enough to assure the schedulability of the task set. As seen in Fig. 4, the first busy period in M 1 is [0,5], as t=5 is the first instant when all requests have already been served and no additional requests have arrived yet. Then, it may be assumed that the system is schedulable. However, due to interferences, a deadline miss is produced in t=10. So, we can conclude that when interference is considered, the worst scenario may happen at any time during the hyperperiod.
Moreover, not always this interference will be received, it will depend on the real scheduling. For example, suppose that the WCET of 0 is 1 unit instead of 2. Then, the second activation of 0 will not interfere with 1 as it ends just when the second activation of 1 starts. However, as this work evaluates the worst-case scenario, it will consider that these activations interfere as one falls within the other. The schedulability condition for constrained-deadline synchronous and periodic task models based on the demand bound function was presented in Eq. 3. This equation is applied with periodic or sporadic tasks, whose requests happen every inter-arrival time, T i . When interference is considered with the first approach dbf ′ , the behaviour of the task set is no longer periodic, as there is no repeatability. Other works as [5,29] include the definition of the demand bound function for extended models, for example, those in which tasks are also defined by their start times, whose behaviour would be similar to ours with interference. Therefore, schedulability tests are evaluated by intervals, in particular, by the intervals of activation of each task, to ensure that all temporal constraints are met. For this reason and from now on, the demand bound function will be evaluated by intervals, dbf . It can be applied to all the demand bound functions presented in this work.
Considering the interference in the demand bound function and the previous considerations, the schedulability test is now presented.

Theorem 4 A task set M k allocated to a core M k with constrained deadlines is schedulable by dynamic priorities if:
Proof Similar to the proof of Theorem 3, ����� ⃗ v j→i [a] represents the maximum number of times a task j can cause interference in another task j at an activation a. Thus, it is not possible to receive in total more than: interference units. If the system slack ( t 2 − t 1 − dbf (t 1 , t 2 ) ) is greater than or equal to this value, the set of tasks will be schedulable. ◻ Let us follow with the example in Sect. 4.2.3. Figure 5 shows the demand bound functions dbf, dbf ′ and dbf ′′ for both cores. First, the activation patterns are calculated: ������� ⃗ v 1→0 = [1, 2, 2, 2, 2, 1] and ������� ⃗ v 0→1 = [2, 2, 2, 2, 2] . Figures 5a and b show the demand bound functions for cores 0 and 1, respectively. In Fig. 5b, ∀a. As seen in Fig. 5a, there is a deadline missed in the execution of the tasks in core M 1 . This infeasibility is demonstrated with the demand bound functions (Fig. 5b) as dbf �

Experimental conditions
In order to obtain the schedule in a multicore system, first the tasks are allocated to cores (allocation phase) and then each core is scheduled (scheduling phase) independently, as this work does not consider migration of tasks between cores. Therefore, to validate the proposed technique, a simulator that considers both allocation and scheduling phases is implemented. The simulation scenario developed for this work is depicted in Fig. 6. It is divided into three steps:  Schedulability analysis of dynamic priority real-time systems…

Load generation
The load is generated using a synthetic task generator. The number of tasks in each set and the total system utilisation depends on the number of cores in which tasks are allocated to. Given the total system utilisation and a number of tasks for each set, the utilisation is shared among the tasks using the UUniFast discard algorithm of [13]. Periods are generated randomly in [20,1000] and computation times are deduced from the system utilisation. Deadlines are constrained to be less or equal to periods and are set to The experimental parameters of the evaluation process are specified in Table 1. To ensure the reproducibility of the results, these parameters coincide with those used in [1] ( Table 2).
The theoretical utilisation varies between 50 and 75% of the possible maximum load of the system. For example, the maximum load of a system with 4 cores is 4, so for evaluation purposes, the initial utilisation is set to 2.1 ( ≈50%) and 3 (75%). The number of broadcasting tasks is set to 25% of the total number of tasks, except for scenarios 1-6 (2 cores), which is 50%. This is due to the fact that, if only one task is broadcasting, no interference will be produced. Each combination of number of cores and utilisation is evaluated with 10, 20 and 30% of interference over the WCET. Note that not all the tasks in a task set have the same interference value, but the same percentage of interference over the WCET.

Allocation phase
Once the load is generated, it is shared among the cores using different algorithms. In the following, we briefly discuss several existing allocation techniques.
Bin packing heuristics such as Worst Fit (WF) and First Fit (FF) are typically used to solve the allocation problem [8,28]. Moreover, task ordering such as decreasing utilisation (DU) directly affects the task allocation outcomes. In this sense: • First Fit (FF) algorithm. Each item is allocated into the first bin that it fits into, without exceeding the maximum capacity of the bin. If there is no one available, a new bin will be opened. This algorithm results in an unbalanced allocation between cores. • Worst Fit (WF) algorithm. WF allocates each item into the bin that leaves more remaining capacity, i.e., the emptiest bin. This algorithm results in a balanced allocation between cores. • FFDU algorithm (WFDU algorithm). Arrange items i in the decreasing order of utilisation U i and apply FF (WF) in the resulting order of i.
In addition to these heuristics, there are other bin packing algorithms used to solve the allocation problem. [9] presents a survey and classification of these algorithms. However, these heuristic techniques do not consider the interference delays due to contention of shared hardware resources but only the utilisation of the tasks. In [1], authors present an allocation algorithm Wmin, whose objective consists of minimizing a binary matrix W that describes if there is (1) or not (0) interference between tasks. They consider that the contention-aware execution time C ′ ia of i in activation a is the sum of C i plus the interferences caused by running tasks in other cores. This approximation is similar to the one presented in Sect. 4.2.1. Once these algorithms are introduced, let us continue with the description of the allocation phase in the simulation scenario. Tasks are allocated to cores following the three allocation methods: WFDU, FFDU and Wmin. Each allocator generates an allocation file, that contains the information about how tasks are allocated to cores. Then, the feasibility of this allocation plan must be checked. The validation of the allocation phase consists of assuring that the maximum capacity per core is not exceeded, i.e., U M k ≤ 1 ∀k = 0, .., m − 1 and that all tasks are allocated. If these conditions are not satisfied, the corresponding task set is discarded and a new one is generated. Otherwise, the task set moves to the scheduling phase.

Scheduling phase
The contention aware scheduling algorithm proposed in [1] is applied in the scheduling phase. As any priority-based algorithm can be used as the basis for this algorithm, we selected EDF, following the proposal of this paper. The scheduler generates a temporal plan, that contains the information about how tasks are scheduled at each time at each core. This plan must also be validated, checking that all temporal constraints are satisfied. First, we need the following definitions: The utilisation of the core M k , U ′ The actual utilisation of the system is defined as U real and is determined after the scheduling phase, when the actual interference is measured. This utilisation is always lower or equal than U ′ and U ′′ , as not always the estimated interference will be produced, as stated in Sect. 4.2.3. From previous sections (see Corollary 1), it is easy to deduce that:

Experimental results
After conducting the experiments, the evaluation phase consists of measuring the previous utilisation factors and making a comparison between them, for all the scenarios in Table 1. The objective is to compare the allocation algorithms and confirm that no set with U real > U ′′ is schedulable. We also want to know how pessimistic dbf ′ and dbf ′′ are.
First, the difference in terms of utilisation between both demand bound functions presented in this work is evaluated. To do that, we measure two parameters: • Difference between U ′ and U real , measured as � = U � −U real U real (%). • Difference between U ′′ and U real , measured as �� = Figures 7, 8 and 9 depict the percentage difference ′ and ′′ for each scenario and different allocators. As expected, for all scenarios and all allocators ′′ ≤ ′ , as a consequence of Eq. 17. As a general trend, the more cores in the system, the bigger ′ vs ′′ are. This is due to the fact that the estimated worst-case interference increases with the number of cores, as there is more contention between tasks allocated to different cores. However, this difference becomes zero in some cases from scenarios 13. One can differentiate between: • FFDU (Fig. 7): This allocator unbalances the load among cores. It allocates the tasks in the less possible number of cores. Therefore, the used cores are overloaded. Then, when interference appears, the feasibility of the system decreases, as there is little scope to schedule this interference. Generally, FFDU presents low schedulability rates (10% and decreasing in systems from 8 cores [1] • WFDU (Fig. 8): This allocator balances the load among cores. It maximizes the number of used cores so when interference appears, there is enough scope to schedule this interference. With this allocator, the schedulability ratio is high (almost 100% for all number of cores [1]) and we can observe the expected behaviour: the more cores in the system, the more ′ and ′′ are obtained, up to 60 and 50% in scenarios with many cores, respectively. Again, with 10 cores,  75% of utilisation and 20-30% of interference over WCET, the schedulability ratio becomes zero so the percentage difference ′ and ′′ become zero. • Wmin (Fig. 9): This allocator tries to group broadcasting tasks together, in order to reduce the overall provoked interference. In scenarios with few numbers of cores (and consequently few broadcasting tasks), the percentage difference is almost zero as interference is avoided in most of the cases by grouping broadcasting tasks in the same cores. As the number of cores increases, ′ and ′′ increase. Last scenarios (10 cores and 75% of utilisation), the feasibility is reduced and systems cannot be scheduled when interference appears. So ′ and ′′ are zero. Figure 10 depicts the average values of all scenarios for each allocator. From this figure we can conclude that Wmin is the allocator in which ′ and ′′ are lower ( U ′ and U ′′ are closer to the actual utilisations) because it tries to decrease the interference. For WFDU, ′ and ′′ are the highest with respect to the studied allocators. We can conclude that the proposed bounds dbf ′ M k and dbf ′′ M k are valid to assure the schedulability but they are pessimistic as not in all activations the worst case interference may be produced. However, with dbf ′′ M k this pessimism is reduced. Moreover, depending on the allocation method, these upper bounds are more accurate, especially in those cases in which the interference is considered in the allocation phase (Wmin allocator).

Conclusions
This paper proposes two contention-aware schedulability analysis for real-time task models that consider constrained deadlines and dynamic priorities in hard real-time multicore systems. Both approaches are based on the demand bound function dbf to determine the schedulability of the system. The first approximation, dbf ′ , is pessimistic in the sense that it considers that all activations of all tasks receive the maximum possible interference. The second approximation, dbf ′′ , reduces this pessimism as it considers specifically the maximum interference at each activation of the tasks. A schedulability test for each approach is proposed in this work.
We evaluate both approaches with different allocation techniques: FFDU, WFDU and Wmin. We measure the difference between both approaches proposed in this work (in terms of utilisation factors) and the actual utilisation factor measured after the scheduling phase for all the allocators. With this evaluation it is demonstrated that the dbf ′′ approach is much closer to the real value than the dbf ′ approach, as demonstrated mathematically in this work. Among all allocators, Wmin is the algorithm in which both approaches are more accurate, due to the fact that it considers the interference factor in the allocation process.
We plan to further investigate to use scheduling techniques that reduce interference as much as possible. Some variants of well-known scheduling algorithms such as Modified Least Laxity First [27] or Modified Maximum Urgency First [32], can achieve promising results with respect to interference.
We also plan to consider more task models such as mixed-criticality systems or partitioned systems.
Funding Open Access funding provided thanks to the CRUE-CSIC agreement with Springer Nature. his work was supported under Grant PLEC2021-007609 funded by MCIN/ AEI/ 10.13039/501100011033 and by the "European Union NextGenerationEU / PRTR".
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http:// creat iveco mmons. org/ licen ses/ by/4. 0/.