# k2U: A General Framework from k-Point Effective Schedulability Analysis to Utilization-Based Tests

To deal with a large variety of workloads in different application domains in real-time embedded systems, a number of expressive task models have been developed. For each individual task model, researchers tend to develop different types of techniques for deriving schedulability tests with different computation complexity and performance. In this paper, we present a general schedulability analysis framework, namely the k2U framework, that can be potentially applied to analyze a large set of real-time task models under any fixed-priority scheduling algorithm, on both uniprocessor and multiprocessor scheduling. The key to k2U is a k-point effective schedulability test, which can be viewed as a "blackbox" interface. For any task model, if a corresponding k-point effective schedulability test can be constructed, then a sufficient utilization-based test can be automatically derived. We show the generality of k2U by applying it to different task models, which results in new and improved tests compared to the state-of-the-art. Analogously, a similar concept by testing only k points with a different formulation has been studied by us in another framework, called k2Q, which provides quadratic bounds or utilization bounds based on a different formulation of schedulability test. With the quadratic and hyperbolic forms, k2Q and k2U frameworks can be used to provide many quantitive features to be measured, like the total utilization bounds, speed-up factors, etc., not only for uniprocessor scheduling but also for multiprocessor scheduling. These frameworks can be viewed as a "blackbox" interface for schedulability tests and response-time analysis.

## Authors

• 17 publications
• 2 publications
• 23 publications
• ### Evaluate and Compare Two Utilization-Based Schedulability-Test Frameworks for Real-Time Systems

This report summarizes two general frameworks, namely k2Q and k2U, that ...
05/08/2015 ∙ by Jian-Jia Chen, et al. ∙ 0

• ### Schedulability Bounds for Parallel Real-Time Tasks under Global Rate-Monotonic Scheduling

Schedulability bounds not only serve as efficient tests to decide schedu...
11/13/2020 ∙ by Xu Jiang, et al. ∙ 0

• ### New Analysis Techniques for Supporting Hard Real-Time Sporadic DAG Task Systems on Multiprocessors

The scheduling and schedulability analysis of real-time directed acyclic...
07/31/2018 ∙ by Zheng Dong, et al. ∙ 0

• ### HeRTA: Heaviside Real-Time Analysis

We investigate the mathematical properties of event bound functions as t...
07/23/2020 ∙ by Frank Slomka, et al. ∙ 0

• ### EDF-VD Scheduling of Mixed-Criticality Systems with Degraded Quality Guarantees

This paper studies real-time scheduling of mixed-criticality systems whe...
05/04/2016 ∙ by Di Liu, et al. ∙ 0

• ### LINTS^RT: A Learning-driven Testbed for Intelligent Scheduling in Embedded Systems

Due to the increasing complexity seen in both workloads and hardware res...
07/10/2020 ∙ by Zelun Kong, et al. ∙ 0

• ### Sufficient FTP Schedulability Test for the Non-Cyclic Generalized Multiframe Task Model

Our goal is to provide a sufficient schedulability test -ideally polynom...
10/26/2011 ∙ by Vandy Berten, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Over the years, real-time systems researchers have devoted a significant amount of time and efforts to efficiently analyze different task models. Many successful stories have been told. For many of the above-mentioned task models, efficient scheduling and schedulability analysis techniques have been developed (see [16] for a recent survey). Unfortunately, for certain complex models such as the self-suspending task model, existing schedulability tests are rather pessimistic, particularly for the multiprocessor case (e.g., no utilization-based schedulability test exists for globally-scheduled multiprocessor self-suspending task systems).

In this paper, we present , a general schedulability analysis framework that is fundamentally based on a -point effective schedulability test under fixed-priority scheduling. The key observation behind our proposed -point test is the following. Traditional fixed-priority schedulability tests often have pseudo-polynomial-time (or even higher) complexity. For example, to verify the schedulability of a (constrained-deadline) task

under fixed-priority scheduling in uniprocessor systems, the time-demand analysis (TDA) developed in

[26] can be adopted. That is, if

 ∃t with 0

then task is schedulable under the fixed-priority scheduling algorithm, where is the set of the tasks with higher priority than , , , and represent ’s relative deadline, worst-case execution time, and period, respectively. TDA incurs pseudo-polynomial-time complexity to check the time points that lie in for Eq. (1).

To obtain sufficient schedulability tests under fixed priority scheduling with reduced time complexity (e.g., polynomial-time), our conceptual innovation is based on the observations by testing only a subset of such points to derive the minimum that cannot pass the schedulability tests. This idea is implemented in the framework by providing a general -point effective schedulability test, which only needs to test points under any fixed-priority scheduling when checking schedulability of the task with the highest priority in the system. This -point effective schedulability test can be viewed as a “blackbox” interface that can result in sufficient utilization-based tests. We show the generality of by applying it to analyze several concrete example task models, including the constrained- and arbitrary-deadline sporadic task models, the multi-frame task model, the self-suspending task model, and the DAG task model. Note that is not only applicable to uniprocessor systems, but also applicable to multiprocessor systems.

Related Work. An extensive amount of research has been conducted over the past forty years on verifying the schedulability of the classical sporadic task model in both uniprocessor and multiprocessor systems (see [16] for a survey of such results). Much progress has also been made in recent years on analyzing more complex task models that are more expressive. There have been several results in the literature with respect to utilization-based, e.g., [31, 22, 24, 37, 23, 7, 30], and non-utilization-based, e.g., [11, 20], schedulability tests for the sporadic real-time task model and its generalizations in uniprocessor systems. The approaches in [11, 20] convert the stair function in the time-demand analysis into a linear function if in Eq. (1) is large enough. The methods in [11, 20] are completely different from this paper, in which the linear function of task starts after , in which our method is based on points, defined individually by .

Most of the existing utilization-based schedulability analyses focus on the total utilization bound. That is, if the total utilization of the task system is no more than the derived bound, the task system is schedulable by the scheduling policy. For example, the total utilization bounds derived in [31, 22, 10] are mainly for rate-monotonic (RM) scheduling, in which the results in [22] can be extended for arbitrary fixed-priority scheduling. Kuo et al. [23] further improve the total utilization bound by using the notion of divisibility. Lee et al. [24]

use linear programming formulations for calculating total utilization bounds when the period of a task can be selected. Moreover, Wu et al.

[37] adopt the Network Calculus to analyze the total utilization bounds of several task models.

The novelty of comes from a different perspective from these approaches [31, 22, 24, 37, 23]. We do not specifically seek for the total utilization bound. Instead, we look for the critical value in the specified sufficient schedulability test while verifying the schedulability of task . A natural schedulability condition to express the schedulability of task is a hyperbolic bound, (to be shown in Lemma 1), whereas the corresponding total utilization bound can be obtained (in Lemmas 2 and 3).

The hyperbolic forms are the centric features in analysis, in which the test by Bini et al. [7] for sporadic real-time tasks and our recent result in [30] for bursty-interference analysis are both special cases and simple implications from the framework. With the hyperbolic forms, we are then able to provide many interesting observations with respect to the required quantitive features to be measured, like the total utilization bounds, speed-up factors, etc., not only for uniprocessor scheduling but also for multiprocessor scheduling. For more details, we will provide further explanations at the end of Sec. 4 after the framework is presented. For the studied task models to demonstrate the applicability of , we will summarize some of the latest results on these task models in their corresponding sections.

Contributions. In this paper, we present a general schedulability analysis framework, , that can be applied to analyze a number of complex real-time task models, on both uniprocessors and multiprocessors. For any task model, if a corresponding -point effective schedulability test can be constructed, then a sufficient utilization-based test can be derived by the framework. We show the generality of by applying it to several task models, in which the results are better or more general compared to the state-of-the-art:

1. For uniprocessor constrained-deadline sporadic task systems, the speed-up factor of our obtained schedulability test is 1.76322. This value is the same as the lower bound and upper bound of deadline-monotonic (DM) scheduling shown by Davis et al. [18]. Our result is thus stronger (and requires a much simpler proof), as we show that the same factor holds for a polynomial-time schedulability test (not just the DM scheduler). For uniprocessor arbitrary-deadline sporadic task systems, our obtained utilization-based test works for any fixed-priority scheduling with arbitrary priority-ordering assignment.

2. For multiprocessor DAG task systems under global rate-monotonic (RM) scheduling, the capacity-augmentation factor, as defined in  [28] and Sec. 6 in this paper, of our obtained test is 3.62143. This result is better than the best existing result, which is 3.73, given by Li et al. [28]. Our result is also applicable for conditional sporadic DAG task systems [3].

3. For multiprocessor self-suspending task systems, we obtain the first utilization-based test for global RM.

4. For uniprocessor multi-frame task systems, our obtained utilization bound is superior to the results by Mok and Chen [35] analytically and Lu et al. [32] in our simulations. The analysis is in Appendix C, whereas the evaluation result is in Appendix D.

Note that the emphasis of this paper is not to show that the resulting tests for different task models by applying the framework are better than existing work. Rather, we want to show that the framework is general, easy to use, and has relatively low time complexity, but is still able to generate good tests. By demonstrating the applicability of the framework to several task models, we believe that this framework has great potential in analyzing many other complex real-time task models, where the existing analysis approaches are insufficient or cumbersome. To the best of our knowledge, together with to be explained later, these are the first general schedulability analysis frameworks that can be potentially applied to analyze a large set of real-time task models under any fixed-priority scheduling algorithm in both uniprocessor and multiprocessor systems.

Comparison to : The concept of testing points only is also the key in another framework designed by us, called [15]. Even though and share the same idea by testing and evaluating only points, they are based on completely different criteria for testing. In , all the testings and formulations are based on only the higher-priority task utilizations. In , the testings are based not only on the higher-priority task utilizations, but also on the higher-priority task execution times. The above difference in the formulations results in completely different properties and mathematical closed-forms. The natural schedulability condition of is a hyperbolic form for testing the schedulability, whereas the natural schedulability condition of is a quadratic form for testing the schedulability or the response time of a task.

If one framework were dominated by another or these two frameworks were just with minor difference in mathematical formulations, it wouldn’t be necessary to separate and present them as two different frameworks. Both frameworks are in fact needed and have to be applied for different cases. Due to space limitation, we can only shortly explain their differences, advantages, and disadvantages in this paper. For completeness, another document has been prepared in [14] to present the similarity, the difference and the characteristics of these two frameworks in details.

Since the formulation of is more restrictive than , its applicability is limited by the possibility to formulate the tests purely by using higher-priority task utilizations without referring to their execution times. There are cases, in which formulating the higher-priority interference by using only task utilizations for is troublesome. For such cases, further introducing the upper bound of the execution time by using is more precise. The above cases can be found in (1) the schedulability tests for arbitrary-deadline sporadic task systems in uniprocessor scheduling, (2) multiprocessor global fixed-priority scheduling when adopting the forced-forwarding schedulability test, etc.111 c.f. Sec. 5/6 in [15] for the detailed proofs and Sec. 5/6 in [14] for the performance comparisons. In general, if we can formulate the schedulability tests into the framework by purely using higher-priority task utilizations, it is also usually possible to formulate it into the framework by further introducing the task execution times. In such cases, the same pseudo-polynomial-time (or exponential time) test is used, and the utilization bound or speed-up factor analysis derived from the framework is, in general, tighter and better.

In a nutshell, with respect to quantitive metrics, like utilization bounds or speedup factor analysis, is more precise, whereas is more general. If the exact (or very precise) schedulability test can be constructed and the test can be converted into , e.g., uniprocessor scheduling for constrained-deadline task sets, then, adopting may lead to tight results. By adopting , we may be able to start from a more complicated test with exponential-time complexity and convert it to a linear-time approximation with better results than . Although is more restrictive than , both of them are general enough to cover a range of applications, ranging from uniprocessor systems to multiprocessor systems. For more information and comparisons, please refer to [14].

A sporadic task is released repeatedly, with each such invocation called a job. The job of , denoted , is released at time and has an absolute deadline at time . Each job of any task is assumed to have execution time . Here in this paper, whenever we refer to the execution time of a job, we mean for the worst-case execution time of the job since all the analyses we use are safe by only considering the worst-case execution time. Successive jobs of the same task are required to execute in sequence. Associated with each task are a period , which specifies the minimum time between two consecutive job releases of , and a deadline , which specifies the relative deadline of each such job, i.e., . The utilization of a task is defined as .

A task is said schedulable by a scheduling policy if all of its jobs can finish before their absolute deadlines. A task system is said schedulable by a scheduling policy if all the tasks in the task system are schedulable. A schedulability test expresses sufficient conditions to ensure the feasibility of the resulting schedule by a scheduling policy.

Throughout the paper, we will focus on fixed-priority preemptive scheduling. That is, each task is associated with a priority level. For a uniprocessor system, i.e., except Sec. 6, the scheduler always dispatches the job with the highest priority in the ready queue to be executed. For a uniprocessor system, it has been shown that RM scheduling is an optimal fixed-priority scheduling policy for implicit-deadline systems [31] and DM scheduling is an optimal fixed-priority scheduling policy for constrained-deadline systems[27].

To verify the schedulability of task under fixed-priority scheduling in uniprocessor systems, the time-demand analysis developed in [26] can be adopted, as discussed earlier. That is, if Eq. (1) holds, then task is schedulable under the fixed-priority scheduling algorithm. For the simplicity of presentation, we will demonstrate how the framework works using ordinary sporadic real-time task systems in Sec. 4 and Sec. 5. We will demonstrate more applications with respect to multi-frame tasks [35] in Appendix C and with respect to multiprocessor scheduling in Sec. 6.

## 3 Analysis Flow

The proposed framework only tests the schedulability of a specific task , under the assumption that the higher-priority tasks are already verified to be schedulable by the given scheduling policy. Therefore, this framework has to be applied for each of the given tasks. A task system is schedulable by the given scheduling policy only when all the tasks in the system can be verified to meet their deadlines. The results can be extended to test the schedulability of a task system in linear time complexity or to allow on-line admission control in constant time complexity if the schedulability condition (or with some more pessimistic simplifications) is monotonic. Such extensions are provided in Appendix A for some cases.

Therefore, for the rest of this paper, we implicitly assume that all the higher-priority tasks are already verified to be schedulable by the scheduling policy. We will only present the schedulability test of a certain task , that is being analyzed, under the above assumption. For notational brevity, we implicitly assume that there are tasks, say with higher-priority than task . Moreover, we only consider the cases when , since is pretty trivial.

## 4 k2U Framework

This section presents the basic properties of the framework for testing the schedulability of task in a given set of real-time tasks (depending on the specific models given in each application as shown later in this paper). We will first provide examples to explain and define the -point effective schedulability test. Then, we will provide the fundamental properties of the corresponding utilization-based tests. Throughout this section, we will implicitly use sporadic task systems defined in Sec. 2 to simplify the presentation. The concrete applications will be presented in Secs. 5 - 6.

The -point effective schedulability test is a sufficient schedulability test that verifies only time points, defined by the higher-priority tasks and task . For example, instead of testing all the possible in the range of and in Eq. (1), we can simply test only points. It may seem to be very pessimistic to only test points. However, if these points are effective,222As to be clearly illustrated later, the points can be considered effective if they can define certain extreme cases of task parameters. For example, the “difficult-to-schedule” concept first introduced by Liu and Layland [31] defines effective points that are used in Example 1. In their case [31], the selected set of the points was “very” effective because the tested task becomes unschedulable if is increased by an arbitrarily small value . the resulting schedulability test may be already good. We now demonstrate two examples.

###### Example 1.

Implicit-deadline task systems: Suppose that the tasks are indexed by the periods, i.e., . When , task is schedulable by RM if there exists where

 Ck+k−1∑i=1Ci+j−1∑i=1Ci=Ck+k−1∑i=1TiUi+j−1∑i=1TiUi≤Tj. (2)

That is, in the above example, it is sufficient to only test . The case defined in the above example is utilized by Liu and Layland [31] for deriving the least utilization upper bound for RM scheduling. We can make the above example more generalized as follows:

###### Example 2.

Implicit-deadline task systems with given ratios of periods: Suppose that for a given integer with for any higher-priority task , for all . Let be . Suppose that the higher priority tasks are indexed such that , where is defined as . Task is schedulable under RM if there exists with such that

 Ck+k−1∑i=1tiUi+j−1∑i=1Ci≤Ck+k−1∑i=1tiUi+j−1∑i=11ftiUi≤tj, (3)

where the first inequality in Eq. (3) is due to the fact . That is, in the above example, it is sufficient to only test .

With the above examples, for a given set , we now define the -point effective schedulability test as follows:

###### Definition 1.

A -point effective schedulability test is a sufficient schedulability test of a fixed-priority scheduling policy, that verifies the existence of with such that

 Ck+k−1∑i=1αitiUi+j−1∑i=1βitiUi≤tj, (4)

where , , , and are dependent upon the setting of the task models and task .

For Example 1, the effective values in are , and for each task . For Example 2, the effective values in are with and for each task .

Moreover, we only consider non-trivial cases, in which , , , , and for . The definition of the -point last-release schedulability test in Definition 1 only slightly differs from the test in the framework [15]. However, since the tests are different, they are used for different situations.

With these points, we are able to define the corresponding coefficients and in the -point effective schedulability test of a scheduling algorithm. The elegance of the framework is to use only the parameters and to analyze whether task can pass the schedulability test. Therefore, the framework provides corresponding utilization-based tests automatically if the -point effective schedulability test and the corresponding parameters and can be defined, which will be further demonstrated in the following sections with several applications.

We are going to present the properties resulting from the -point effective schedulability test under given and . In the following lemmas, we are going to seek the extreme cases for these testing points under the given setting of utilizations and the defined coefficients and . To make the notations clear, these extreme testing points are denoted as for the rest of this paper. The procedure will derive extreme testing points, denoted as , whereas is defined as plus a slack variable (to be defined in the proof of Lemma 1) for notational brevity. Lemmas 1 to 3 are useful to analyze the utilization bound, the hyperbolic bound, etc., for given scheduling strategies, when and can be easily defined based on the scheduling policy, with and , and for any .

###### Lemma 1.

For a given -point effective schedulability test of a scheduling algorithm, defined in Definition 1, in which and , and for any , task is schedulable by the scheduling algorithm if the following condition holds

 Cktk≤αβ+1∏k−1j=1(βUj+1)−αβ. (5)

Proof. If , the condition in Eq. (5) never holds since , and the statement is vacuously true. We focus on the case .

We prove this lemma by showing that the condition in Eq. (5) leads to the satisfactions of the schedulability condition listed in Eq. (4) by using contrapositive. By taking the negation of the schedulability condition in Eq. (4), we know that if task is not schedulable by the scheduling policy, then for each

 Ck+αk−1∑i=1tiUi+βj−1∑i=1tiUi≥Ck+k−1∑i=1αitiUi+j−1∑i=1βitiUi>tj, (6)

due to , and for any To enforce the condition in Eq. (6), we are going to show that must have some lower bound. Therefore, if is no more than this lower bound, then task is schedulable by the scheduling policy.

For the rest of the proof, we replace with in Eq. (6), as the infimum and the minimum are the same when presenting the inequality with . Moreover, we also relax the problem by replacing the constraint with for . Therefore, the unschedulability for satisfying Eq. (6) implies that , where is defined in the following optimization problem:

 min C∗k (7a) s.t. C∗k+k−1∑i=1αt∗iUi+j−1∑i=1βt∗iUi≥t∗j ∀j=1,…,k−1, (7b) t∗j≥0 ∀j=1,…,k−1, (7c) C∗k+k−1∑i=1(α+β)t∗iUi≥tk, (7d)

where and are variables; and , are constants.

Let be a slack variable such that . Therefore, . By replacing in Eq. (7b), we have

 tk+s−(k−1∑i=1αt∗iUi+k−1∑i=1βt∗iUi)+k−1∑i=1αt∗iUi+j−1∑i=1βt∗iUi = tk+s−k−1∑i=jβt∗iUi≥t∗j,∀j=1,…,k−1. (8)

For notational brevity, let be . Therefore, the linear programming in Eq. (7) can be rewritten as follows:

 min t∗k−k−1∑i=1(α+β)t∗iUi (9a) s.t. t∗k−βk−1∑i=jt∗iUi≥t∗j, ∀1≤j≤k−1 (9b) t∗j≥0 ∀1≤j≤k−1 (9c) t∗k≥tk (9d)

The remaining proof is to solve the above linear programming to obtain the minimum if . Our proof strategy is to solve the linear programming analytically as a function of . This can be imagined as if is given. At the end, we will prove the optimality by considering all possible . This involves three steps:

• Step 1: we analyze certain properties of optimal solutions based on the extreme point theorem for linear programming [33] under the assumption that is given as a constant, i.e., is known.

• Step 2: we present a specific solution in an extreme point, as a function of .

• Step 3: we prove that the above extreme point solution gives the minimum if .

[Step 1:] In this step, we assume that is given, i.e., is specified as a constant. The original linear programming in Eq. (9) has variables and constraints. After specifying the value as a given constant, the new linear programming without the constraint in Eq. (9d) has only variables and constraints. Thus, according to the extreme point theorem for linear programming [33], the linear constraints form a polyhedron of feasible solutions. The extreme point theorem states that either there is no feasible solution or one of the extreme points in the polyhedron is an optimal solution when the objective of the linear programming is finite. To satisfy Eqs. (9b) and (9c), we know that for , due to , , and for . As a result, the objective of the above linear programming is , which is finite (as a function of , , and ) under the assumption , and .

According to the extreme point theorem, one of the extreme points is the optimal solution of Eq. (9) for a given . There are variables with constraints in Eq. (9) for a given . An extreme point must have at least active constraints in Eqs. (9b) and (9c), in which their are set to equality .

We now prove that an extreme point solution is feasible for Eq. (9) by setting either to or to for . Suppose for contradiction that there exists a task with . Let be the index of the next task after with in this extreme point solution, i.e., . If for , then is set to and is . Therefore, the conditions and imply the contradiction that when or when .

By the above analysis and the pigeonhole principle, a feasible extreme point solution of Eq. (9) can be represented by two sets and of the higher-priority tasks, in which if is in and if task is in . With the above discussions, we have and .

[Step 2:] For a given , one special extreme point solution is to put for every , i.e., as an empty set. Therefore,

 ∀1≤i≤k−1,t∗i+1−t∗i=βt∗iUi, (10)

which implies that

 t∗i+1t∗i=βUi+1. (11)

Moreover,

 t∗it∗k=k−1∏j=it∗jt∗j+1=1∏k−1j=i(βUj+1). (12)

The above extreme point solution is always feasible in the linear programming of Eq. (9) since

 0

By Eq. (10), we have

 (α+β)Uit∗i=(t∗i+1−t∗i)(αβ+1). (14)

Therefore, in this extreme point solution, the objective function of Eq. (9) is

 t∗k−k−1∑i=1(α+β)Uit∗i=t∗k−(t∗k−t∗1)(αβ+1) = t∗k(t∗1t∗k(αβ+1)−αβ)1=t∗k⎛⎝αβ+1∏k−1j=1(βUj+1)−αβ⎞⎠, (15)

where the last equality is due to Eq. (12) when is .

[Step 3:] From Step 1, a feasible extreme point solution is with and . As a result, we can simply drop all the tasks in and use the remaining tasks in by adopting the same procedures from Eq. (10) to Eq. (14) in Step 2. The resulting objective function of this extreme point solution for the linear programming in Eq. (9) is due to the fact that .

Therefore, for a given , i.e., , all the other extreme points of Eq. (9) were dominated by the one specified in Step 2. By the above analysis, if , we know that is an increasing function of , in which the minimum happens when is . As a result, we reach the conclusion of the lemma.

We now provide two extended lemmas based on Lemma 1, used for given and when and for . Their proofs are in Appendix B.

###### Lemma 2.

For a given -point effective schedulability test of a scheduling algorithm, defined in Definition 1, in which and and for any , task is schedulable by the scheduling algorithm if

 Cktk+k−1∑i=1Ui≤⎧⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪⎨⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪⎩1,(α+β)1k<1(k−1)((1+βα)1k−1−1)β,(α+β)1k<α(k−1)((α+β)1k−1)+((α+β)1k−α)β otherwise. (16)
###### Lemma 3.

For a given -point effective schedulability test of a scheduling algorithm, defined in Definition 1, in which and and for any , task is schedulable by the scheduling algorithm if

 βk−1∑i=1Ui≤ln(αβ+1Cktk+αβ). (17)

We also construct the following Lemma 4, c.f. Appendix B for the proof, as the most powerful method for a concrete task system. Throughout the paper, we will not build theorems and corollaries based on Lemma 4 but we will evaluate how it performs in the experimental section.

###### Lemma 4.

For a given -point effective schedulability test of a fixed-priority scheduling algorithm, defined in Definition 1, task is schedulable by the scheduling algorithm, in which and and for any , if the following condition holds

 0

Remarks and how to use the framework: After presenting the framework, here, we explain how to use the framework and summarize how we plan to demonstrate its applicability in several task models in the following sections. The framework relies on the users to index the tasks properly and define and as constants for based on Eq. (4). The set in Definition 1 is used only for the users to define those constants, where is usually defined to be the interval length of the original schedulability test, e.g., in Eq. (1). Therefore, the framework can only be applicable when and are well-defined. These constants depend on the task models and the task parameters.

The choice of good parameters and affects the quality of the resulting schedulability bounds in Lemmas 1 to 3. However, deriving the good settings of and is actually not the focus of this paper. The framework does not care how the parameters and are obtained. The framework simply derives the bounds according to the given parameters and , regardless of the settings of and . The correctness of the settings of and is not verified by the framework.

The ignorance of the settings of and actually leads to the elegance and the generality of the framework, which works as long as Eq. (4) can be successfully constructed for the sufficient schedulability test of task in a fixed-priority scheduling policy. With the availability of the framework, the hyperbolic bounds or utilization bounds can be automatically derived by adopting Lemmas 1 to 3 as long as the safe upper bounds and to cover all the possible settings of and for the schedulability test in Eq. (4) can be derived, regardless of the task model or the platforms.

The other approaches in [24, 10, 22] also have similar observations by testing only several time points in the TDA schedulability analysis based on Eq. (1) in their problem formulations. Specifically, the problem formulations in [10, 22] are based on non-linear programming by selecting several good points under certain constraints. Moreover, the linear-programming problem formulation in [24] considers as variables and as constants and solves the corresponding linear programming analytically. However, as these approaches in [24, 10, 22] seek for the total utilization bounds, they have limited applications and are less flexible. For example, they are typically not applicable directly when considering sporadic real-time tasks with arbitrary deadlines or multiprocessor systems. Here, we are more flexible in the framework. For task , after and or their safe upper bounds and are derived, we completely drop out the dependency to the periods and models inside .

We will demonstrate the applicability and generality of by using the most-adopted sporadic real-time task model in Sec. 5, multi-frame tasks in Appendix C and multiprocessor scheduling in Sec. 6, as illustrated in Figure 1. In all these cases, we can find reasonable settings of and to provide better results or new results for schedulability tests, with respect to the utilization bounds, speed-up factors, or capacity augmentation factors, compared to the literature. More specifically, (after certain reorganizations), we will greedily set as in all of the studied cases.333Setting as is actually the same in [24] for the sporadic real-time task model with implicit deadlines and the multi-frame task model when is given and is considered as a variable. Table I summarizes the and parameters derived in this paper, as well as an earlier result by Liu and Chen in [30] for self-suspending task models and deferrable servers.

## 5 Applications for Fixed-Priority Scheduling

This section provides demonstrations on how to use the framework to derive efficient schedulability analysis for sporadic task systems in uniprocessor systems. We will consider constrained-deadline systems first in Sec. 5.1 and explain how to extend to arbitrary-deadline systems in Sec. 5.2. For the rest of this section, we will implicitly assume .

For a specified fixed-priority scheduling algorithm, let be the set of tasks with higher priority than

. We now classify the task set

into two subsets:

• consists of the higher-priority tasks with periods smaller than .

• consists of the higher-priority tasks with periods larger than or equal to .

For any , we know that a safe upper bound on the interference due to higher-priority tasks is given by

 ∑τi∈hp(τk)⌈tTi⌉Ci=∑τi∈hp2(τk)Ci+∑τi∈hp1(τk)⌈tTi⌉Ci.

As a result, the schedulability test in Eq. (1) is equivalent to the verification of the existence of such that

 Ck+∑τi∈hp2(τk)Ci+∑τi∈hp1(τk)⌈tTi⌉Ci≤t. (19)

We can then create a virtual sporadic task with execution time , relative deadline , and period . It is clear that the schedulability test to verify the schedulability of task under the interference of the higher-priority tasks is the same as that of task under the interference of the higher-priority tasks .

Therefore, with the above analysis, we can use the framework in Sec. 4 as in the following theorem.