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 This report presents some initial results of our research which addresses the increasing gaps be- tween the power of multicore/multiprocessor sys- tems and the lack of development models and tools that help programmers exploit such power while ensuring correctness and predictability. One spe- cific goal of our research is to support service con- tracts on multicore/multiprocessor platforms that support resource partitioning and therefore allow a compositional development of parallel real-time systems. In such a system, each application or application component is described by a service contract, all of which collectively form a hierarchy of service contracts. After successful negotiations, such a hierarchy will be mapped to a hierarchical scheduling system. As with other real-time sys- tems, such systems require schedulability analysis, which is the main focus of this report 1 Introduction Up until now, unicore/uniprocessor systems have dominated real-time embedded computing re- search and engineering. However, increasing de- mand on processing power caused by complex new real-time embedded applications forces re- searchers and engineers to consider developing mul- ticore/multiprocessor real-time embedded systems. The urgent demand for such systems and the lack of development model and tools bring a new soft- ware crisis. We aim to develop a new environment ∗ This work has been funded by the European Com- mission’s 7th framework program’s JEOPARD project, no. 216682 and eMuCo project, no. FP7-ICT-2007-1 where real-time embedded software can be devel- oped for multicore/multiprocessor systems with the confidence that the power of such a platform can be exploited and the software’s logical and tempo- ral correctness can be achieved. One thing essential for the success of a mul- ticore/multiprocessor real-time embedded system is its schedulability analysis which is related to the scheduling policy chosen. In existing litera- ture, there are two main approaches for scheduling schedulable entities (such as threads and servers) on multicores or multiprocessors: fully partitioned and global scheduling. In a fully partitioned system, each schedulable entity is assigned to a processing unit which is the only place where that schedulable entity can exe- cute [9, 11]. All the schedulable entities assigned to the same processing unit compete with each other according to a uniprocessor scheduling algorithm. Therefore, the uniprocessor schedulability analysis techniques can be used. However, it is very diffi- cult to find an optimal assignment of schedulable entities to processing units [10]. In a global scheduling system, a schedulable en- tity can be scheduled to run on any processing unit. All the schedulable entities compete with each other globally under one of the global schedul- ing algorithms such as proportionate fair [6], global EDF [20, 4], global rate monotonic [1], global dead- line monotonic [4] and so on. A fundamental dif- ference 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 char- acteristic of global scheduling systems is their dif- ficulty in finding the critical instant which, in a 1
Transcript
Schedulability Analysis for a Real-time Multiprocessor System
Based on Service Contracts and Resource Partitioning∗
Yang Chang, Robert Davis and Andy WellingsUniversity of York, UK,
{yang, robdavis, andy}@cs.york.ac.uk
Abstract
This report presents some initial results of ourresearch which addresses the increasing gaps be-tween the power of multicore/multiprocessor sys-tems and the lack of development models and toolsthat help programmers exploit such power whileensuring correctness and predictability. One spe-cific goal of our research is to support service con-tracts on multicore/multiprocessor platforms thatsupport resource partitioning and therefore allowa compositional development of parallel real-timesystems. In such a system, each application orapplication component is described by a servicecontract, all of which collectively form a hierarchyof service contracts. After successful negotiations,such a hierarchy will be mapped to a hierarchicalscheduling system. As with other real-time sys-tems, such systems require schedulability analysis,which is the main focus of this report
1 Introduction
Up until now, unicore/uniprocessor systems havedominated real-time embedded computing re-search and engineering. However, increasing de-mand on processing power caused by complexnew real-time embedded applications forces re-searchers and engineers to consider developing mul-ticore/multiprocessor real-time embedded systems.The urgent demand for such systems and the lackof development model and tools bring a new soft-ware crisis. We aim to develop a new environment
∗This work has been funded by the European Com-mission’s 7th framework program’s JEOPARD project, no.216682 and eMuCo project, no. FP7-ICT-2007-1
where real-time embedded software can be devel-oped for multicore/multiprocessor systems with theconfidence that the power of such a platform canbe exploited and the software’s logical and tempo-ral correctness can be achieved.
One thing essential for the success of a mul-ticore/multiprocessor real-time embedded systemis its schedulability analysis which is related tothe scheduling policy chosen. In existing litera-ture, there are two main approaches for schedulingschedulable entities (such as threads and servers)on multicores or multiprocessors: fully partitioned
and global scheduling.
In a fully partitioned system, each schedulableentity is assigned to a processing unit which is theonly place where that schedulable entity can exe-cute [9, 11]. All the schedulable entities assigned tothe same processing unit compete with each otheraccording to a uniprocessor scheduling algorithm.Therefore, the uniprocessor schedulability analysistechniques can be used. However, it is very diffi-cult to find an optimal assignment of schedulableentities to processing units [10].
In a global scheduling system, a schedulable en-tity can be scheduled to run on any processingunit. All the schedulable entities compete witheach other globally under one of the global schedul-ing algorithms such as proportionate fair [6], global
EDF [20, 4], global rate monotonic [1], global dead-
line monotonic [4] and so on. A fundamental dif-ference between such a system and a uniprocessorsystem is that migration, in a global schedulingsystem, may occur whenever a schedulable entityis preempted or suspended. Another unique char-acteristic of global scheduling systems is their dif-ficulty in finding the critical instant which, in a
1
uniprocessor system, is the time instant at whichall the schedulable entities are released [16, 5]. Be-cause of such fundamental differences, the unipro-cessor schedulability analysis techniques can nolonger be used and therefore, many new schedu-lability analysis approaches have been proposed forglobal scheduling systems in recent years [5].
Another trend of real-time embedded softwareis to become more and more dynamic and flex-ible. In order to cope with such developments,component-based real-time embedded systems havebeen studied. In such systems, components are de-veloped, analyzed and tested independent of eachother. When they are put together, analysis andtesting can be made without knowing any internalinformation of any component because the impactsof one component on the others are independent ofits internal behaviour. Therefore, it is possible tomake schedulable entities with very different timingrequirements or criticality coexist without jeopar-dizing each other’s execution.
Utilizing execution time servers to implementcomponent-based real-time embedded systems hasbeen a common practice on uniprocessors [13,12]. Based on such techniques, Harbour pro-posed service contracts in a FRESCOR (Frame-work for Real-time Embedded Systems based onCOntRacts) project report [14]. In his proposedmodel, every application or application componentshould have a contract with the rest of the sys-tem, describing the minimum resource requirementof this application or application component. Ne-gotiations are made across the whole system, eitheroffline or online, to guarantee, if successfully negoti-ated, that enough resources are always available tosatisfy the minimum requirements of all contracts.
The FRESCOR contracts are devised to be plat-form independent such that any scheduling methodcan be used to support such contracts. Currently,FRESCOR contracts are mapped to execution timeservers at runtime and all the tasks within an ap-plication or application component are executedunder the server that represents the correspond-ing service contract. This means that the FRES-COR contract model is a hierarchical schedulingframework, which includes the scheduling of execu-tion time servers and the scheduling of tasks withinthose servers.
Our research aims to facilitate the developmentof component-based multicore/multiprocessor real-time systems. As part of this effort, this reportfocuses on the schedulability analysis of such a sys-tem, leaving the detailed description of implemen-tation, contract specification and so on to otherdocuments. The main contribution of this report:
• A new schedulability analysis for acomponent-based real-time system on amulticore/multiprocessor platform with re-source partitioning. To the best of ourknowledge, this has not been done before.
• A way to extend the FRESCOR contractmodel to multicore/multiprocessor platformswithout introducing too much implementationcomplexity.
• An extension to the FRESCOR contract modelto allow resource partitioning to support ser-vice contracts (external contracts).
This report is organized as follows. In section 2, ageneral model of resource partitioning is introducedwith the concerns initially focused on uniprocessorplatforms and subsequently switched to a proposedextension for multicore/multiprocessor platforms.In section 3, we extend the FRESCOR contractmodel to multicore/multiprocessor platforms andalso introduce a two-level service contract modelwhich allows resource partitioning to support ser-vice contracts as well. Sections 4 and 5 elaboratethe proposed schedulability analyses for servers andthreads respectively. Some initial experiment re-sults are presented in section 6. Section 7 sum-marises existing work that is relevant to our re-search. Finally, we draw conclusions and discusspossible future work in section 8.
2 Resource Partitioning
Resource partitioning is widely used in many ap-plication areas (e.g. avionic systems) to allow in-dependent execution of more than one applicationon the same processor [2, 15]. Both temporal andspatial partitioning are essential for the correct exe-cution of all the applications. However, this report
2
is only concerned with the temporal aspect of thisissue.
Usually, partitions in a uniprocessor system arescheduled on a fixed, cyclic basis which is imple-mented by maintaining a fixed length major timeframe composed of fixed scheduling windows andrepeating such a scheduling scheme during the life-time of the system. Each partition, which corre-sponds to an application, is allocated to one ormore scheduling windows in the major time frame.A scheduling window can normally be defined byits offset from the beginning of the major timeframe and its length (see figure 1). Since all theinformation needed to make scheduling decisionsis available offline, deterministic behaviour can beachieved.
Figure 1: An example of resource partitioning sys-tems
Because the scheduling scheme of the major timeframe is always repeated, any scheduling window isessentially periodic. It is important to distinguishan individual scheduling window from a periodicscheduling window set, which is defined by the off-set of its first individual window, its period and itsduration in each period.
A periodic scheduling window set must followsome rules:
1. the length of the major time frame is an exactmultiple of its period
2. the duration of its windows in different periods
are identical
3. individual scheduling windows do not overlapbut gaps between them are allowed
An example of such scheduling schemes is givenin figure 2. Two periodic scheduling window setsare illustrated in that diagram. Scheduling windowset 1 starts at time 0 and has a period of 25 timeunits as well as a duration of 10 time units in eachperiod. On the other hand, scheduling window set2 starts at time 15 and ends at time 25 which givesa 10 time unit duration. Then, it repeats everymajor time frame.
0 10 35 100
315 25 50 60
3 375 85
34Periodic Scheduling Window Set 1
Periodic Scheduling Window Set 2
Figure 2: An example of uniprocessor PikeOSscheduling schemes
Each partition, which corresponds to an applica-tion, can be associated with one or more periodicscheduling window sets. However, every schedul-ing window in the same periodic scheduling windowset must be associated with the same partition andtherefore the same application.
Uniprocessor operating systems exist that im-plement resource partitioning mechanisms that aresimilar to the above general model. PikeOS is oneof them. It is a microkernel operating system whichpartitions and virtualizes resources providing spa-tial and temporal isolation for guest OSes and ap-plications (which may or may not be running onguest OSes). A multicore/multiprocessor version ofPikeOS is being developed. Essential changes pro-posed by Almeida of Sysgo (the company that de-
3
velops PikeOS) [Almeida, private communication,2008] to allow PikeOS to be used in a multiproces-sor environment (currently SMP only) include:
1. Different processors should have their own ma-jor time frames, the lengths of which are iden-tical. They should be synchronized as well.
2. The scheduling scheme within each major timeframe on each processor is not required to bethe same as others. They can have schedulingwindow sets with different active intervals andperiods.
3. A time partition can be allocated to anyscheduling window set on any processor. Then,threads of that time partition can only exe-cute when at least one of their scheduling win-dows is active. Therefore, time partitions effec-tively allow both fully partitioned and globalscheduling.
Figure 3 illustrates an example of multiprocessorPikeOS scheduling schemes. In this dual proces-sor example, time partition A is associated witha periodic scheduling window set on processor P1as well as two periodic window sets on processorP2 with periods equal to the length of the majortime frame. Time partition B is associated with aperiodic scheduling window set on processor P2 aswell as two periodic window sets on processor P1with periods equal to the length of the major timeframe.
As the proposed changes do not rely on any spe-cific PikeOS features, we use it as a general modelof multicore/multiprocessor resource partitioningin this report.
3 Contracts and Hierarchical
Scheduling
One goal of our research is to support resource con-tracts [14] at two levels. First, each applicationshould have a contract with the underlying operat-ing system which specifies a portion of resources tobe reserved (i.e. external contracts). Second, com-ponents of each application should have their owncontracts as well (i.e. internal contracts). Such
0 50 75 100
A A A
0 50 100
P1
P2A A
A
A Scheduling Windows of Time Partition A
Scheduling Windows of Time Partition B
2510 35 60 85
15 30 80 9065
B B
B B
B
Figure 3: An example of multiprocessor PikeOSscheduling schemes
contracts specify how to distribute the resourcesreserved according to the corresponding externalcontract among all the components.
The multicore/multiprocessor resource partition-ing model proposed in the previous section is usedto facilitate external contracts. For example, a fewpairs of period and capacity values can be definedin each external contract which, after successful ne-gotiation, can be transformed to parameters of thecorresponding time partition and scheduling win-dow sets (perhaps, on different processors). On theother hand, internal contracts can be supported byusing execution time servers and the period andcapacity in each internal contract can be directlymapped to the scheduling parameters of a serverafter successful negotiation. If parallel executionof an application component is required, the exe-cution time server of that component must run inparallel as well.
In order to support parallel execution of an indi-vidual server without introducing too much imple-mentation complexity, we propose the use of sub-
servers, each of which is a physical execution timeserver that can never run in parallel, yet can stillmigrate across processors. Each such sub-serverhas its own budget (independent of the others)which can only be consumed on a single processorat any time instant. For the purpose of this report,it is assumed that any application component (and
4
therefore its threads) is associated with an abstractserver which must be composed of physical sub-servers that do not belong to any other abstractservers (see figure 4) and that collectively satisfythe abstract server’s timing requirement.
All the sub-servers of an application are sched-uled according to a global fixed priority pre-emptivescheduling policy (i.e. the top x available high pri-ority sub-servers should always run at any timewhere x is the number of scheduling windows activeat that time) within the time partition of that ap-plication. The priorities of sub-servers are globalamong all the sub-servers of the time partitionunder investigation. Moreover, it should be no-ticed that any sub-server of a time partition canbe scheduled to execute in any scheduling windowof that time partition if the sub-server’s priorityallows.
Threads are scheduled according to the globalfixed priority pre-emptive scheduling policy as well,but they compete locally within their abstractserver where a sub-server can serve any thread as-sociated with its server if capacity is still availableand the sub-server’s priority is high enough.
In such a system, the execution of threads is con-strained by the availability of server budgets andthe servers are also constrained by the activationof their time partition. Consequently, this intro-duces a 3-layer hierarchical scheduling model.
3.1 Terminology and System Model
Our schedulability analysis is developed with theassumption that application threads are releasedeither periodically at fixed intervals of time, or spo-radically after some minimum inter-arrival time haselapsed. Aperiodic threads can be allocated toservers (which comprises aperiodic threads only)but they cannot be guaranteed (although theirservers’ schedulability can be guaranteed). It isalso assumed that all processors are identical. Eachthread τi, has a unique priority i within its abstractserver and is characterised by its relative deadlineDi, worst-case execution time Ci and the minimuminter-arrival time Ti, otherwise referred to as its pe-riod. It is required that Di ≤ Ti. Currently, we alsoassume that threads are independent of each otherso there is not any blocking factor (Efforts will bemade to relax this restriction as part of our futurework.). Notice, the utilization of thread i, denotedas Ui, must be less than 1 because an individualthread is not allowed to run in parallel in the pro-posed system.
The execution time server algorithms that can beadopted in our system (for the sub-servers) includethe periodic server, deferrable server [21] and spo-radic server algorithms [17]. Any sub-server can becharacterised by a unique priority s within its ap-plication, its capacity Cs, capacity replenishmentperiod and deadline Ts. Notice, the utilization ofsub-server s, denoted as Us, must be less than 1because an individual sub-server is not allowed torun in parallel in the proposed system.
4 Server Schedulability Anal-
ysis
In order to guarantee the schedulability of threads,it is necessary to first make sure that all the sub-servers of a time partition are schedulable.
Although our server schedulability analysis isbased on the same essential idea as Baruah’s work[5], there are two significant differences. First, theexecution of sub-servers is constrained by their timepartition’s scheduling windows. Second, our sub-servers are scheduled according to fixed static pri-orities while Baruah’s analysis is based on EDF
5
scheduling. Solving these problems are our maincontributions.
4.1 Least Supply Function of a Par-
titioned Multiprocessor System
This subsection is dedicated to showing how theminimum computation time during a given timeinterval can be obtained in a time partitioned mul-tiprocessor system. The result presented at the endof this subsection will be used as the upper boundof the server workload allowed under any circum-stance. In order to achieve this goal, we model thesystem in a similar way as Mok et al.’s work [18]which is aimed at uniprocessor systems.
Theory
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 someN ≥ 1, and P is the length of the major timeframe, and m is the number of processors onwhich this time partition can run.
For example, time partition A in fig-ure 3 consists of 2 tuples: (Γ1, 100) and(Γ2, 100). Γ1 is an array of 4 time pairs{(0, 10), (25, 35), (50, 60), (75, 85)} whilst Γ2 isan array of 2 time pairs {(15, 30), (80, 90)}.
Definition 2 The supply function S(t) of a timepartition is the total amount of time that isavailable in that time partition from time 0 tot.
Definition 3 The Least Supply Function LSF (t) ofa time partition is the minimum of all (S(d +t)−S(d)) where t is a time interval and t, d ≥ 0.
Definition 4 A least supply time interval (u, u+v)is a time interval that satisfies S(u+v)−S(u) =LSF (v).
Definition 5 All ends of scheduling win-dows of a time partition (ST1, ST2, . . . , STN
and EN1, EN2, . . . , ENN ) are called IntervalBased Critical Points (IBCPs).
Based on the above definitions, the followinglemma can be proven.
Lemma 1. For any least supply time interval
(u, u + v) of a time partition, either
• at least on one processor, u or u + v is at an
IBCP, or
• there exists another least supply time interval
(u′, u′+v) where u′ or u′+v is at some IBCP.
Proof. In order to prove this lemma, it is requiredto contradict the following assertion:
There exists a least supply time interval (u, u+v)where neither u nor u + v is at any IBCP and forthis least supply time interval, one cannot find any(u′, u′ + v) where u′ or u′ + v is at some IBCP.
First of all, it is assumed that the latest IBCP (onany processor) before u is at u− x and the earliestIBCP (on any processor) after u is at u + y. It isalso 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′. Sinceu and u + v are not supposed to be at any IBCP,x, y, x′ and y′ must be greater than zero.
Because u−x and u+ y are the closest IBCPs ofu, scheduling windows do not change their status(active or not) in between u−x and u+ y. Neitherdo they change status in between u + v − x′ andu + v + y′ due to the same reason. Therefore, wecan assume that q scheduling windows (on q pro-cessors) are active in between u−x and u+y whileq′ scheduling windows (on q′ processors) are activein between u + v − x′ and u + v + y′.
In the cases where q < q′, we define a small offsetδ such that δ ≤ x and δ ≤ x′. Then,
S(u+v−δ)−S(u−δ) = S(u+v)−S(u)+q ·δ−q′ ·δ(1)
Since q < q′,
S(u + v − δ) − S(u − δ) < S(u + v) − S(u) (2)
which contradicts the definition of least supplytime interval.
6
In the cases where q > q′, we define another smalloffset δ such that δ ≤ y and δ ≤ y′. Then,
S(u+v+δ)−S(u+δ) = S(u+v)−S(u)+q′ ·δ−q ·δ(3)
Since q > q′,
S(u + v + δ) − S(u + δ) < S(u + v) − S(u) (4)
which again contradicts the definition of leastsupply time interval.
Consequently, when either q < q′ or q > q′, thereis not any least supply time interval, the start andend of which are not at any IBCP.
However, when q = q′, if we change the smalloffset δ to the smaller value of x and x′, then
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 leastsupply time interval. However, since at least one ofu+v−δ and u−δ is at an IBCP, this contradicts theprevious assertion which states that there exists aleast supply time interval (u, u + v) where neitheru nor u+v is at any IBCP and for this least supplytime interval, one cannot find any (u′, u′+v) whereu′ or u′ + v is at some IBCP.
Therefore, it has been proven that in all circum-stances, the previous assertion is false, which provesLemma 1.
Next, we narrow down the IBCPs referred to inLemma 1.
Lemma 2. For any least supply time interval
(u, u + v) of a time partition, either
• 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
• 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.
Proof. In order to prove this lemma, it is onlyrequired to contradict the following assertion (wehave proven Lemma 1):
There exists a least supply time interval (u, u+v)where
• u is only at IBCPs that are the starts of somescheduling windows and u + v is not at anyIBCP, or
• u + v is only at IBCPs that are the ends ofsome scheduling windows and u is not at anyIBCP.
First of all, it is assumed that the latest IBCP(on any processor) before u is at u − x and theearliest IBCP (on any processor) after u is at u +y (excluding the scheduling windows that start atu). It is also assumed that latest IBCP (on anyprocessor) before u + v is at u + v − x′ (excludingthe scheduling windows that end at u + v) and theearliest IBCP (on any processor) after u + v is atu + v + y′. Since u and u + v are not supposed tobe at any IBCP other than the starts of schedulingwindows that start at u and the ends of schedulingwindows that end at u + v, x, y, x′ and y′ must begreater than zero.
Then, let’s consider the first part of the aboveassertion. Assume that there are q scheduling win-dows (excluding those that start at u) that are ac-tive in between u − x and u + y while q′ schedul-ing windows are active in between u + v − x′ andu + v + y′.
If q < q′, we again define a small offset δ suchthat δ ≤ x and δ ≤ x′. Then,
S(u+v−δ)−S(u−δ) = S(u+v)−S(u)+q ·δ−q′ ·δ(7)
Since q < q′,
S(u + v − δ) − S(u − δ) < S(u + v) − S(u) (8)
7
which contradicts the definition of least supplytime interval.
if q ≥ q′, we define another offset δ such thatδ ≤ y and δ ≤ y′. Then,
S(u+v+δ)−S(u+δ) ≤ S(u+v)−S(u)+q′·δ−(q+1)·δ(9)
Since q ≥ q′,
S(u + v + δ) − S(u + δ) < S(u + v) − S(u) (10)
which again contradicts the definition of leastsupply time interval. This proves the first part ofthe above assertion false.
Then, let’s consider the second part of the aboveassertion. Assume that there are q scheduling win-dows that are active in between u − x and u + ywhile q′ scheduling windows are active in betweenu + v − x′ and u + v + y′ (including those that endat u + v).
If q < q′, we again define a small offset δ suchthat δ ≤ x and δ ≤ x′. Then,
S(u+v−δ)−S(u−δ) = S(u+v)−S(u)+q ·δ−q′ ·δ(11)
Since q < q′,
S(u + v − δ) − S(u − δ) < S(u + v) − S(u) (12)
which contradicts the definition of least supplytime interval.
if q ≥ q′, we define another offset δ such thatδ ≤ y and δ ≤ y′. Then,
S(u+v+δ)−S(u+δ) ≤ S(u+v)−S(u)+(q′−1)·δ−q·δ(13)
Since q ≥ q′,
S(u + v + δ) − S(u + δ) < S(u + v) − S(u) (14)
which again contradicts the definition of leastsupply time interval. This proves the second partof the above assertion false.
Consequently, the above assertion is false, whichproves Lemma 2.
Based on Lemma 1 and 2, it is straightforwardto draw the conclusion that estimating LSF (t) forany time interval t only requires checking the end ofeach scheduling window as a potential start pointof a least supply time interval as well as the startof each scheduling window as a potential end pointof a least supply time interval. Such an estimationof LSF (t) shows no pessimism so the results areaccurate.
Algorithm
t + 3 t + 5t
t
t + 1
t+0.5 t+1.5 t+2.5
t + 4.5
t + 4.5
t + 6
t + 6
hijklmnopq roplsrt su svjkw voxk yzwvovospthijklmnopq roplsrt su vjk ispikwpkl voxk yzwvovospFigure 5: An example of under estimation of theleast supply function
One way to obtain the LSF (t) function is tofind each processor’s contribution to it, denoted asLSFx(t), by examining the end of each schedul-ing window on the corresponding processor for(Sx(t + α) − Sx(α)) where α denotes the end. Letnx denote the number of scheduling windows onprocessor x, we get:
LSFx(t) = mink=1···nx
{Sx(αk + t) − Sx(αk)} (15)
8
and∑m
k=1 LSFk(t) gives a lower bound onLSF (t) (this algorithm can be proven correct yetpessimistic).
Unfortunately, although simple, this approachis too pessimistic because the combinations ofscheduling windows on different processors that re-sult in the above LSF (t) may be impossible asmeaningful combinations of scheduling windows aredetermined by the scheduling scheme. For exam-ple, 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 minimumcomputation time provided by this example within2 time units is zero. However, LSF1(2) = 0 andLSF2(2) = 0 are obtained at two scheduling win-dows’ ends (t+5 on processor P1; t+2.5 on proces-sor P2) that can never be combined. Consequently,LSF1(2) = 0 and LSF2(2) = 0 never occur at thesame time.
Initialize the least supply function LSF(t) =
MAX VALUE;
For each scheduling window of the time partition
under investigation
{
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;
For each processor x
{
Use the chosen β to calculate Sx(β + t) − Sx(β);
f ′(t) = f ′(t) + 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
taking advantage of the conclusion drawn at theend of the theory part of this subsection. Thepseudo code of this algorithm is given in Algorithm1. This algorithm is in fact exact and has no pes-simism in the values computed.
Figure 5 gives an example of multiprocessor re-source partitioning systems. Based on this exam-ple, we demonstrate how to use Algorithm 1 to es-timate LSF (2):
For scheduling window (t, t + 0.5), its f(2) andf ′(2) are 2 and 2.5 respectively. For schedulingwindow (t+1, t+3), its f(2) and f ′(2) are 1.5 and 1respectively. For scheduling window (t+1.5, t+2.5),its f(2) and f ′(2) are 1.5 and 0.5 respectively. Forscheduling 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 2respectively.
Hence, the estimation of LSF (2) given by thisalgorithm is 0.5. By contrast, the estimation ofLSF (2) given by the previous algorithm that isbased on the calculation of LSFx(t) is 0. Conse-quently, this is also a pragmatic example that jus-tifies Algorithm 1 being exact.
With this accurate algorithm, the time requiredto estimate LSF (t), given a specific value of t, islinear, in the worst case, to the total number ofscheduling windows of the time partition under in-vestigation (within a single major time frame). Ifmultiple scheduling windows start or end at thesame time instant, the number of iterations can befurther reduced.
4.2 Workload of Sub-servers and
Schedulability Condition
Following Baruah’s approach, we determine theschedulability of each sub-server by finding cer-tain critical durations of that sub-server as well asthe maximum possible total workloads of all sub-servers with equal or higher priorities in those du-rations. Then, if the workload in every critical du-ration (with a length of t ) is no more than the leastcomputation time that the system can provide dur-ing any interval of length t, the sub-server underinvestigation will be guaranteed to be schedulable.In this subsection, we present how the critical du-
9
rations and total workloads are determined.
Suppose that a release of sub-server SSk is thefirst job of that sub-server to miss its deadline. Thisjob is called a problem job and the time interval be-tween the release time of the problem job and itsdeadline [ta, td) is called a problem window. Intu-itively, ta = td−Tk where Tk represents the relativedeadline and period of SSk.
After ignoring servers with lower priorities thanSSk, suppose that t0 is the latest time instant ear-lier than ta at which, if the number of remainingsub-servers is less than currently available proces-sors, at least one sub-server is not executing thoughenough resources are available. If the number of re-maining servers is more than available processors,suppose that t0 is the latest time instant earlierthan ta at which at least one processor is idle eventhough it is available for use according to the timepartition configuration. Then let Ak = ta − t0 (seefigure 6). Notice that Ak is not a fixed value forSSk because there is not any assumption on thearrivals of servers and their relation to schedulingwindows.
T{t| t}t~ Idle point Deadline miss
A{Figure 6: Notation
Since the deadline of the problem job is missed,the problem job must execute less than Ck timeunits during [ta, td) and no scheduling window canbe idle when the problem job is not running. Itseems that the total workload of other jobs during[ta, td) must be higher than LSF (Tk)−Ck to forcethe problem job to miss its deadline. However, be-
cause the problem job cannot run in parallel, thetotal workload of other jobs during [ta, td) does nothave to be higher than LSF (Tk) − Ck to cause adeadline miss. In fact, when we try to lower boundthe workload of other jobs, it has to be assumedthat overlapped scheduling windows other than theproblem job’s are always idle when the problem jobis running.
As a result, it is necessary to know the maxi-mum total computation time provided by the timepartition under investigation during any Ck out ofTk, which is denoted as MP (Ck). Notice that thetime intervals that compose Ck are not necessarilycontiguous, yet they have to be within time inter-val Tk. For ease of presentation, we first considerMP (Ck) as a parameter of each SSk that is alreadyknown. A detailed study of MP (Ck) will be givenin subsection 4.3.
Therefore, the total workload of other jobs dur-ing [ta, td) must be higher than LSF (Tk)−MP (Ck)to force the problem job to miss its deadline. More-over, the definition of t0 suggests that t0 shouldbe the last time instant before ta when the con-cerned sub-servers waste any resource so the to-tal workload of sub-server jobs except the problemjob during [t0, td) should be at least higher thanLSF (Ak + Tk) − MP (Ck).
For each i such that k ≤ i ≤ n (n is the high-est sub-server priority and also the total numberof sub-servers of the time partition under discus-sion), let I(SSi) denote the contribution of SSi tothe total workload of sub-servers in this time parti-tion during [t0, ta)∪ωk where ωk denotes the inter-vals (not necessarily contiguous) during which allprocessors allowed by time partitioning are execut-ing jobs other than the problem job during [ta, td).Then, in order for the deadline miss of the problemjob to occur, the following inequality must alwayshold.
∑
i≥k
I(SSi) > LSF (Ak + Tk) − MP (Ck) (16)
In other words, if for all possible Ak,∑i≥k I(SSi) ≤ LSF (Ak + Tk) − MP (Ck), sub-
server SSk will be guaranteed to always meet itsdeadline.
Next, we will present how to derive I(SSi) and
10
therefore∑
i I(SSi).
Suppose that a job of SSi arrives before t0 andhas not completed execution by t0. Then, SSi issaid to have a carry-in job with respect to the sub-server SSk under investigation. If a sub-server hasno carry-in job with respect to SSk, its contributionto SSk’s
∑i I(SSi) will be denoted as Inc(SSi).
Otherwise, it will be denoted as Ic(SSi).
Computing Inc(SSi)
t�t� T�...........T� C�The execution of subserver i within time interval [t�, t�)
A� + T�
Figure 7: Worst-case arrivals of sub-server SSi
within time interval [t0, td) with respect to SSk
If a sub-server SSi has no carry-in job, all itsjobs that contribute to Inc(SSi) arrive in the inter-val [t0, td). Let’s first consider the situation wherei > k (see figure 7). The maximum contributionof SSi is made when the last job arrives exactlyCi time units before td and executes immediately.Moreover, this contribution should not exceed thetotal length of [t0, ta) ∪ ωk which is definitely notlonger than Ak + Tk − Ck. Thus,
Inc(SSi) = min((⌊Ak + Tk − Ci
Ti
⌋ + 1)Ci
, Ak + Tk − Ck) if i > k (17)
It is worth noticing that Ak + Tk may be lessthan some Ci in which case, ⌊Ak+Tk−Ci
Ti
⌋ becomesnegative. However, since Ak +Tk is always positive
and Ci ≤ Ti is always true, ⌊Ak+Tk−Ci
Ti
⌋ is no less
than −1. Therefore, (⌊Ak+Tk−Ci
Ti⌋ + 1)Ci is never
negative. When Ak + Tk is less than Ci and i > k,Inc(SSi) is always 0. This indicates that when Ci
is too large, server SSi can no longer have any non-carry-in job.
Moreover, if i = k, the last job of the sub-serverarrives at ta and contributes nothing to Inc(SSi) asit is out of [t0, ta)∪ωk. Since SSi has no other jobsbetween [ta, td), the maximum contribution of SSi
should not exceed the total length of [t0, ta) whichis Ak. Thus,
Inc(SSi) = min(⌊Ak
Ti
⌋Ci, Ak) if i = k (18)
Computing Ic(SSi)
t�t� C �T�...........T�T�The execution of subserver i within time interval [t�, t�)
The execution of subserver i outside time interval [t�, t�)A� + T�
Figure 8: The carry-in jobs
Consider the situation when SSi is active (re-leased and not completed) at t0. Some work of thecarry-in job will be carried into [t0, td) and thereforeis part of Ic(SSi). All other jobs that contributeto Ic(SSi) arrive in the interval [t0, td). Let’s firstconsider the situation where i > k and Ak+Tk ≥ Ci
(see figure 8). The maximum contribution of SSi
is made when the last job arrives exactly Ci timeunits before td and executes immediately. On theother hand, the carry-in job is assumed to executeas late as possible, which gives the greatest impact
11
to Ic(SSi). Moreover, Ic(SSi) should not exceedthe total length of [t0, ta) ∪ ωk which is definitelynot longer than Ak + Tk − Ck. Thus,
Ic(SSi) = min((⌊Ak + Tk − Ci
Ti
⌋ + 1)Ci
+min(Ci, (Ak + Tk − Ci) mod Ti)
, Ak + Tk − Ck)
if i > k ∧ Ak + Tk ≥ Ci (19)
On the other hand, if Ak + Tk < Ci and i >k, then sub-server SSi has only one carry-in jobwhich executes, in the worst case, during the whole[t0, ta) ∪ ωk time interval. Therefore,
Ic(SSi) = Ak +Tk −Ck if i > k∧Ak +Tk < Ci
(20)
When i = k, the last job of the sub-server arrivesat ta and contributes nothing to Ic(SSi) as it is outof [t0, ta)∪ωk. Since SSi has no other jobs between[ta, td), the maximum contribution of SSi shouldnot exceed the total length of [t0, ta) which is Ak.Thus,
Ic(SSi) = min(⌊Ak
Ti
⌋Ci + min(Ci, Ak mod Ti)
, Ak) if i = k(21)
Computing∑
i I(SSi)
First, we define IDIFF (SSi) as the difference be-tween Ic(SSi) and Inc(SSi) with respect to thesame SSk and Ak. Thus,
IDIFF (SSi) = Ic(SSi) − Inc(SSi) (22)
According to the definition of t0, when there aremore sub-servers than available processors, thereare at most (γmax−1) active sub-servers at t0 whereγmax is the maximum number of scheduling win-dows of this time partition that can run in parallel.This is because there is at least one processor thatis idle at t0 even though it is available for use ac-cording to the time partition configuration. If more
than (γmax −1) sub-servers are active at that time,it will be guaranteed that all available processortime at t0 will be used.
When there are fewer sub-servers than availableprocessors, there are at most (ϕ − 1) active sub-servers at t0 where ϕ is the total number of sub-servers of the time partition under discussion thathave equal or higher priorities than k. This is be-cause there is at least one sub-server that is idleat t0 even though there is enough resource. If allϕ sub-servers are active at that time, all availableresources will be used.
Based on this observation, we define ξ as thesmaller one of γmax and ϕ. Then, we can get:
∑
i≥k
I(SSi) =∑
i≥k
Inc(SSi) +∑
the(ξ−1)largest
IDIFF (SSi)
(23)
Therefore, if the following inequality holds for allpossible Ak, sub-server SSk will be guaranteed toalways meet its deadline.
∑
i≥k
Inc(SSi) +∑
the(ξ−1)largest
IDIFF (SSi)
≤ LSF (Ak + Tk) − MP (Ck) (24)
Notice, SSk is definitely unschedulable ifLSF (Ak + Tk) < MP (Ck) which makes the righthand side of inequality (24) negative.
Computing Ak
As defined in subsection 4.2, Ak is the length ofthe interval [t0, ta) with respect to sub-server SSk.Therefore, Ak ≥ 0.
For any sub-server, we can also observe fromequation (17) that if i > k:
Inc(SSi) ≤ (⌊Ak + Tk − Ci
Ti
⌋ + 1)Ci (25)
and from equation (18) that if i = k
12
Inc(SSi) ≤ ⌊Ak
Ti
⌋Ci ≤ (⌊Ak + Tk − Ci
Ti
⌋ + 1)Ci
(26)
Let’s define CΣ as the sum of the (ξ − 1) largestΘ(i) of all concerned sub-servers where Θ(i) is de-fined as:
Θ(i) = min(Ci, Ak + Tk − Ck) (i ≥ k) (27)
Because IDIFF (SSi) cannot be larger than Ci
and Ak + Tk − Ck ≤ Θ(i), IDIFF (SSi) ≤ Θ(i).Consequently,
∑the(ξ−1)largest IDIFF (SSi) ≤∑
the(ξ−1)largest Θ(i) = CΣ. Therefore,
X
i≥k
I(SSi) =X
i≥k
Inc(SSi) +X
the(ξ−1)largest
IDIF F (SSi)
≤X
i≥k
(⌊Ak + Tk − Ci
Ti
⌋ + 1)Ci + CΣ
(28)
Whenever the deadline of SSk is missed, it mustbe true that
∑
i≥k
(⌊Ak + Tk − Ci
Ti
⌋ + 1)Ci + CΣ > LSF (Ak + Tk)
−MP (Ck)(29)
Otherwise,∑
i≥k I(SSi) will be guaranteed to beno more than LSF (Ak + Tk) − MP (Ck).
Moreover,
∑
i≥k
(⌊Ak + Tk − Ci
Ti
⌋ + 1)Ci
≤∑
i≥k
(Ak + Tk − Ci
Ti
+ 1)Ci (30)
Thus,
∑
i≥k
(⌊Ak + Tk − Ci
Ti
⌋ + 1)Ci ≤ (Ak + Tk)∑
i≥k
Ci
Ti
+∑
i≥k
(Ti − Ci)Ci
Ti
(31)
Hence, the following inequality must hold in or-der for a deadline miss to occur.
(Ak + Tk)∑
i≥k
Ci
Ti
+∑
i≥k
(Ti − Ci)Ci
Ti
+ CΣ
> LSF (Ak + Tk) − MP (Ck) (32)
which can be transformed to:
LSF (Ak + Tk) − Ak
∑
i≥k
Ui < Tk
∑
i≥k
Ui
+∑
i≥k
(Ti − Ci)Ui + CΣ + MP (Ck) (33)
where Ui = Ci
Ti
is the utilization of sub-server i.
For any Ak ≥ 0 that violates inequality (33),it makes
∑i I(SSi) definitely no higher than
LSF (Ak + Tk) − MP (Ck). Therefore, it is onlyrequired to check those Ak ≥ 0 that satisfy inequal-ity (33). As discussed previously, if any Ak in thisrange makes LSF (Ak + Tk) < MP (Ck), SSk isdefinitely unschedulable.
Solving inequality 33 is not trivial as LSF (Ak +Tk) is not a simple function of Ak and CΣ is alsounder the influence of Ak. First of all, it is re-quired to derive a simple function LSFlb(t) suchthat LSFlb(t) ≤ LSF (t). We observe that LSF (t)can never grow faster than f(t) = γmax · t whereγmax is the maximum number of scheduling win-dows of this time partition that can run in parallel.Therefore, P − LSF (P )/γmax (P is the length ofthe major time frame) gives the last time instantbefore P when LSF (t) can possibly grow less fasterthan f(t) = γmax · t. Therefore, a lower bound ofLSF (t) in [0, P ] can be given as:
LSFlb(t) = 0, 0 ≤ t ≤ (P −LSF (P )
γmax
)
LSFlb(t) = γmax · (t − P +LSF (P )
γmax
)
(P −LSF (P )
γmax
) < t ≤ P (34)
Because LSF (t) repeats itself every major timeframe, LSFlb(t) can be further simplified to:
13
LSFlb(t) = (t − P +LSF (P )
γmax
) ·LSF (P )
Pt ≥ 0
(35)
By transforming inequality 33, we can get:
Ak
∑
i≥k
Ui > LSF (Ak + Tk) − Tk
∑
i≥k
Ui
−∑
i≥k
(Ti − Ci)Ui − CΣ − MP (Ck) (36)
Here, it is assumed that Ak is sufficiently large sothat CΣ is only a function of sub-server executiontimes. Hence,
Ak
∑
i≥k
Ui > LSFlb(Ak + Tk) − Tk
∑
i≥k
Ui
−∑
i≥k
(Ti − Ci)Ui − CΣ − MP (Ck) (37)
Consequently,
Ak < (LSF (P ) · P −LSF (P )2
γmax
+ (∑
i≥k
(Ti − Ci)Ui
+CΣ + MP (Ck)) · P )/(LSF (P ) − P ·∑
i≥k
Ui) − Tk
(38)
From here, this estimation of Ak bound is goingto be used to estimate CΣ. This helps to reducesome pessimism.
4.3 A Detailed Study of MP (Ck)
As defined in the previous subsection, MP (Ck) rep-resents the maximum total computation time pro-vided by the time partition under investigation dur-ing any Ck out of Tk. This can be obtained by firstfinding all the time intervals in which schedulingwindows on different processors overlap. As all suchtime intervals repeat every P time units (which isthe length of the major time frame), it is sufficientto identify only those within a major time frame.
Each such time interval can be denoted as (γx, lx)where γx is the number of processors that overlap ininterval x (γx > 1) and lx is the length of intervalx. Sort all such intervals in descending order oftheir γx (and lx if some pairs have identical γx).Then, the top pair can be identified as (γ1, l1) andthe lower a pair is, the greater its identifier is. Forexample, γ3 ≥ γ4 and if γ3 = γ4, it must be truethat l3 ≥ l4.
t� P P P...........
T�t�
A time interval in which certain schedulingwindows overlap every P time units
Figure 9: Overlapped Scheduling Windows
As illustrated in figure 9, ⌊Tk
P⌋ represents the
maximum number of an overlapping interval’s com-plete 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 maximumtotal length of (γx, lx)’s instances within any Tk isgiven by ⌊Tk
P⌋lx + min{Tk mod P, lx}.
Then, MP (Ck) can be calculated according toAlgorithm 2.
0
0
0
10
10
10
5 72.5
2.5 4 6
1
Figure 10: An example to demonstrate how to ob-tain MP (Ck)
14
Initialize mpc = 0;Initialize cumulation = 0;Initialize sum of cumulation = 0;Initialize i = 1;
While sum of cumulation < Ck and there exists (γi, li)
{
cumulation = ⌊Tk
P⌋li + min{Tk mod P, li};
mpc = mpc + min{cumulation,
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
MP (Ck) = mpc;
else
/* when no overlapped intervals are left */
MP (Ck) = mpc + Ck − sum of cumulation;
Algorithm 2: Computing MP (Ck)
In the example illustrated in figure 10, there are3 time intervals when scheduling windows on dif-ferent processors overlap. After being ordered ac-cording to the above rule, these time intervals canbe identified as interval 1 (3, 1), interval 2 (2, 1.5)and interval 3 (2, 1). By using Algorithm 2, we canestimate MP (Ck) corresponding to the sub-serverSSk which has a period (Tk) of 20 and a budget(Ck)of 10.
For interval 1, cumulation = 2, mpc = 0 +2 · 3 = 6 and sum of cumulation = 2. Sincesum of cumulation is less than 10 (Ck) and thereexists interval 2, the algorithm continues with in-terval 2.
For interval 2, cumulation = 3, mpc = 6+3 ·2 =12 and sum of cumulation = 2 + 3 = 5. Sincesum of cumulation is less than 10 (Ck) and thereexists interval 3, the algorithm continues with in-terval 3.
For interval 3, cumulation = 2, mpc = 12 +2 · 2 = 16 and sum of cumulation = 5 + 2 = 7.Since sum of cumulation is less than 10 (Ck) andthere does not exist any more such intervals, thisMP (Ck) can be estimated as 16+10−7 = 19 whichmeans that this partitioning example can provideat most 19 time units computation time during any
time intervals within 20 time units which have atotal length of 10 time units.
Algorithm 2 has a complexity of O(n) where nrepresents the total number of separate time inter-vals in which certain scheduling windows overlap.However, all such time intervals must be sorted be-fore this algorithm can be used. Sorting such timeintervals has a complexity of O(n log n).
4.4 Analysis Implementation
In subsection 4.2, it has been concluded that a sub-server SSk is guaranteed to always meet its dead-line if inequality (24) holds for all possible valuesof Ak where the values of Ak satisfy inequality (38)and Ak ≥ 0. Consequently, analyzing any sub-server’s schedulability requires an investigation onall Ak values within its range as indicated above.It is not possible to implement such an analysis.
Based on equations (17) and (18), we observedthe term
∑i Inc(SSi) could only change when (x
is any integer):
Ak = x · Ti + Ci − Tk, i > k (39)
or when (x is any integer):
Ak = x · Ti, i = k (40)
We call all such discrete values of an Ak withinits whole range the effective values.
On the other hand, it is computationally veryexpensive to exhaust all the possible values of Ak
that may lead to the change of the second term ininequality (33)
∑the(ξ−1)largest IDIFF (SSi). How-
ever, because IDIFF (SSi) is always bounded byΘ(i) (see page 13), even the worst value of∑
the(ξ−1)largest IDIFF (SSi) is no more than CΣ
(see page 13), which has a constant bound. More-over, LSF (Ak + Tk)−MP (Ck) is a monotonicallynon-descreasing function. Hence, it is safe but morepessimistic to draw a new conclusion that a sub-server SSk is guaranteed to always meet its dead-line if the following inequality holds for all effectivevalues of Ak:
15
∑
i≥k
Inc(SSi) + CΣ ≤ LSF (Ak + Tk) − MP (Ck)
(41)
This revised analysis has been implemented atthe University of York. The experimental resultsshown in later sections are based on this implemen-tation.
5 Thread Schedulability
Analysis
As discussed in section 3, threads with real-timerequirements in our system are all released eithersporadically or periodically. Each of them mustbe bound to a server and can only be bound toone server at all times. A thread can run on anysub-server of its server which, in turn, can runon any processor allowed by the time partition towhich this thread and its server belong. In thissection, we present an approach to analyzing theschedulability of threads provided that all relevantsub-servers meet their deadlines. This is achievedby first obtaining the least supply function of theserver under investigation. Once this function hasbeen obtained, an analysis of the workload of allthe threads of that server can be performed in asimilar way as the one proposed in the previous sec-tion. Then, a similar schedulability condition canbe achieved. Due to the similarity between threadand server schedulability analysis, some results inthis section are presented without further explana-tion.
5.1 Least Supply Function of a
Server
This subsection proposes a way to find the mini-mum computation time a server can provide dur-ing a given time interval. First of all, terminologyintroduced in the previous section is extended toservers.
Definition 6 The supply function s(t) (ss(t)) of aserver (sub-server) is the total amount of timeprovided by that server (sub-server) from time0 to t.
Definition 7 The Least Supply Function lsf(t)(slsf(t)) of a server (sub-server) is the mini-mum of all its s(t+d)−s(d) (ss(t+d)−ss(d))where t is a time interval and t, d ≥ 0.
Definition 8 A least supply time interval of a server(sub-server) (u, u + v) is a time interval thatsatisfies (s(u+v)−s(u)) = lsf(v) ((ss(u+v)−ss(u)) = slsf(v)).
A possible [u, u + v) is given in figure 11. Forthe purpose of this analysis, we assume that all re-leases of the sub-server under discussion after u areexecuted as late as possible within their deadlines.Therefore, if t > 2(Ts − Cs), the number of com-plete instances of this sub-server within [u, u + v)
should be ⌊ t−2(Ts−Cs)Ts
⌋. Their contributions to the
least supply function are ⌊ t−2(Ts−Cs)Ts
⌋Cs. On theother hand, the contribution of the last release ismin{Cs, (t−2(Ts−Cs)) mod Ts}. Moreover, thefirst release contributes nothing to the least supplyfunction as u is the completion time of that release.Therefore,
slsf(t) = ⌊t − 2(Ts − Cs)
Ts
⌋Cs + min{Cs,
(t − 2(Ts − Cs)) mod Ts}
if t > 2(Ts − Cs) (42)
slsf(t) = 0 if t ≤ 2(Ts − Cs) (43)
Then, for each server, we can add up all its sub-server’s least supply functions to form its own.
With this algorithm, time required to estimatelsf(t), given a specific value of t, is linear in thetotal number of sub-servers of the server under in-vestigation.
5.2 Workload of Threads and
Schedulability Condition
This subsection generally follows the method intro-duced in subsection 4.2 to analyze the schedulabil-ity of any thread τk. Suppose that a release of thisthread is the first job of that thread to miss itsdeadline. This job is called a problem job and the
16
...........T� - C�
tu
T�T� - C�
u+v
The execution of subserver s
Cs
Figure 11: A possible least supply interval of a sub-server
time interval between the release time of the prob-lem job and its deadline [ta, td) is called a problem
window. Intuitively, ta = td − Dk where Dk repre-sents the relative deadline of τk.
After ignoring threads with lower priorities thanτk, suppose that t0 is the latest time instant ear-lier than ta at which, if the number of remainingthreads is less than currently available processors(constrained by server availability), at least onethread is not executing though enough resourcesare available. If the number of remaining threadsis more than available processors, suppose that t0is the latest time instant earlier than ta at which atleast one processor is idle even though it is avail-able for use according to the time partition configu-ration and the corresponding server’s budget avail-ability. Then let Ak = ta − t0.
Moreover, it is necessary to know the maximumtotal computation time provided by the server un-der investigation during any Ck out of Dk, which isdenoted as mp(Ck)(Ck and Dk are the worst-caseexecution time and deadline of thread τk respec-tively). For ease of presentation, we first considermp(Ck) as a parameter of each τk that is alreadyknown. A detailed study of mp(Ck) will be givenin subsection 5.3.
For each i such that k ≤ i ≤ n (n is the highestthread priority and the total number of threads ofthe server under discussion), let I(τi) denote the
contribution of τi to the total workload of threadsin this server during [t0, ta) ∪ ωk where ωk denotesthe intervals (not necessarily contiguous) duringwhich all processors allowed by time partitioningand server scheduling are executing jobs other thanthe problem job during [ta, td). Then, if for all pos-sible Ak,
∑i I(τi) ≤ lsf(Ak+Dk)−mp(Ck), thread
τk will be guaranteed to always meet its deadline.
Next, we will present how to derive I(τi) andtherefore
∑i I(τi).
Suppose that a job of τi arrives before t0 and hasnot completed execution by t0. Then, τi is said tohave a carry-in job with respect to the thread τk
under investigation. If a thread has no carry-in jobwith respect to τk, its contribution to τk’s
∑i I(τi)
will be denoted as Inc(τi). Otherwise, it will bedenoted as Ic(τi).
Computing Inc(τi)
The following equations which are similar to equa-tion (17) and (18), give Inc(τi):
Inc(τi) = min((⌊Ak + Dk − Ci
Ti
⌋ + 1)Ci
, Ak + Dk − Ck) if i > k (44)
Inc(τi) = min(⌊Ak
Ti
⌋Ci, Ak) if i = k (45)
Computing Ic(τi)
The following equations give Ic(τi):
Ic(τi) = min{(⌊Ak + Dk − Ci
Ti
⌋ + 1)Ci
+min(Ci, (Ak + Dk − Ci) mod Ti)
, Ak + Dk − Ck}
if i > k ∧ Ak + Dk ≥ Ci (46)
Ic(τi) = Ak + Dk −Ck if i > k∧Ak + Dk < Ci
(47)
17
Ic(τi) = min{⌊Ak
Ti
⌋Ci + min{Ci, Ak mod Ti}
, Ak} if i = k(48)
Computing∑
i I(τi)
First, we define IDIFF (τi) as the difference betweenIc(τi) and Inc(τi) with respect to the same τk andAk. Thus,
IDIFF (τi) = Ic(τi) − Inc(τi) (49)
According to the definition of t0, when there aremore threads than the maximum number of threadsof this server that could execute in parallel, thereare at most (Ψmax − 1) active threads at t0 whereΨmax is the maximum number of threads of thisserver that could execute in parallel. This is be-cause there is at least one processor that is idle att0 even though it is available for use according tothe time partition configuration and server schedul-ing. If more than (Ψmax − 1) threads are active atthat time, it will be guaranteed that all availableprocessor time at t0 will be used.
When there are fewer threads than available pro-cessors, there are at most (ς − 1) active threads att0 where ς is the total number of threads of theserver under discussion that have equal or higherpriorities than k. This is because there is at leastone thread that is idle at t0 even though there isenough resource. If all ς threads are active at thattime, all available resources will be used.
Based on this observation, we define ξ as thesmaller one of Ψmax and ς. Then, we can get:
∑
i≥k
I(τi) =∑
i≥k
Inc(τi) +∑
the(ξ−1)largest
IDIFF (τi)
(50)
Therefore, if the following inequality holds for allpossible Ak, thread τk will be guaranteed to alwaysmeet its deadline.
∑
i≥k
Inc(τi) +∑
the(ξ−1)largest
IDIFF (τi)
≤ lsf(Ak + Dk) − mp(Ck) (51)
Notice, τk is definitely unschedulable if lsf(Ak +Dk) < mp(Ck) which makes the right hand side ofinequality (51) negative.
Computing Ak
As defined in subsection 5.2, Ak is the length of theinterval [t0, ta) with respect to thread τk. There-fore, Ak ≥ 0.
Let’s define Cσ as the sum of the (ξ − 1) largestθ(i) (i ≥ k) of all threads of the current serverwhere θ(i) is defined as:
θ(i) = min(Ci, Ak + Dk − Ck) i ≥ k (52)
Because∑
the(ξ−1)largest IDIFF (τi) ≤ Cσ, weget:
lsf(Ak + Dk) − Ak
∑
i≥k
Ui < Dk
∑
i≥k
Ui
+∑
i≥k
(Ti − Ci)Ui + Cσ + mp(Ck) (53)
where Ui = Ci
Tiis the utilization of thread τi.
For any Ak ≥ 0 that violates inequality (53), itmakes
∑i I(τi) definitely no higher than lsf(Ak +
Dk) − mp(Ck). Therefore, it is only required tocheck those Ak ≥ 0 that satisfy inequality (53).Solving inequality 53 can be done according to thesame approach as presented on page 14.
5.3 A Detailed Study of mp(Ck)
In the previous subsection, we defined mp(Ck) asthe maximum total computation time provided bythe server under investigation during any Ck out ofDk where Ck and Dk denotes the worst-case exe-cution time and deadline of thread τk respectively.Since a server, in this report, is merely a conceptualcontainer of sub-servers which are the real schedul-ing entities, mp(Ck) can also be interpreted as the
18
maximum total computation time provided by allthe sub-servers of the concerned server during anyCk out of Dk.
It has been observed that each sub-server’s con-tribution to the total computation time within anyDk is upper bounded by ⌊Dk
Ts
⌋ ·Cs + min{Cs, Dk −
⌊Dk
Ts⌋ · Ts} where Ts and Cs denotes the period
and budget of sub-server SSs respectively. LetCNs = ⌊Dk
Ts
⌋ ·Cs +min{Cs, Dk −⌊Dk
Ts
⌋ ·Ts}. Then,we can sort all relevant sub-servers in ascending or-der of their CNs. The top sub-server can be iden-tified as sub-server 1 which has the least CNs. Thelower 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 themaximum length of their parallel execution timecomposed of exactly x sub-servers is upper boundedby the least CNs among them. For example, threesub-servers 1, 2 and 3 can run in parallel for at mostCN1 given that they have been sorted according tothe above requirement.
It should also be noted that the maximum num-ber of scheduling windows of the server’s time par-tition that can run in parallel (denoted as γmax)may be less than the total number of sub-servers ofthe concerned server (denoted as h) and thereforemay put further restrictions on the parallelism ofsub-server execution (The smaller one of γmax andh is Ψmax). Hence, the analysis of mp(Ck) is madein two different scenarios.
When γmax ≥ h
In this case, the maximum number of sub-serversthat can run in parallel is only limited by thesub-servers themselves. However, mp(Ck) is up-per bounded by M̂P (Ck) which denotes the maxi-mum total computation time provided by the timepartition under investigation during any Ck out ofDk where Ck and Dk are the worst-case executiontime and deadline of thread τk respectively. NoticeM̂P (Ck) can be obtained according to the algo-rithm presented in subsection 4.3 as well. There-fore,
Sub-server CNs Identifier
(1, 5) 3 1(2, 6) 5 3(1, 6) 3 2(3, 10) 6 4
Table 1: CNs and identifier of each sub-server
mp(Ck) = min{∑
s
min{CNs, Ck}, M̂P (Ck)}
(54)
In this case, sorting all the CNs is not necessaryas ordering information of CNss is not used. Thus,estimating the mp(Ck) of a specific thread τk in thiscase has a complexity of O(n) where n representsthe total number of sub-servers of the server underinvestigation.
When γmax < h
This is a more complicated situation where at mostγmax sub-servers under discussion can execute inparallel at any time whilst other sub-servers haveto wait. In order to get mp(Ck), Algorithm 3 hasbeen developed to search for the combination ofsub-server executions that has the maximum par-allelism during Ck.
Moreover, mp(Ck) is still upper bounded byM̂P (Ck) because a server cannot provide morecomputation time than its time partition. Hence,mp(Ck) can be represented as:
mp(Ck) = min{total, M̂P(Ck)} (55)
where total is the result of Algorithm 3.
Let’s consider a time partition in which γmax = 3and an abstract server in that time partition whichhas 4 sub-servers. These sub-servers, representedas such pairs of parameters (Cs, Ts), are (1, 5), (2,6), (1, 6) and (3, 10). By using Algorithm 3, wecan estimate mp(Ck) corresponding to the threadτk which has a relative deadline (Dk) of 13 and aworst-case execution time (Ck) of 5.
First of all, we need to obtain the initial CNs ofeach sub-server, which is the maximum computa-
19
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 serverunder discussion{
Sort all relevant sub-servers in ascending orderof their CNs;
if the length of the sorted list of sub-servers is lessthan γmax
Choose all remaining sub-servers from thesorted list;
elseChoose the last γmax sub-servers from thesorted list;
Let CN denote the least CNs of the chosensub-servers;Let num denote the number of chosen sub-servers;if length + CN ≥ Ck
{total = total + (Ck − length)num;Break the loop;
}
total = total + CN · num;
length = length + CN ;
for each chosen sub-server s
CNs = CNs − CN ;
Remove any sub-server with a zero CNs;
}
Output total as the result of this algorithm;
Algorithm 3: Searching for the combination of
sub-server executions that has the maximum par-
allelism during Ck
Then, all the sub-servers are ordered in ascendingorder of their CNs. An identifier can be given toeach of those sub-servers subsequently. The resultsare also given in table 1.
Since γmax is less than the number of sub-serversin this case, the last 3 sub-servers in the sortedlist are chosen. The least CNs among those of thechosen sub-servers is CN2 = 3. Therefore, total =0 + 3 · 3 = 9 and length = 0 + 3 = 3.
After updating the CNs of the chosen sub-servers, the CNs of sub-server (1, 6) becomes zeroand therefore it is ignored. This leaves sub-server
(1, 5) which has a CNs of 3, sub-server (2, 6) whichhas a CNs of 2 and sub-server (3, 10) which has aCNs of 3. All the remaining sub-servers must bereordered according to their CNs. This reorderingalso gives each sub-server a new identifier.
The least CNs among those of the remaining 3sub-servers is CN1 = 2. Since the sum of lengthand the current least CNs is the same as Ck = 5,total = 9 + 2 · 3 = 15 gives the result.
Algorithm 3 has a complexity of O(n2 log n)where n represents the total number of sub-serversof the server under investigation.
5.4 Analysis Implementation
Due to the same reason as presented in subsection4.4, it is safe but more pessimistic to draw a conclu-sion that a thread τk is guaranteed to always meetits deadline if the following inequality holds for alleffective values of Ak:
∑
i≥k
Inc(τi) + Cσ ≤ lsf(Ak + Tk) − mp(Ck) (56)
where the effective values of Ak are those thatsatisfy:
Ak ≥ 0 (57)
and,
lsf(Ak + Dk) − Ak
∑
i≥k
Ui < Dk
∑
i≥k
Ui
+∑
i≥k
(Ti − Ci)Ui + Cσ + mp(Ck) (58)
and (x is any integer)
Ak = x · Ti + Ci − Dk, i > k
Ak = x · Ti, i = k (59)
6 Empirical Evaluation
In order to better understand the proposed schedu-lability analysis, a series of experiments were con-
20
ducted. This section depicts our methodology andsome initial results obtained from these experi-ments. Although the proposed analysis concernsboth sub-servers and threads, the experiments pre-sented in this section were conducted on sub-serversonly. More experiments are planned as part of ourfuture work.
6.1 Methodology
In order to observe the behaviour of the proposedanalysis in different circumstances, our experimentswere conducted on randomly generated sub-serversets with very different features specified. Suchfeatures include priority assignment policy, totalutilization, maximum period/minimum period andthe number of sub-servers in each set.
As can be seen shortly, priority assignment pol-icy has a great impact on the schedulability of sub-server sets in virtually all cases. The policies wetested include rate monotonic (also deadline mono-tonic, since deadline equals period), (T −C) mono-tonic (the higher the (Ti −Ci), the lower the prior-ity) and utilization monotonic (the higher the uti-lization, the lower the priority). However, due tothe poor performance of utilization monotonic pol-icy, only the first two policies are compared in thisreport.
Moreover, the total utilization of our sub-serversets ranges between 0 and the utilization of theirtime partitions. Other features vary from test totest as well.
For each experiment, we randomly generate20000 sub-server sets for each configuration (includ-ing all the above features) and record the number ofthese sub-server sets that pass the proposed anal-ysis. Notice that we have no way of knowing howmany sub-server sets are indeed schedulable. Thefigures from our experiments only show the numberof schedulable sub-server sets that can be identifiedby our analysis.
The method we used to generate random sub-servers is standard. Periods were generated witha uniform distribution between the specified max-imum/minimum values. Utilization of each sub-server was also generated with a uniform distribu-tion in the range of (0, 1]. However, the total uti-lization of a sub-server set must be the same as
specified.
Also, we used three typical configurations for thetime partitions we used to accommodate sub-serversets. With the first configuration, the schedul-ing windows of our time partition are never ac-tive on different processors simultaneously. Withthe second configuration, the scheduling windowsof our time partition are never active alone. Thethird configuration gives a more general time par-tition scheme where no restrictions are put on thescheduling windows.
6.2 Impacts of Different Features
Priority Assignment Policy
The goal of this experiment is not to find the op-timal priority assignment policy for the proposedscheduling algorithm. Instead, we are interested incomparing some simple priority assignment policiesto find out which one of them is generally better.This experiment includes all three time partitionconfigurations with total utilization of 0.8 (con-figuration 1), 4.5 (configuration 2) and 4.5 (con-figuration 3) respectively. All of them have thesame major time frame length, which is 500 timeunits. For each time partition configuration, theminimum/maximum sub-server period is specifiedto 200/25000 (some periods are shorter than themajor time frame) or 1000/25000 (all periods arelonger than the major time frame).
Figures 12 to 17 in Appendix depict the num-ber of schedulable sub-server sets identified by ouranalysis in all the above circumstances. Data foreach curve are obtained from the sub-server setsthat have the same number of sub-servers and arescheduled according to the same priority assign-ment policy. The only difference is their total uti-lization. All the curves are represented by “pol-icy, number” where “policy” is the priority assign-ment policy and “number” is the number of sub-servers in each sub-server set. For example, “RM,30” means all the concerned sub-server sets have30 sub-servers and their priority assignment policyis rate monotonic.
In order to make the presentation clearer, we alsohighlighted the range of data that changes most infigures 18 to 23 in Appendix. As can be seen in
21
figures 12, 13, 18 and 19, the best results in bothcases are obtained when rate monotonic assignmentis applied. However, in all other figures, it is the(T − C) monotonic (the higher the (Ti − Ci), thelower the priority) assignment policy that gives thebest results. We believe this is because MP (Ck)s ofsub-servers in time partition configuration 2 and 3are much larger and therefore have a bigger impacton inequality 24 on page 12.
On the other hand, one may have noticed thatthe number of sub-servers in each sub-server setcan also influence the schedulability of sub-serversets. Next, we study the impacts of the number ofsub-servers on the schedulability of sub-server sets.
Sub-server Number
The time partitions used in this experiment arethe same as those used in the previous experi-ment. Sub-server sets with different number ofsub-servers, two different period ranges (“200 /25000” and “1000/ 25000”) and different total uti-lization are tested for each time partition config-uration. The priorities of sub-servers under timepartition configuration 1 are assigned according torate monotonic policy. In all other cases, the priori-ties of sub-servers are assigned according to (T−C)monotonic policy.
As in figure 24 and 25 in Appendix, the successrate of sub-server sets with the same total utiliza-tion does not always increase or decrease while thenumber of sub-servers increases. In this specific ex-periment, the sub-server set success rate always de-creases until the number of sub-servers reaches 25.After that, the success rate first increases and thendecreases and then repeat the same pattern. Onthe other hand, under time partition configuration2 and 3, the success rate of sub-server sets with thesame total utilization usually improves (with onlya few exceptions) when the number of sub-serversis increased.
As presented in this section, our analysis showsvery different features when it is used with non-parallel and parallel time partitions. Rate mono-tonic policy outperforms (T −C) monotonic policyin non-parallel configurations. However, (T − C)monotonic policy outperforms rate monotonic pol-icy in parallel configurations. Moreover, in the non-
parallel configurations, we can not expect that asub-server set with more sub-servers are more likelyto be schedulable than another sub-server set withfewer sub-servers but the same total utilization.On the other hand, we can assume that the suc-cess rate of sub-server sets generally increases alongwith their sub-server number when they are underparallel configurations and have the same utiliza-tion.
7 Related Work
Muticore/multiprocessor real-time scheduling hasdrawn great attention during the last decade.Many algorithms and schedulability analyses havebeen proposed. A survey by Capenter et al. sum-marized many of those algorithms and schedula-bility analyses techniques [10]. A very clear cat-egorization of those algorithms was also presentedalong with detailed comparisons between each classof algorithms. A main conclusion of that survey isthat some of the algorithms are incomparable interms of schedulability. For example, there existtask sets that can be scheduled under the globalfixed priority pre-emptive scheduling algorithm, yetcannot be scheduled under the partitioned fixedpriority pre-emptive scheduling algorithm and viceversa.
Baruah also noticed that certain types of globaland fully partitioned algorithms are incomparable[3, 5]. He has also proposed a schedulability analy-sis for multiprocessor systems scheduled under theglobal EDF algorithm. In his approach, it is as-sumed that a release of the thread under investi-gation misses its deadline and that there is a timeinstant before that release when at least one pro-cessor is idle. The workload of all the threads thatcould be scheduled to execute between that pro-cessor idle point and the missed deadline shouldbe at least higher than the minimum computationtime provided during the same time interval in or-der for the thread under investigation to possiblymiss its deadline. If such conditions can never besatisfied, the schedulability of the thread under in-vestigation will be ensured. The fundamental tech-nique used was first introduced by Baker in 2003[4], who covered both global EDF and fixed prior-ity scheduling. An alternative sufficient test based
22
on the same technique was proposed by Bertognaet al. [7].
Shin et al. extended a global EDF algorithm andits schedulability analysis to support multiproces-sor periodic resources which are essentially execu-tion time servers [19]. In order to provide com-positional real-time guarantees, they proposed theleast supply function of their resource model whichgives lower bounds to the amount of resource sup-ply that the model provides in a given time interval[19]. Based on such input, threads within differentmultiprocessor periodic resources can be analyzedindependently according to Baruah’s analysis [5].Moreover, each multiprocessor periodic resource istransformed to several conceptual periodic threadsso that Baruah’s analysis can also be used uponthem to make sure that all periodic resources them-selves are schedulable.
The research done by Shin et al. differs fromthat presented in this report. First of all, the mul-tiprocessor periodic resource model does not takeresource partitioning into consideration. Secondly,every server (multiprocessor periodic resource) isassumed, in [19], to have only one budget whichcan be consumed on different processors simul-taneously. This makes budget monitoring muchmore complex in real implementations. Moreover,the scheduling algorithm adopted in this report isglobal fixed priority scheduling rather than globalEDF.
Brandenburg and Anderson also proposed toschedule servers (along with their threads) on mul-tiprocessors with a variant of a global EDF schedul-ing algorithm [8]. In such a system, some serverscalled hard real-time servers are fixed on certainprocessors and can never migrate. On the otherhand, there exists best effort servers which can mi-grate across certain processors. However, a serveris not allowed to run in parallel in this algorithm.Moreover, this work does not provide hard real-time guarantees to threads running within best ef-fort servers.
8 Conclusions
In this report, we have proposed a component-based multicore/multiprocessor real-time system
which utilizes resource partitions and executiontime servers to support service contracts at twodifferent levels. In order to support parallel ex-ecution of an individual server without introduc-ing too much implementation complexity, we pro-posed the use of sub-servers, the budget of eachof which is maintained separately and can be con-sumed in parallel. More importantly, we developeda schedulability analysis for such a system, whichforms the basis of service contract negotiation ofthis model and the foundation of the tools that fa-cilitate software development in such environments.A very important step of this analysis is identify-ing the least supply function of a time partition onmulticores or multiprocessors. It has been proventhat our approach to identifying such least sup-ply functions is correct and optimal. We also ex-tended Baruah’s analysis [5] to global fixed priorityscheduling and consider the constraints caused byresource partitioning and server execution (whenstudying server schedulability and thread schedu-lability respectively).
Currently, we assume that all the threads, ap-plication components and applications execute in-dependently. This simplified the proposed analysisthough it is likely to be unacceptable in real andcomplete implementations. Therefore, future re-search will include the investigation of the impactsof communication and synchronization on the pro-posed analysis. Furthermore, this report does notspecify the exact content of service contracts andhow negotiation generates time partition schedul-ing schemes and sub-server parameters. Our futurework will utilize results from this report to addressthe above issue. Moreover, case studies and simu-lations will also be planned.
Acknowledgements
The authors of this report would like to thank theJEOPARD and eMuCo project partners for theircontributions to this report. In particular, we aregrateful to Jose Almeida for helping us understandthe current PikeOS operating system and its mul-tiprocessor version which is in development. Wewould also like to thank Professor Alan Burns forhis comments and suggestions.
23
References
[1] B. Andersson, S. Baruah, and J. Jonsson. Static-priority scheduling on multiprocessors. In Proceed-
ings of the 22nd IEEE Real-time Systems Synm-
posium, pages 193–202, 2001.[2] ARINC. Avionics application software standard
[3] T. Baker and S. Baruah. Schedulability analysisof multiprocessor sporadic task systems. TechnicalReport TR-060601, The Florida State University,2007.
[4] T. P. Baker. Multiprocessor EDF and deadlinemonotonic schedulability analysis. In Proceedings
of the 24th IEEE Real-time Systems Symposium,pages 120–129, 2003.
[5] S. Baruah. Techniques for multiprocessor globalschedulability 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, andD. A. Varvel. Proportionate progress: A notionof fairness in resource allocation. Algorithmica,15:600–625, 1996.
[7] M. Bertogna, M. Cirinei, and G. Lipari. Newschedulability tests for real-time task sets sched-uled by deadline monotonic on multiprocessors. InProc. 9th International Conference on Principles
of Distributed Systems, 2005.[8] B. B. Brandenburg and J. H. Anderson. Inte-
grating hard/soft real-time tasks and best-effortjobs on multiprocessors. In Proceedings of the 19th
Euromicro conference on real-time systems, pages61–70, 2007.
[9] A. Burchard, J. Liebeherr, Y. Oh, and S. Son. As-signing real-time tasks to homogeneous multipro-cessor systems. IEEE Transactions on Computers,44(12):1429–1442, 1995.
[10] J. Carpenter, S. Funk, P. Holman, A. Srini-vasan, J. Anderson, and S. Baruah. Acategorization of real-time multiprocessorscheduling problems and algorithms. In Hand-
[11] S. Davari and S. Dhall. An on-line algorithm forreal-time tasks allocation. In Proceedings of the
7th IEEE Real-time Systems Symposium, pages194–200, 1986.
[12] R. I. Davis and A. Burns. Hierarchical fixed pri-ority preemptive scheduling. In Proceedings of the
26th IEEE Real-time Systems Symposium, pages389–398, 2005.
[13] Z. Deng and J. Liu. Scheduling real-time applica-tions in open environment. In Proceedings of the
18th IEEE Real-time Systems Symposium, pages308–319, 1997.
[14] M. G. Harbour. Architecture and con-tract model for processors and networks.Technical Report DAC1, Universidadde Cantabria (Frescor Project), 2006.http://www.frescor.org/index.php?page=publications.
[15] R. Kaiser. Combining partitioning andvirtualization for safety-critical systems.Technical Report White Paper, SYSGOAG, 2007. http://www.sysgo.com/news-events/whitepapers/.
[16] S. Lauzac, R. Melhem, and D. Mosse. Compari-son of global and partitioning schemes for schedul-ing rate monotonic tasks on a multiprocessor. InProc. of the EuroMicro Workshop on Real-Time
Systems, pages 188–195, 1998.[17] J. P. Lehoczky, L. Sha, and J. K. Strosnider. En-
hanced aperiodic responsiveness in a hard real-time environment. In Proceedings of the IEEE
Real-Time Systems Symposium, pages 261–270,1987.
[18] A. K. Mok, X. Feng, and D. Chen. Resource par-tition 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 mul-tiprocessors. In Proceedings of the 20th Euromicro
conference on real-time systems, pages 181–190,2008.
[20] A. Srinivasan and S. Baruah. Deadline-basedscheduling of periodic task systems on multipro-cessors. Information Processing Letters, 84(2):93–98, 2002.
[21] J. Strosnider, J. Lehoczky, and L. Sha. The de-ferrable server algorithm for enhanced aperiodicresponsiveness in hard real-time environments.IEEE Transactions on Computers, 44(1):73–91,1995.
Appendix
24
0
10
20
30
40
50
60
70
80
90
100
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 10RM, 10T-C, 20RM, 20
Figure 12: Schedulability of sub-server sets withtime partition configuration 1 and “200 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 10RM, 10T-C, 20RM, 20
Figure 13: Schedulability of sub-server sets withtime partition configuration 1 and “1000 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 20RM, 20T-C, 30RM, 30
Figure 14: Schedulability of sub-server sets withtime partition configuration 2 and “200 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 20RM, 20T-C, 30RM, 30
Figure 15: Schedulability of sub-server sets withtime partition configuration 2 and “1000 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 20RM, 20T-C, 30RM, 30
Figure 16: Schedulability of sub-server sets withtime partition configuration 3 and “200 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 20RM, 20T-C, 30RM, 30
Figure 17: Schedulability of sub-server sets withtime partition configuration 3 and “1000 / 25000”period range
25
0
10
20
30
40
50
60
70
80
90
100
0.55 0.6 0.65 0.7 0.75 0.8
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 10RM, 10T-C, 20RM, 20
Figure 18: Schedulability of sub-server sets withtime partition configuration 1 and “200 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
0.5 0.55 0.6 0.65 0.7 0.75 0.8
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 10RM, 10T-C, 20RM, 20
Figure 19: Schedulability of sub-server sets withtime partition configuration 1 and “1000 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
1 1.25 1.5 1.75 2 2.25 2.5 2.75 3
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 20RM, 20T-C, 30RM, 30
Figure 20: Schedulability of sub-server sets withtime partition configuration 2 and “200 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
1.25 1.5 1.75 2 2.25 2.5 2.75
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 20RM, 20T-C, 30RM, 30
Figure 21: Schedulability of sub-server sets withtime partition configuration 2 and “1000 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
1.5 1.75 2 2.25 2.5 2.75 3 3.25 3.5
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 20RM, 20T-C, 30RM, 30
Figure 22: Schedulability of sub-server sets withtime partition configuration 3 and “200 / 25000”period range
0
10
20
30
40
50
60
70
80
90
100
1.5 1.75 2 2.25 2.5 2.75 3 3.25 3.5
Succ
ess
rate
(%)
Sub-server set utilization
T-C, 20RM, 20T-C, 30RM, 30
Figure 23: Schedulability of sub-server sets withtime partition configuration 3 and “1000 / 25000”period range
