The DP-LoCBP Algorithm

5.5 Extension for Dependent Jobs

5.5.2 The DP-LoCBP Algorithm

Here we propose the DP-LoCBP algorithm which can construct the two scheduling tables S_LO and S_HI for a dual-criticality instance with dependent jobs. A DAG of mixed-criticality jobs isMC-schedulable if there exists a correct online scheduling policy for it. Our algorithm finds a LO-criticality priority order for the jobs of instanceI which is used to construct the table S_LO. Then the same job allocation order of S_LO is used to construct the table S_HI, where HI-criticality jobs have greater priority than LO-criticality jobs, and the HI-criticality jobs are allocated theirC_iHI units of execution time inS_HI without violating the dependency constraints. The priority between two jobsj_i and j_k is denoted by j_i. j_k, wherej_i is higher priority thanj_k. This priority ordering must satisfy two properties:

• If a nodeji is assigned higher priority than nodejk(i.e., ji. jk), then there should not be a path in the DAG from node j_k to nodej_i.

• If the DAG is scheduled according to this priority ordering then each job j_i of the DAG must finish its Ci(LO) units of execution time before d^∆_i .

Now we present the algorithm DP-LoCBP which finds a priority order for mixed-criticality dependent jobs.

The DP-LoCBP algorithm finds a priority order which is used to construct the scheduling tables for all the processors in steps 1 to 11. First, DP-LoCBP finds the LO- scenario deadline (d_i^∆) of each job. For the LO-criticality jobs d_i^∆ = d_i, but d_i^∆ ≤ d_i for the HI-criticality jobs. Then the algorithm starts to assign the lowest priority jobs from the instanceI. It always selects the latest deadline job which does not have an outward edge as the lowest priority job, but LO-criticality jobs are considered before the HI-criticality jobs. A jobji can be assigned the lowest priority if and only if all other jobsjk finish their execution and there remains sufficient time forj_i to complete itsC_i(LO) units of execution time before d_i^∆. After a job j_i is assigned the lowest priority, it is removed from the instance and added to the priority order Ψ. Then the remaining jobs are considered for priority assignment. If at any step a job cannot be assigned a priority, the algorithm declares failure. In step 12, the algorithm constructs the tableS_LO. In steps 13 to 15, it checks for any possible HI-criticality scenario failure. If it does not find a HI-criticality scenario failure, then the priority order constructed by the DP-LoCBP algorithm can successfully schedule the instanceI. Then the table S_HI is constructed for each processor by allocating C_i(HI) units of execution time of

Algorithm 15 DP-LoCBP(I) Notation:

I ={j₁, j₂, ..., j_n}, wherej_i =< a_i, d_i, χ_i, C_i(LO), C_i(HI)>.

Input: I, Dependency relation E ⊆I×I Output : Tables S_LO and S_HI

Assume earliest arrival time is 0.

1: Compute the LO-scenario deadline (di∆

) of each jobji asdi∆

=di−(Ci(HI)−Ci(LO));

2: while I is not empty do

3: Assign a LO-criticality latest deadline job j_i which does not have an outward edge as the lowest priority job if j_i can finish its execution in the interval [a_i, d_i^∆] after all other jobs finish their execution in LO-scenario under the global EDF scheme;

4: If any LO-criticality job with no outward edge cannot be given the lowest priority then a HI-criticality latest deadline job ji which does not have an outward edge is assigned as the lowest priority job if ji can finish its execution in the interval [ai, di∆

] after all other jobs finishes their execution in LO-scenario under the global EDF scheme;

5: if no job is assigned a lowest priority then

6: Declare FAIL and EXIT;

7: else

8: Add the jobj_i to the priority order Ψ.

9: Remove jobji from the instance and continue;

10: end if

11: end while

12: Construct table S_LO for each processor P_i using the priority order Ψ;

13: if anyHIscenarioF ailure(S_LO, I, Ψ) then

14: return FAIL and EXIT;

15: else

16: Construct table S_HI for each processor Pi using the same order of allocated jobs in S_LO.

17: The same order asS_LO is followed to allocate the jobs in S_HI;

18: After a HI-criticality job j_i is allocated its C_i(LO) execution time in S_HI, C_i(HI)− C_i(LO) units of execution time of jobj_i is allocated after the rightmost segment of jobj_i inS_LO without violating the dependency constraints and without disturbing the priority order Ψ;

19: end if

each HI-criticality job using the same order of allocated jobs as S_LO where a HI-criticality job is given higher priority over LO-criticality jobs. InS_HI each HI-criticality job is allocated itsC_i(LO) units of execution time without violating the dependency constraints. Once the C_i(LO) units of execution time are allocated for HI-criticality jobs in S_HI, the remaining C_i(HI)−C_i(LO) units of execution time are allocated immediately without disturbing the priority order Ψ and without violating the dependency constraints. At each instant, the allocation is done without violating the dependency constraints.

We illustrate the operation of this algorithm by an example.

Example 5.5.1: Consider the mixed-criticality instance given in Table 5.3 which is going to be scheduled on a multiprocessor system having two homogeneous processors, i.e.,P₀ and P1. The corresponding DAG is given in Fig. 5.4.

Figure 5.3: An example instance to explain the DP-LoCBP algorithm

Job Arrival time Deadline Criticality C_i(LO) C_i(HI)

j₁ 0 3 LO 1 1

j₂ 0 3 LO 1 1

j₃ 0 3 LO 1 1

j₄ 0 4 HI 1 3

j₅ 1 6 HI 1 3

j1 j2 j3 j4

j5

Figure 5.4: A DAG showing job dependencies among the jobs of an instance

Now we construct a priority order using the DP-LoCBP algorithm. The LO-criticality scenario d^∆_i of the jobs j₁, j₂, j₃, j₄.j₅ are 3,3,3,2,4 respectively. Next we start assigning priorities to each job.

• We start with a node having no outward edges from it. The only such node is job j₅.

So Algorithm 15 assigns job j₅ the lowest priority. Ifj₅ is assigned the lowest priority, then j₁ and j₂ can run simultaneously in P₀ and P₁ over [0,1] and [0,1] respectively.

Thenj₃ andj₄ can run over [1,2] in P₀ and P₁ respectively. Thenj₅ can easily execute its 1 unit of execution on eitherP₀ orP₁ over [2,3] to finish by its LO-scenario deadline (d^∆_i ). Now we can assign job j₅ the lowest priority job.

We remove job j₅ and consider{j₁, j₂, j₃, j₄} to find the next lowest priority job.

• Since the LO-criticality jobs are given the lowest priority by the proposed algorithm, it is easy to verify that the successive lowest priority jobs will bej₁, j₂ andj₃ respectively.

Finally, j₄ is the highest priority job.

So the final priority order of jobs in instanceI isj4. j3. j2. j1. j5. The tableSLO for each processor is given in Fig. 5.5.

Now the anyHIscenarioF ailure(S_LO, I,Ψ) subroutine checks for all possible HI- criticality scenarios. We can check that all HI-criticality scenarios are schedulable using the priority orderj₄. j₃. j₂. j₁. j₅ of the instanceI. Finally, the tableS_HIis constructed for each processor by allocating C_i(HI) units of execution time of each HI-criticality job using the same order of allocated jobs inSLOwhere a HI-criticality job is given higher priority over a LO-criticality job. On processorP₀, the job order of S_HI remains the same as in S_LO. Job j₄ is a HI-criticality job and does not depend on any other job, so it is allocated itsC_i(LO) units of execution time over [0,1] and the remainingCi(HI)−Ci(LO) units of execution time are allocated in the interval [1,3]. Jobj₅ is allocated in the interval [2,3] in table S_LO of P₀. Butj₅ is allocated in the interval [3,6] due to dependency constraints which does not affect the scheduling after a mode change. On processorP1, jobj3 andj2 (LO-criticality) which do not depend on any other jobs, are allocated their one unit of execution time in the intervals [0,1] and [1,2] respectively. The table S_HI for each processor is given in Fig. 5.6.

S_LO P₁ P₀

j₃ j₂ j₄ j₁ j₅

0 1 2 3 6

Figure 5.5: Table S_LO for processor P₀ and P₁

S_HI P₁ P₀

j₃ j₂

j₄ j₅

0 1 2 3 6

Figure 5.6: TableS_HIfor processorP₀and P₁