HETERO-SCHED Algorithm

4.4 HETERO-SCHED: A Low-overhead Heterogeneous Multi-core Scheduler

4.4.1 HETERO-SCHED Algorithm

4.4 HETERO-SCHED: A Low-overhead Heterogeneous Multi-core Scheduler

invokes COMPUTE-SHARES-REQUIRED (Algorithm 11) to compute the share sh_i,j,k required by each task T_i ∈T at T S_k on theV_j^th processing core, as follows:

sh_i,j,k =du_i,j × |T S_k|e (4.1)

The computed share sh_i,j,k along with the task (T_i) and the processor (V_j) id’s have been used to form the tuple hi, j, shi,j,ki, which is then inserted into the list L1 (Line 6 of Algorithm 11). After computing the shares required by each task over all the m processing cores, Algorithm 11 sorts the list L₁ in non-decreasing order of shares and returns it back to COMPUTE-ALLOCATION algorithm.

ALGORITHM 10: COMPUTE-ALLOCATION Input: T, V, T S_k, AM_k

Output: Allocation matrix AM_k, Feasibility flag F

1 Initialize the lists L1 =∅, L2 =∅

2 COMPUTE-SHARES-REQUIRED (T,T S_k, L₁)

3 ALLOCATE-NON-MIGRATE (L₁, L₂,AM_k, V)

4 ALLOCATE-MIGRATE (L₂,AM_k, V)

5 return AM_k

ALGORITHM 11: COMPUTE-SHARES-REQUIRED Input: T, T S_k, L₁

Output: The sorted list L₁ consisting of shares required

1 {Compute the shares required by each task at T S_k }

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 L₁ =L₁∪ {hi, j, sh_i,j,ki}

6 Sort the list L₁ innon-decreasing order of sh_i,j,k

7 return L1

After computing required shares, Algorithm 10 invokes ASSIGN-NON-MIGRATE (Algorithm 12) to compute the schedule for the set of tasks which can be fully assigned on to any one of the cores for its complete share of sh_i,j,k.

4.4 HETERO-SCHED: A Low-overhead Heterogeneous Multi-core Scheduler for Real-time Periodic Tasks

4.4.1.2 ASSIGN-NON-MIGRATE

It extracts-out the first element (say, hi, j, sh_i,j,ki) from the list L₁. Then, it checks whether it is possible to schedule task T_i on V_j for sh_i,j,k time units. If possible, it allocates Ti onVj by setting the allocation matrixAMk[i][j] = shi,j,k and subsequently, sets the migration count ofT_i to 0. SinceT_i has been allocated completely, Algorithm 12 deletes all the entries corresponding to T_i from both L₁ and L₂.

On the other hand, if the allocation requirement sh_i,j,k of task T_i cannot be ful- filled on core V_j, then Algorithm 12 inserts the element hi, j, sh_i,j,ki in to the list L₂. Once all elements in L1 has been verified, Algorithm 12 returns the schedule for non- migrating tasks and list L2 containing the migrating tasks. Then, Algorithm 10 invokes ALLOCATE-MIGRATE (Algorithm 13) to compute the schedule for each migrating task in L₂.

ALGORITHM 12: ALLOCATE-NON-MIGRATE Input: L₁, L₂,AM_k, V

Output: AM_k (Allocation matrix with non-migrating tasks), L₂ (Sorted list of migrating tasks)

1 while L₁ is not empty do

2 Extract-out the first element hi, j, sh_i,j,kifrom L₁

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

4 Update AMk[i][j] = shi,j,k 5 Set migration count of Ti to 0

6 Delete all entries of T_i fromL₁ and L₂

7 else

8 Tentatively insert hi, j, sh_i,j,ki at the end of L₂

9 returnAM_k, L₂

4.4.1.3 ASSIGN-MIGRATE

It starts the allocation process by selecting the task that is part of the first element hi, j, sh_i,j,kiinL₂ (Line 4). Initially, ALLOCATE-MIGRATE moves all elements related to T_i from the list L₂ to L₃ (Line 6). Then, it iterates over L₃ until the task T_i is completely allocated with its computation demand on the processing platform (Lines 8 to 27). Suppose, the allocation ofT_i is infeasible, then the entire setT is declared to be

infeasible (Lines 28 to 30).

(Lines 8 to 27): ALLOCATE-MIGRATE extracts-out the first element (say,hi, j, sh_i,j,ki) fromL₃ and computes the unused capacityuc_j ofV_j (Lines 9 and 10). Ifuc_j is non-zero, then ALLOCATE-MIGRATE checks the migration count of T_i to compute the unallo- cated share of T_i with respect to core V_j, i.e., uc_j (Line 12 to 15). While utilizing the unused capacity ofV_j, there are two possibilities:

• us_i > uc_j: This implies that the unallocated share ofT_i is greater than the unused capacity of coreV_j. Hence, the taskT_i is partially allocated onV_j (AM_k[i][j] =uc_j) and the normalized unallocated share of T_i is updated as: us_i = (us_i−uc_j)/u_i,j. Finally, the migration count is incremented by one (M C_k[i] =M C_k[i] + 1).

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

4.4.1.4 COMPUTE-SCHEDULE

If task allocation is successful, then HETERO-SCHED invokes COMPUTE-SCHEDULE.

It may be noted that the objective of this scheduling phase is to assign start and finish times of all tasks on their allocated processing cores such that, (i) all tasks are scheduled according to their allocation, and (ii) the same task is never simultaneously executed on more than one processing core.

In order to achieve this objective, we use the following guidelines (also known as HETERO-SCHED guidelines) during the scheduling of tasks:

(i) Schedule tasks on unused time slots starting from left to right over the given time- slice,

(ii) Always schedule the task with the highest number of migrations,

(iii) Schedule a migrating task in stair-case fashion such that its executions are not over- lapped, where starting time of a migrating task on a core is assigned after incrementing

4.4 HETERO-SCHED: A Low-overhead Heterogeneous Multi-core Scheduler for Real-time Periodic Tasks

ALGORITHM 13: ALLOCATE-MIGRATE Input: L2, AMk,V

Output: AM_k (Allocation matrix with all tasks)

1 while L₂ is not empty do

2 Let hi, j, sh_i,j,ki be the first element in L₂

3 Create and Initialize a list L₃ to∅

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

5 Let us_i be the normalized unallocated share of T_i

6 while L₃ is not empty do

7 Extract-out the first element hi, j, sh_i,j,kifrom L₃

8 Compute unused capacity of V_j inT S_k, i.e., uc_j

9 if uc_j 6= 0 then

10 if migration count M C_k[i] = 0 then

11 Unallocated share of T_i: us_i =sh_i,j,k

12 else

13 Unallocated share of T_i: us_i =us_i×u_i,j

14 if us_i > uc_j then

15 Allocate T_i onV_j: AM_k[i][j] = uc_j

16 Update the normalized unallocated share of T_i: us_i = (us_i−uc_i)/u_i,j

17 Migration count: M C_k[i] =M C_k[i] + 1

18 else

19 AMk[i][j] = ucj− dusie

20 Reset us_i to 0

21 Delete all entries of Ti from L3 22 if usi 6= 0 then

23 Declare that the allocation of task set T on multi-core platformV is infeasible

24 returnAM_k

it’s ending time on previous core by 1. The starting and ending times of execution for each task in the times-slice Gk is stored in the Schedule Matrix SMk,

(iv) Break the execution of a non-migrating task into multiple chunks when it cannot be scheduled non-preemptively on the same allocated core. COMPUTE-SCHEDULE (Algorithm 14) uses the above guidelines to guarantee the feasible scheduling of tasks on a given heterogeneous platform.

ALGORITHM 14: COMPUTE-SCHEDULE Input: AMk,SMk

Output: Schedule matrix SM_k at time-slice T S_k

1 while all tasks in SM_k are not scheduled do

2 From AM_k, select T_i with the highest number of migrations (handle tie-brakes arbitrarily)

3 for each V_j (j = 1 to m) and AM_k[i][j]6= 0 do

4 Schedule T_i’s allocated share on V_j according to HETERO-SCHED guidelines

5 return SM_k