1 / 50

Meeting End-to-End Deadlines through Distributed Local Deadline Assignment

Meeting End-to-End Deadlines through Distributed Local Deadline Assignment. Shengyan Hong, Thidapat Chantem, X. Sharon Hu Dept. of Computer Science and Engineering University of Notre Dame, USA. Introduction and problem statement Related work and motivation Proposed OLDA algorithm

ngrice
Download Presentation

Meeting End-to-End Deadlines through Distributed Local Deadline Assignment

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Meeting End-to-End Deadlines through Distributed Local Deadline Assignment Shengyan Hong, Thidapat Chantem, X. Sharon Hu Dept. of Computer Science and Engineering University of Notre Dame, USA

  2. Introduction and problem statement Related work and motivation Proposed OLDA algorithm Experimental results Summary and future work Outline

  3. Distributed real-time systems Jobs are executed on a sequence of processors Jobs must complete by their end-to-end deadlines Systems of Interests Chatterjee and J. Strosnider, ICDCS, 1995

  4. Resource competition among jobs on a single processor Different jobs are executed on different sequences of processors Workloads on different processors may be dissimilar Need to adapt to dynamic changes, such as job assignment changes due to processor failure job deadline, period and execution time changes Meeting End-to-End Deadlines

  5. What We Want to Achieve • Assign local deadlines to jobs on different processors • Employ EDF scheduling on each processor • Is done on-line, in a distributed fashion • Is invoked every time a new job comes to the system • Reserve enough time for jobs at later stages

  6. Introduction and Problem statement Related work and motivation Proposed OLDA algorithm Experimental results Summary and future work Outline

  7. Assign local deadlines to jobs Jonsson et al. (J.RTS’02), Zhang et al. (RTSS’04), Buttazzo et al. (ECRTS’10), Serreli et al. (ETFA’10) Decide the local deadline of a job according to the job’s path, execution time distribution, and local release time Do not consider the workload contributed by other jobs on the processor Cannot guarantee the job set schedulability Assign priorities to jobs Jayanchandran et al. (ECRTS’08, J.RTS’08) Decide the priority of a job according to the job’s end-to-end deadline Does not work well for high workload systems if jobs have different paths and workloads on processors vary significantly Related Work

  8. Schedulability analysis of tasks in distributed real-time system Rahni et al. (RTNS’08), Serreli et al. (ECRTS’10) Compute the time demand bound function of tasks scheduled by EDF Palencia et al. (ECRTS’03), Hawkins et al. (RTSS’05), Jayachandran et al. (ECRTS’09) Compute the worst case response times for the system under EDF or fixed priority Time consuming and not suitable for on-line use Related Work (cont’d)

  9. Motivational Example Processor Name Job τ1 Job τ2 Exec. Time E2E Deadline Exec. Time E2E Deadline V1 100 N/A 70 N/A V2 200 N/A 430 N/A V3 100 N/A 100 N/A V4 600 1100 0 N/A V5 0 N/A 100 930

  10. Motivational Example Processor Name Local Deadline Assignment BBW Response Time BBW / JA Job τ1 Job τ2 Job τ1 Job τ2 V1 111 90 170 / 170 70 / 70 V2 331 663 370 / 700 700 / 500 V3 441 797 470 / 800 800 / 600 V4 1100 N/A 1070/ 1400 N/A N/A 900 / 700 930 V5 N/A BBW: ByButtazzo, et. al. (ECRTS’10) JA: By Jayanchandran, et. al. (ECRTS’08, J.RTS’08)

  11. Motivational Example Processor Name Job τ1 Job τ2 Exec. Time E2E Deadline Exec. Time E2E Deadline V1 100 N/A 70 N/A V2 200 N/A 430 N/A V3 100 N/A 100 N/A V4 600 1100 0 N/A 430 930 V5 0 N/A 430 930 failed

  12. Motivational Example Processor Name Local Deadline Assignment BBW Response Time BBW / JA Job τ1 Job τ2 Job τ1 Job τ2 V1 111 90 170 / 170 70 / 70 V2 331 663 370 / 700 700 / 500 V3 441 797 470 / 800 800 / 600 V4 1100 930 1170 / 1400 900 / 700 Require an effective distributed algorithm that can handle such dynamic changes adaptively! failed

  13. Introduction and Problem statement Related work and motivation Proposed OLDA algorithm Experimental results Summary and future work Outline

  14. Formulate an Optimization Problem • Objective function • Maximize time slack of each job on a processor, but difficult to capture • Employ an approximate objective function • Maximize the minimum time slack among all the jobs on the local processor • Constraints • Guarantee the schedulability of jobs on each local processor • Bound the local deadline of each job by • the earliest completion time of the job in the previous stage • the latest start time of the next stage

  15. An Existing Feasibility Condition • Proposed by Chetto et al. (J.RTS’90) • Cannot be used to formulate a constraint due to deadlines being unknown • Job set Ω(Vx)can be scheduled by EDF policy, if and only if, • within any time interval L, • for all the jobswhose release • times and deadlines fall into L, • sum of these jobs’ execution times • Ch’s<=L. L

  16. Modified Feasibility Condition • Job set Ω(Vx)can be scheduled by EDF policy, if and only if, • for any job subset ω(Vx),and • any L ϵ[min release time of • jobs in ω(Vx), max deadline of • jobs in ω(Vx)], • sum of these jobs’ execution times • Ch’s<=L L min{rj} max{di}

  17. Requirements for OLDA Design • Need to be applicable on-line • Finding the optimal solution with low time complexity, but • Time consuming to explore exponential number of subsets in Ω(Vx) by using the modified condition • Solvers, such as, Loqo, is expensive • Need to be distributed • Avoid global synchronization overhead • Require information local to processor Vx and the information known upon a job’s release

  18. Basic Idea of OLDA (1) • Base job subset • The job subset having the latest “pseudo completion time”, i.e., min{ri} + sum{ci} is largest • Once the first job in this set gets executed, the processor is busy till all the jobs in the set are completed • All the jobs in the base job subset are executed after the completion of the jobs in the other job subsets

  19. Example: Base Job Subset • All job subsets: {τ1} , {τ2}, {τ3}, {τ4}, {τ1, τ2}, {τ1, τ3}, … {τ3, τ4}, • {τ1, τ2, τ3}, {τ1, τ2, τ3}, … {τ2, τ3, τ4}, {τ1, τ2, τ3, τ4} • Search for base job subset: {τ1, τ2, τ3, τ4}, {τ2, τ3, τ4}, {τ3, τ4}, {τ4} • Pseudo completion times: 7 9 8 7 The base job subset τ2 τ3 τ4 t 10 7 8 9 0 5 6 3 4 1 2

  20. Basic Idea of OLDA (2) • Base job • The job with the largest local-deadline upper bound in the base job subset • UB of a job’s local deadline = E2E deadline – exec times on downstream processors • The deadline of the base job is set to the pseudo completion time of the job base subset, which is the optimal local deadline for this job

  21. Example: Base Job The base job is τ3. Set τ3 deadline to 9 τ1 τ2 τ3 τ4 t 10 7 8 9 0 5 6 3 4 1 2 τ2 τ3 τ4

  22. In O(|Ω(Vx)|3) time, OLDA returns a set of local deadlines if and only if there exists a solution to the local-deadline optimization problem The set of local deadlines returned by OLDA is optimal OLDA is optimal on each processor, but not for the global system Properties of OLDA

  23. Introduction and Problem statement Related work and motivation Proposed OLDA algorithm Experimental results Summary and future work Outline

  24. Back to the Motivational Example Processor Name Local Deadline Assignment BBW / OLDA Response Time BBW / JA / OLDA Job τ1 Job τ2 Job τ1 Job τ2 V1 111 / 100 90 / 170 170 / 170 / 100 70 / 70 / 170 V2 331 / 300 663 / 730 370 / 700 / 300 700 / 500 / 730 V3 441 / 400 797 / 830 470 / 800 / 400 800 / 600 / 830 V4 1100 / 1100 930 / 930 1170 / 1400 / 1100 900 / 700 / 930 • Both BBW and JA fail to find a feasible solution, while OLDA solves the problem

  25. 100 task sets consisting of 50 tasks each for 10 different utilization levels (Ulevel=400%,…,625%) 8 processors in the system and each task randomly passes through 4 to 6 stages Task periods raged from 1000 to 10000 time units Two randomly generated task sets Set 1: processor loads are balanced Set 2: processor loads are imbalanced Random Task Sets

  26. Feasible Solutions Found: Balanced Workloads • OLDA leads to 75% and 22% on average more feasible task sets than BBW and JA • OLDA can find on average 98% and 99% of the feasible task sets found by BBW and JA

  27. Feasible Solutions Found: Imbalanced Workloads • OLDA leads to 57% and 46% on average more feasible task sets than BBW and JA • OLDA can find on average 88% and 99% of the feasible task sets found by BBW and JA

  28. Average Drop Rate: Balanced Workloads • BBW and JA on average drop 3.25X and 2.25X more jobs than OLDA

  29. Average Drop Rate: Imbalanced Workloads • BBW and JA on average drop 89% and 379% more jobs than OLDA

  30. Average number of cycles to process a job is 149 and 153 for the balanced and imbalanced workloads, respectively Compared with BBW and JA For balanced workloads, OLDA requires 1.53 and 2.30 times more cycles per task set than BBW and JA, respectively For imbalanced workloads, OLDA requires 1.74 and 2.32 times more cycles per task set than BBW and JA, respectively OLDA is more than 10,000 times faster than Loqo (a tool for solving smooth constrained optimization problems) Computational Cost

  31. Presented an on-line distributed local deadline assignment algorithm Formulated an optimization problem to maximize the minimum time slack among all the jobs on the local processor Devised a locally optimal distributed algorithm to solve the problem and prove its optimality Experimental results show the strength of OLDA Future work Support transactions having more general execution sequences Improve job prediction and dropping policies Summary and future work

  32. Thank You!

  33. Introduction and Problem statement Related work and motivation Proposed OLDA algorithm Experimental results Summary and future work Outline

  34. Distributed real-time systems Jobs are executed on a sequence of processors Jobs must complete by their end-to-end deadlines Systems of Interests Chatterjee and J. Strosnider, ICDCS, 1995

  35. What We Want to Achieve • Assign local deadlines to jobs on different processors • Employ EDF scheduling on each processor • Is done on-line, in a distributed fashion • Is invoked every time a new job comes to the system • Reserve enough time for jobs at later stages τ1 τ2

  36. Some Key Observations • Local deadlines should be bounded by • theearliest completion time of the job, and • the latest start time of the immediate next stage • Local deadlines should satisfy the modified feasibility condition • Reserve maximum time slack for each job to be executed in its downstream processors

  37. A Flight Control System Task Name Exec. Time Period End2End Deadline AH NV FC BS FG AP SV PF FCP 0 0 15 29 10 15 0 10 500 450 PAA 10 0 0 16 15 20 10 0 100 100 NIP 0 10 0 14 20 0 0 0 250 200 • Flight control system • Introduced in Jayachandran et al. (ECRTS 2008) • 3 periodic tasks and 8 heterogeneous processors and each task has an end-to-end deadline • Simulate the application for the time interval [0,54000ms]

  38. Results by OLDA Trans. Name Period E2E Dl. Dropped Job Num. OLDA / JA / BBW Period E2E Dl. Dropped Job Num. OLDA / JA / BBW FCP 500 450 0 / 0 / 0 120 120 0 / 0 / 0 PAA 100 100 0 / 0 / 0 72 72 0 / 180 / 0 NIP 250 200 0 / 0 / 0 75 75 0 / 0 / 30 • At some time interval, the periods and end-to-end deadlines of the three tasks are decreased • If the previous local deadline assignments by BBW are reused, 60 jobs of 1920 released jobs will miss deadlines • Applying OLDA, JA and BBW, OLDA leads to all jobs meeting the deadlines, while JA and BBW fail

  39. Problem Formulation • Objective function • Maximize time slack of each job on a processor, but difficult to capture • Employ an approximate objective function • Constraints • Guarantee the schedulability of jobs on each local processor • Bound the local deadline of each job The upper bound of job Ji,k(i,x)

  40. Problem Formulation • Modified the existing feasibility condition proposed by Chetto et al. (Real-Time Systems 1990) • The existing condition can not be used to formulate a constraint • The problem can be solved by a standard mathematic solver • The new condition is still necessary and sufficient di,k(i,x) is unknown rj,k(j,x) di,k(i,x) min{rj,k(j,x)} max{di,k(i,x)} a constant

  41. Problem Formulation (1) s.t. (2) (3)

  42. Motivational Example An example to show deficiencies of existing approaches

  43. Loqo is a system for solving smooth constrained optimization problems Apply Loqo in our problem Formulate the optimization problem on the local processor each time a new job comes to the processor Solve the problem Disadvantages Extremely slow (see experiment results) Why Not Loqo?

  44. Existing Feasibility Condition Proposed by Chetto et al. (Real-Time Systems 1990) Cannot be used to formulate a constraint Job set Ω(Vx)can be scheduled by EDF policy if and only if Ji,k(i,x), Jj,k(j,x)∈ω(Vx), ??? ri,k(i,x)≤di,k(i,x), rj,k(j,x) di,k(i,x) di,k(i,x) is unknown How about using words instead of the complicated formula?? Use formula as backup.

  45. Modified Feasibility Condition Modified the existing feasibility condition The problem can be solved by a standard mathematic solver Loqo, but it is time consuming The new condition is still necessary and sufficient Job setΩ(Vx)can be scheduled by EDF policy if and only if a constant See my comment on previous page min{rj,k(j,x)} max{di,k(i,x)}

  46. System Model ri,1=Ri di,Mi=Di ri,k(i,x) di,k(i,x) Ji,k(i,x) Ji,Mi Ji,1 • Parameters • Ri,Di : release time and relative deadline of Ji • Mi: the last stage index of Ji on processor Vx • Ci,k(i,x): the execution time of Ji on processor Vx • K(i,x): the stage index of Ji on processor Vx • ri,k(i,x),di,k(i,x): the absolute release time and absolute local deadline of Ji on processor Vx • Ω(Vx): the job set on processor Vx • Need these??

  47. Main Steps in OLDA Yes Compute the upper bound on local deadline of each job Max_upper_bound<Max_Deadline No Select the base job subset ω*(Vx) and compute the completion time (= Max_Deadline of ω*(Vx)) Assign Max_Deadline to J* and remove J* from Ω(Vx) Ω(Vx) is empty No Yes Return local deadlines Select the base job J* whose local deadline upper bound is Max_upper_bound Drop a job • UB of a job’s local deadline = E2E deadline – exec time on downstream processors • Drop the job in the base job subset having the largest remaining execution times on its downstream processors

  48. Main Steps in OLDA Yes Compute the upper bound on local deadline of each job Max_upper_bound<Max_Deadline No Select the base job subset ω*(Vx) and compute the completion time (= Max_Deadline of ω*(Vx)) Assign Max_Deadline to J* and remove J* from Ω(Vx) Ω(Vx) is empty No Yes Return local deadlines Select the base job J* whose local deadline upper bound is Max_upper_bound Drop a job • UB of a job’s local deadline = E2E deadline – exec time on downstream processors • Base job subset is the job subset having the latest busy interval • Base job = job with the largest local deadline UB in the base job subset • Drop the job in the base job subset having the largest remaining execution times on its downstream processors

  49. Local deadlines d*i ’s satisfy the constraints in the problem?? Local deadlines d*i’s maximizes the objective function?? Once the first job in ω*(Vx) gets executed, the processor will never be idle till all the jobs in ω*(Vx) are completed In O(|Ω(Vx)|) time, OLDA returns a set of local deadlines if and only if there exists a solution to the optimization problem. Furthermore, the set of local deadlines returned by OLDA is optimal OLDA is optimal on each processor, but not for the global system Properties of OLDA

  50. Base Job Subset & Base Job τ1 τ2 τ2 τ4 t 10 7 8 9 0 5 6 3 4 1 2 Local processor has no idle time when executing jobs τ2 , τ3, and τ4. In the example, the base job subset is {τ2 , τ3, and τ4} and the base job is τ4.

More Related