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

0.68 MB·English

by  Jian-Jia Chen

k2U: A General Framework from k-Point Effective
Schedulability Analysis to Utilization-Based Tests
Jian-Jia Chen and Wen-Hung Huang Cong Liu
Department of Informatics Department of Computer Science
TU Dortmund University, Germany The University of Texas at Dallas
Abstract—To deal with a large variety of workloads in different task models. Many successful stories have been
different application domains in real-time embedded systems, told. For many of the above-mentioned task models, efficient
5
a number of expressive task models have been developed. For scheduling and schedulability analysis techniques have been
1
eachindividualtaskmodel,researcherstendtodevelopdifferent developed (see [16] for a recent survey). Unfortunately, for
0
typesoftechniquesforderivingschedulabilitytestswithdifferent
certain complex models such as the self-suspending task
2
computation complexity and performance. In this paper, we
model, existing schedulability tests are rather pessimistic, par-
p present a general schedulability analysis framework, namely the
ticularly for the multiprocessor case (e.g., no utilization-based
e k2U framework, that can be potentially applied to analyze
schedulabilitytestexistsforglobally-scheduledmultiprocessor
S a large set of real-time task models under any fixed-priority
scheduling algorithm, on both uniprocessor and multiprocessor self-suspending task systems).
14 scheduling. The key to k2U is a k-point effective schedulability In this paper, we present k2U, a general schedulability
test, which can be viewed as a “blackbox” interface. For any
task model, if a corresponding k-point effective schedulability analysis framework that is fundamentally based on a k-point
] effective schedulability test under fixed-priority scheduling.
test can be constructed, then a sufficient utilization-based test
S
canbeautomaticallyderived.Weshowthegeneralityofk2Uby The key observation behind our proposed k-point test is the
O
applying it to different task models, which results in new and following. Traditional fixed-priority schedulability tests often
. improved tests compared to the state-of-the-art. have pseudo-polynomial-time (or even higher) complexity.
s
c For example, to verify the schedulability of a (constrained-
Analogously, a similar concept by testing only k points
[ deadline) task τ under fixed-priority scheduling in unipro-
with a different formulation has been studied by us in another k
3 framework,calledk2Q,whichprovidesquadraticboundsoruti- cessor systems, the time-demand analysis (TDA) developed in
[26] can be adopted. That is, if
v lizationboundsbasedonadifferentformulationofschedulability
4 test. With the quadratic and hyperbolic forms, k2Q and k2U (cid:88) (cid:24) t (cid:25)
8 frameworkscanbeusedtoprovidemanyquantitivefeaturestobe ∃t with 0<t≤Dk and Ck+ T Ci ≤t, (1)
0 measured,likethetotalutilizationbounds,speed-upfactors,etc., i
τi∈hp(τk)
7 not only for uniprocessor scheduling but also for multiprocessor
0 scheduling. These frameworks can be viewed as a “blackbox” then task τk is schedulable under the fixed-priority scheduling
. interface for schedulability tests and response-time analysis. algorithm, where hp(τk) is the set of the tasks with higher
1
priority than τ , D , C , and T represent τ ’s relative dead-
0 k k k i k
line, worst-case execution time, and period, respectively. TDA
5 1 Introduction
incurs pseudo-polynomial-time complexity to check the time
1
: Giventheemergingtrendtowardsbuildingcomplexcyber- points that lie in (0,Dk] for Eq. (1).
v
i physical systems that often integrate external and physical Toobtainsufficientschedulabilitytestsunderfixedpriority
X devices, many real-time and embedded systems are expected scheduling with reduced time complexity (e.g., polynomial-
r to handle a large variety of workloads. Different formal real- time), our conceptual innovation is based on the observations
a
time task models have been developed to accurately represent by testing only a subset of such points to derive the minimum
theseworkloadswithvariouscharacteristics.Examplesinclude C that cannot pass the schedulability tests. This idea is
k
thesporadictaskmodel[34],themulti-frametaskmodel[35], implemented in the k2U framework by providing a general
theself-suspendingtaskmodel[29],thedirected-acyclic-graph k-point effective schedulability test, which only needs to test
(DAG) task model, etc. Many of such formal models have k points under any fixed-priority scheduling when checking
been shown to be expressive enough to accurately model real schedulability of the task with the kth highest priority in
systems in practice. For example, the DAG task model has the system. This k-point effective schedulability test can be
been used to represent many computation-parallel multimedia viewed as a “blackbox” interface that can result in sufficient
application systems and the self-suspending task model is utilization-based tests. We show the generality of k2U by
suitabletomodelworkloadsthatmayinteractwithI/Odevices. applying it to analyze several concrete example task models,
For each of these task models, researchers tend to develop includingtheconstrained-andarbitrary-deadlinesporadictask
different types of techniques that result in schedulability tests models, the multi-frame task model, the self-suspending task
with different computation complexity and performance (e.g., model, and the DAG task model. Note that k2U is not only
different utilization bounds). applicable to uniprocessor systems, but also applicable to
multiprocessor systems.
Overtheyears,real-timesystemsresearchershavedevoted
a significant amount of time and efforts to efficiently analyze Related Work. An extensive amount of research has been
1
conducted over the past forty years on verifying the schedula- k2Ubyapplyingittoseveraltaskmodels,inwhichtheresults
bilityoftheclassicalsporadictaskmodelinbothuniprocessor are better or more general compared to the state-of-the-art:
and multiprocessor systems (see [16] for a survey of such
results). Much progress has also been made in recent years on 1) For uniprocessor constrained-deadline sporadic task sys-
analyzingmorecomplextaskmodelsthataremoreexpressive. tems, the speed-up factor of our obtained schedulability
There have been several results in the literature with respect testis1.76322.Thisvalueisthesameasthelowerbound
to utilization-based, e.g., [7], [22]–[24], [30], [31], [37], and andupperboundofdeadline-monotonic(DM)scheduling
non-utilization-based, e.g., [11], [20], schedulability tests for shownbyDavisetal.[18].Ourresultisthusstronger(and
the sporadic real-time task model and its generalizations in requiresamuchsimplerproof),asweshowthatthesame
uniprocessor systems. The approaches in [11], [20] convert factor holds for a polynomial-time schedulability test
(cid:108) (cid:109)
the stair function t in the time-demand analysis into a (not just the DM scheduler). For uniprocessor arbitrary-
Ti deadline sporadic task systems, our obtained utilization-
linear function if t in Eq. (1) is large enough. The methods in
based test works for any fixed-priority scheduling with
[11], [20] are completely different from this paper, in which
arbitrary priority-ordering assignment.
the linear function of task τ starts after t ≥ k, in which
our method is based on k ipoints, defineTdi individually by 2) For multiprocessor DAG task systems under global rate-
monotonic (RM) scheduling, the capacity-augmentation
τ ,τ ,...,τ .
1 2 k factor, as defined in [28] and Sec. 6 in this paper, of
Most of the existing utilization-based schedulability analy- our obtained test is 3.62143. This result is better than the
ses focus on the total utilization bound. That is, if the total bestexistingresult,whichis3.73,givenbyLietal.[28].
utilization of the task system is no more than the derived OurresultisalsoapplicableforconditionalsporadicDAG
bound,thetasksystemisschedulablebytheschedulingpolicy. task systems [3].
For example, the total utilization bounds derived in [10], 3) For multiprocessor self-suspending task systems, we ob-
[22], [31] are mainly for rate-monotonic (RM) scheduling, in tain the first utilization-based test for global RM.
which the results in [22] can be extended for arbitrary fixed- 4) For uniprocessor multi-frame task systems, our obtained
priority scheduling. Kuo et al. [23] further improve the total utilization bound is superior to the results by Mok and
utilization bound by using the notion of divisibility. Lee et Chen [35] analytically and Lu et al. [32] in our sim-
al. [24] use linear programming formulations for calculating ulations. The analysis is in Appendix C, whereas the
total utilization bounds when the period of a task can be evaluation result is in Appendix D.
selected.Moreover,Wuetal.[37]adopttheNetworkCalculus
Note that the emphasis of this paper is not to show that
to analyze the total utilization bounds of several task models.
the resulting tests for different task models by applying the
The novelty of k2U comes from a different perspective k2U framework are better than existing work. Rather, we
fromtheseapproaches[22]–[24],[31],[37].Wedonotspecif- want to show that the k2U framework is general, easy to
ically seek for the total utilization bound. Instead, we look use, and has relatively low time complexity, but is still able
for the critical value in the specified sufficient schedulability to generate good tests. By demonstrating the applicability of
test while verifying the schedulability of task τ . A natural the k2U framework to several task models, we believe that
k
schedulability condition to express the schedulability of task this framework has great potential in analyzing many other
τ is a hyperbolic bound, (to be shown in Lemma 1), whereas complex real-time task models, where the existing analysis
k
the corresponding total utilization bound can be obtained (in approaches are insufficient or cumbersome. To the best of our
Lemmas 2 and 3). knowledge, together with k2Q to be explained later, these are
the first general schedulability analysis frameworks that can
The hyperbolic forms are the centric features in k2U
be potentially applied to analyze a large set of real-time task
analysis, in which the test by Bini et al. [7] for sporadic real-
models under any fixed-priority scheduling algorithm in both
time tasks and our recent result in [30] for bursty-interference
uniprocessor and multiprocessor systems.
analysis are both special cases and simple implications from
the k2U framework. With the hyperbolic forms, we are then Comparison to k2Q: The concept of testing k points only
able to provide many interesting observations with respect to is also the key in another framework designed by us, called
the required quantitive features to be measured, like the total k2Q [15]. Even though k2Q and k2U share the same idea
utilization bounds, speed-up factors, etc., not only for unipro- by testing and evaluating only k points, they are based on
cessor scheduling but also for multiprocessor scheduling. For completelydifferentcriteriafortesting.Ink2U,allthetestings
more details, we will provide further explanations at the end and formulations are based on only the higher-priority task
of Sec. 4 after the framework is presented. For the studied utilizations. In k2Q, the testings are based not only on the
task models to demonstrate the applicability of k2U, we will higher-prioritytaskutilizations,butalsoonthehigher-priority
summarize some of the latest results on these task models in task execution times. The above difference in the formulations
their corresponding sections. results in completely different properties and mathematical
closed-forms. The natural schedulability condition of k2U is
Contributions. In this paper, we present a general schedu-
a hyperbolic form for testing the schedulability, whereas the
lability analysis framework, k2U, that can be applied to natural schedulability condition of k2Q is a quadratic form
analyze a number of complex real-time task models, on both
for testing the schedulability or the response time of a task.
uniprocessors and multiprocessors. For any task model, if
a corresponding k-point effective schedulability test can be If one framework were dominated by another or these two
constructed, then a sufficient utilization-based test can be frameworks were just with minor difference in mathematical
derived by the k2U framework. We show the generality of formulations,itwouldn’tbenecessarytoseparateandpresent
2
them as two different frameworks. Both frameworks are in τ issaidto beaconstrained-deadlinesystem ifD ≤T holds
i i
fact needed and have to be applied for different cases. Due to for each τ . Otherwise, such a sporadic task system τ is an
i
spacelimitation,wecanonlyshortlyexplaintheirdifferences, arbitrary-deadline system.
advantages,anddisadvantagesinthispaper.Forcompleteness,
A task is said schedulable by a scheduling policy if all
another document has been prepared in [14] to present the
of its jobs can finish before their absolute deadlines. A task
similarity, the difference and the characteristics of these two
system is said schedulable by a scheduling policy if all the
frameworks in details.
tasks in the task system are schedulable. A schedulability test
Sincetheformulationofk2Uismorerestrictivethank2Q, expresses sufficient conditions to ensure the feasibility of the
its applicability is limited by the possibility to formulate the resulting schedule by a scheduling policy.
tests purely by using higher-priority task utilizations without
Throughout the paper, we will focus on fixed-priority
referring to their execution times. There are cases, in which
preemptive scheduling. That is, each task is associated with a
formulating the higher-priority interference by using only task
utilizations for k2U is troublesome. For such cases, further prioritylevel.Forauniprocessorsystem,i.e.,exceptSec.6,the
scheduleralwaysdispatchesthejobwiththehighestpriorityin
introducing the upper bound of the execution time by using
k2Q is more precise. The above cases can be found in (1) the ready queue to be executed. For a uniprocessor system, it
hasbeenshownthatRMschedulingisanoptimalfixed-priority
the schedulability tests for arbitrary-deadline sporadic task
scheduling policy for implicit-deadline systems [31] and DM
systems in uniprocessor scheduling, (2) multiprocessor global
scheduling is an optimal fixed-priority scheduling policy for
fixed-priorityschedulingwhenadoptingtheforced-forwarding
schedulability test, etc.1 In general, if we can formulate the constrained-deadline systems [27].
schedulability tests into the k2U framework by purely using To verify the schedulability of task τ under fixed-priority
k
higher-priority task utilizations, it is also usually possible to scheduling in uniprocessor systems, the time-demand analy-
formulate it into the k2Q framework by further introducing sis developed in [26] can be adopted, as discussed earlier.
the task execution times. In such cases, the same pseudo- That is, if Eq. (1) holds, then task τ is schedulable under
k
polynomial-time (or exponential time) test is used, and the the fixed-priority scheduling algorithm. For the simplicity of
utilization bound or speed-up factor analysis derived from the presentation, we will demonstrate how the framework works
k2U framework is, in general, tighter and better. using ordinary sporadic real-time task systems in Sec. 4 and
Sec. 5. We will demonstrate more applications with respect
In a nutshell, with respect to quantitive metrics, like
utilization bounds or speedup factor analysis, k2U is more to multi-frame tasks [35] in Appendix C and with respect to
precise, whereas k2Q is more general. If the exact (or very multiprocessor scheduling in Sec. 6.
precise) schedulability test can be constructed and the test
3 Analysis Flow
can be converted into k2U, e.g., uniprocessor scheduling for
constrained-deadlinetasksets,then,adoptingk2Umayleadto Theproposedk2Uframeworkonlyteststheschedulability
tight results. By adopting k2Q, we may be able to start from of a specific task τ , under the assumption that the higher-
k
amorecomplicatedtestwithexponential-timecomplexityand priority tasks are already verified to be schedulable by the
convert it to a linear-time approximation with better results given scheduling policy. Therefore, this framework has to be
than k2U. Although k2U is more restrictive than k2Q, both appliedforeachofthegiventasks.Atasksystemisschedula-
of them are general enough to cover a range of applications, ble by the given scheduling policy only when all the tasks in
ranging from uniprocessor systems to multiprocessor systems. the system can be verified to meet their deadlines. The results
For more information and comparisons, please refer to [14]. can be extended to test the schedulability of a task system in
linear time complexity or to allow on-line admission control
2 Sporadic Task and Scheduling Models in constant time complexity if the schedulability condition
(or with some more pessimistic simplifications) is monotonic.
A sporadic task τ is released repeatedly, with each such
i Such extensions are provided in Appendix A for some cases.
invocation called a job. The jth job of τ , denoted τ , is
i i,j
released at time r and has an absolute deadline at time d . Therefore, for the rest of this paper, we implicitly assume
i,j i,j
Each job of any task τ is assumed to have execution time C . that all the higher-priority tasks are already verified to be
i i
Here in this paper, whenever we refer to the execution time schedulablebytheschedulingpolicy.Wewillonlypresentthe
of a job, we mean for the worst-case execution time of the schedulability test of a certain task τ , that is being analyzed,
k
job since all the analyses we use are safe by only considering undertheaboveassumption.Fornotationalbrevity,weimplic-
the worst-case execution time. Successive jobs of the same itlyassumethattherearek−1tasks,sayτ ,τ ,...,τ with
1 2 k−1
taskarerequiredtoexecuteinsequence.Associatedwitheach higher-priority than task τ . Moreover, we only consider the
k
task τ are a period T , which specifies the minimum time cases when k ≥2, since k =1 is pretty trivial.
i i
between two consecutive job releases of τ , and a deadline
i
Di,whichspecifiestherelativedeadlineofeachsuchjob,i.e., 4 k2U Framework
d = r + D . The utilization of a task τ is defined as
i,j i,j i i
Ui =Ci/Ti. This section presents the basic properties of the k2U
framework for testing the schedulability of task τ in a
A sporadic task system τ is said to be an implicit-deadline k
given set of real-time tasks (depending on the specific models
system if D = T holds for each τ . A sporadic task system
i i i given in each application as shown later in this paper). We
1 c.f. Sec. 5/6 in [15] for the detailed proofs and Sec. 5/6 in [14] for the will first provide examples to explain and define the k-
performancecomparisons. point effective schedulability test. Then, we will provide the
3
fundamental properties of the corresponding utilization-based upon the setting of the task models and task τ .
i
tests. Throughout this section, we will implicitly use sporadic
task systems defined in Sec. 2 to simplify the presentation.
For Example 1, the effective values in {t ,t ,...t } are
The concrete applications will be presented in Secs. 5 - 6. 1 2 k
T ,T ,...,T , and α = β = 1 for each task τ . For
1 2 k i i i
The k-point effective schedulability test is a sufficient Example 2, the effective values in {t1,t2,...tk} are with
schedulability test that verifies only k time points, defined αi =1 and βi ≤ f1 for each task τi.
by the k−1 higher-priority tasks and task τ . For example,
k
instead of testing all the possible t in the range of 0 and D Moreover, we only consider non-trivial cases, in which
k
in Eq. (1), we can simply test only k points. It may seem to Ck > 0, tk > 0, 0 < αi, 0 < βi, and 0 < Ui ≤ 1 for
be very pessimistic to only test k points. However, if these k i = 1,2,...,k−1. The definition of the k-point last-release
points are effective,2 the resulting schedulability test may be schedulability test Ck + (cid:80)ki=−11αitiUi + (cid:80)ji=−11βitiUi ≤ tj
already good. We now demonstrate two examples. in Definition 1 only slightly differs from the test Ck +
(cid:80)k−1α t U + (cid:80)j−1β C ≤ t in the k2Q framework
Example 1. Implicit-deadline task systems: Suppose that i=1 i i i i=1 i i j
[15]. However, since the tests are different, they are used for
the tasks are indexed by the periods, i.e., T ≤ ··· ≤ T .
1 k different situations.
When T ≤ 2T , task τ is schedulable by RM if there exists
k 1 k
j ∈{1,2,...,k} where
Withthesekpoints,weareabletodefinethecorresponding
k(cid:88)−1 (cid:88)j−1 k(cid:88)−1 (cid:88)j−1 coefficients αi and βi in the k-point effective schedulability
Ck+ Ci+ Ci =Ck+ TiUi+ TiUi ≤Tj. (2) test of a scheduling algorithm. The elegance of the k2U
i=1 i=1 i=1 i=1 framework is to use only the parameters αi and βi to analyze
whether task τ can pass the schedulability test. Therefore,
k
the k2U framework provides corresponding utilization-based
That is, in the above example, it is sufficient to only tests automatically if the k-point effective schedulability test
test T1,T2,...,Tk. The case defined in the above example and the corresponding parameters αi and βi can be defined,
is utilized by Liu and Layland [31] for deriving the least which will be further demonstrated in the following sections
utilization upper bound 69.3% for RM scheduling. We can with several applications.
make the above example more generalized as follows:
We are going to present the properties resulting from the
Example2. Implicit-deadlinetasksystemswithgivenratios k-point effective schedulability test under given α and β . In
i i
of periods: Suppose that fTi ≤Tk for a given integer f with the following lemmas, we are going to seek the extreme cases
f ≥1for(cid:106)any(cid:107)higher-prioritytaskτi,foralli=1,2,...,k−1. forthesek testingpointsunderthegivensettingofutilizations
aLreettinidbeexedTTkisucThi.thSautppt1os≤etth2a≤tth·e··k≤−t1k−h1ig≤hetrkp,rwiohreirtyettakskiss acnledart,htehedseefienxetdrecmoeeftfiecstiienngtspαoiinatsndareβid.eTnootemdaaksett∗ihefonrotthaetiroensst
defined as T . Task τ is schedulable under RM if there exists of this paper. The procedure will derive k−1 extreme testing
k k
j with 1≤j ≤k such that points, denoted as t∗1,t∗2,...,t∗k−1, whereas t∗k is defined as tk
plus a slack variable (to be defined in the proof of Lemma 1)
k(cid:88)−1 (cid:88)j−1 k(cid:88)−1 (cid:88)j−1 1 for notational brevity. Lemmas 1 to 3 are useful to analyze
C + t U + C ≤C + t U + t U ≤t , (3)
k i i i k i i f i i j the utilization bound, the hyperbolic bound, etc., for given
i=1 i=1 i=1 i=1 scheduling strategies, when α and β can be easily defined
where the first inequality in Eq. (3) is due to the fact Ci = based on the scheduling policy, with 0<tk and 0<αi ≤α,
T U ≤ 1t U . That is, in the above example, it is sufficient to and 0<β ≤β for any i=1,2,...,k−1.
i i f i i i
(cid:106) (cid:107) (cid:106) (cid:107) (cid:106) (cid:107)
only test TTk1 T1, TTk2 T2,..., TTk−k1 Tk−1,Tk. Lscehmedmulain1g. aFlogroaritghimve,ndke-fipnoeidntineffDecetfiinveitisocnhe1d,uilnabwihliitcyhte0st<ofta
k
and 0 < α ≤ α, and 0 < β ≤ β for any i = 1,2,...,k−
Withtheaboveexamples,foragivenset{t ,t ,...t },we i i
1 2 k 1, task τ is schedulable by the scheduling algorithm if the
now define the k-point effective schedulability test as follows: k
following condition holds
Definition 1. A k-point effective schedulability test is a suf-
C α +1 α
ficient schedulability test of a fixed-priority scheduling pol- k ≤ β − . (5)
icy, that verifies the existence of tj ∈ {t1,t2,...tk} with tk (cid:81)kj=−11(βUj +1) β
0<t ≤t ≤···≤t such that
1 2 k
k(cid:88)−1 (cid:88)j−1 Proof: If αβ+1 − α ≤0, the condition in Eq. (5)
Ck+ αitiUi+ βitiUi ≤tj, (4) (cid:81)kj=−11(βUj+1) β
neverholdssinceC >0,andthestatementisvacuouslytrue.
i=1 i=1 k
where Ck > 0, αi > 0, Ui > 0, and βi > 0 are dependent We focus on the case (cid:81)kj=−11αβ(β+U1j+1) − αβ >0.
2Astobeclearlyillustratedlater,thek pointscanbeconsideredeffective We prove this lemma by showing that the condition in
if they can define certain extreme cases of task parameters. For example, Eq.(5)leadstothesatisfactionsoftheschedulabilitycondition
the “difficult-to-schedule” concept first introduced by Liu and Layland [31]
listedinEq.(4)byusingcontrapositive.Bytakingthenegation
definesk effectivepointsthatareusedinExample1.Intheircase[31],the
oftheschedulabilityconditioninEq.(4),weknowthatiftask
selected set of the k points was “very” effective because the tested task τk
becomesunschedulableifCk isincreasedbyanarbitrarilysmallvalueε. τk is not schedulable by the scheduling policy, then for each
4
j =1,2,...,k ming [33] under the assumption that t∗ is given as a
k
constant, i.e., s is known.
k−1 j−1 k−1 j−1
(cid:88) (cid:88) (cid:88) (cid:88) • Step2:wepresentaspecificsolutioninanextremepoint,
C +α t U +β t U ≥C + α t U + β t U >t ,
k i i i i k i i i i i i j as a function of t∗.
k
i=1 i=1 i=1 i=1 (6) • Step 3: we prove that the above extreme point solution
dueto0<α ≤α,and0<β ≤β foranyi=1,2,...,k−1 gives the minimum C∗ if αβ+1 − α >0.
To enforce thie condition in Eiq. (6), we are going to show k (cid:81)kj=−11(βUj+1) β
that C must have some lower bound. Therefore, if C is no [Step 1:] In this step, we assume that s is given, i.e., t∗
k k k
morethanthislowerbound,thentaskτ isschedulablebythe is specified as a constant. The original linear programming
k
scheduling policy. in Eq. (9) has k variables and 2(k − 1) + 1 constraints.
After specifying the value t∗ as a given constant, the new
Fortherestoftheproof,wereplace>with≥inEq.(6),as k
the infimum and the minimum are the same when presenting linearprogrammingwithouttheconstraintinEq.(9d)hasonly
the inequality with ≥. Moreover, we also relax the problem k−1 variables and 2(k−1) constraints. Thus, according to
by replacing the constraint t ≥ t with t ≥ 0 for j = the extreme point theorem for linear programming [33], the
j+1 j j
1,2,...,k−1. Therefore, the unschedulability for satisfying linearconstraintsformapolyhedronoffeasiblesolutions.The
Eq. (6) implies that Ck > Ck∗, where Ck∗ is defined in the extreme point theorem states that either there is no feasible
following optimization problem: solution or one of the extreme points in the polyhedron is an
min C∗ (7a) optimalsolutionwhentheobjectiveofthelinearprogramming
k is finite. To satisfy Eqs. (9b) and (9c), we know that t∗ ≤ t∗
s.t. C∗+k(cid:88)−1αt∗U +(cid:88)j−1βt∗U ≥t∗ ∀j =1,...,k−1, for j = 1,2,...,k −1, due to t∗i ≥ 0, 0 < β, 0 <jα andk
k i i i i j U > 0 for i = 1,2,...,k−1. As a result, the objective of
i=1 i=1 (7b) thie above linear programming is t∗ −(cid:80)k−1(α+β)t∗U ≥
k i=1 i i
t∗ ≥0 ∀j =1,...,k−1, t∗ − (cid:80)k−1(α + β)t∗U , which is finite (as a function of
j k i=1 k i
(7c) t∗, α, and β) under the assumption 0 < β, 0 < α and
k
k−1 0<(cid:80)k−1U ≤1.
C∗+(cid:88)(α+β)t∗U ≥t , (7d) i=1 i
k i i k
Accordingtotheextremepointtheorem,oneoftheextreme
i=1
points is the optimal solution of Eq. (9) for a given t∗. There
where t∗,t∗,...,t∗ and C∗ are variables; and α, β are k
1 2 k−1 k are k −1 variables with 2(k −1) constraints in Eq. (9) for
constants.
a given t∗. An extreme point must have at least k−1 active
Let s ≥ 0 be a slack variable such that C∗+(cid:80)k−1(α+ constraintks in Eqs. (9b) and (9c), in which their ≥ are set to
k i=1
β)t∗U =t +s.Therefore, C∗ =t +s−(cid:80)k−1(α+β)t∗U . equality =.
i i k k k i=1 i i
By replacing C∗ in Eq. (7b), we have
k We now prove that an extreme point solution is feasible
k(cid:88)−1 k(cid:88)−1 k(cid:88)−1 (cid:88)j−1 for Eq. (9) by setting t∗j either to 0 or to t∗k−β(cid:80)ki=−j1t∗iUi =
t +s−( αt∗U + βt∗U )+ αt∗U + βt∗U t∗ >0 for j =1,2,...,k−1. Suppose for contradiction that
k i i i i i i i i j
i=1 i=1 i=1 i=1 there exists a task τ with 0 = t∗ = t∗ −β(cid:80)k−1t∗U . Let
h h k i=h i i
k−1 ω be the index of the next task after τ with t∗ > 0 in this
=tk+s−(cid:88)βt∗iUi ≥t∗j, ∀j =1,...,k−1. (8) extreme point solution, i.e., t∗h = t∗h+1h= ··· =ω t∗ω−1 = 0.
i=j If t∗ = 0 for h ≤ i ≤ k − 1, then ω is set to k and t∗
i ω
FproorgnraomtamtioinngalinbrEevqi.ty(,7)lectatn∗kbbeeretkwr+ittse.nTahsefroelfloorwe,s:the linear aisndt∗k.t∗hT+h1er=efo·re·,· t=he tc∗ωo−n1dit=ion0s ti∗km−plyβ(cid:80)theki=−ch1ont∗itrUadii=ctiot∗hn =tha0t
0 = t∗ = t∗ −β(cid:80)k−1t∗U = t∗ −β(cid:80)k−1t∗U ≥ t∗ > 0
k−1 h k i=h i i k i=ω i i ω
min t∗k−(cid:88)(α+β)t∗iUi (9a) wωh=enkω. ≤k−1 or 0=t∗h =t∗k−(cid:80)ik=−h1t∗iUi =t∗k >0 when
i=1
k−1 By the above analysis and the pigeonhole principle, a
(cid:88)
s.t. t∗k−β t∗iUi ≥t∗j, ∀1≤j ≤k−1 (9b) feasible extreme point solution of Eq. (9) can be represented
i=j by two sets T1 and T2 of the k−1 higher-priority tasks, in
t∗ ≥0 ∀1≤j ≤k−1 (9c) which t∗ = 0 if τ is in T and t∗ −β(cid:80)k−1t∗U = t∗ > 0
j j j 1 k i=j i i j
t∗k ≥tk (9d) if task τj is in T2. With the above discussions, we have
T ∪T ={τ ,τ ,...,τ } and T ∩T =∅.
1 2 1 2 k−1 1 2
The remaining proof is to solve the above linear program- [Step2:]Foragivent∗,onespecialextremepointsolution
mingtoobtaintheminimumC∗ if αβ+1 −α >0.Our is to put t∗−β(cid:80)k−1t∗Uk =t∗ for every j =1,2,...,k−1,
proof strategy is to solve the liknear(cid:81)pkjr=−o11g(rβaUmj+m1i)ng aβnalytically i.e., T1 askan empit=yjseit. Tiherejfore,
as a function of t∗k. This can be imagined as if t∗k is given. ∀1≤i≤k−1, t∗ −t∗ =βt∗U , (10)
At the end, we will prove the optimality by considering all i+1 i i i
possible t∗ ≥t . This involves three steps: which implies that
k k
• Step1:weanalyzecertainpropertiesofoptimalsolutions t∗i+1 =βU +1. (11)
based on the extreme point theorem for linear program- t∗ i
i
5
Moreover, task τ is schedulable by the scheduling algorithm if
k
t∗i =k(cid:89)−1 t∗j = 1 . (12) βk(cid:88)−1U ≤ln( αβ +1 ). (17)
t∗k j=i t∗j+1 (cid:81)kj=−i1(βUj +1) i=1 i Ctkk + αβ
The above extreme point solution is always feasible in the
We also construct the following Lemma 4, c.f. Appendix
linear programming of Eq. (9) since
B for the proof, as the most powerful method for a concrete
t∗ tasksystem.Throughoutthepaper,wewillnotbuildtheorems
0< i , ∀i=1,2,...,k−1. (13)
t∗ and corollaries based on Lemma 4 but we will evaluate how
k
it performs in the experimental section.
By Eq. (10), we have
Lemma 4. For a given k-point effective schedulability test of
α
(α+β)U t∗ =(t∗ −t∗)( +1). (14) a fixed-priority scheduling algorithm, defined in Definition 1,
i i i+1 i β
task τ is schedulable by the scheduling algorithm, in which
k
Therefore,inthisextremepointsolution,theobjectivefunction 0<tk and 0<αi and 0<βi for any i=1,2,...,k−1, if
of Eq. (9) is the following condition holds
t∗ −k(cid:88)−1(α+β)U t∗ =t∗ −(t∗ −t∗)(α +1) 0< Ck ≤1−k(cid:88)−1 Ui(αi+βi) . (18)
k i=1 i i k k 1 β tk i=1 (cid:81)kj=−i1(βjUj +1)
(cid:18)t∗ α α(cid:19) (cid:32) α +1 α(cid:33)
=t∗ 1( +1)− =1 t∗ β − , Remarks and how to use the framework: After
k t∗k β β k (cid:81)kj=−11(βUj +1) β presenting the k2U framework, here, we explain how to
(15) use the k2U framework and summarize how we plan to
demonstrate its applicability in several task models in the
1
where the last equality = is due to Eq. (12) when i is 1. following sections. The k2U framework relies on the users to
index the tasks properly and define α and β as constants for
i i
[Step 3:] From Step 1, a feasible extreme point solution i=1,2,...,k−1basedonEq.(4).Theset{t ,t ,...,t }
1 2 k−1
is with T1∪T2 = {τ1,τ2,...,τk−1} and T1∩T2 = ∅. As in Definition 1 is used only for the users to define those
a result, we can simply drop all the tasks in T1 and use the constants, where tk is usually defined to be the interval
remaining tasks in T2 by adopting the same procedures from length of the original schedulability test, e.g., Dk in Eq. (1).
Eq.(10)toEq.(14)inStep2.Theresultingobjectivefunction Therefore, the k2U framework can only be applicable when
of this extreme point solution for the linear programming in α andβ arewell-defined.Theseconstantsdependonthetask
Eq.(9)ist∗( αβ+1 −α)≥t∗( αβ+1 −α)due miodels aind the task parameters.
k (cid:81)τj∈T2(βUj+1) β k (cid:81)kj=−11(βUj+1) β
to the fact that (cid:81)τj∈T2(βUj +1)≤(cid:81)kj=−11(βUj +1). of tThheercehsouilctienogfgscohoeddpualarbamilietyterbsoαuinadnsdiβni aLfefmecmtsatshe1qutoalit3y.
Therefore, for a given s ≥ 0, i.e., t∗k ≥ tk, all the other However, deriving the good settings of αi and βi is actually
extremepointsofEq.(9)weredominatedbytheonespecified not the focus of this paper. The framework does not care how
in Step 2. By the above analysis, if αβ+1 −α >0, we the parameters αi and βi are obtained. The framework simply
(cid:81)kj=−11(βUj+1) β derives the bounds according to the given parameters αi and
konfosw, inthawth(itckh+thse)(m(cid:81)ikjn=−im11αβ(uβ+mU1j+h1a)p−peαβns)wishaennisncirsea0s.iAngsfaunrecstuioltn, βthie, rseegttairndglsesosfoαfithaendseβttiinigssnooft αveiriafineddβbiy. Tthheefcroarmreecwtnoerkss. of
we reach the conclusion of the lemma. The ignorance of the settings of α and β actually leads
i i
to the elegance and the generality of the framework, which
WenowprovidetwoextendedlemmasbasedonLemma1, works as long as Eq. (4) can be successfully constructed
used for given α and β when α ≤ α and β ≤ β for i = for the sufficient schedulability test of task τ in a fixed-
i i k
1,2,...,k−1. Their proofs are in Appendix B. priority scheduling policy. With the availability of the k2U
framework, the hyperbolic bounds or utilization bounds can
Lemma2. Foragivenk-pointeffectiveschedulabilitytestofa
be automatically derived by adopting Lemmas 1 to 3 as long
scheduling algorithm, defined in Definition 1, in which 0<t
k as the safe upper bounds α and β to cover all the possible
and 0<α ≤α and 0<β ≤β for any i=1,2,...,k−1,
i i settings of α and β for the schedulability test in Eq. (4) can
task τ is schedulable by the scheduling algorithm if i i
k be derived, regardless of the task model or the platforms.
Ctkk+k(cid:88)i=−11Ui ≤(1(kk,−−1)1(()α(cid:18)+(β1)+k1αβ−)β1k)−1+1(−(α1+(cid:19)β,)k1−α) ((oααth++erββw))ikk11se<<. 1α osfocbhrsmeeTdruhvuleaalattoiibootihnnliesstry.baSyappnpetaercolsiytfiaiscncihasgellsobyn,ainsltyeh[de1se0pov]rn,eor[ba2Ell2eq]tm.i,m[(f2e1o4)rp]moianuilnlsatotsthiheoinianrvstehpienrsoimTb[1lDie0lmaA]r,
β [22]arebasedonnon-linearprogrammingbyselectingseveral
(16)
good points under certain constraints. Moreover, the linear-
Lemma3. Foragivenk-pointeffectiveschedulabilitytestofa programming problem formulation in [24] considers U as
i
scheduling algorithm, defined in Definition 1, in which 0<t variables and t as constants and solves the corresponding
k i
and 0<α ≤α and 0<β ≤β for any i=1,2,...,k−1, linearprogramminganalytically.However,astheseapproaches
i i
6
in [10], [22], [24] seek for the total utilization bounds, they the higher-priority tasks hp (τ ) is the same as that of task τ
1 k k
have limited applications and are less flexible. For example, under the interference of the higher-priority tasks hp(τ ).
k
theyaretypicallynotapplicabledirectlywhenconsideringspo-
Therefore, with the above analysis, we can use the k2U
radicreal-timetaskswitharbitrarydeadlinesormultiprocessor
systems. Here, we are more flexible in the k2U framework. framework in Sec. 4 as in the following theorem.
For task τi, after αi and βi or their safe upper bounds α and Theorem1. Taskτkinasporadictasksystemwithconstrained
β are derived, we completely drop out the dependency to the deadlines is schedulable by the fixed-priority scheduling algo-
periods and models inside k2U. rithm if
C(cid:48) (cid:89)
We will demonstrate the applicability and generality of ( k +1) (U +1)≤2 (20)
k2Ubyusingthemost-adoptedsporadicreal-timetaskmodel Dk j
τj∈hp1(τk)
inSec.5,multi-frametasksinAppendixCandmultiprocessor
or
sccahseesd,uwlinegcainn Sfiencd.r6e,asaosnailblulestrsaettetidngisnoFfigαuraend1.βIntoalplrothveidsee DCk(cid:48) + (cid:88) Uj ≤k(2k1 −1). (21)
better results or new results for schedulability tests, with k τj∈hp1(τk)
respect to the utilization bounds, speed-up factors, or capacity
augmentation factors, compared to the literature. More specif- Proof:Fornotationalbrevity,supposethattherearek−1
(cid:106)icall(cid:107)y,(aftercertainreorganizations),wewillgreedilysetti as tasks in hp1(τk).4 Now, we index the higher-priority tasks in
anTtdki βTiipianraamlleotefrtshedesrtuivdeidedincatsheiss.3paTpaebrl,eaIsswumelml aarsizaensethaerliαeri hhipg1h(eτrk-)prtioorfiotyrmtatshk(cid:106)escinor(cid:107)hreps1p(oτnkd)inagreτo1r,dτe2r,e.d..t,oτke−ns1u.rTehtehakt−th1e
raensduldtebfyerLraibuleansderCvheresn.in[30]forself-suspendingtaskmodels aarrerivinalatinmoens-,dei.cer.e,asiDTnikgoTrdie,ro.fThthaetilsa,swt jiothbsthneoablaotveer itnhdaenxDingk
(cid:106) (cid:107)
5 Applications for Fixed-Priority Scheduling o(cid:106)f the(cid:107)higher-priority tasks in hp1(τk), we have DT(cid:106)ik T(cid:107)i ≤
This section provides demonstrations on how to use the foTrDi+ki1=T1i+,21,f.o.r.i,k=−1,12,,.a.n.d,kt−2as.NDow.,Dwueesettotithaes faDTctikthTait
k2U framework to derive efficient schedulability analysis T ≤D for i=1,2,...,k−1k, we knkow that t >0.
i k i
for sporadic task systems in uniprocessor systems. We will
consider constrained-deadline systems first in Sec. 5.1 and Therefore, for a given t with j =1,2,...,k, the demand
j
explainhowtoextendtoarbitrary-deadlinesystemsinSec.5.2. requested up to time t is at most
j
For the rest of this section, we will implicitly assume Ck >0. C + (cid:88) C + (cid:88) (cid:24)tj(cid:25)C
k i T i
5.1 Constrained-Deadline Systems τi∈hp2(τk) τi∈hp1(τk) i
k−1(cid:24) (cid:25) k−1 j−1
For a specified fixed-priority scheduling algorithm, let =C(cid:48) +(cid:88) tj C ≤C(cid:48) +(cid:88) tiC +(cid:88)C ,
hp(τk) be the set of tasks with higher priority than τk. We k Ti i k Ti i i
now classify the task set hp(τ ) into two subsets: i=1 i=1 i=1
k
where the inequality comes from the indexing policy defined
• hp1(τk) consists of the higher-priority tasks with periods above, i.e., (cid:108)tj(cid:109) ≤ ti +1 if j > i and (cid:108)tj(cid:109) ≤ ti if j ≤ i.
smaller than Dk. Ti Ti Ti Ti
Since T < D for any task τ in hp (τ ), we know that
• hp (τ ) consists of the higher-priority tasks with periods i k i 1 k
2 k
t ≥ T . Instead of testing all the t values in Eq. (19), we
larger than or equal to D . i i
k
only apply the test for these k different t values, which is
i
For any 0<t≤Dk, we know that a safe upper bound on equivalent to the test of the existence of tj such that
the interference due to higher-priority tasks is given by
k−1 j−1
(cid:88) (cid:24) t (cid:25)C = (cid:88) C + (cid:88) (cid:24) t (cid:25)C . Ck(cid:48) +(cid:88)tiUi+(cid:88)TtitiUi ≤tj. (22)
T i i T i i=1 i=1 i
i i
τi∈hp(τk) τi∈hp2(τk) τi∈hp1(τk) Therefore, we reach the schedulability in the form of Eq. (4)
Athseaverreisfiuclat,tiothneosfchtheeduelxaibsitleintyceteosft 0in<Etq.≤(1D)kisseuqcuhivthaaletnt to ufonrdeir=the1s,e2t,ti.n.g.,okf−αi1t.oB1yantdakβinigtoβTitii≤≤11 a(dnudeαtoi t=i ≥1Tfio)r,
(cid:24) (cid:25) i=1,2,...,k−1inLemmas1and2,wereachtheconclusion.
(cid:88) (cid:88) t
C + C + C ≤t. (19)
k i T i
i
τi∈hp2(τk) τi∈hp1(τk) When RM priority ordering is applied for an implicit-
aWtinmedecpCaenrk(cid:48)iot=hdenCTk(cid:48)cr=+ea(cid:80)Dteτa.i∈Ivthiprit2su(τcaklle)saCpriot,rharaedtliactthitevaesskcdheτeak(cid:48)ddulwilnaietbhiDlietxk(cid:48)ye=tceusDttiotkno, dUeka.dFlionre stausckhsaysctaesme,, Cthk(cid:48)eicsoenqduitaiolntoinCkEqa.nd(20DC)kk(cid:48)isistheequsaalmtoe
k k
verify the schedulability of task τ(cid:48) under the interference of
k 4Whenhp2(τk)isnotempty,therearek−1−|hp2(τk)|tasksinhp1(τk).
(cid:106) (cid:107) Tobenotationallyprecise,wecandenotethenumberoftasksinhp1(τk)bya
3Setting ti as Ttki Ti is actually the same in [24] for the sporadic real- newsymbolk∗.Sincek∗≤k,weknowk∗(2k1∗−1)≥k(2k1−1)asasafe
timetaskmodelwithimplicitdeadlinesandthemulti-frametaskmodelwhen bound in Eq. (21). However, this may make the notations too complicated.
Ti isgivenandUi isconsideredasavariable. Wehavedecidedtokeepitask−1forthesakeofnotationalbrevity.
7
Demonstrated Applications:
s
sk Sec. 5.1: Constrained-deadline sporadic tasks
a
t Sec. 5.2: Arbitrary-deadline sporadic tasks Hyperbolic
1
− App. C: Multiframe tasks bound
k Sec. 6.1: Multiprocessor DAG
r Sec. 6.2: Multiprocessor self-suspension 1
e
d a
or m Other
and Derive parameters Lem 2 & 3 utilization
k by Definition 1 as bounds
< m
m
∀i Ui,∀i < k L e
t,i αi,∀i < k k2U Lemma 4 Extreme
e β ,∀i < k framework
n i points test
fi
de Ck,tk
Fig. 1: The k2U framework.
Model αi βi c.f.
UniprocessorSporadicTasks αi=1 0<βi≤1 Theorem1andCorollary2
MultiprocessorGlobalRMforDifferentModels 0<αi≤ M2 0<βi≤ M1 Theorems4-5
UniprocessorMulti-frameTasks 0<αi≤1 0<βi≤ φi(2φ)i−(1φ)i(1) Theorem7
UniprocessorSelf-SuspendingTasks 0<αi≤2 0<βi≤1 Theorems 5 and 6 in [30],
implicitly
TABLE I: The applicability of k2U for different task models: their α and β parameters, where M is the number of processors in global
i i
RM scheduling and φ ((cid:96)) is the maximum of the sum of the execution time of any (cid:96) consecutive frames of task τ in the multi-frame model.
i i
as the hyperbolic bound provided in [7], and the condition in or
Eq. (21) is the same as least utilization upper bound in [31]. C(cid:48) (cid:88) (cid:32)(cid:18)f +1(cid:19)k1 (cid:33)
k + U ≤fk −1 . (24)
D j f
TheschedulabilitytestinTheorem1mayseempessimistic k
τj∈hp1(τk)
at first glance. We evaluate the quality of the schedulability
test in Theorem 1 by quantifying the speed-up factor with
Proof: This is based on the same proof as Theorem 1,
raecspaseec)t.tWoethsehoowptitmhaatlthscehsepdeuelde-u(ip.ef.,acEtoDrFofscthheedsuclhinegduilnabsiulicthy by taking the fact that ti = (cid:106)DTik(cid:107)Ti ≥ f. In the k-point
tbeosutnidnaEnqd.u(p2p0e)risbo1u.n7d63o2f2D, wMhiacshshisowthneisnam[1e8]a.sTthheeslpoewede-r eTfhfeecretifvoeres,cwheedhualavbeilαity≤teTsαit,=we1,caβnTi≤setβα=i to1,1a,nβdi =α iTtsiif≤. Bf1y.
upfactorofDM,regardlessoftheschedulabilitytests,obtained i i f β
adoptingLemma1,weknowthattaskτ isschedulableunder
byDavisetal.[18]isthesameasourresult.Ourresultisthus k
the scheduling policy if
stronger, as we show that the factor already holds when using
the schedulability test in Eq. (20) in the following theorem. (Ck(cid:48) +f) (cid:89) (Uj +1)≤f +1,
D f
Theorem 2. The speed-up factor of the schedulability test in k
τj∈hp1(τk)
Eq. (20) under DM scheduling for constrained-deadline tasks
is 1.76322 with respect to EDF. which is the same as the condition in Eq. (23) by dividing
both sides by f. By using a similar argument and applying
Lemma 2, we can reach the condition in Eq. (24).
TheproofofTheorem2intheAppendixB,whichismuch
Note that the right-hand side of Eq. (24) converges to
simpler than the proof in [18], can also be considered as an
alternative proof of the speed-up factor of DM. fln(f+f1) when k goes to ∞.
Corollary 1. Supposethatf·T ≤D foranyhigherpriority
i k
task τ in hp (τ ), where f is a positive integer. Task τ in
i 1 k k 5.2 Arbitrary-Deadline Systems
a constrained-deadline sporadic task system is schedulable by
the fixed-priority scheduling algorithm if Wenowfurtherexplorehowtousetheproposedframework
( Ck(cid:48) +1) (cid:89) (Uj +1)≤ f +1 (23) ttoaskpersfeotsrm. Tthhee secxhaecdtulsacbhielidtyulaabnialiltyysisanfaolrysairsbitfroarrya-drbeiatdralirnye-
f ·D f f
k deadline task sets under fixed-priority scheduling has been
τj∈hp1(τk)
8
developedin[25].Theschedulabilityanalysisistouseabusy- following corollary comes from a similar argument as in
windowconcepttoevaluatetheworst-caseresponsetime.That Sec. 5.1.
is,wereleaseallthehigher-prioritytaskstogetherwithtaskτ
k Corollary2. Taskτ inasporadicarbitrary-deadlinetasksys-
at time 0 and all the subsequent jobs are released as early as k
tem is schedulable by the fixed-priority scheduling algorithm
possible by respecting to the minimum inter-arrival time. The
if Eq. (20) or (21) holds, in which there are k − 1 higher
tbhuesynewxtinrdeolewasefinoifshaesjobwhoefntaaskjoτbk.oIft htaasskbτekenfisnhioshwensibne[f2o5re] p(cid:80)riority tasks in hp1(τk) and Ck(cid:48) is defined as (cid:108)DTkk(cid:109)Ck +
that the worst-case response time of task τ can be found in C .
one of the jobs of task τ in the busy windkow. τi∈hp2(τk) i
k Corollary 3. Suppose that f ·T ≤ D for any higher task
i k
Therefore, a simpler sufficient schedulability test for a τ in the task system and f ·T ≤ D , where f is a positive
i k k
task τk is to test whether the length of the busy window is integer. Task τk in a sporadic task system is schedulable by
within Dk. If so, all invocations of task τk released in the using RM, i.e., Ti ≤Ti+1, if
busy window can finish before their relative deadline. Such
k−1
an observation has also been adopted in [17]. Therefore, a (Uk +1)(cid:89)(Uj +1)≤ f +1 (27)
sufficient test is to verify whether5 f f f
j=1
(cid:24) (cid:25) (cid:24) (cid:25)
∃t with 0<t≤Dk and Ttk Ck+ (cid:88) Tti Ci ≤t. or (cid:88)k (cid:32)(cid:18)f +1(cid:19)k1 (cid:33)
τi∈hp(τk) (25) Uj ≤fk f −1 . (28)
j=1
If the condition in Eq. (25) holds, it implies that the busy
window (when considering task τ ) is no more than D , and,
k k Proof: Based on the above assumption f ·T ≤ D for
hence,taskτ hasworst-caseresponsetimenomorethanD . i k
k k any higher task τ in the task system, f ·T ≤ D , and the
i k k
IfDk ≤Tk,theanalysisinSec.5.1canbedirectlyapplied. rate monotonic scheduling, we can safely set αi to 1, βi to f1,
IwfinDdkow>forTtka,skwτeknaesesdhotwoncaobnosvidee.rFothrethelernegstthofotfhitshesecbtuiosyn-, banydadCok(cid:48)pttiongfL·Cemk.mNao1teatnhdatLfeCm·tk(cid:48)km≤a2U,fkwienrtehaicshctahsee.cTonhcelruesfioorne,,
we will focus on the case D >T . We can rewrite Eq. (25)
k k as in the proof of Corollary 1.
to use a more pessimistic condition by releasing the workload
(cid:108) (cid:109)
DTkk Ck at time 0. That is, if 6 Application for Multiprocessor Scheduling
(cid:24) (cid:25) (cid:24) (cid:25)
∃t with 0<t≤Dk and DTk Ck+ (cid:88) Tt Ci ≤t, It may seem, at first glance, that the k2U framework
k τi∈hp(τk) i only works for uniprocessor systems. We demonstrate in this
(26) section how to use the framework in multiprocessor global
then, the length of the busy window for task τk is no more RMschedulingwhenconsideringimplicit-deadline,DAG,and
than Dk. Again, similar to the strategy we use in Sec. 5.1, we self-suspending task systems. The methodology can also be
classify the tasks in τi ∈ hp(τk) into two sets hp1(τk) and extended to handle constrained-deadline systems.
hp (τ ) with the same definition.
2 k
In multiprocessor global scheduling, we consider that the
Similarly, we can then(cid:108)cre(cid:109)ate a virtual sporadic task τk(cid:48) system has M identical processors, each with the same com-
wdeiathdleinxeecuDti(cid:48)on=timDeC,k(cid:48)an=d pDTekkriodCkT+(cid:48) (cid:80)=τi∈Dhp.2(Fτko)rCnio,traetliaotnivael pscuhtaetdiuolnerpotowedri.sMpaotcrehovtheer,jtohbesr.eWiseacgolonbsaidleqruoeunelyangdloabaglloRbMal
k k k k scheduling, in which the priority of the tasks is defined based
brevity, suppose that there are k−1 tasks in hp (τ ). Now,
1 k
on RM. At any time, the M-highest-priority jobs in the ready
we index the higher-priority tasks in hp (τ ) to form the
1 k
queue are dispatched and executed on these M processors.
corresponding τ ,τ ,...,τ . In the above definition of the
1 2 (cid:106) k(cid:107)−1
bjoubsyofwtiansdkowτ croenlecaespet,d nDToiklatTeir itshathneDarr.ivTahletimke−o1f thhieghlaesr-t tionGbloobuanldsR. MHowinevegre,niefrawledcooensstnraoitn hthaevetotgaolodutiluiztialtiizoan-
tpirmioersitoyfttahsekslaiisnthjopb1s(τbke)foarreeDordearreedintoaeknnosnu-rdeetchraetastihnegaorrrdivearl. (cid:80)it iτsipMoCsTisiib≤le t1boapnrodvtihdee tmheaxsicmhuemduluatbiilliiztaytigounarmanatxeτeioCTfiig≤lob1bal,
k
Moreover, t is the specified testing point D . Instead of RM by setting b to 3− 1 [1], [2], [5]. Such a factor b has
k k M
testing all the t values in Eq. (26), we only apply the test been recently named as a capacity augmentation factor [28].
for these k different t values, which is equivalent to the test
i Wewillusethefollowingtime-demandfunctionW (t)for
of the existence of t such that Eq. (22) holds, where α ≤1 i
j i the simple sufficient schedulability analysis:
oanfdThβeio=remTtii1≤. 1 for i = 1,2,...,k−1, similar to the proof (cid:24) t (cid:25)
W (t)=( −1)C +2C , (29)
i T i i
Therefore, we can then use the k2U framework, i.e., i
Lemmas 1 to 3 to test the schedulability of task τk. The which can be imagined as if the carry-in job is fully carried
intotheanalysisinterval[21].Thatis,weallowthefirstrelease
5This analysis is pretty pessimistic. But, as our objective in this paper is
oftaskτ tobeinflatedbyafactor2,whereastheotherjobsof
to show the applicability and generality of k2U, how to use k2U to get i
task τ have the same execution time C . Again, we consider
tighter analysis for arbitrary-deadline task systems is not our focus in this i i
paper.Someevaluationscanbefoundin[14]. testingtheschedulabilityoftaskτk underglobalRM,inwhich
9
there are k−1 higher-priority tasks τ ,τ ,...,τ . We have The analysis is based on the two given parameters C and Ψ .
1 2 k−1 i i
the following schedulability condition for global RM. Therefore, we can also allow flexible DAG structures. That is,
jobs of a task may have different DAG structures, under the
Lemma 5. Task τ is schedulable under global RM on M
k total execution time constraint C and the critical path length
identical processors, if i
constraint Ψ . Therefore, the model can also be applied for
i
k−1 conditional sporadic DAG task systems [3]. With the above
∃t with 0<t≤T and C +(cid:88)Wi(t) ≤t, (30) definition, we have the following lemma, in which the proof
k k M
i=1 is Appendix B.
where Wi(t) is defined in Eq. (29). Lemma 6. Task τk in a sporadic DAG system with implicit
deadlines is schedulable under global RM on M identical
Proof: This has been shown in Sec. 3.2 (The Basic processors, if
Multiprocessor Case) in [21].
k−1
Theorem 3. Task τk in a sporadic implicit-deadline task ∃t with 0<t≤Tk and Ψk+ CkM−Ψk +(cid:88)WMi(t) ≤t,
system is schedulable by global RM on M processors if i=1
(33)
(Ck +2)k(cid:89)−1(Uj +1)≤3, (31) where Wi(t) is defined in Eq. (29).
Tk j=1 M Theorem 4. Task τk in a sporadic DAG system with implicit
deadlines is schedulable by global RM on M processors if
or
k(cid:88)−1Uj ≤ln 3 . (32) (Ψk +2)(cid:89)k (Uj +1)≤3 (34)
M Ck +2 T M
j=1 Tk k j=1
or
(cid:106) (cid:107)
Proof: Let ti be TTki Ti for i=1,2,...,k, and reindex (cid:88)k Uj ≤ln 3 . (35)
the tasks such that t1 ≤ t2 ≤ ... ≤ tk. By testing only M Ψk +2
these k points in the schedulability test in (30) results in a k- j=1 Tk
point effective schedulability test with α ≤ 2 and β ≤ 1 .
i M i M Proof: Based on Lemma 6, which is very similar to
Therefore, we can adopt the k2U framework. By Lemma 1
Lemma 5, we can perform a similar transformation as in
and Lemma 3, we have concluded the proof. Theorem 3, in which α ≤ 2 and β ≤ 1 . By adopting
i M i M
Lemma 1, we know that if
Note that Theorem 3 is not superior to the known analysis
fcoorndsiptioornadiinc tLaesmkmsyast5emiss t[o1o],p[e2s]s,im[5i]s,tiacs. Tthheisscisheodnullyabuilsietyd (Ψk+ CkM−Ψk +2)k(cid:89)−1(Uj +1)≤3, (36)
as the basis to analyze a sporadic task set with DAG tasks in Tk M
j=1
Sec. 6.1 and self-suspending tasks in Sec. 6.2 when adopting
then task τ is schedulable. Due to the fact that C −Ψ ≤
global RM, in which we will demonstrate similar structures k k k
as used in Theorem 3. We also demonstrate a tighter test in Ck, we know that (Ψk+TCkkM−Ψk + 2) ≤ (ΨkT+kCMk + 2) ≤
AppendixFforimprovingtheschedulabilitytestofglobalRM (Ψk +2)·(Uk +1). Therefore, if the condition in Eq. (34)
for sporadic tasks. hoTlkds, the conMdition in Eq. (36) also holds, which implies the
schedulability.WiththeresultinEq.(34),wecanusethesame
procedure as in Lemma 3 to obtain Eq. (35).
6.1 Global RM for DAG Task Systems
Corollary 4. The capacity augmentation factor of global RM
For multiprocessor scheduling, the DAG task model has
forasporadicDAGsystemwithimplicitdeadlinesis3.62143.
been recently studied [9]. The utilization-based analysis can
be found in [28] and [9]. Each task τi ∈ T in a DAG task Proof: Suppose that (cid:80) Ci ≤ 1 and Ψk ≤
system is a parallel task. Each task is characterized by its τi MTi b Tk
execution pattern, defined by a set of directed acyclic graphs smchaexdτiulΨTaiibi≤lity1b.ofThtaesrkefoτre,ifby1E≤q. (ln35),3w.eTchainsgiusaeraqnutievealtehnet
(DDAAGGss.)E.aTchheneoxdeec(ustuiobntatsikm)einoafDaAjoGbroefprteasseknτtsiaisseoqnueenocfethoef to solving x = ln 3 k, whbich hold2s+1bwhen x ≈ 3.62143
2+x
instructions (a thread) and each edge represents a dependency by solving the equation numerically. Therefore, we reach the
betweennodes.Anode(subtask)isreadytobeexecutedwhen conclusion of the capacity augmentation factor 3.62143.
allitspredecessorshavebeenexecuted.Wewillonlyconsider
two parameters related to the execution pattern of task τ : 6.2 Global RM for Self-Suspending Tasks
i
• total execution time (or work) C of task τ : This is the The self-suspending task model extends the sporadic task
i i
summation of the execution times of all the subtasks of model by allowing tasks to suspend themselves. An overview
task τ among all the DAGs of task τ . of work on scheduling self-suspending task systems can be
i i
• critical-path length Ψ of task τ : This is the length found in [30]. In [30], a general interference-based analysis
i i
of the critical path among the given DAGs, in which framework was developed that can be applied to derive suf-
each node is characterized by the execution time of the ficient utilization-based tests for self-suspending task systems
corresponding subtask of task τ . on uniprocessors.
i
10