Failure Tolerance of Multicore Real-Time Systems scheduled by a Pfair Algorithm

Transcription

1 Failure Tolerance of Multicore Real-Time Systems scheduled by a Pfair Algorithm Yves MOUAFO Supervisors A. CHOQUET-GENIET, G. LARGETEAU-SKAPIN

2 OUTLINES 2 1. Context and Problematic 2. State of the art 3. Different scenarios 4. First feasibility result 5. Second feasibility result 6. Future works

3 The Context Increased use of multicore platforms in Real-Time System 3 Period T i r i 1 st release Relative deadline D i + C i r i + D i 1 st deadline r i + T i 2 nd release time - Independa nt - periodic - r i = 0 - D i = T i WCET Temporal modelling of a periodic task

4 Context Scheduling by the Pfair algorithm PD2 4 - Optimal in our context - Feasibility condition on m-cores : U = (U i = C i T i ) m Feasibility windows C i D i =T i r i =0 r j i = j U d j i i = j + 1 Pseudo-release date U i Pseudo-deadline τ i < C i, T i > C i subtasks τ i j r i j, di j - Priority order: increasing pseudo-deadlines + rules for ex-aequo.

5 Problematic Failure occurrence on any core at any time 5 Increased processing capacity Low weight Small size Cheap Low energy consumption Several transistors on a single chip Feasibility condition may not longer be satisfied

6 Problematic Some tasks may be affected by the failure 6 Core 1 l: lost execution Failing Core x: delay 1 core affected x = 1 time unit l 1 subtask Core m t p failure time t d detection time

7 State of the art Existing techniques are not suitable 7 Classical approaches Hardware redundancy [Pradhan 1996] Provide each core with a spare or a twin => Over redundant cores as needed Software redundancy [Koren et al, 2007] Provide to each task 2 copies: a primary and a backup => Increase of system load Time redundancy [Kopetz et al. 2003] Exploit the slack between task completion and deadline => similar to our approach => useful only for transient and intermittant failures Most used in partitioned scheduling

8 Our goals Avoid the limitations of the classical techniques 8 Provide strictly the number of cores needed m = U + 1 Limit the hardware redundancy to one core Avoid the use of backup copies Resume only the lost execution

9 Different scenarios 9 At any time, a failure may occur on any of the cores

10 Two Possible Scenarios Allocate or not additional time to affected tasks No task is affected Continue the execution One affected task 10 Partial completion is acceptable No further time allocation eg. iterative tasks Full completion is needed Additional time allocation

11 No Further Time Allocation Limited Hardware Redundancy 11 U m 0 time m + 1 t m p cores cores Provide an additional core

12 First Feasibility Result Limited Hardware Redundancy provide a valid schedule 12 Notations - Sched m S : PD2 schedule of S on a m-core processor S - Sched m+1 m Theorem : PD2 schedule of S with limited hardware redundancy - Pending(Sched, t) : List of pending subtasks in schedule Sched at time t - Exec(τ i j, Sched) : Execution time of subtask τ i j in schedule Sched Assumption - U m => SchedS S m and Sched m+1 are valid and fair S The resulting schedule Sched m+1 m is valid and fair τ i j, r j i Exec τ j S i, Sched m+1 m < d i j

13 Proof Based on two lemmas 13 Lemma 1 S At any time, subtasks pending in are Sched m+1 m Lemma 2 Pending(τ j S i, Sched m+1 m ) Pending(τ i j, Sched m S ) also pending in Sched m S S Any subtask is scheduled earlier in Sched m+1 m than in Sched m S τ j i, Exec(τ j S i, Sched m+1 m Proof of the theorem ) Exec(τ i j, Sched m S ) S S - At t t p Sched m+1 m = Sched m+1 valid and fair - At t p t H, τ j i, r j i Exec τ j S i, Sched m+1 m S S - At t > H Sched m+1 m = Sched m valid and fair Exec(τ i j, Sched m S ) < d i j (lemma2)

14 Additional Time Allocated Two combined techniques Limited hardware redundancy 14 Constrain and release C i Tolerance margin C i r i =0 D i T i r i =0 D i =T i Before the failure detection After the failure detection

15 Deadlines computation Ghost subtasks method Add one ghost subtask 2. Compute the feasibility windows with the ghost subtasks 3. Task deadline = pseudodeadline of the subtask before the last

16 Dynamic Reconfiguration Subtasks switch from one system parameters to another Involved systems - Initial System S: τ i < C i, D i = T i > 16 - Constrained System S : τ i < C i, D i < T i > - Intermediate System S i0 : τ i i0 < C i, D i = T i >, τ i0 < C i0 + 1, D i0 = T i0 > Resulting system notation: S tp S i0 U S = CH S = U Si0 = C i T i m C i D i C i T i i i0 m m C i0 + 1 T i0 Non-affected tasks Affected task m+1 cores m cores 0 t p t d Next H t S S i0 S

17 Example t p = 1, x=1, τ i0 17 j0 = τ S: τ 1 < 1, 3 >, τ 2 < 3, 6 >, τ 3 < 3, 4 >, τ 4 < 5, 12 >, τ 5 < 7, 12 >

18 CH S = Scheduling analysis Comparison between S tp S i0 and S i0 schedules C i D i m+1 cores m + 1 m cores Analysis area 18 U S = C i T i m 0 t p t d Next H S S i0 S Valid and fair Valid and fair t m cores S i0 Next H Valid and fair U Si0 = C i T i i i0 + C i0 + 1 T i0 m t

19 An issue Subtasks priority inversion 19 - Pending subtasks at t=0 S : τ 3 0 τ 2 0 τ 5 0 τ 1 0 τ 4 0 S i0 : τ 3 0 τ 5 0 τ 2 0 τ 4 0 τ 1 0 In S In S i0 0 0 τ 2 > PD2 τ τ 5 > PD2 τ τ 1 > PD2 τ τ 4 > PD2 τ 1 > PD2 i.e has higher priority over 2 kinds of subtasks at t d S tp S i0 x t d + 1 anticipated S i0 Staggered t t + 1 t p t d

20 Example 1 Without staggered subtasks 20 S: τ 1 < 1, 3 >, τ 2 < 3, 6 >, τ 3 < 3, 4 >, τ 4 < 5, 12 >, τ 5 < 7, 12 > affected anticipated Staggered

21 S1: τ 0 3 < 1, 20 >, τ 4 7 < 1, 36 >, τ 8 47 < 2, 38 >. Example 2 With staggered subtasks 21 S1 : τ 0 3 < 1, 10,20 >, τ 4 7 < 1, 18,36 >, τ 8 47 < 2, 26,38 >. S1 i3 : τ 0 2 < 1, 20 >, τ 3 < 2, 20 >, τ 4 7 < 1, 36 >, τ 8 47 < 2, 38 >. affected anticipated Staggered Postponed

22 Our Result The resulting scheduling is valid and fair 22 Assumptions - S is feasible on m cores - S is feasible on m+1 cores - S i0 is feasible on m cores - There is no staggered subtask and t p is arbitrary - Or there are some staggered subtasks and t p = 0[H] Theorem The resulting scheduling of S tp S i0 on (m + 1) m cores is valid and fair τ i j, r i j Exec τ i j, S tp S i0 < d i j

23 Proof For any t p with no staggered subtasks Proposition 1 (Remark 1) R t : a subtask is not scheduled later in S tp S i0 than in S i0 Proof At any time t t p : - Prop1 t : Pending(τ i j, S tp S i0 ) Pending(τ i j, S i0 ) - Prop2 t : k subtasks with higher priority than τ i j in S tp S i0 k subtasks with higher priority than τ i j in S i0 Conclusion r i j S i0 Exec τ i j, S tp S i0 Exec τ i j, S i0 < d i j (S i0 ) 23

24 Proof For t p = 0[H] with some staggered subtasks Notations τ s g : staggered subtask Proposition 2 (Remark 2) - x staggered subtasks => x + 1 anticipated subtasks - The staggered subtasks meet their pseudo-deadlines Exec τ s g, S tp S i0 = t d < d s g (Si0 ) - The postponed subtasks meet their pseudo-deadlines Exec τ u p, S i0 = t Exec τ u p, S tp S i0 = t + 1 < d u p (S i0 ) - When the postponement ends subtasks are scheduled earlier Conclusion 24 If Exec τ i j, S i0 t Exec τ i j, S tp S i0 t Then R t of Proposition 1 is true. τu p : postponed subtask r i j S i0 Exec τ i j, S tp S i0 < d i j (S i0 ) τ i j : any subtask

25 Future works Complete the proof and explore other situations 25 Proof: t p H and there are staggered subtasks The failure detection delay x is larger Use an aperiodic flow Several cores are affected Reduce the system load (delete tasks or subtasks)

26 26