Lecture Notes for 10/24/01

Embedded Software Architecture

Definitions

1. Let T be a set of run-to-completion tasks {T₁,…,T_n}

2. Let C be a set of conditions {C₁,…,C_n}

3. Ti is runnable if C_i is true.

4. Execution of Ti makes C_i false (at the beginning of execution).

5. Worst Case Latency, L_i, is the longest time from assertion of C_i to initiation of T_i.

6. R_i is the worst case run time of T_i assuming no interruptions.

6. The deadline, D_i, is the longest allowable time from assertion of Ci to completion of Ti completes (for each instance of C_i becoming true).

7. A Scheduler determines which runnable task gets to run and for how long. The objective of a real time scheduler is to ensure that all deadlines are satisfied.

8. A system is “schedulable” if the chosen scheduling algorithm guarantees that all of the deadlines are always satisfied.

Examples

Round Robin Scheduling

while (1) {

if (C₁) T₁();

if (C₂) T₂();

…
if (C_n) T_n();

}

in this case:

L_i = S_j¹i (R_j) at worst, T_i must wait for all other tasks to run at most once.

The deadlines are satisfied if

"i D_i ³ L_i + R_i = S_iR_i

Note : "ij min Di = min Dj !!

One long running task can prevent all others from meeting their deadlines.

assuming that "_j¹i, C_j = false, and that no other tasks are running:
L_i µ n which is not very good if a very high speed response is needed.

Alternative Extreme: Purely Interrupt Driven. This is equivalent to a priority based scheduling algorithm with no task preemption (no task can interrupt a running task). This scheduling algorithm is consistent with how most microprocessors handle multiple interrupt sources. After execution of an interrupt routine all the highest priority pending interrupt is handled first. It is not first come first serve.

Let T_i have a higher priority than T_j if i>j.

In general, if we know nothing about the frequency of interrupts at each priority level, we have to conclude that:

L_i = ¥ for all but T_n. and L_n = max(R_j).
A frequent high priority task can starve all other lower priority tasks.

Since this is not a useful system, lets make the following assumption:

"i, 1/F_i > S_jR_j where f_i is the frequency at which T_i becomes runnable. If the period of interrupts for any task is greater than the sum of the run times for all tasks, then we can find an upper bound on latency for each task. This constraint prevents starvation but does not guarantee satisfaction of deadlines.

Given this assumption, here is the schedulability analysis for this scenario:

L_i = R_max +S_j>i R_j this means that T_i only has to wait for the longest task of any priority plus each of the higher priority tasks to execute at most once before it gets a chance to execute. This is a slight improvement over the round robin algorithm.

Since T_i cannot be interrupted, the deadline constraint is:

"i, D_i ³ L_i + R_i same as in the round robin case since neither allows preemption, so

"i, D_i ³ R_max +S_j³i R_j

We still have not solved the problem of one bad (even low priority) apple preventing all others from meeting their deadlines. This is why even low priority interrupts must be short!

A Hybrid Approach (that matches what you are building in lab)

We now consider a hybrid architecture. Divide each task T_i into top and bottom halves.

Let a top half task be T_i an a bottom half task be t_i. Also, let the condition for T_i be C_i and the condition for t_i be c_i, and so on.

The top half tasks are the critical time sensitive tasks. We will use non-preemptive priority scheduling for these tasks. The lower priority bottom halves will use preemptive round robin scheduling. Any bottom half can be preempted (interrupted) by any top half.

The code for a top half looks like this:

void T_i() {

C_i = false;
<execute task>

if (necessary) c_i = true;
}

The schedulability analysis for the top half is the same as for the pure priority scheduling algorithm presented above because the existence of the bottom half routines has no effect on the schedulability of the top half routines, so

L_i = R_max + S_j>i R_j

"i, D_i ³ R_max +S_j³i R_j

Homework 5 solution:

In the original HW5, c_i was asserted every time Ti was executed. In the worst case, all T_i are running at their maximum frequency (minimum period). The problem is easy to solve if we make the assumption that "_i, P_i ³ S_i R_i+S_i r_i

Let P = S_i R_i+S_i r_i

Assuming that c_i is asserted at the end of T_i, the minimum guaranteed deadline for bottom half tasks is

d_i = P – (the best case time to completion for T_i)

The best case time to completion for T_i is when L_i = 0, thus we get

d_i ³ (P – R_i) = (S _j¹i R_j)+S_i r_i

Note that this is not a proof, just a conjecture.

It can be proved by induction:

Base Case: n = 1;

The min period of R₁ is R₁+r₁, so t₁ will get to complete once before c₁ can be asserted twice.

Inductive Step:

Assuming true for n = i, prove that it is true for n = i+1.

Left as an exercise for the reader. The key is to use the inductive assumption to claim that, without task T_i+1, for any x, r_x gets to complete before c_x can be asserted twice. Then show that this condition holds when T_i+1 is added to back to the system.

More general case in which c_i is not asserted every time T_i is executed:

The latency for the bottom half follows round robin so we can start with:

"i d_i ³ l_i + r_i = S_i r_i

Except that the bottom half tasks are interruptible by top half tasks. To account for this affect, we can divide the total time required to run the bottom half by the available computing resource. The available computing resource is 100% minus the utilization of the top half.

Here is the more complex schedulability analysis that arises if we drop the assumption that bottom half and top half tasks are run at the same frequency (it also drops the 1-1 mapping between top half and bottom half tasks):

Let U(x,y) be the utilization of the CPU by the top half over a period of time starting at time x and ending at time y.

Let c_i becomes true at x and

Let y = c_i+d_i.

Thus, the worst case time to complete a bottom half task is:

di ³ S_i r_i / 1-U(x,y)

where U(x,y) is the worst case utilization over the specified time period. In general, U(x,y) is only a probably distribution so we cannot provide a hard deadline. But, in the special case that (y-x) = n*LCM(P_i) = n*P_t, the wost case U(x,y) is always equal to the sum of the average worst case utilizations of all of the top half tasks (U_t). Since the average worst case utilization for each top half task is knowable, we can write:

M = S_i r_i / (1-U_t)

where M is the effective run time of the whole bottom half under the assumption that U(x,y) == U_t

We can make this assumption only if we round M up to a multiple of P_t. So let

M’ = ciel(M/P_t). So the minimum deadline that guarantees S_i r_i units of work is

d_i ³ Pt * M’

By rounding up the number of P_t periods needed to complete the bottom half, we are making a pessimistic assumption about the utilization of the CPU during the fractional part of (y-x/P_t).

for example, if S_i r_i = 104, P_t = 10, U_t = .5 we get

104/.5 = 108

208/10 = 20.8

so we need ciel(20.8) = 21 P_t units to guarantee completion of the bottom half.

therefore our minimum guaranteed deadline is

10*21 = 210!

But, our average time to completion is guaranteed to be less than or equal to 204. We can call 204 our soft deadline. The actual distribution of U(x,y) will determine the probability that our soft deadline will be violated.

The key statement that is not proved here is that U(x,y) <= U_t when y-x = n*P_t. Does this relationship hold when the actual periods of the top halves vary such that there is no repeating pattern??

You should make sure that you understand the meaning of U_t --- the worst case average utilization of the top half tasks, and why this it is reasonable to know this number. Proof is left to the reader.