Tardiness Bounds for Global Multiprocessor Scheduling Algorithms Jim Anderson UNC Chapel-Hill

1. Tardiness Bounds for Global Multiprocessor Scheduling Algorithms Jim Anderson UNC Chapel-Hill Joint work with Uma Devi and Hennadiy Leontyev

2. Context: Real-Time on Multicore • Most chip manufacturers are moving to multicore. • Heat/energy issues are limiting clock speeds. • Solution: multiple cores per chip. • A common architecture today: Core 1 Core M … • Symmetric cores. • One thread per core. L1 L1 L2

3. Context: Real-Time on Multicore • This is only the beginning! • Tens (hundreds?) of cores per chip. • Multiple (hardware) threads per core. • Asymmetric platforms. • Complex cache configurations. • Most chip manufacturers are moving to multicore. • Heat/energy issues are limiting clock speeds. • Solution: multiple cores per chip. • A common architecture today: Core 1 Core M … • Symmetric cores. • One thread per core. L1 L1 L2

4. Some Research Issues • How to deal with cache asymmetry? • How to deal with processor asymmetry? • How to mix real-time and non-real-time? • How to manage energy? • How to support adaptive behavior? • How to design the operating system? • Our Platform: LITMUSRT (LInux Testbed for MUltiprocessor Scheduling in Real-Time systems). • Can download from my webpage.

5. Multiprocessor Scheduling P1 P1 P2 P2 Partitioned Global

6. Task set denoted Sporadic Task Model Period (min. inter-arrival separation), relative deadline worst-case execution cost job release job deadline 4 5 6 7 16 1 2 3 8 9 10 11 12 13 14 15 Total System Utilization  ui = ei/pi utilization of Ti (ei ≤ pi; ui ≤ 1) m– the number of processors TaskTiis denoted Ti(ei,pi). Example:Ti (2,4) ei  ei ei Ti,2 Ti,2 time Ti,1 Ti,3 0 = pi  pi = pi =pi

7. Soft Real-Time Systems tardiness (T3,1) = tardiness (T3,2) = 1 time 0 1 2 3 4 5 6 7 8 • Schedule tasks such that tardiness of any job is bounded. • Tardiness:Amount by which a deadline is missed. EDF schedule on 2 procs. T1 ; e1=2 p1=3 T1 T2,1 T2 ; e2=2 p2=3 T1,1 T3 ; e3=2 p3=3 T2 T2,1 T2,2 T3 T3,1 T3,2 job release job deadline

8. Two Tardiness Theorems Defined using a general prioritization function… Assuming U ≤ m… Theorem(Devi and Anderson 2005): Tardiness under global EDF (GEDF) is bounded. Theorem(Leontyev and Anderson 2007): Tardiness under any window-constrained global algorithm is bounded.

9. Some Well-Studied Scheduling Schemes Scheduling Policy Task Ordering Global EDFd(Ti,j) < d(Tk,h) Global FIFOr(Ti,j) < r(Tk,h) LLFslack(Ti,j,t) < slack(Tk,h,t) EDZLEDF unless zero slack

10. General Prioritization Function • Job Ti,j’spriority is given by: • Priority order: • Can model existing schemes (e.g., GEDF, FIFO, etc.). • Can also combine schemes (e.g., GEDF+FIFO).

11. Example: Global FIFO Task set:T1=(1,3), T2=(2,3), T3=(1,4), T4=(3,4) m=2, U=2 job deadline job release T1 T1,1 T1,2 T1,3 T1,4 T2,1 T2,2 T2,3 T2,4 T2 T3,1 T3,2 T3,3 T3 T4,1 T4,2 T4,3 T4 0 1 2 3 4 5 6 7 8 9 10 11 12

12. Example: GEDF + Global FIFO Task set:T1=(1,3), T2=(2,3), T3=(1,4), T4=(3,4) m=2, U=2 job deadline job release T1 T1,1 T1,2 T1,3 T1,4 T2,1 T2,2 T2,3 T2,4 T2 T3,1 T3,2 T3,3 T3 T4,1 T4,2 T4,3 T4 0 1 2 3 4 5 6 7 8 9 10 11 12

13. Laxity (Slack) and LLF Mapping Deadline ofTi,j Execution cost ofTi,j The timeTi,jalready executed beforet

14. Laxity (Slack) and LLF Mapping ei-δ(Ti,j,t)=3 slack(Ti,j,t)=2 d(Ti,j) ek-δ(Tk,h,t)=3 slack(Tk,h,t)=3 d(Tk,h) t+2 t+3 t+4 t+6 t t+1 t+5

15. Laxity (Slack) and LLF Mapping d(Ti,j) ek-δ(Tk,h,t+1)=3 d(Tk,h) ei-δ(Ti,j,t+1)=2 slack(Ti,j,t+1)=2 slack(Tk,h,t+1)=2 t+2 t+3 t+4 t+6 t t+1 t+5

16. Laxity (Slack) and LLF Mapping d(Ti,j) ek-δ(Tk,h,t+1)=3 d(Tk,h) ei-δ(Ti,j,t+1)=2 slack(Ti,j,t+1)=2 slack(Tk,h,t+1)=2 t+2 t+3 t+4 t+6 t t+1 t+5

17. EDZL mapping ei-δ(Ti,j,t) d(Ti,j) slack(Tk,h,t) ek-δ(Tk,h,t) d(Tk,h) EDF prioritization: LLF prioritization: Original EDZL: Use EDF, give highest priority if slack becomes 0. slack(Ti,j,t) t+2 t+3 t+4 t+6 t t+1 t+5

18. EDZL mapping ei-δ(Ti,j,t+1) d(Ti,j) slack(Tk,h,t+1) ek-δ(Tk,h,t+1) d(Tk,h) EDF prioritization: LLF prioritization: Original EDZL: Use EDF, give highest priority if slack becomes 0. slack(Ti,j,t+1) t+2 t+3 t+4 t+6 t t+1 t+5

19. EDZL mapping ei-δ(Ti,j,t+2) d(Ti,j) ek-δ(Tk,h,t+2) d(Tk,h) EDF prioritization: LLF prioritization: Original EDZL: Use EDF, give highest priority if slack becomes 0. slack(Ti,j,t+2)=0 slack(Tk,h,t+2) t+2 t+3 t+4 t+6 t t+1 t+5

20. EDZL mapping EDF prioritization: LLF prioritization: Original EDZL: Use EDF, give highest priority if slack becomes 0. Proposed EDZL: (note: does not require slack to be non-negative)

21. Window-Constrained Priorities r(Ti,j)+φi d(Ti,j) r(Ti,j) d(Ti,j)+ψi t GEDF, FIFO, Pfair, EPDF, LLF, EDZL are indeed window-constrained. If either inequality is violated, then there exists a scheme with unbounded deadline tardiness.

22. Example, not Window-Constrained: Global RM Task set:T1=(1,3), T2=(2,3), T3=(1,4), T4=(3,4) m=2, U=2 job deadline job release T1 T1,1 T1,2 T1,3 T1,4 T2,1 T2,2 T2,3 T2,4 T2 T3,1 T3,2 T3,3 T3 T4,1 T4,1 T4,1 T4,2 T4,2 T4 0 1 2 3 4 5 6 7 8 9 10 11 12

23. Proof Outline Proposed by Devi for GEDF. Goal: For anyTi, tardiness of any job≤ x+ei. • Consider an arbitrary job Ti,j with deadline at di,j=td. • Assume that all jobs Tk,l with deadlines < td have tardiness at most x+ek. • Prove that the tardiness of Ti,j is at most x+ei.

24. Induction Step What factors affect tardiness of Ti,j? Ti,j Ti,j 0 d(Ti,j)=td

25. Induction Step What factors affect tardiness of Ti,j? Remaining work from jobs with earlier deadlines. By the induction hypothesis, we do not need to know exactly what happens in this part of the schedule. Ti,j Ti,j 0 d(Ti,j)=td

26. Induction Step What factors affect tardiness of Ti,j? Remaining work from jobs with earlier deadlines. Potential competing demand from jobs with later deadlines. Because priorities are window-constrained, we can bound this demand. Ti,j Ti,j 0 d(Ti,j)=td

27. Some Research Questions • Is this really soft real-time? • We assumed worst-case execution costs. • Would probably use average-case costs in a SRT system. •  overload can occur. •  two kinds of tardiness: “intrinsic” and “overload-driven”. • How to deal with overloads? Utilities? • With average-case costs, can we derive expected tardiness bounds?

28. Some Research Questions • Can we do interesting things by moving priority points around? • Yes: In a new paper, we show how to improve cache performance by doing this. • Other uses? • Is it possible to enforce different tardiness bounds for different classes of tasks? • What happens if tasks self-suspend (e.g., for I/O)?

29. Some Research Questions • What about other task models? • E.g., multi-frame, models that allow precedence constraints, etc.

30. Thanks!