COMPUTE-SCHEDULE

5.3 HEALERS Algorithm

5.3.1 COMPUTE-SCHEDULE

COMPUTE-SCHEDULE attempts to allocate each taskTi ∈T onto the heterogeneous platform V such that their execution requirements within the given time-slice T Sk are satisfied. It first computes the shares required by each task in T S_k, and inserts them into the list L₁ (Lines 2 to 5). As the tasks may possibly have distinct share values corresponding to each one of the m heterogeneous processing cores, there are m entries for each task in L₁. Then, it sortsL₁ innon-decreasing order of shares. Subsequently, it invokes SCHEDULE-NON-MIGRATE (Algorithm 17) to assign tasks whose shares can be fully allocated on any one of the available processing cores and then adds the rest of the tasks in list L₂. It may be noted that L₂ contains tasks whose execution demand shi,j,k in T Sk cannot be entirely fulfilled by the remaining capacities of any individual processing core. Therefore, these tasks must be allocated upon multiple cores each of which together satisfy its total execution requirement. Hence, tasks in L₂ form the set of migrating tasks in T S_k. COMPUTE-SCHEDULE invokes SCHEDULE-MIGRATE (Algorithm 18) in order to allocate each migrating taskT_i on more than one processing core. Each such core satisfies a fraction ofT_i’s total execution demand.

5.3 HEALERS Algorithm

ALGORITHM 16: COMPUTE-SCHEDULE Input: T,V,T S_k, SM_k

Output: Schedule Matrix SM_k

1 Initialize the lists L₁ =∅, L₂ =∅ {COMPUTE-SHARES-REQUIRED by tasks at T Sk}

2 for i= 1 to n do

3 for j = 1 to m do

4 sh_i,j,k =du_i,j × |T S_k|e

5 L1 =L1∪ {hi, j, shi,j,ki}

6 Sort L₁ in non-decreasing order of sh_i,j,k

7 SCHEDULE-NON-MIGRATE(L1, L2, SMk, V)

8 SCHEDULE-MIGRATE(L₂, SM_k, V)

9 returnSM_k

ALGORITHM 17: SCHEDULE-NON-MIGRATE Input: L₁, L₂,SM_k, V

Output: SMk (Schedule matrix with non-migrating tasks), L2 (Sorted list of migrating tasks)

1 while L₁ is not empty do

2 Extract the first element hi, j, sh_i,j,ki from L₁

3 if τ_i can be allocated fully on V_j for sh_i,j,k then

4 Assign start and end times of τ_i onV_j, i.e., SM_k[i][j] = hstart time(T_i), end time(T_i)i

5 Decrement the capacity of V_k bysh_i,j,k

6 Delete all entries of T_i fromL₁ and L₂

7 else

8 Tentatively insert hi, j, sh_i,j,ki at end ofL₂

9 returnSM_k, L₂

5.3.1.1 SCHEDULE-NON-MIGRATE

SCHEDULE-NON-MIGRATE attempts to assign start and end times to tasks which can be fully allocated onto any one of the m cores in the platform. In order to conduct such assignment, this function sequentially considers the sharessh_i,j,k inL₁ and attempts to allocate sh_i,j,k entirely on core V_k. If such an allocation is successful, task T_i becomes a non-migrating/fixed task in T S_k and the remaining capacity of V_j is decremented by sh_i,j,k. On the other hand, if allocation ofsh_i,j,k onV_j is unsuccessful, it is removed from L₁ and inserted in L₂. Once a task T_i is scheduled, all its entries are deleted from both the lists L₁ and L₂ (Lines 3 to 8).

5.3.1.2 SCHEDULE-MIGRATE

This attempts to schedule tasks which require more than one processing core for their execution. First, it creates a list L₃ from L₂ to keep track of the unallocated share of T_i (Lines 2 to 4). Next, it extracts the first element (say, hi, j, sh_i,j,ki) from L₃ and also computes the unused capacity uc_j of V_j (Line 7). If uc_j is non-zero, then SCHEDULE- MIGRATE computes the unallocated share of T_i with respect to V_j, i.e., us_i,j (Lines 9 to 13). While utilizing the unused capacity of V_j, there are two possibilities (Lines 14 to 20):

• us_i,j > uc_j: This implies that the unallocated share ofT_i is greater than the unused capacity of coreV_j. Hence,T_iis partially scheduled onV_j and the unallocated share of T_i is updated.

• us_i,j ≤ uc_j: This implies that the unused capacity of core V_j is sufficient enough to meet the unallocated demand of T_i. Hence, task T_i is allocated on V_j. Since, T_i’s allocation is completed, us_i,j is reset to 0 and all entries of T_i are deleted from L3.

While scheduling a migrating task T_i, HEALERS attempts to ensure that T_i does not execute on multiple processing cores simultaneously (Lines 22 to 23). In order to schedule a migrating task T_i, HEALERS uses the following heuristic mechanism. First,

5.3 HEALERS Algorithm

non-terminating part of a migrating task is always scheduled at start of the time-slice on its available favoured core. Thereafter, all other parts of it’s execution are scheduled on cores in staircase fashion, where the starting time of the task on the second and subsequent cores is assigned by incrementing it’s end time on the previous core, by 1.

The starting and ending times of execution for each task in time-slice T Sk is stored in the Schedule Matrix SM_k. In the absence of sufficient spare capacity to schedule a migrating task on multiple cores, HEALERS declares the scheduling of T on V to be infeasible. Otherwise, it returns the schedule matrix SM_k, consisting of schedules for all ready tasks in the current time-slice T S_k.

ALGORITHM 18: SCHEDULE-MIGRATE Input: L₂, SM_k, V

Output: SM_k (Schedule Matrix for all tasks)

1 while L₂ is not empty do

2 Create a list L₃ and initialize it to∅

3 Extract all entries of T_i from L₂ and move to L₃

4 Let us_i,j be the unallocated share of T_i on V_j

5 while L₃ is not empty do

6 Extract-out the first entry hi, j, sh_i,j,kifrom L₃

7 Compute unused capacity of V_j: uc_j

8 if uc_j 6= 0 then

9 /* Compute unallocated share of T_i on V_j: us_i,j*/

10 if T_i is not yet allocated partially on any core then

11 unallocated share of T_i w.r.t V_j: us_i,j =sh_i,j,k

12 else

13 Let V_l be the last core in which T_i was partially scheduled

14 unallocated share of T_i w.r.t V_j: us_i,j =us_i,l×u_i,j/u_i,l

15 if us_i,j > uc_j then

16 Update SM_k[i][j] to schedule T_i on V_j for the duration uc_j

17 Update the unallocated share of T_i w.r.t V_j: us_i,j =us_i,j −uc_j

18 else

19 Update SM_k[i][j] to schedule T_i onV_j for the duration uc_j − dus_i,je

20 Reset us_i,j to 0

21 Delete all entries of T_i from L₃

22 if (us_i,j 6= 0) then

23 Declare the scheduling of T onV is infeasible

24 returnSM_k

ALGORITHM 19: COMPUTE-EA-SCHEDULE Input: T Sk, SMk, Frequency Set F

Output: Schedule Matrix SM_k at time-sliceT S_k

1 for each processor V_j ∈V do

2 Let |T^j| denotes the set of tasks scheduled on V_j in T S_k Compute unused capacity of V_j: uc_j

3 if uc_j 6= 0 then

4 Compute the frequency f_opt for V_j using Eqn. (5.4)

5 if f_opt < f_cr then

6 Modify shares of each non-migrating task Ti onVj: shi,j,k =shi,j,k/fcr 7 Set fopt ←fcr

8 Calculate time duration tsm for which Vj can be suspended using Eqn. (5.6)

9 else

10 Modify shares of each non-migrating task T_i onV_j: sh_i,j,k =sh_i,j,k/f_opt

11 Determine the amount of time t₁ (t₁ ≤ |T S_k|) for whichV_j should operate at frequency bf_optc

12 Update SM_k for all tasks scheduled on V_j

13 return SM_k