Schedulability Analysis for a Real-time Multiprocessor System
Based on Service Contracts and Resource Partitioning∗
Yang Chang, Robert Davis and Andy Wellings
University of York, UK,
{yang, robdavis, andy}@cs.york.ac.uk
Abstract
where real-time embedded software can be developed for multicore/multiprocessor systems with the
This report presents some initial results of our confidence that the power of such a platform can
research which addresses the increasing gaps be- be exploited and the software’s logical and tempotween the power of multicore/multiprocessor sys- ral correctness can be achieved.
tems and the lack of development models and tools
One thing essential for the success of a multhat help programmers exploit such power while ticore/multiprocessor real-time embedded system
ensuring correctness and predictability. One spe- is its schedulability analysis which is related to
cific goal of our research is to support service con- the scheduling policy chosen. In existing literatracts on multicore/multiprocessor platforms that ture, there are two main approaches for scheduling
support resource partitioning and therefore allow schedulable entities (such as threads and servers)
a compositional development of parallel real-time on multicores or multiprocessors: fully partitioned
systems. In such a system, each application or and global scheduling.
application component is described by a service
In a fully partitioned system, each schedulable
contract, all of which collectively form a hierarchy
entity is assigned to a processing unit which is the
of service contracts. After successful negotiations,
only place where that schedulable entity can exesuch a hierarchy will be mapped to a hierarchical
cute [9, 11]. All the schedulable entities assigned to
scheduling system. As with other real-time systhe same processing unit compete with each other
tems, such systems require schedulability analysis,
according to a uniprocessor scheduling algorithm.
which is the main focus of this report
Therefore, the uniprocessor schedulability analysis
techniques can be used. However, it is very difficult to find an optimal assignment of schedulable
1 Introduction
entities to processing units [10].
In a global scheduling system, a schedulable entity can be scheduled to run on any processing
unit. All the schedulable entities compete with
each other globally under one of the global scheduling algorithms such as proportionate fair [6], global
EDF [20, 4], global rate monotonic [1], global deadline monotonic [4] and so on. A fundamental difference between such a system and a uniprocessor
system is that migration, in a global scheduling
system, may occur whenever a schedulable entity
is preempted or suspended. Another unique characteristic of global scheduling systems is their difficulty in finding the critical instant which, in a
Up until now, unicore/uniprocessor systems have
dominated real-time embedded computing research and engineering. However, increasing demand on processing power caused by complex
new real-time embedded applications forces researchers and engineers to consider developing multicore/multiprocessor real-time embedded systems.
The urgent demand for such systems and the lack
of development model and tools bring a new software crisis. We aim to develop a new environment
∗ This work has been funded by the European Commission’s 7th framework program’s JEOPARD project, no.
216682 and eMuCo project, no. FP7-ICT-2007-1
1
uniprocessor system, is the time instant at which
all the schedulable entities are released [16, 5]. Because of such fundamental differences, the uniprocessor schedulability analysis techniques can no
longer be used and therefore, many new schedulability analysis approaches have been proposed for
global scheduling systems in recent years [5].
Our research aims to facilitate the development
of component-based multicore/multiprocessor realtime systems. As part of this effort, this report
focuses on the schedulability analysis of such a system, leaving the detailed description of implementation, contract specification and so on to other
documents. The main contribution of this report:
Another trend of real-time embedded software
is to become more and more dynamic and flexible. In order to cope with such developments,
component-based real-time embedded systems have
been studied. In such systems, components are developed, analyzed and tested independent of each
other. When they are put together, analysis and
testing can be made without knowing any internal
information of any component because the impacts
of one component on the others are independent of
its internal behaviour. Therefore, it is possible to
make schedulable entities with very different timing
requirements or criticality coexist without jeopardizing each other’s execution.
• A new schedulability analysis for a
component-based real-time system on a
multicore/multiprocessor platform with resource partitioning.
To the best of our
knowledge, this has not been done before.
• A way to extend the FRESCOR contract
model to multicore/multiprocessor platforms
without introducing too much implementation
complexity.
• An extension to the FRESCOR contract model
to allow resource partitioning to support service contracts (external contracts).
Utilizing execution time servers to implement
component-based real-time embedded systems has
been a common practice on uniprocessors [13,
12]. Based on such techniques, Harbour proposed service contracts in a FRESCOR (Framework for Real-time Embedded Systems based on
COntRacts) project report [14]. In his proposed
model, every application or application component
should have a contract with the rest of the system, describing the minimum resource requirement
of this application or application component. Negotiations are made across the whole system, either
offline or online, to guarantee, if successfully negotiated, that enough resources are always available to
satisfy the minimum requirements of all contracts.
This report is organized as follows. In section 2, a
general model of resource partitioning is introduced
with the concerns initially focused on uniprocessor
platforms and subsequently switched to a proposed
extension for multicore/multiprocessor platforms.
In section 3, we extend the FRESCOR contract
model to multicore/multiprocessor platforms and
also introduce a two-level service contract model
which allows resource partitioning to support service contracts as well. Sections 4 and 5 elaborate
the proposed schedulability analyses for servers and
threads respectively. Some initial experiment results are presented in section 6. Section 7 summarises existing work that is relevant to our research. Finally, we draw conclusions and discuss
possible future work in section 8.
The FRESCOR contracts are devised to be platform independent such that any scheduling method
can be used to support such contracts. Currently,
FRESCOR contracts are mapped to execution time
servers at runtime and all the tasks within an application or application component are executed
under the server that represents the corresponding service contract. This means that the FRESCOR contract model is a hierarchical scheduling
framework, which includes the scheduling of execution time servers and the scheduling of tasks within
those servers.
2
Resource Partitioning
Resource partitioning is widely used in many application areas (e.g. avionic systems) to allow independent execution of more than one application
on the same processor [2, 15]. Both temporal and
spatial partitioning are essential for the correct execution of all the applications. However, this report
2
is only concerned with the temporal aspect of this
issue.
are identical
3. individual scheduling windows do not overlap
but gaps between them are allowed
Usually, partitions in a uniprocessor system are
scheduled on a fixed, cyclic basis which is implemented by maintaining a fixed length major time
frame composed of fixed scheduling windows and
repeating such a scheduling scheme during the lifetime of the system. Each partition, which corresponds to an application, is allocated to one or
more scheduling windows in the major time frame.
A scheduling window can normally be defined by
its offset from the beginning of the major time
frame and its length (see figure 1). Since all the
information needed to make scheduling decisions
is available offline, deterministic behaviour can be
achieved.
An example of such scheduling schemes is given
in figure 2. Two periodic scheduling window sets
are illustrated in that diagram. Scheduling window
set 1 starts at time 0 and has a period of 25 time
units as well as a duration of 10 time units in each
period. On the other hand, scheduling window set
2 starts at time 15 and ends at time 25 which gives
a 10 time unit duration. Then, it repeats every
major time frame.
Major Time Frame
3
0
15 35
!"#$%&'
( %&")( *
!"#$%&'
( %&")( 1
0
50
75
.%.%
+,- )& /
/00$%,.%)& /
.%.%
+,- )& 2
/00$%,.%)& 2
4
10 15
3
25
3
35
50
3
60
75
85
100
Periodic Scheduling Window Set 1
100
Periodic Scheduling Window Set 2
Figure 2: An example of uniprocessor PikeOS
scheduling schemes
Figure 1: An example of resource partitioning systems
Each partition, which corresponds to an application, can be associated with one or more periodic
scheduling window sets. However, every schedulBecause the scheduling scheme of the major time
ing window in the same periodic scheduling window
frame is always repeated, any scheduling window is
set must be associated with the same partition and
essentially periodic. It is important to distinguish
therefore the same application.
an individual scheduling window from a periodic
Uniprocessor operating systems exist that imscheduling window set, which is defined by the offset of its first individual window, its period and its plement resource partitioning mechanisms that are
similar to the above general model. PikeOS is one
duration in each period.
of them. It is a microkernel operating system which
A periodic scheduling window set must follow
partitions and virtualizes resources providing spasome rules:
tial and temporal isolation for guest OSes and applications (which may or may not be running on
1. the length of the major time frame is an exact
guest OSes). A multicore/multiprocessor version of
multiple of its period
PikeOS is being developed. Essential changes pro2. the duration of its windows in different periods posed by Almeida of Sysgo (the company that de3
velops PikeOS) [Almeida, private communication,
2008] to allow PikeOS to be used in a multiprocessor environment (currently SMP only) include:
P1
1. Different processors should have their own major time frames, the lengths of which are identical. They should be synchronized as well.
A
0
P2
2. The scheduling scheme within each major time
frame on each processor is not required to be
the same as others. They can have scheduling
window sets with different active intervals and
periods.
A
10
25
B
0
B
35
A
50
A
15
B
A
75
60
B
30
50
100
85
A
65
80
90
A
Scheduling Windows of Time Partition A
B
Scheduling Windows of Time Partition B
100
3. A time partition can be allocated to any
scheduling window set on any processor. Then,
threads of that time partition can only exe- Figure 3: An example of multiprocessor PikeOS
cute when at least one of their scheduling win- scheduling schemes
dows is active. Therefore, time partitions effectively allow both fully partitioned and global
scheduling.
contracts specify how to distribute the resources
reserved according to the corresponding external
Figure 3 illustrates an example of multiprocessor
contract among all the components.
PikeOS scheduling schemes. In this dual procesThe multicore/multiprocessor resource partitionsor example, time partition A is associated with
a periodic scheduling window set on processor P1 ing model proposed in the previous section is used
as well as two periodic window sets on processor to facilitate external contracts. For example, a few
P2 with periods equal to the length of the major pairs of period and capacity values can be defined
time frame. Time partition B is associated with a in each external contract which, after successful neperiodic scheduling window set on processor P2 as gotiation, can be transformed to parameters of the
well as two periodic window sets on processor P1 corresponding time partition and scheduling winwith periods equal to the length of the major time dow sets (perhaps, on different processors). On the
other hand, internal contracts can be supported by
frame.
using execution time servers and the period and
As the proposed changes do not rely on any specapacity in each internal contract can be directly
cific PikeOS features, we use it as a general model
mapped to the scheduling parameters of a server
of multicore/multiprocessor resource partitioning
after successful negotiation. If parallel execution
in this report.
of an application component is required, the execution time server of that component must run in
parallel as well.
3
Contracts and Hierarchical
Scheduling
In order to support parallel execution of an individual server without introducing too much implementation complexity, we propose the use of subservers, each of which is a physical execution time
server that can never run in parallel, yet can still
migrate across processors. Each such sub-server
has its own budget (independent of the others)
which can only be consumed on a single processor
at any time instant. For the purpose of this report,
it is assumed that any application component (and
One goal of our research is to support resource contracts [14] at two levels. First, each application
should have a contract with the underlying operating system which specifies a portion of resources to
be reserved (i.e. external contracts). Second, components of each application should have their own
contracts as well (i.e. internal contracts). Such
4
therefore its threads) is associated with an abstract 3.1 Terminology and System Model
server which must be composed of physical subservers that do not belong to any other abstract Our schedulability analysis is developed with the
servers (see figure 4) and that collectively satisfy assumption that application threads are released
either periodically at fixed intervals of time, or spothe abstract server’s timing requirement.
radically after some minimum inter-arrival time has
elapsed. Aperiodic threads can be allocated to
servers (which comprises aperiodic threads only)
but they cannot be guaranteed (although their
5
5
servers’ schedulability can be guaranteed). It is
FA
F
E @C GH<<@GG HI ?@J=AKEAK=?
QRST
6778
UVWXRXRYZ[
\]^_`abcde
also assumed that all processors are identical. Each
KG
cd`g
thread τi , has a unique priority i within its abstract
<=>:=G@L \]^f `abcdf
KG <=>:=G@L =F
_ e
=F
f cd`gf
server
and is characterised by its relative deadline
\]^_`abcde
f cd`gf
EFA@C GH<<@GGF HI ?@J=AKEAK=?
Di , worst-case execution time Ci and the minimum
5
5
9::;
inter-arrival time Ti , otherwise referred to as its peB@CD@C;
<=>:=?@?A;
CH?G
riod. It is required that Di ≤ Ti . Currently, we also
KG <=>:=G@L =F
KG <=>:=G@L =F
assume that threads are independent of each other
CH?G
so there is not any blocking factor (Efforts will be
made to relax this restriction as part of our future
BHOPG@CD@CG
MNC@ELG
work.). Notice, the utilization of thread i, denoted
as Ui , must be less than 1 because an individual
thread is not allowed to run in parallel in the proFigure 4: Contracts and Hierarchical Scheduling posed system.
The execution time server algorithms that can be
adopted in our system (for the sub-servers) include
the periodic server, deferrable server [21] and sporadic server algorithms [17]. Any sub-server can be
characterised by a unique priority s within its application, its capacity Cs , capacity replenishment
period and deadline Ts . Notice, the utilization of
sub-server s, denoted as Us , must be less than 1
because an individual sub-server is not allowed to
run in parallel in the proposed system.
All the sub-servers of an application are scheduled according to a global fixed priority pre-emptive
scheduling policy (i.e. the top x available high priority sub-servers should always run at any time
where x is the number of scheduling windows active
at that time) within the time partition of that application. The priorities of sub-servers are global
among all the sub-servers of the time partition
under investigation. Moreover, it should be noticed that any sub-server of a time partition can
be scheduled to execute in any scheduling window
of that time partition if the sub-server’s priority
allows.
4
Threads are scheduled according to the global
fixed priority pre-emptive scheduling policy as well,
but they compete locally within their abstract
server where a sub-server can serve any thread associated with its server if capacity is still available
and the sub-server’s priority is high enough.
Server Schedulability Analysis
In order to guarantee the schedulability of threads,
it is necessary to first make sure that all the subservers of a time partition are schedulable.
Although our server schedulability analysis is
based on the same essential idea as Baruah’s work
[5], there are two significant differences. First, the
execution of sub-servers is constrained by their time
partition’s scheduling windows. Second, our subservers are scheduled according to fixed static priorities while Baruah’s analysis is based on EDF
In such a system, the execution of threads is constrained by the availability of server budgets and
the servers are also constrained by the activation
of their time partition. Consequently, this introduces a 3-layer hierarchical scheduling model.
5
scheduling. Solving these problems are our main
Based on the above definitions, the following
contributions.
lemma can be proven.
Lemma 1. For any least supply time interval
4.1
Least Supply Function of a Par- (u, u + v) of a time partition, either
titioned Multiprocessor System
• at least on one processor, u or u + v is at an
This subsection is dedicated to showing how the
IBCP, or
minimum computation time during a given time
• there exists another least supply time interval
interval can be obtained in a time partitioned mul(u′ , u′ + v) where u′ or u′ + v is at some IBCP.
tiprocessor system. The result presented at the end
of this subsection will be used as the upper bound
of the server workload allowed under any circum- Proof. In order to prove this lemma, it is required
stance. In order to achieve this goal, we model the to contradict the following assertion:
system in a similar way as Mok et al.’s work [18]
There exists a least supply time interval (u, u+v)
which is aimed at uniprocessor systems.
where neither u nor u + v is at any IBCP and for
this least supply time interval, one cannot find any
(u′ , u′ + v) where u′ or u′ + v is at some IBCP.
Theory
First of all, it is assumed that the latest IBCP (on
any processor) before u is at u − x and the earliest
IBCP (on any processor) after u is at u + y. It is
also assumed that latest IBCP (on any processor)
before u + v is at u + v − x′ and the earliest IBCP
(on any processor) after u + v is at u + v + y ′. Since
u and u + v are not supposed to be at any IBCP,
x, y, x′ and y ′ must be greater than zero.
Definition 1 A time partition is a set of m tuples
(Γ, P ), where Γ is an array of N time pairs
{(ST1 , EN1 ), (ST2 , EN2 ), . . . (STN , ENN )}
that satisfies (0 ≤ ST1 < EN1 ≤ ST2 <
EN2 ≤ . . . ≤ STN < ENN ≤ P ) for some
N ≥ 1, and P is the length of the major time
frame, and m is the number of processors on
which this time partition can run.
Because u − x and u + y are the closest IBCPs of
u, scheduling windows do not change their status
For example, time partition A in fig(active or not) in between u − x and u + y. Neither
ure 3 consists of 2 tuples:
(Γ1 , 100) and
do they change status in between u + v − x′ and
(Γ2 , 100).
Γ1 is an array of 4 time pairs
u + v + y ′ due to the same reason. Therefore, we
{(0, 10), (25, 35), (50, 60), (75, 85)} whilst Γ2 is
can assume that q scheduling windows (on q proan array of 2 time pairs {(15, 30), (80, 90)}.
cessors) are active in between u − x and u + y while
q ′ scheduling windows (on q ′ processors) are active
Definition 2 The supply function S(t) of a time
in between u + v − x′ and u + v + y ′ .
partition is the total amount of time that is
In the cases where q < q ′ , we define a small offset
available in that time partition from time 0 to
δ such that δ ≤ x and δ ≤ x′ . Then,
t.
Definition 3 The Least Supply Function LSF (t) of
a time partition is the minimum of all (S(d +
S(u+v −δ)−S(u−δ) = S(u+v)−S(u)+q ·δ −q ′ ·δ
t)−S(d)) where t is a time interval and t, d ≥ 0.
(1)
′
Definition 4 A least supply time interval (u, u + v)
Since q < q ,
is a time interval that satisfies S(u+v)−S(u) =
LSF (v).
S(u + v − δ) − S(u − δ) < S(u + v) − S(u) (2)
Definition 5 All ends of scheduling windows of a time partition (ST1 , ST2 , . . . , STN
and EN1 , EN2 , . . . , ENN ) are called Interval
which contradicts the definition of least supply
Based Critical Points (IBCPs).
time interval.
6
In the cases where q > q ′ , we define another small
offset δ such that δ ≤ y and δ ≤ y ′ . Then,
• there exists another least supply time interval
(u′ , u′ +v) where u′ is at the end of a scheduling
window or u′ + v is at the start of a scheduling
window.
S(u+v +δ)−S(u+δ) = S(u+v)−S(u)+q ′ ·δ −q ·δ
(3) Proof. In order to prove this lemma, it is only
required to contradict the following assertion (we
′
Since q > q ,
have proven Lemma 1):
S(u + v + δ) − S(u + δ) < S(u + v) − S(u)
There exists a least supply time interval (u, u+v)
(4) where
which again contradicts the definition of least
supply time interval.
• u is only at IBCPs that are the starts of some
scheduling windows and u + v is not at any
IBCP, or
Consequently, when either q < q ′ or q > q ′ , there
is not any least supply time interval, the start and
end of which are not at any IBCP.
• u + v is only at IBCPs that are the ends of
some scheduling windows and u is not at any
IBCP.
However, when q = q ′ , if we change the small
offset δ to the smaller value of x and x′ , then
First of all, it is assumed that the latest IBCP
(on any processor) before u is at u − x and the
earliest IBCP (on any processor) after u is at u +
y (excluding the scheduling windows that start at
u). It is also assumed that latest IBCP (on any
processor) before u + v is at u + v − x′ (excluding
the scheduling windows that end at u + v) and the
earliest IBCP (on any processor) after u + v is at
u + v + y ′ . Since u and u + v are not supposed to
be at any IBCP other than the starts of scheduling
windows that start at u and the ends of scheduling
windows that end at u + v, x, y, x′ and y ′ must be
greater than zero.
S(u+v −δ)−S(u−δ) = S(u+v)−S(u)+q ·δ −q ′ ·δ
(5)
and thus (q = q ′ ),
S(u + v − δ) − S(u − δ) = S(u + v) − S(u)
(6)
which does not contradict the definition of least
supply time interval. However, since at least one of
u+v−δ and u−δ is at an IBCP, this contradicts the
previous assertion which states that there exists a
Then, let’s consider the first part of the above
least supply time interval (u, u + v) where neither
u nor u + v is at any IBCP and for this least supply assertion. Assume that there are q scheduling wintime interval, one cannot find any (u′ , u′ + v) where dows (excluding those that start at u) that are active in between u − x and u + y while q ′ schedulu′ or u′ + v is at some IBCP.
ing windows are active in between u + v − x′ and
Therefore, it has been proven that in all circumu + v + y′.
stances, the previous assertion is false, which proves
If q < q ′ , we again define a small offset δ such
Lemma 1.
that δ ≤ x and δ ≤ x′ . Then,
Next, we narrow down the IBCPs referred to in
Lemma 1.
S(u+v −δ)−S(u−δ) = S(u+v)−S(u)+q ·δ −q ′ ·δ
Lemma 2. For any least supply time interval
(7)
(u, u + v) of a time partition, either
′
Since q < q ,
• at least on one processor, u is at the end of a
scheduling window or u + v is at the start of a
scheduling window, or
S(u + v − δ) − S(u − δ) < S(u + v) − S(u) (8)
7
which again contradicts the definition of least
which contradicts the definition of least supply
supply time interval. This proves the second part
time interval.
if q ≥ q ′ , we define another offset δ such that of the above assertion false.
δ ≤ y and δ ≤ y ′ . Then,
Consequently, the above assertion is false, which
proves Lemma 2.
Based on Lemma 1 and 2, it is straightforward
S(u+v+δ)−S(u+δ) ≤ S(u+v)−S(u)+q ′ ·δ−(q+1)·δ
(9) to draw the conclusion that estimating LSF (t) for
any time interval t only requires checking the end of
Since q ≥ q ′ ,
each scheduling window as a potential start point
of a least supply time interval as well as the start
of each scheduling window as a potential end point
S(u + v + δ) − S(u + δ) < S(u + v) − S(u) (10) of a least supply time interval. Such an estimation
of LSF (t) shows no pessimism so the results are
which again contradicts the definition of least accurate.
supply time interval. This proves the first part of
the above assertion false.
Algorithm
Then, let’s consider the second part of the above
assertion. Assume that there are q scheduling windows that are active in between u − x and u + y
while q ′ scheduling windows are active in between
u + v − x′ and u + v + y ′ (including those that end
at u + v).
t
If q < q ′ , we again define a small offset δ such
that δ ≤ x and δ ≤ x′ . Then,
t+1
t t+0.5
S(u+v −δ)−S(u−δ) = S(u+v)−S(u)+q ·δ −q ′ ·δ
(11)
t+3
t+1.5
t+2.5
t + 4.5 t + 5
t + 4.5
t+6
t+6
hijklmnopq r oplsrt su v jk ispikwpkl voxk yzwvovosp
′
Since q < q ,
hijklmnopq r oplsrt su sv jkw voxk yzwvovospt
S(u + v − δ) − S(u − δ) < S(u + v) − S(u) (12)
Figure 5: An example of under estimation of the
which contradicts the definition of least supply least supply function
time interval.
if q ≥ q ′ , we define another offset δ such that
δ ≤ y and δ ≤ y ′ . Then,
One way to obtain the LSF (t) function is to
find each processor’s contribution to it, denoted as
LSFx (t), by examining the end of each scheduling window on the corresponding processor for
S(u+v+δ)−S(u+δ) ≤ S(u+v)−S(u)+(q ′ −1)·δ−q·δ (Sx (t + α) − Sx (α)) where α denotes the end. Let
(13) nx denote the number of scheduling windows on
processor x, we get:
Since q ≥ q ′ ,
LSFx (t) = min {Sx (αk + t) − Sx (αk )}
S(u + v + δ) − S(u + δ) < S(u + v) − S(u) (14)
k=1···nx
8
(15)
Pm
and
k=1 LSFk (t) gives a lower bound on taking advantage of the conclusion drawn at the
LSF (t) (this algorithm can be proven correct yet end of the theory part of this subsection. The
pessimistic).
pseudo code of this algorithm is given in Algorithm
Unfortunately, although simple, this approach 1. This algorithm is in fact exact and has no pesis too pessimistic because the combinations of simism in the values computed.
scheduling windows on different processors that result in the above LSF (t) may be impossible as
meaningful combinations of scheduling windows are
determined by the scheduling scheme. For example, when this approach is used to estimate LSF (2)
of the example given in figure 5, it finds LSF1 (2) =
LSF2 (2) = 0 and concludes that the minimum
computation time provided by this example within
2 time units is zero. However, LSF1 (2) = 0 and
LSF2 (2) = 0 are obtained at two scheduling windows’ ends (t+ 5 on processor P1; t+ 2.5 on processor P2) that can never be combined. Consequently,
LSF1 (2) = 0 and LSF2 (2) = 0 never occur at the
same time.
Figure 5 gives an example of multiprocessor resource partitioning systems. Based on this example, we demonstrate how to use Algorithm 1 to estimate LSF (2):
For scheduling window (t, t + 0.5), its f (2) and
f ′ (2) are 2 and 2.5 respectively. For scheduling
window (t+1, t+3), its f (2) and f ′ (2) are 1.5 and 1
respectively. For scheduling window (t+1.5, t+2.5),
its f (2) and f ′ (2) are 1.5 and 0.5 respectively. For
scheduling window (t+ 4.5, t+ 5), its f (2) and f ′ (2)
are 0.5 and 1.5 respectively. For scheduling window
(t + 4.5, t + 6), its f (2) and f ′ (2) are 0.5 and 2
respectively.
Hence, the estimation of LSF (2) given by this
algorithm is 0.5. By contrast, the estimation of
LSF (2) given by the previous algorithm that is
based on the calculation of LSFx (t) is 0. Consequently, this is also a pragmatic example that justifies Algorithm 1 being exact.
Initialize the least supply function LSF(t) =
MAX VALUE;
For each scheduling window of the time partition
under investigation
{
With this accurate algorithm, the time required
to estimate LSF (t), given a specific value of t, is
linear, in the worst case, to the total number of
scheduling windows of the time partition under investigation (within a single major time frame). If
multiple scheduling windows start or end at the
same time instant, the number of iterations can be
further reduced.
Find its start point and set β to that point;
Initialize a function f(t) = 0;
For each processor x
{
Use the chosen β to calculate Sx (β) − Sx (β − t);
f (t) = f (t) + Sx (β) − Sx (β − t);
}
Find its end point and set β to that point;
Initialize a function f’(t) = 0;
4.2
For each processor x
{
Following Baruah’s approach, we determine the
schedulability of each sub-server by finding certain critical durations of that sub-server as well as
the maximum possible total workloads of all subservers with equal or higher priorities in those durations. Then, if the workload in every critical duration (with a length of t ) is no more than the least
computation time that the system can provide during any interval of length t, the sub-server under
investigation will be guaranteed to be schedulable.
In this subsection, we present how the critical du-
Use the chosen β to calculate Sx (β + t) − Sx (β);
f ′ (t)
=
f ′ (t)
Workload of Sub-servers and
Schedulability Condition
+ Sx (β + t) − Sx (β);
}
LSF (t) = min{LSF (t), f (t), f ′ (t)};
}
Algorithm 1: Least supply function algorithm
A more accurate approach can be developed by
9
cause the problem job cannot run in parallel, the
Suppose that a release of sub-server SSk is the total workload of other jobs during [ta , td ) does not
first job of that sub-server to miss its deadline. This have to be higher than LSF (Tk ) − Ck to cause a
job is called a problem job and the time interval be- deadline miss. In fact, when we try to lower bound
tween the release time of the problem job and its the workload of other jobs, it has to be assumed
deadline [ta , td ) is called a problem window. Intu- that overlapped scheduling windows other than the
itively, ta = td −Tk where Tk represents the relative problem job’s are always idle when the problem job
is running.
deadline and period of SS .
rations and total workloads are determined.
k
After ignoring servers with lower priorities than
SSk , suppose that t0 is the latest time instant earlier than ta at which, if the number of remaining
sub-servers is less than currently available processors, at least one sub-server is not executing though
enough resources are available. If the number of remaining servers is more than available processors,
suppose that t0 is the latest time instant earlier
than ta at which at least one processor is idle even
though it is available for use according to the time
partition configuration. Then let Ak = ta − t0 (see
figure 6). Notice that Ak is not a fixed value for
SSk because there is not any assumption on the
arrivals of servers and their relation to scheduling
windows.
A{
T{
Idle point
t~
Deadline miss
t|
t}
As a result, it is necessary to know the maximum total computation time provided by the time
partition under investigation during any Ck out of
Tk , which is denoted as M P (Ck ). Notice that the
time intervals that compose Ck are not necessarily
contiguous, yet they have to be within time interval Tk . For ease of presentation, we first consider
M P (Ck ) as a parameter of each SSk that is already
known. A detailed study of M P (Ck ) will be given
in subsection 4.3.
Therefore, the total workload of other jobs during [ta , td ) must be higher than LSF (Tk )−M P (Ck )
to force the problem job to miss its deadline. Moreover, the definition of t0 suggests that t0 should
be the last time instant before ta when the concerned sub-servers waste any resource so the total workload of sub-server jobs except the problem
job during [t0 , td ) should be at least higher than
LSF (Ak + Tk ) − M P (Ck ).
For each i such that k ≤ i ≤ n (n is the highest sub-server priority and also the total number
of sub-servers of the time partition under discussion), let I(SSi ) denote the contribution of SSi to
the total workload of sub-servers in this time partition during [t0 , ta ) ∪ ωk where ωk denotes the intervals (not necessarily contiguous) during which all
processors allowed by time partitioning are executing jobs other than the problem job during [ta , td ).
Then, in order for the deadline miss of the problem
job to occur, the following inequality must always
hold.
Figure 6: Notation
X
I(SSi ) > LSF (Ak + Tk ) − M P (Ck ) (16)
i≥k
Since the deadline of the problem job is missed,
the problem job must execute less than Ck time
units during [ta , td ) and no scheduling window can PIn other words, if for all possible Ak ,
i≥k I(SSi ) ≤ LSF (Ak + Tk ) − M P (Ck ), subbe idle when the problem job is not running. It
server
SSk will be guaranteed to always meet its
seems that the total workload of other jobs during
deadline.
[ta , td ) must be higher than LSF (Tk ) − Ck to force
the problem job to miss its deadline. However, beNext, we will present how to derive I(SSi ) and
10
P
and Ci ≤ Ti is always true, ⌊ Ak +TTik −Ci ⌋ is no less
Ak +Tk −Ci
⌋ + 1)Ci is never
Suppose that a job of SSi arrives before t0 and than −1. Therefore, (⌊
Ti
has not completed execution by t0 . Then, SSi is negative. When Ak + Tk is less than Ci and i > k,
nc
said to have a carry-in job with respect to the sub- I (SSi ) is always 0. This indicates that when Ci
server SSk under investigation. If a sub-server has is too large, server SSi can no longer have any nonno carry-inPjob with respect to SSk , its contribution carry-in job.
nc
to SSk ’s
Moreover, if i = k, the last job of the sub-server
i I(SSi ) will be denoted as I (SSi ).
c
Otherwise, it will be denoted as I (SSi ).
arrives at ta and contributes nothing to I nc (SSi ) as
it is out of [t0 , ta ) ∪ ωk . Since SSi has no other jobs
between [ta , td ), the maximum contribution of SSi
nc
Computing I (SSi )
should not exceed the total length of [t0 , ta ) which
is Ak . Thus,
therefore
i
I(SSi ).
I nc (SSi ) = min(⌊
A ‚ + T‚
Ak
⌋Ci , Ak ) if
Ti
i=k
(18)
Computing I c (SSi )
T
t€
...........
T
C
t
The execution of subserver i within time interval [t€, t)
A† + T†
T…
Figure 7: Worst-case arrivals of sub-server SSi
within time interval [t0 , td ) with respect to SSk
T…
t„
...........
T…
C…
tƒ
The execution of subserver i within time interval [t„, tƒ)
If a sub-server SSi has no carry-in job, all its
The execution of subserver i outside time interval [t„, tƒ)
jobs that contribute to I nc (SSi ) arrive in the interval [t0 , td ). Let’s first consider the situation where
i > k (see figure 7). The maximum contribution
of SSi is made when the last job arrives exactly
Figure 8: The carry-in jobs
Ci time units before td and executes immediately.
Moreover, this contribution should not exceed the
total length of [t0 , ta ) ∪ ωk which is definitely not
Consider the situation when SSi is active (relonger than Ak + Tk − Ck . Thus,
leased and not completed) at t0 . Some work of the
carry-in job will be carried into [t0 , td ) and therefore
is part of I c (SSi ). All other jobs that contribute
Ak + Tk − Ci
to I c (SSi ) arrive in the interval [t0 , td ). Let’s first
I nc (SSi ) = min((⌊
⌋ + 1)Ci
Ti
consider the situation where i > k and Ak +Tk ≥ Ci
, Ak + Tk − Ck ) if i > k (17) (see figure 8). The maximum contribution of SSi
is made when the last job arrives exactly Ci time
It is worth noticing that Ak + Tk may be less units before td and executes immediately. On the
than some Ci in which case, ⌊ Ak +TTki −Ci ⌋ becomes other hand, the carry-in job is assumed to execute
negative. However, since Ak + Tk is always positive as late as possible, which gives the greatest impact
11
to I c (SSi ). Moreover, I c (SSi ) should not exceed than (γmax − 1) sub-servers are active at that time,
the total length of [t0 , ta ) ∪ ωk which is definitely it will be guaranteed that all available processor
time at t0 will be used.
not longer than Ak + Tk − Ck . Thus,
When there are fewer sub-servers than available
processors, there are at most (ϕ − 1) active subAk + Tk − Ci
⌋ + 1)Ci
I c (SSi ) = min((⌊
servers at t0 where ϕ is the total number of subTi
servers of the time partition under discussion that
+min(Ci , (Ak + Tk − Ci ) mod Ti )
have equal or higher priorities than k. This is be, Ak + Tk − Ck )
cause there is at least one sub-server that is idle
if i > k ∧ Ak + Tk ≥ Ci
(19) at t0 even though there is enough resource. If all
ϕ sub-servers are active at that time, all available
On the other hand, if Ak + Tk < Ci and i > resources will be used.
k, then sub-server SSi has only one carry-in job
Based on this observation, we define ξ as the
which executes, in the worst case, during the whole smaller one of γmax and ϕ. Then, we can get:
[t0 , ta ) ∪ ωk time interval. Therefore,
c
I (SSi ) = Ak + Tk − Ck
if
i > k ∧ Ak + Tk < Ci
(20)
X
i≥k
I(SSi ) =
X
I nc (SSi ) +
i≥k
X
IDIF F (SSi )
the(ξ−1)largest
(23)
When i = k, the last job of the sub-server arrives
at ta and contributes nothing to I c (SSi ) as it is out
Therefore, if the following inequality holds for all
of [t0 , ta )∪ωk . Since SSi has no other jobs between possible Ak , sub-server SSk will be guaranteed to
[ta , td ), the maximum contribution of SSi should always meet its deadline.
not exceed the total length of [t0 , ta ) which is Ak .
Thus,
X
X
IDIF F (SSi )
I nc (SSi ) +
i≥k
the(ξ−1)largest
Ak
I c (SSi ) = min(⌊ ⌋Ci + min(Ci , Ak mod Ti )
≤ LSF (Ak + Tk ) − M P (Ck ) (24)
Ti
, Ak ) if i = k
(21)
Notice, SSk is definitely unschedulable if
LSF (Ak + Tk ) < M P (Ck ) which makes the right
P
hand side of inequality (24) negative.
Computing
i
I(SSi )
First, we define IDIF F (SSi ) as the difference between I c (SSi ) and I nc (SSi ) with respect to the
same SSk and Ak . Thus,
IDIF F (SSi ) = I c (SSi ) − I nc (SSi )
Computing Ak
As defined in subsection 4.2, Ak is the length of
the interval [t0 , ta ) with respect to sub-server SSk .
(22) Therefore, Ak ≥ 0.
For any sub-server, we can also observe from
According to the definition of t0 , when there are
more sub-servers than available processors, there equation (17) that if i > k:
are at most (γmax −1) active sub-servers at t0 where
γmax is the maximum number of scheduling winAk + Tk − Ci
dows of this time partition that can run in parallel.
⌋ + 1)Ci
(25)
I nc (SSi ) ≤ (⌊
Ti
This is because there is at least one processor that
is idle at t0 even though it is available for use acand from equation (18) that if i = k
cording to the time partition configuration. If more
12
I nc (SSi ) ≤ ⌊
Ak + Tk − Ci
Ak
⌋Ci ≤ (⌊
⌋ + 1)Ci
Ti
Ti
(26)
Hence, the following inequality must hold in order for a deadline miss to occur.
Let’s define CΣ as the sum of the (ξ − 1) largest
Θ(i) of all concerned sub-servers where Θ(i) is defined as:
Θ(i) = min(Ci , Ak + Tk − Ck ) (i ≥ k)
(27)
Because IDIF F (SSi ) cannot be larger than Ci
and Ak + Tk − CP
k ≤ Θ(i), IDIF F (SSi ) ≤ Θ(i).
≤
Consequently,
the(ξ−1)largest IDIF F (SSi )
P
Θ(i)
=
C
.
Therefore,
Σ
the(ξ−1)largest
X
I(SSi ) =
i≥k
X
I
nc
X Ci
i≥k
X
(⌊
(Ti − Ci )
i≥k
LSF (Ak + Tk ) − Ak
X
Ci
+ CΣ
Ti
Ui < T k
i≥k
+
X
(32)
Ui
i≥k
X
(Ti − Ci )Ui + CΣ + M P (Ck )
Ak + Tk − Ci
⌋ + 1)Ci + CΣ
Ti
where Ui =
the(ξ−1)largest
≤
X
which can be transformed to:
IDIF F (SSi )
X
Ti
+
> LSF (Ak + Tk ) − M P (Ck )
i≥k
(SSi ) +
i≥k
(Ak + Tk )
Ci
Ti
(33)
is the utilization of sub-server i.
For any P
Ak ≥ 0 that violates inequality (33),
it makes
i I(SSi ) definitely no higher than
LSF (Ak + Tk ) − M P (Ck ). Therefore, it is only
Whenever the deadline of SSk is missed, it must
required to check those Ak ≥ 0 that satisfy inequalbe true that
ity (33). As discussed previously, if any Ak in this
range makes LSF (Ak + Tk ) < M P (Ck ), SSk is
X Ak + Tk − Ci
definitely unschedulable.
⌋ + 1)Ci + CΣ > LSF (Ak + Tk )
(⌊
Ti
Solving inequality 33 is not trivial as LSF (Ak +
i≥k
Tk ) is not a simple function of Ak and CΣ is also
−M P (Ck )
under the influence of Ak . First of all, it is re(29)
quired to derive a simple function LSFlb (t) such
P
Otherwise, i≥k I(SSi ) will be guaranteed to be that LSFlb (t) ≤ LSF (t). We observe that LSF (t)
can never grow faster than f (t) = γmax · t where
no more than LSF (Ak + Tk ) − M P (Ck ).
γmax is the maximum number of scheduling winMoreover,
dows of this time partition that can run in parallel.
Therefore, P − LSF (P )/γmax (P is the length of
the major time frame) gives the last time instant
X Ak + Tk − Ci
(⌊
⌋ + 1)Ci
before P when LSF (t) can possibly grow less faster
Ti
i≥k
than f (t) = γmax · t. Therefore, a lower bound of
X Ak + Tk − Ci
LSF (t) in [0, P ] can be given as:
+ 1)Ci
(30)
≤
(
Ti
i≥k
(28)
i≥k
LSF (P )
)
γmax
LSF (P )
LSFlb (t) = γmax · (t − P +
)
γmax
LSF (P )
(P −
)<t≤P
γmax
Thus,
LSFlb (t) = 0,
X Ak + Tk − Ci
X Ci
(⌊
⌋ + 1)Ci ≤ (Ak + Tk )
Ti
Ti
i≥k
i≥k
X
Ci
+
(Ti − Ci )
Ti
i≥k
0 ≤ t ≤ (P −
(34)
Because LSF (t) repeats itself every major time
(31) frame, LSF (t) can be further simplified to:
lb
13
Each such time interval can be denoted as (γx , lx )
where γx is the number of processors that overlap in
LSF (P ) LSF (P )
LSFlb (t) = (t − P +
)·
t ≥ 0 interval x (γx > 1) and lx is the length of interval
γmax
P
x. Sort all such intervals in descending order of
(35)
their γx (and lx if some pairs have identical γx ).
By transforming inequality 33, we can get:
Then, the top pair can be identified as (γ1 , l1 ) and
the lower a pair is, the greater its identifier is. For
example, γ3 ≥ γ4 and if γ3 = γ4 , it must be true
X
X
that l3 ≥ l4 .
Ak
Ui > LSF (Ak + Tk ) − Tk
Ui
i≥k
i≥k
X
−
(Ti − Ci )Ui − CΣ − M P (Ck )
(36)
i≥k
P
Here, it is assumed that Ak is sufficiently large so
that CΣ is only a function of sub-server execution
times. Hence,
Ak
X
Ui > LSFlb (Ak + Tk ) − Tk
i≥k
−
X
X
P
P
...........
Tˆ
t‡
t‰
A time interval in which certain scheduling
windows overlap every P time units
Ui
i≥k
(Ti − Ci )Ui − CΣ − M P (Ck )
(37)
Figure 9: Overlapped Scheduling Windows
i≥k
Consequently,
As illustrated in figure 9, ⌊ TPk ⌋ represents the
maximum number of an overlapping interval’s complete periods within Tk . min{Tk mod P, lx }
gives the length of the incomplete period of interval
(γx , lx ) at the end of Tk . Therefore, the maximum
total length of (γx , lx )’s instances within any Tk is
given by ⌊ TPk ⌋lx + min{Tk mod P, lx }.
X
LSF (P )2
+ ( (Ti − Ci )Ui
γmax
i≥k
X
+CΣ + M P (Ck )) · P )/(LSF (P ) − P ·
Ui ) − T k
Ak < (LSF (P ) · P −
i≥k
(38)
Then, M P (Ck ) can be calculated according to
Algorithm 2.
From here, this estimation of Ak bound is going
to be used to estimate CΣ . This helps to reduce
some pessimism.
0
4.3
2.5
5
7
10
A Detailed Study of MP (Ck )
0
2.5
4
6
10
As defined in the previous subsection, M P (Ck ) represents the maximum total computation time provided by the time partition under investigation dur0 1
10
ing any Ck out of Tk . This can be obtained by first
finding all the time intervals in which scheduling
windows on different processors overlap. As all such
time intervals repeat every P time units (which is Figure 10: An example to demonstrate how to obthe length of the major time frame), it is sufficient tain M P (Ck )
to identify only those within a major time frame.
14
Initialize
Initialize
Initialize
Initialize
time intervals within 20 time units which have a
total length of 10 time units.
mpc = 0;
cumulation = 0;
sum of cumulation = 0;
i = 1;
While sum of cumulation < Ck and there exists (γi , li )
{
cumulation = ⌊ TPk ⌋li + min{Tk
mod
P, li };
mpc = mpc + min{cumulation,
Algorithm 2 has a complexity of O(n) where n
represents the total number of separate time intervals in which certain scheduling windows overlap.
However, all such time intervals must be sorted before this algorithm can be used. Sorting such time
intervals has a complexity of O(n log n).
Ck − sum of cumulation} · γi ;
sum of cumulation = sum of cumulation
+ min{cumulation, Ck − sum of cumulation};
i = i + 1;
}
If sum of cumulation = Ck
M P (Ck ) = mpc;
else
/* when no overlapped intervals are left */
M P (Ck ) = mpc + Ck − sum of cumulation;
Algorithm 2: Computing M P (Ck )
4.4
Analysis Implementation
In subsection 4.2, it has been concluded that a subserver SSk is guaranteed to always meet its deadline if inequality (24) holds for all possible values
of Ak where the values of Ak satisfy inequality (38)
and Ak ≥ 0. Consequently, analyzing any subserver’s schedulability requires an investigation on
all Ak values within its range as indicated above.
It is not possible to implement such an analysis.
Based on
P equations (17) and (18), we observed
the term i I nc (SSi ) could only change when (x
In the example illustrated in figure 10, there are is any integer):
3 time intervals when scheduling windows on different processors overlap. After being ordered according to the above rule, these time intervals can
Ak = x · Ti + Ci − Tk , i > k
(39)
be identified as interval 1 (3, 1), interval 2 (2, 1.5)
and interval 3 (2, 1). By using Algorithm 2, we can
or when (x is any integer):
estimate M P (Ck ) corresponding to the sub-server
SSk which has a period (Tk ) of 20 and a budget(Ck )
of 10.
Ak = x · Ti , i = k
(40)
For interval 1, cumulation = 2, mpc = 0 +
2 · 3 = 6 and sum of cumulation = 2. Since
We call all such discrete values of an Ak within
sum of cumulation is less than 10 (Ck ) and there its whole range the effective values.
exists interval 2, the algorithm continues with inOn the other hand, it is computationally very
terval 2.
expensive to exhaust all the possible values of Ak
For interval 2, cumulation = 3, mpc = 6 + 3 · 2 = that may lead to the change of the second term in
P
12 and sum of cumulation = 2 + 3 = 5. Since inequality (33) the(ξ−1)largest IDIF F (SSi ). Howsum of cumulation is less than 10 (Ck ) and there ever, because IDIF F (SSi ) is always bounded by
exists interval 3, the algorithm continues with in- Θ(i) (see page 13), even the worst value of
P
terval 3.
the(ξ−1)largest IDIF F (SSi ) is no more than CΣ
For interval 3, cumulation = 2, mpc = 12 + (see page 13), which has a constant bound. More2 · 2 = 16 and sum of cumulation = 5 + 2 = 7. over, LSF (Ak + Tk ) − M P (Ck ) is a monotonically
Since sum of cumulation is less than 10 (Ck ) and non-descreasing function. Hence, it is safe but more
there does not exist any more such intervals, this pessimistic to draw a new conclusion that a subM P (Ck ) can be estimated as 16+10−7 = 19 which server SSk is guaranteed to always meet its deadmeans that this partitioning example can provide line if the following inequality holds for all effective
at most 19 time units computation time during any values of Ak :
15
(41)
Definition 7 The Least Supply Function lsf (t)
(slsf (t)) of a server (sub-server) is the minimum of all its s(t + d) − s(d) (ss(t + d) − ss(d))
where t is a time interval and t, d ≥ 0.
This revised analysis has been implemented at
the University of York. The experimental results
shown in later sections are based on this implementation.
Definition 8 A least supply time interval of a server
(sub-server) (u, u + v) is a time interval that
satisfies (s(u+v)−s(u)) = lsf (v) ((ss(u+v)−
ss(u)) = slsf (v)).
X
nc
I (SSi ) + CΣ ≤ LSF (Ak + Tk ) − M P (Ck )
i≥k
A possible [u, u + v) is given in figure 11. For
the purpose of this analysis, we assume that all releases of the sub-server under discussion after u are
executed as late as possible within their deadlines.
Therefore, if t > 2(Ts − Cs ), the number of comAs discussed in section 3, threads with real-time
plete instances of this sub-server within [u, u + v)
requirements in our system are all released either
should be ⌊ t−2(TTss−Cs ) ⌋. Their contributions to the
sporadically or periodically. Each of them must
t−2(Ts −Cs )
⌋Cs . On the
be bound to a server and can only be bound to least supply function are ⌊
Ts
one server at all times. A thread can run on any other hand, the contribution of the last release is
sub-server of its server which, in turn, can run min{Cs , (t−2(Ts −Cs )) mod Ts }. Moreover, the
on any processor allowed by the time partition to first release contributes nothing to the least supply
which this thread and its server belong. In this function as u is the completion time of that release.
section, we present an approach to analyzing the Therefore,
schedulability of threads provided that all relevant
sub-servers meet their deadlines. This is achieved
t − 2(Ts − Cs )
by first obtaining the least supply function of the
⌋Cs + min{Cs ,
slsf (t) = ⌊
Ts
server under investigation. Once this function has
been obtained, an analysis of the workload of all
(t − 2(Ts − Cs )) mod Ts }
the threads of that server can be performed in a
if t > 2(Ts − Cs ) (42)
similar way as the one proposed in the previous section. Then, a similar schedulability condition can
be achieved. Due to the similarity between thread
slsf (t) = 0 if t ≤ 2(Ts − Cs )
(43)
and server schedulability analysis, some results in
this section are presented without further explanaThen, for each server, we can add up all its subtion.
server’s least supply functions to form its own.
5
5.1
Thread
Analysis
Least Supply
Server
Schedulability
Function
of
With this algorithm, time required to estimate
a lsf (t), given a specific value of t, is linear in the
total number of sub-servers of the server under investigation.
This subsection proposes a way to find the minimum computation time a server can provide during a given time interval. First of all, terminology
introduced in the previous section is extended to
servers.
Definition 6 The supply function s(t) (ss(t)) of a
server (sub-server) is the total amount of time
provided by that server (sub-server) from time
0 to t.
5.2
Workload of Threads
Schedulability Condition
and
This subsection generally follows the method introduced in subsection 4.2 to analyze the schedulability of any thread τk . Suppose that a release of this
thread is the first job of that thread to miss its
deadline. This job is called a problem job and the
16
TŠ
T Š - CŠ
u
T Š - CŠ
...........
t
Cs
u+v
The execution of subserver s
Figure 11: A possible least supply interval of a subserver
contribution of τi to the total workload of threads
in this server during [t0 , ta ) ∪ ωk where ωk denotes
the intervals (not necessarily contiguous) during
which all processors allowed by time partitioning
and server scheduling are executing jobs other than
the problem
P job during [ta , td ). Then, if for all possible Ak , i I(τi ) ≤ lsf (Ak +Dk )−mp(Ck ), thread
τk will be guaranteed to always meet its deadline.
Next, we
P will present how to derive I(τi ) and
therefore i I(τi ).
Suppose that a job of τi arrives before t0 and has
not completed execution by t0 . Then, τi is said to
have a carry-in job with respect to the thread τk
under investigation. If a thread has no carry-in
P job
with respect to τk , its contribution to τk ’s i I(τi )
will be denoted as I nc (τi ). Otherwise, it will be
denoted as I c (τi ).
Computing I nc (τ )
i
time interval between the release time of the problem job and its deadline [ta , td ) is called a problem The following equations which are similar to equawindow. Intuitively, ta = td − Dk where Dk repre- tion (17) and (18), give I nc (τ ):
i
sents the relative deadline of τk .
After ignoring threads with lower priorities than
Ak + Dk − Ci
τk , suppose that t0 is the latest time instant ear⌋ + 1)Ci
I nc (τi ) = min((⌊
Ti
lier than ta at which, if the number of remaining
threads is less than currently available processors
, Ak + Dk − Ck ) if i > k
(constrained by server availability), at least one
thread is not executing though enough resources
are available. If the number of remaining threads
Ak
is more than available processors, suppose that t0
I nc (τi ) = min(⌊ ⌋Ci , Ak ) if i = k
Ti
is the latest time instant earlier than ta at which at
least one processor is idle even though it is available for use according to the time partition configu- Computing I c (τ )
i
ration and the corresponding server’s budget availability. Then let Ak = ta − t0 .
The following equations give I c (τi ):
Moreover, it is necessary to know the maximum
total computation time provided by the server unAk + Dk − Ci
der investigation during any Ck out of Dk , which is
I c (τi ) = min{(⌊
⌋ + 1)Ci
Ti
denoted as mp(Ck )(Ck and Dk are the worst-case
+min(Ci , (Ak + Dk − Ci ) mod Ti )
execution time and deadline of thread τk respectively). For ease of presentation, we first consider
, Ak + Dk − Ck }
mp(Ck ) as a parameter of each τk that is already
if i > k ∧ Ak + Dk ≥ Ci
known. A detailed study of mp(Ck ) will be given
in subsection 5.3.
For each i such that k ≤ i ≤ n (n is the highest
thread priority and the total number of threads of I c (τi ) = Ak + Dk − Ck
the server under discussion), let I(τi ) denote the
17
if
(44)
(45)
(46)
i > k ∧ Ak + Dk < Ci
(47)
X
Ak
I (τi ) = min{⌊ ⌋Ci + min{Ci , Ak mod Ti }
Ti
, Ak } if i = k
(48)
c
Computing
P
i
I nc (τi ) +
i≥k
X
IDIF F (τi )
the(ξ−1)largest
≤ lsf (Ak + Dk ) − mp(Ck )
(51)
Notice, τk is definitely unschedulable if lsf (Ak +
Dk ) < mp(Ck ) which makes the right hand side of
inequality (51) negative.
I(τi )
First, we define IDIF F (τi ) as the difference between Computing A
k
I c (τi ) and I nc (τi ) with respect to the same τk and
Ak . Thus,
As defined in subsection 5.2, Ak is the length of the
interval [t0 , ta ) with respect to thread τk . Therefore,
Ak ≥ 0.
IDIF F (τi ) = I c (τi ) − I nc (τi )
(49)
Let’s define Cσ as the sum of the (ξ − 1) largest
θ(i) (i ≥ k) of all threads of the current server
According to the definition of t0 , when there are
where θ(i) is defined as:
more threads than the maximum number of threads
of this server that could execute in parallel, there
θ(i) = min(Ci , Ak + Dk − Ck ) i ≥ k
(52)
are at most (Ψmax − 1) active threads at t0 where
P
Ψmax is the maximum number of threads of this
Because
the(ξ−1)largest IDIF F (τi ) ≤ Cσ , we
server that could execute in parallel. This is be- get:
cause there is at least one processor that is idle at
t0 even though it is available for use according to
X
X
the time partition configuration and server schedullsf (Ak + Dk ) − Ak
Ui < Dk
Ui
ing. If more than (Ψmax − 1) threads are active at
i≥k
i≥k
X
that time, it will be guaranteed that all available
+
(Ti − Ci )Ui + Cσ + mp(Ck )
(53)
processor time at t0 will be used.
When there are fewer threads than available processors, there are at most (ς − 1) active threads at
t0 where ς is the total number of threads of the
server under discussion that have equal or higher
priorities than k. This is because there is at least
one thread that is idle at t0 even though there is
enough resource. If all ς threads are active at that
time, all available resources will be used.
Based on this observation, we define ξ as the
smaller one of Ψmax and ς. Then, we can get:
i≥k
where Ui =
X
X
is the utilization of thread τi .
For any
P Ak ≥ 0 that violates inequality (53), it
makes i I(τi ) definitely no higher than lsf (Ak +
Dk ) − mp(Ck ). Therefore, it is only required to
check those Ak ≥ 0 that satisfy inequality (53).
Solving inequality 53 can be done according to the
same approach as presented on page 14.
5.3
X
Ci
Ti
A Detailed Study of mp(Ck )
In the previous subsection, we defined mp(Ck ) as
the maximum total computation time provided by
i≥k
i≥k
the(ξ−1)largest
the server under investigation during any Ck out of
(50)
Dk where Ck and Dk denotes the worst-case execution time and deadline of thread τk respectively.
Therefore, if the following inequality holds for all Since a server, in this report, is merely a conceptual
possible Ak , thread τk will be guaranteed to always container of sub-servers which are the real schedulmeet its deadline.
ing entities, mp(Ck ) can also be interpreted as the
I(τi ) =
I nc (τi ) +
IDIF F (τi )
18
Sub-server
(1, 5)
(2, 6)
(1, 6)
(3, 10)
maximum total computation time provided by all
the sub-servers of the concerned server during any
Ck out of Dk .
It has been observed that each sub-server’s contribution to the total computation time within any
k
Dk is upper bounded by ⌊ D
Ts ⌋ · Cs + min{Cs , Dk −
k
⌊D
Ts ⌋ · Ts } where Ts and Cs denotes the period
and budget of sub-server SSs respectively. Let
Dk
k
CNs = ⌊ D
Ts ⌋ · Cs + min{Cs , Dk − ⌊ Ts ⌋ · Ts }. Then,
we can sort all relevant sub-servers in ascending order of their CNs . The top sub-server can be identified as sub-server 1 which has the least CNs . The
lower a sub-server is, the greater its identifier is.
For example, CN3 ≤ CN4 should always hold.
Another observation is that if a certain number
(x) of such sub-servers can run in parallel, then the
maximum length of their parallel execution time
composed of exactly x sub-servers is upper bounded
by the least CNs among them. For example, three
sub-servers 1, 2 and 3 can run in parallel for at most
CN1 given that they have been sorted according to
the above requirement.
It should also be noted that the maximum number of scheduling windows of the server’s time partition that can run in parallel (denoted as γmax )
may be less than the total number of sub-servers of
the concerned server (denoted as h) and therefore
may put further restrictions on the parallelism of
sub-server execution (The smaller one of γmax and
h is Ψmax ). Hence, the analysis of mp(Ck ) is made
in two different scenarios.
CNs
3
5
3
6
Identifier
1
3
2
4
Table 1: CNs and identifier of each sub-server
mp(Ck ) = min{
X
min{CNs , Ck }, MˆP (Ck )}
s
(54)
In this case, sorting all the CNs is not necessary
as ordering information of CNs s is not used. Thus,
estimating the mp(Ck ) of a specific thread τk in this
case has a complexity of O(n) where n represents
the total number of sub-servers of the server under
investigation.
When γmax < h
This is a more complicated situation where at most
γmax sub-servers under discussion can execute in
parallel at any time whilst other sub-servers have
to wait. In order to get mp(Ck ), Algorithm 3 has
been developed to search for the combination of
sub-server executions that has the maximum parallelism during Ck .
Moreover, mp(Ck ) is still upper bounded by
MˆP (Ck ) because a server cannot provide more
computation time than its time partition. Hence,
mp(Ck ) can be represented as:
mp(Ck ) = min{total, MˆP (Ck )}
When γmax ≥ h
In this case, the maximum number of sub-servers
that can run in parallel is only limited by the
sub-servers themselves. However, mp(Ck ) is upper bounded by MˆP (Ck ) which denotes the maximum total computation time provided by the time
partition under investigation during any Ck out of
Dk where Ck and Dk are the worst-case execution
time and deadline of thread τk respectively. Notice
MˆP (Ck ) can be obtained according to the algorithm presented in subsection 4.3 as well. Therefore,
(55)
where total is the result of Algorithm 3.
Let’s consider a time partition in which γmax = 3
and an abstract server in that time partition which
has 4 sub-servers. These sub-servers, represented
as such pairs of parameters (Cs , Ts ), are (1, 5), (2,
6), (1, 6) and (3, 10). By using Algorithm 3, we
can estimate mp(Ck ) corresponding to the thread
τk which has a relative deadline (Dk ) of 13 and a
worst-case execution time (Ck ) of 5.
First of all, we need to obtain the initial CNs of
each sub-server, which is the maximum computa-
19
(1, 5) which has a CNs of 3, sub-server (2, 6) which
has a CNs of 2 and sub-server (3, 10) which has a
CNs of 3. All the remaining sub-servers must be
reordered according to their CNs . This reordering
also gives each sub-server a new identifier.
tion time a sub-server can provide during any Dk
time interval. The results are given in table 1.
Initialize length = 0;
Initialize total = 0;
While there are any remaining sub-servers of the server
under discussion
{
Sort all relevant sub-servers in ascending order
of their CNs ;
The least CNs among those of the remaining 3
sub-servers is CN1 = 2. Since the sum of length
and the current least CNs is the same as Ck = 5,
total = 9 + 2 · 3 = 15 gives the result.
if the length of the sorted list of sub-servers is less
than γmax
Choose all remaining sub-servers from the
sorted list;
else
Choose the last γmax sub-servers from the
sorted list;
Algorithm 3 has a complexity of O(n2 log n)
where n represents the total number of sub-servers
of the server under investigation.
Let CN denote the least CNs of the chosen
sub-servers;
Let num denote the number of chosen sub-servers;
if length + CN ≥ Ck
{
total = total + (Ck − length)num;
Break the loop;
}
Due to the same reason as presented in subsection
4.4, it is safe but more pessimistic to draw a conclusion that a thread τk is guaranteed to always meet
its deadline if the following inequality holds for all
effective values of Ak :
5.4
Analysis Implementation
X
total = total + CN · num;
I nc (τi ) + Cσ ≤ lsf (Ak + Tk ) − mp(Ck ) (56)
i≥k
length = length + CN ;
for each chosen sub-server s
where the effective values of Ak are those that
satisfy:
CNs = CNs − CN ;
Remove any sub-server with a zero CNs ;
}
Ak ≥ 0
Output total as the result of this algorithm;
(57)
and,
Algorithm 3: Searching for the combination of
lsf (Ak + Dk ) − Ak
sub-server executions that has the maximum parallelism during Ck
+
Ui < Dk
i≥k
X
Ui
i≥k
(Ti − Ci )Ui + Cσ + mp(Ck )
(58)
i≥k
Then, all the sub-servers are ordered in ascending
order of their CNs . An identifier can be given to
each of those sub-servers subsequently. The results
are also given in table 1.
Since γmax is less than the number of sub-servers
in this case, the last 3 sub-servers in the sorted
list are chosen. The least CNs among those of the
chosen sub-servers is CN2 = 3. Therefore, total =
0 + 3 · 3 = 9 and length = 0 + 3 = 3.
X
X
and (x is any integer)
6
Ak = x · Ti + Ci − Dk ,
i>k
Ak = x · Ti ,
i=k
(59)
Empirical Evaluation
After updating the CNs of the chosen subservers, the CNs of sub-server (1, 6) becomes zero In order to better understand the proposed scheduand therefore it is ignored. This leaves sub-server lability analysis, a series of experiments were con20
ducted. This section depicts our methodology and
some initial results obtained from these experiments. Although the proposed analysis concerns
both sub-servers and threads, the experiments presented in this section were conducted on sub-servers
only. More experiments are planned as part of our
future work.
specified.
Also, we used three typical configurations for the
time partitions we used to accommodate sub-server
sets. With the first configuration, the scheduling windows of our time partition are never active on different processors simultaneously. With
the second configuration, the scheduling windows
of our time partition are never active alone. The
third configuration gives a more general time par6.1 Methodology
tition scheme where no restrictions are put on the
In order to observe the behaviour of the proposed scheduling windows.
analysis in different circumstances, our experiments
were conducted on randomly generated sub-server
sets with very different features specified. Such 6.2 Impacts of Different Features
features include priority assignment policy, total
utilization, maximum period/minimum period and Priority Assignment Policy
the number of sub-servers in each set.
The goal of this experiment is not to find the opAs can be seen shortly, priority assignment pol- timal priority assignment policy for the proposed
icy has a great impact on the schedulability of sub- scheduling algorithm. Instead, we are interested in
server sets in virtually all cases. The policies we comparing some simple priority assignment policies
tested include rate monotonic (also deadline mono- to find out which one of them is generally better.
tonic, since deadline equals period), (T − C) mono- This experiment includes all three time partition
tonic (the higher the (Ti − Ci ), the lower the prior- configurations with total utilization of 0.8 (conity) and utilization monotonic (the higher the uti- figuration 1), 4.5 (configuration 2) and 4.5 (conlization, the lower the priority). However, due to figuration 3) respectively. All of them have the
the poor performance of utilization monotonic pol- same major time frame length, which is 500 time
icy, only the first two policies are compared in this units. For each time partition configuration, the
report.
minimum/maximum sub-server period is specified
Moreover, the total utilization of our sub-server to 200/25000 (some periods are shorter than the
sets ranges between 0 and the utilization of their major time frame) or 1000/25000 (all periods are
time partitions. Other features vary from test to longer than the major time frame).
test as well.
Figures 12 to 17 in Appendix depict the numFor each experiment, we randomly generate
20000 sub-server sets for each configuration (including all the above features) and record the number of
these sub-server sets that pass the proposed analysis. Notice that we have no way of knowing how
many sub-server sets are indeed schedulable. The
figures from our experiments only show the number
of schedulable sub-server sets that can be identified
by our analysis.
ber of schedulable sub-server sets identified by our
analysis in all the above circumstances. Data for
each curve are obtained from the sub-server sets
that have the same number of sub-servers and are
scheduled according to the same priority assignment policy. The only difference is their total utilization. All the curves are represented by “policy, number” where “policy” is the priority assignment policy and “number” is the number of subThe method we used to generate random sub- servers in each sub-server set. For example, “RM,
servers is standard. Periods were generated with 30” means all the concerned sub-server sets have
a uniform distribution between the specified max- 30 sub-servers and their priority assignment policy
imum/minimum values. Utilization of each sub- is rate monotonic.
server was also generated with a uniform distribuIn order to make the presentation clearer, we also
tion in the range of (0, 1]. However, the total uti- highlighted the range of data that changes most in
lization of a sub-server set must be the same as figures 18 to 23 in Appendix. As can be seen in
21
figures 12, 13, 18 and 19, the best results in both
cases are obtained when rate monotonic assignment
is applied. However, in all other figures, it is the
(T − C) monotonic (the higher the (Ti − Ci ), the
lower the priority) assignment policy that gives the
best results. We believe this is because M P (Ck )s of
sub-servers in time partition configuration 2 and 3
are much larger and therefore have a bigger impact
on inequality 24 on page 12.
parallel configurations, we can not expect that a
sub-server set with more sub-servers are more likely
to be schedulable than another sub-server set with
fewer sub-servers but the same total utilization.
On the other hand, we can assume that the success rate of sub-server sets generally increases along
with their sub-server number when they are under
parallel configurations and have the same utilization.
On the other hand, one may have noticed that
the number of sub-servers in each sub-server set
can also influence the schedulability of sub-server 7
Related Work
sets. Next, we study the impacts of the number of
sub-servers on the schedulability of sub-server sets. Muticore/multiprocessor real-time scheduling has
drawn great attention during the last decade.
Many algorithms and schedulability analyses have
Sub-server Number
been proposed. A survey by Capenter et al. summarized many of those algorithms and schedulaThe time partitions used in this experiment are bility analyses techniques [10]. A very clear catthe same as those used in the previous experi- egorization of those algorithms was also presented
ment. Sub-server sets with different number of along with detailed comparisons between each class
sub-servers, two different period ranges (“200 / of algorithms. A main conclusion of that survey is
25000” and “1000/ 25000”) and different total uti- that some of the algorithms are incomparable in
lization are tested for each time partition config- terms of schedulability. For example, there exist
uration. The priorities of sub-servers under time task sets that can be scheduled under the global
partition configuration 1 are assigned according to fixed priority pre-emptive scheduling algorithm, yet
rate monotonic policy. In all other cases, the priori- cannot be scheduled under the partitioned fixed
ties of sub-servers are assigned according to (T −C) priority pre-emptive scheduling algorithm and vice
monotonic policy.
versa.
As in figure 24 and 25 in Appendix, the success
Baruah also noticed that certain types of global
rate of sub-server sets with the same total utiliza- and fully partitioned algorithms are incomparable
tion does not always increase or decrease while the [3, 5]. He has also proposed a schedulability analynumber of sub-servers increases. In this specific ex- sis for multiprocessor systems scheduled under the
periment, the sub-server set success rate always de- global EDF algorithm. In his approach, it is ascreases until the number of sub-servers reaches 25. sumed that a release of the thread under investiAfter that, the success rate first increases and then gation misses its deadline and that there is a time
decreases and then repeat the same pattern. On instant before that release when at least one prothe other hand, under time partition configuration cessor is idle. The workload of all the threads that
2 and 3, the success rate of sub-server sets with the could be scheduled to execute between that prosame total utilization usually improves (with only cessor idle point and the missed deadline should
a few exceptions) when the number of sub-servers be at least higher than the minimum computation
is increased.
time provided during the same time interval in orAs presented in this section, our analysis shows
very different features when it is used with nonparallel and parallel time partitions. Rate monotonic policy outperforms (T − C) monotonic policy
in non-parallel configurations. However, (T − C)
monotonic policy outperforms rate monotonic policy in parallel configurations. Moreover, in the non-
der for the thread under investigation to possibly
miss its deadline. If such conditions can never be
satisfied, the schedulability of the thread under investigation will be ensured. The fundamental technique used was first introduced by Baker in 2003
[4], who covered both global EDF and fixed priority scheduling. An alternative sufficient test based
22
on the same technique was proposed by Bertogna which utilizes resource partitions and execution
et al. [7].
time servers to support service contracts at two
Shin et al. extended a global EDF algorithm and different levels. In order to support parallel exits schedulability analysis to support multiproces- ecution of an individual server without introducsor periodic resources which are essentially execu- ing too much implementation complexity, we protion time servers [19]. In order to provide com- posed the use of sub-servers, the budget of each
positional real-time guarantees, they proposed the of which is maintained separately and can be conleast supply function of their resource model which sumed in parallel. More importantly, we developed
gives lower bounds to the amount of resource sup- a schedulability analysis for such a system, which
ply that the model provides in a given time interval forms the basis of service contract negotiation of
[19]. Based on such input, threads within different this model and the foundation of the tools that famultiprocessor periodic resources can be analyzed cilitate software development in such environments.
independently according to Baruah’s analysis [5]. A very important step of this analysis is identifyMoreover, each multiprocessor periodic resource is ing the least supply function of a time partition on
transformed to several conceptual periodic threads multicores or multiprocessors. It has been proven
so that Baruah’s analysis can also be used upon that our approach to identifying such least supthem to make sure that all periodic resources them- ply functions is correct and optimal. We also extended Baruah’s analysis [5] to global fixed priority
selves are schedulable.
scheduling and consider the constraints caused by
The research done by Shin et al. differs from resource partitioning and server execution (when
that presented in this report. First of all, the mul- studying server schedulability and thread schedutiprocessor periodic resource model does not take lability respectively).
resource partitioning into consideration. Secondly,
Currently, we assume that all the threads, apevery server (multiprocessor periodic resource) is
plication
components and applications execute inassumed, in [19], to have only one budget which
dependently.
This simplified the proposed analysis
can be consumed on different processors simulthough
it
is
likely
to be unacceptable in real and
taneously. This makes budget monitoring much
complete
implementations.
Therefore, future remore complex in real implementations. Moreover,
search
will
include
the
investigation
of the impacts
the scheduling algorithm adopted in this report is
of
communication
and
synchronization
on the proglobal fixed priority scheduling rather than global
posed
analysis.
Furthermore,
this
report
does not
EDF.
specify the exact content of service contracts and
Brandenburg and Anderson also proposed to how negotiation generates time partition schedulschedule servers (along with their threads) on mul- ing schemes and sub-server parameters. Our future
tiprocessors with a variant of a global EDF schedul- work will utilize results from this report to address
ing algorithm [8]. In such a system, some servers the above issue. Moreover, case studies and simucalled hard real-time servers are fixed on certain lations will also be planned.
processors and can never migrate. On the other
hand, there exists best effort servers which can migrate across certain processors. However, a server
is not allowed to run in parallel in this algorithm.
Acknowledgements
Moreover, this work does not provide hard realtime guarantees to threads running within best efThe authors of this report would like to thank the
fort servers.
JEOPARD and eMuCo project partners for their
contributions to this report. In particular, we are
grateful to Jose Almeida for helping us understand
8 Conclusions
the current PikeOS operating system and its multiprocessor version which is in development. We
In this report, we have proposed a component- would also like to thank Professor Alan Burns for
based multicore/multiprocessor real-time system his comments and suggestions.
23
References
[1] B. Andersson, S. Baruah, and J. Jonsson. Staticpriority scheduling on multiprocessors. In Proceedings of the 22nd IEEE Real-time Systems Synmposium, pages 193–202, 2001.
[2] ARINC. Avionics application software standard
interface (ARINC specification). Technical Report
653, Aeronautical Radio, Inc., 1997.
[3] T. Baker and S. Baruah. Schedulability analysis
of multiprocessor sporadic task systems. Technical
Report TR-060601, The Florida State University,
2007.
[4] T. P. Baker. Multiprocessor EDF and deadline
monotonic schedulability analysis. In Proceedings
of the 24th IEEE Real-time Systems Symposium,
pages 120–129, 2003.
[5] S. Baruah. Techniques for multiprocessor global
schedulability analysis. In Proceedings of the 28th
IEEE Real-Time Systems Symposium, pages 119–
128, 2007.
[6] S. K. Baruah, N. K. Cohen, C. G. Plaxton, and
D. A. Varvel. Proportionate progress: A notion
of fairness in resource allocation. Algorithmica,
15:600–625, 1996.
[7] M. Bertogna, M. Cirinei, and G. Lipari. New
schedulability tests for real-time task sets scheduled by deadline monotonic on multiprocessors. In
Proc. 9th International Conference on Principles
of Distributed Systems, 2005.
[8] B. B. Brandenburg and J. H. Anderson. Integrating hard/soft real-time tasks and best-effort
jobs on multiprocessors. In Proceedings of the 19th
Euromicro conference on real-time systems, pages
61–70, 2007.
[9] A. Burchard, J. Liebeherr, Y. Oh, and S. Son. Assigning real-time tasks to homogeneous multiprocessor systems. IEEE Transactions on Computers,
44(12):1429–1442, 1995.
[10] J. Carpenter, S. Funk, P. Holman, A. Srinivasan, J. Anderson, and S. Baruah.
A
categorization
of
real-time
multiprocessor
scheduling problems and algorithms. In Handbook on Scheduling Algorithms, Methods, and
Models. Chapman Hall/CRC, Boca, 2004.
http://www.cs.unc.edu/∼anderson/papers
/multibook.pdf.
[11] S. Davari and S. Dhall. An on-line algorithm for
real-time tasks allocation. In Proceedings of the
7th IEEE Real-time Systems Symposium, pages
194–200, 1986.
[12] R. I. Davis and A. Burns. Hierarchical fixed priority preemptive scheduling. In Proceedings of the
26th IEEE Real-time Systems Symposium, pages
389–398, 2005.
[13] Z. Deng and J. Liu. Scheduling real-time applications in open environment. In Proceedings of the
18th IEEE Real-time Systems Symposium, pages
308–319, 1997.
[14] M. G. Harbour.
Architecture and contract model for processors and networks.
Technical
Report
DAC1,
Universidad
de
Cantabria
(Frescor
Project),
2006.
http://www.frescor.org/index.php?page=
publications.
[15] R. Kaiser.
Combining partitioning and
virtualization
for
safety-critical
systems.
Technical Report White Paper,
SYSGO
AG, 2007.
http://www.sysgo.com/newsevents/whitepapers/.
[16] S. Lauzac, R. Melhem, and D. Mosse. Comparison of global and partitioning schemes for scheduling rate monotonic tasks on a multiprocessor. In
Proc. of the EuroMicro Workshop on Real-Time
Systems, pages 188–195, 1998.
[17] J. P. Lehoczky, L. Sha, and J. K. Strosnider. Enhanced aperiodic responsiveness in a hard realtime environment. In Proceedings of the IEEE
Real-Time Systems Symposium, pages 261–270,
1987.
[18] A. K. Mok, X. Feng, and D. Chen. Resource partition for real-time systems. In Proceedings of the
7th IEEE Real-Time Technology and Applications
Symposium, pages 75–84, 2001.
[19] I. Shin, A. Easwaran, and I. Lee. Hierarchical
scheduling framework for virtual clustering of multiprocessors. In Proceedings of the 20th Euromicro
conference on real-time systems, pages 181–190,
2008.
[20] A. Srinivasan and S. Baruah. Deadline-based
scheduling of periodic task systems on multiprocessors. Information Processing Letters, 84(2):93–
98, 2002.
[21] J. Strosnider, J. Lehoczky, and L. Sha. The deferrable server algorithm for enhanced aperiodic
responsiveness in hard real-time environments.
IEEE Transactions on Computers, 44(1):73–91,
1995.
Appendix
24
100
90
90
80
80
70
70
Success rate(%)
Success rate(%)
100
60
50
40
30
T-C, 10
RM, 10
T-C, 20
RM, 20
20
10
0
0
0.1
T-C, 20
RM, 20
T-C, 30
RM, 30
60
50
40
30
20
10
0
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0
0.5
1
Sub-server set utilization
1.5
2
2.5
3
3.5
4
4.5
Sub-server set utilization
100
100
90
90
80
80
70
70
Success rate(%)
Success rate(%)
Figure 12: Schedulability of sub-server sets with Figure 15: Schedulability of sub-server sets with
time partition configuration 1 and “200 / 25000” time partition configuration 2 and “1000 / 25000”
period range
period range
60
50
40
30
T-C, 10
RM, 10
T-C, 20
RM, 20
20
10
0
0
0.1
T-C, 20
RM, 20
T-C, 30
RM, 30
60
50
40
30
20
10
0
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0
0.5
1
Sub-server set utilization
1.5
2
2.5
3
3.5
4
4.5
Sub-server set utilization
Figure 13: Schedulability of sub-server sets with Figure 16: Schedulability of sub-server sets with
time partition configuration 1 and “1000 / 25000” time partition configuration 3 and “200 / 25000”
period range
period range
100
80
T-C, 20
RM, 20
T-C, 30
RM, 30
90
80
70
Success rate(%)
Success rate(%)
100
T-C, 20
RM, 20
T-C, 30
RM, 30
90
60
50
40
30
70
60
50
40
30
20
20
10
10
0
0
0
0.5
1
1.5
2
2.5
3
3.5
4
4.5
0
Sub-server set utilization
0.5
1
1.5
2
2.5
3
Sub-server set utilization
3.5
4
4.5
Figure 14: Schedulability of sub-server sets with Figure 17: Schedulability of sub-server sets with
time partition configuration 2 and “200 / 25000” time partition configuration 3 and “1000 / 25000”
period range
period range
25
100
80
80
70
60
50
40
30
70
60
50
40
30
20
20
10
10
0
0.55
0.6
0.65
0.7
T-C, 20
RM, 20
T-C, 30
RM, 30
90
Success rate(%)
Success rate(%)
100
T-C, 10
RM, 10
T-C, 20
RM, 20
90
0.75
0
1.25
0.8
1.5
1.75
Sub-server set utilization
2
2.25
2.5
2.75
Sub-server set utilization
Figure 18: Schedulability of sub-server sets with Figure 21: Schedulability of sub-server sets with
time partition configuration 1 and “200 / 25000” time partition configuration 2 and “1000 / 25000”
period range
period range
100
80
T-C, 20
RM, 20
T-C, 30
RM, 30
90
80
70
Success rate(%)
Success rate(%)
100
T-C, 10
RM, 10
T-C, 20
RM, 20
90
60
50
40
30
70
60
50
40
30
20
20
10
10
0
0
0.5
0.55
0.6
0.65
0.7
0.75
0.8
1.5
1.75
2
Sub-server set utilization
2.25
2.5
2.75
3
3.25
3.5
Sub-server set utilization
Figure 19: Schedulability of sub-server sets with Figure 22: Schedulability of sub-server sets with
time partition configuration 1 and “1000 / 25000” time partition configuration 3 and “200 / 25000”
period range
period range
100
80
T-C, 20
RM, 20
T-C, 30
RM, 30
90
80
70
Success rate(%)
Success rate(%)
100
T-C, 20
RM, 20
T-C, 30
RM, 30
90
60
50
40
30
70
60
50
40
30
20
20
10
10
0
0
1
1.25
1.5
1.75
2
2.25
2.5
2.75
3
1.5
Sub-server set utilization
1.75
2
2.25 2.5 2.75
3
Sub-server set utilization
3.25
3.5
Figure 20: Schedulability of sub-server sets with Figure 23: Schedulability of sub-server sets with
time partition configuration 2 and “200 / 25000” time partition configuration 3 and “1000 / 25000”
period range
period range
26
100
90
90
80
80
70
70
Success rate(%)
Success rate(%)
100
60
50
40
U = 0.60
U = 0.62
U = 0.64
U = 0.66
U = 0.68
U = 0.70
30
20
10
0
U = 1.3
U = 1.6
U = 1.9
U = 2.2
U = 2.5
U = 2.7
60
50
40
30
20
10
0
5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95100
10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100
Sub-server number
Sub-server number
Figure 24: Schedulability of rate monotonic sub- Figure 26: Schedulability of (T-C) monotonic subserver sets with time partition configuration 1 and server sets with time partition configuration 2 and
“200 / 25000” period range
“200 / 25000” period range
100
70
U = 1.25
U = 1.50
U = 1.90
U = 2.20
U = 2.50
U = 2.60
90
80
Success rate(%)
80
Success rate(%)
100
U = 0.60
U = 0.62
U = 0.64
U = 0.66
U = 0.68
U = 0.70
90
60
50
40
30
70
60
50
40
30
20
20
10
10
0
0
5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95100
Sub-server number
10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100
Sub-server number
Figure 25: Schedulability of rate monotonic sub- Figure 27: Schedulability of (T-C) monotonic subserver sets with time partition configuration 1 and server sets with time partition configuration 2 and
“1000 / 25000” period range
“1000 / 25000” period range
27
100
90
Success rate(%)
80
70
60
50
40
U = 1.5
U = 1.9
U = 2.2
U = 2.5
U = 2.8
U = 3.1
30
20
10
0
10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100
Sub-server number
Figure 28: Schedulability of (T-C) monotonic subserver sets with time partition configuration 3 and
“200 / 25000” period range
100
90
Success rate(%)
80
70
60
50
40
U = 1.5
U = 1.9
U = 2.2
U = 2.5
U = 2.8
U = 3.1
30
20
10
0
10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100
Sub-server number
Figure 29: Schedulability of (T-C) monotonic subserver sets with time partition configuration 3 and
“1000 / 25000” period range
28