The Adaptable Sporadic Task Model, Revisted

In this section, we incorporate the notions of guaranteed and desired weights into the adapt- able sporadic task model that was presented in Section 3.1. It is important to note that, unless otherwise specified, all references to the adaptable sporadic task model in this chap- ter are to the task model presented in this section. We begin our discussion by formally defining when a task changes its weight. A task Ti changes its desired weight at time t if Dwt(Ti, t−ǫ)6=Dwt(Ti, t) whereǫ→0+. Similarly, a task,Ti,changes its guaranteed weight

at timetifGwt(Ti, t−ǫ)=6 Gwt(Ti, t) where ǫ→0+.

Notice that, since we are attempting to minimize MROE, by (4.2), the guaranteed weight for every task on an over-utilized processor is a function of its desired weight and the desired weight of every other task assigned to the same processor. As a result, when a task, Ti,

changes its desired weight at time t, the guaranteed weight for Ti and for every other task

assigned to same processor may change.

Additionally, different actions may occur depending on whether the desired or guaranteed weight of a task changes. Specifically, if a task,Ti, changes its desired weight at timetc when

a jobT_ij is active, then the following two actions may occur.

• The execution time of T_ij may be reduced to the amount of time for which T_ij has executed prior totc, and the execution time ofTij+1may be redefined to be the amount

of time “lost” by reducing the execution time ofT_ij.

• r(T_ij+1) may be redefined to be less than d(T_ij), which would cause jobs T_ij and T_ij+1 to “overlap.”

If the guaranteed weightbut not the desired weight of a task changes, then the following two actions may occur

• The deadline of T_ij may be changed.

• The release time ofT_ij+1 (if it exists) may be changed.

Scheduling weights. Just as with the adaptable sporadic task model presented in Sec- tion 3.1, there can be a difference between when a desired weight change is initiated and when it is enacted. We use the desired scheduling weight of a task Ti at time t, denoted SDwt(Ti, t), to represent the “last enacted desired weight ofTi.” Formally,SDwt(Ti, t) equals Dwt(Ti, u), whereu is the last time at or beforetthat a weight change was enacted forTi. It

is important to note that we use the desired scheduling weight of a task to compute theguar- anteed scheduling weight of a task, denoted SGwt(Ti, t). In turn, the guaranteed scheduling

weight is used to compute the deadlines and releases of tasks.

Formally, the guaranteed scheduling weight of Ti that is assigned to the processor P[q] at timetis SGwt(Ti, t) = SDwt(Ti, t) TS(P_[q], t), (4.5) where TS(P[q], t) =max  1, X Ti∈ASSN(P[q],t) SDwt(Ti, t)   (4.6)

Notice that, by (4.5), the sum of the guaranteed scheduling weights of all active tasks assigned to a processor is at most one, which is formalized by the following property

(W) For any processor P_[q] and any timet,P

Tij∈ASSN(P[q],t)SGwt(Ti, t)≤1.

Because the rules for changing the guaranteed weight of a task are simpler than changing its desired weight, it is possible to integrate them directly into the definition of a job’s release and deadline. To do so, we introduce the notion of a perceived deadline of T_ij at time t, denotedd(T_ij, t), which represents what the deadline of T_ij would be if its guaranteed weight did not change. As a shorthand, we use d(T_ij) to denote the time u such that u=d(T_ij, u). (d(T_ij) represents the actual deadline of the job, but it cannot be determined until it is reached

(see the example below). Formally, we defined(T_ij, t) as, d(T_ij, t) =      t+ Irem(T j i,t) SGwt(Ti,t), ifSGwt(Ti, t)>0 ∞, otherwise. (4.7) where Irem(T_ij, t) =      e(T_ij), if t <r(T_ij) e(T_ij)₋Rt r(T_ij)SGwt(Ti, u)du, otherwise. (4.8)

Additionally, we definer(T_ij) as,

r(T_ij) =θ(T_ij), j = 1 (4.9)

r(T_ij) =d(T_ij−1) +θ(T_ij), j >1, (4.10)

where θ(T_ij) _≥0. Notice that, if for some job T_ij and t > r(T_ij), SGwt(Ti, t) = 0, then it is

possible thatd(T_ij) cannot be reached sinced(T_ij, t) =_∞. The scenario whereSGwt(Ti, t) = 0

is a special case that is used to representTi leaving the system. Thus, onceSGwt(Ti, t) = 0

holds,Ticannot release any more jobs and is no longer allocated any capacity in any schedule.

As a result, if d(T_ij, t) = _∞, then we set d(T_ij) as _∞. Notice that all other terms of Ti are

still well-defined since the only other term that is defined usingd(T_ij) is r(T_ij+1); however, if

d(T_ij) =_∞, thenT_ij+1 does not exist.

From the definition of d(T_ij, t) in (4.7) it is not hard to see that the following property holds.

(D) For any two times u1 and u2 such that r(T_ij) ≤u1 ≤ u2 ≤ d(T_ij), R_uu₁2SGwt(Ti, t)dt ≤ e(T_ij).

Notice that, since for t _∈ [r(T_ij), d(T_ij)), Rt

r(T_ij)SGwt(Ti, u) ≤ e(T

j

i), by (4.8), it follows

that for any timet

Irem(T_ij, t)_≤e(T_ij)_≤emax(Ti) (4.11)

It is important to note that the PEDF and NP-PEDF scheduling algorithms discussed in this chapterprioritize jobs based on their perceived deadlines; however, even though jobs are

prioritized based on their perceived deadlines, the relative scheduling priority between any two jobs is time invariant. Specifically, it two jobs, T_ij and T_ab, are assigned to the same processor and at some time t1 ≥ max(r(T_ij),r(Tab)), d(Tij, t1) < d(Tab, t1) holds, then at any timet_≥max(r(T_ij),r(T_ab)),d(T_ij, t)<d(T_ab, t) holds. Intuitively, the reason for this behavior is that the deadlines for both jobs always scale by the same factor, i.e., _TS(P1

[q],t). Also, when

the desired weight of a task changes, the relative scheduling priority between any two released jobs of any two tasks is unchanged. (When task’s desired weight is changed, it is possible that the current job may halt and release a new job with a higher or lower scheduling priority. Such an action would change the relative scheduling priority between two tasks but not between the jobs themselves because the original job was halted.)

Example (Figure 4.2). Consider the example in Figure 4.2, which depicts a processor that is assigned four tasks: T1, which has e(T1) = 3 and Dwt(T1) = 2/5; T2, which hase(T2) = 2 andDwt(T2) = 1/3;T3, which hase(T3) = 1 andDwt(T3) = 1/3; andT4, which has e(T4) = 4 and Dwt(T4) = 4/15. The total desired weight is 4₃. T41’s perceived deadline is shown above each inset. Inset (a) depicts the scenario whereT1 never leaves. Inset (b) depicts the scenario whereT1leaves at time 10 causing the processor to be under-utilized. Notice that, in inset (b), T₄1’s perceived deadline changes when T1 leaves (at time 10) from 20 to 18.¯3 because T41’s guaranteed scheduling weight changes. This differs from inset (a), in which T₄1’s guaranteed scheduling weight does not change, and as a result,T₄1’s perceived deadline remains constant. One final note: while, in inset (a),d(T₄1) = 20, and in inset (b),d(T₄1) = 18.¯3, neither of these values are known until these corresponding points in time are reached.

Because the reweighting rules may cause r(T_ij+1) < d(T_ij), we must slightly modify the definition of “window,” “active,” and “inactive” presented in Section 1.2.

Definition 4.1(Window, Active, and Inactive). IfT_ij is a job in the adaptable sporadic task system, T, then the window of T_ij is defined as the range [r(T_ij),min(d(T_ij),r(T_ij+1))).

Furthermore, the job T_ij is active at time t iff t is in T_ij’s window (i.e., t _∈

Job deadline 1 T 4 d(T ,t)4 20 20 20 20 20 20 20 20 20 20 Time (a) Scheduled T 1 T 4 Time (b) 20 20 20 T T 2 3 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 18.3 18.3 18.3 18.3 18.3 18.3 18.3 18.3 18.3 18.3 20 20 20 20 20 20 20 20 20 20 d(T ,t)₄1 1 Job released T T T 2 3 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 20 20 20 20 20 20 20 20

Figure 4.2: A one-processor system with four tasks. (a) T1 never leaves. (b) T1 leaves at time 10. The perceived deadline for T₄1 is shown above each figure.