blob: 2a924e19912a23edf0e58ab3582de7246f1fa318 [file] [log] [blame]
Dario Faggioli712e5e32014-01-27 12:20:15 +01001 Deadline Task Scheduling
2 ------------------------
3
4CONTENTS
5========
6
7 0. WARNING
8 1. Overview
9 2. Scheduling algorithm
10 3. Scheduling Real-Time Tasks
11 4. Bandwidth management
12 4.1 System-wide settings
13 4.2 Task interface
14 4.3 Default behavior
15 5. Tasks CPU affinity
16 5.1 SCHED_DEADLINE and cpusets HOWTO
17 6. Future plans
Juri Lellif5801932014-09-09 10:57:15 +010018 A. Test suite
Juri Lelli13924d22014-09-09 10:57:16 +010019 B. Minimal main()
Dario Faggioli712e5e32014-01-27 12:20:15 +010020
21
220. WARNING
23==========
24
25 Fiddling with these settings can result in an unpredictable or even unstable
26 system behavior. As for -rt (group) scheduling, it is assumed that root users
27 know what they're doing.
28
29
301. Overview
31===========
32
33 The SCHED_DEADLINE policy contained inside the sched_dl scheduling class is
34 basically an implementation of the Earliest Deadline First (EDF) scheduling
35 algorithm, augmented with a mechanism (called Constant Bandwidth Server, CBS)
36 that makes it possible to isolate the behavior of tasks between each other.
37
38
392. Scheduling algorithm
40==================
41
42 SCHED_DEADLINE uses three parameters, named "runtime", "period", and
Luca Abenib56bfc62014-09-09 10:57:14 +010043 "deadline", to schedule tasks. A SCHED_DEADLINE task should receive
Dario Faggioli712e5e32014-01-27 12:20:15 +010044 "runtime" microseconds of execution time every "period" microseconds, and
45 these "runtime" microseconds are available within "deadline" microseconds
Luca Abeni3a3a58d2015-05-18 15:00:25 +020046 from the beginning of the period. In order to implement this behavior,
Dario Faggioli712e5e32014-01-27 12:20:15 +010047 every time the task wakes up, the scheduler computes a "scheduling deadline"
48 consistent with the guarantee (using the CBS[2,3] algorithm). Tasks are then
49 scheduled using EDF[1] on these scheduling deadlines (the task with the
Luca Abenib56bfc62014-09-09 10:57:14 +010050 earliest scheduling deadline is selected for execution). Notice that the
51 task actually receives "runtime" time units within "deadline" if a proper
52 "admission control" strategy (see Section "4. Bandwidth management") is used
53 (clearly, if the system is overloaded this guarantee cannot be respected).
Dario Faggioli712e5e32014-01-27 12:20:15 +010054
Luca Abeni3aa2dbe2015-05-18 15:00:26 +020055 Summing up, the CBS[2,3] algorithm assigns scheduling deadlines to tasks so
Dario Faggioli712e5e32014-01-27 12:20:15 +010056 that each task runs for at most its runtime every period, avoiding any
57 interference between different tasks (bandwidth isolation), while the EDF[1]
Luca Abeniad67dc32014-09-09 10:57:12 +010058 algorithm selects the task with the earliest scheduling deadline as the one
59 to be executed next. Thanks to this feature, tasks that do not strictly comply
60 with the "traditional" real-time task model (see Section 3) can effectively
61 use the new policy.
Dario Faggioli712e5e32014-01-27 12:20:15 +010062
63 In more details, the CBS algorithm assigns scheduling deadlines to
64 tasks in the following way:
65
Luca Abeni3a3a58d2015-05-18 15:00:25 +020066 - Each SCHED_DEADLINE task is characterized by the "runtime",
Dario Faggioli712e5e32014-01-27 12:20:15 +010067 "deadline", and "period" parameters;
68
69 - The state of the task is described by a "scheduling deadline", and
Luca Abeniad67dc32014-09-09 10:57:12 +010070 a "remaining runtime". These two parameters are initially set to 0;
Dario Faggioli712e5e32014-01-27 12:20:15 +010071
72 - When a SCHED_DEADLINE task wakes up (becomes ready for execution),
73 the scheduler checks if
74
Luca Abeniad67dc32014-09-09 10:57:12 +010075 remaining runtime runtime
76 ---------------------------------- > ---------
77 scheduling deadline - current time period
Dario Faggioli712e5e32014-01-27 12:20:15 +010078
79 then, if the scheduling deadline is smaller than the current time, or
80 this condition is verified, the scheduling deadline and the
Luca Abeni3a3a58d2015-05-18 15:00:25 +020081 remaining runtime are re-initialized as
Dario Faggioli712e5e32014-01-27 12:20:15 +010082
83 scheduling deadline = current time + deadline
Luca Abeniad67dc32014-09-09 10:57:12 +010084 remaining runtime = runtime
Dario Faggioli712e5e32014-01-27 12:20:15 +010085
Luca Abeniad67dc32014-09-09 10:57:12 +010086 otherwise, the scheduling deadline and the remaining runtime are
Dario Faggioli712e5e32014-01-27 12:20:15 +010087 left unchanged;
88
89 - When a SCHED_DEADLINE task executes for an amount of time t, its
Luca Abeniad67dc32014-09-09 10:57:12 +010090 remaining runtime is decreased as
Dario Faggioli712e5e32014-01-27 12:20:15 +010091
Luca Abeniad67dc32014-09-09 10:57:12 +010092 remaining runtime = remaining runtime - t
Dario Faggioli712e5e32014-01-27 12:20:15 +010093
94 (technically, the runtime is decreased at every tick, or when the
95 task is descheduled / preempted);
96
Luca Abeniad67dc32014-09-09 10:57:12 +010097 - When the remaining runtime becomes less or equal than 0, the task is
Dario Faggioli712e5e32014-01-27 12:20:15 +010098 said to be "throttled" (also known as "depleted" in real-time literature)
99 and cannot be scheduled until its scheduling deadline. The "replenishment
100 time" for this task (see next item) is set to be equal to the current
101 value of the scheduling deadline;
102
103 - When the current time is equal to the replenishment time of a
Luca Abeniad67dc32014-09-09 10:57:12 +0100104 throttled task, the scheduling deadline and the remaining runtime are
Dario Faggioli712e5e32014-01-27 12:20:15 +0100105 updated as
106
107 scheduling deadline = scheduling deadline + period
Luca Abeniad67dc32014-09-09 10:57:12 +0100108 remaining runtime = remaining runtime + runtime
Dario Faggioli712e5e32014-01-27 12:20:15 +0100109
110
1113. Scheduling Real-Time Tasks
112=============================
113
114 * BIG FAT WARNING ******************************************************
115 *
116 * This section contains a (not-thorough) summary on classical deadline
117 * scheduling theory, and how it applies to SCHED_DEADLINE.
118 * The reader can "safely" skip to Section 4 if only interested in seeing
119 * how the scheduling policy can be used. Anyway, we strongly recommend
120 * to come back here and continue reading (once the urge for testing is
121 * satisfied :P) to be sure of fully understanding all technical details.
122 ************************************************************************
123
124 There are no limitations on what kind of task can exploit this new
125 scheduling discipline, even if it must be said that it is particularly
126 suited for periodic or sporadic real-time tasks that need guarantees on their
127 timing behavior, e.g., multimedia, streaming, control applications, etc.
128
129 A typical real-time task is composed of a repetition of computation phases
130 (task instances, or jobs) which are activated on a periodic or sporadic
131 fashion.
Luca Abeni3a3a58d2015-05-18 15:00:25 +0200132 Each job J_j (where J_j is the j^th job of the task) is characterized by an
Dario Faggioli712e5e32014-01-27 12:20:15 +0100133 arrival time r_j (the time when the job starts), an amount of computation
134 time c_j needed to finish the job, and a job absolute deadline d_j, which
135 is the time within which the job should be finished. The maximum execution
Luca Abenic2a68492015-05-18 15:00:28 +0200136 time max{c_j} is called "Worst Case Execution Time" (WCET) for the task.
Dario Faggioli712e5e32014-01-27 12:20:15 +0100137 A real-time task can be periodic with period P if r_{j+1} = r_j + P, or
138 sporadic with minimum inter-arrival time P is r_{j+1} >= r_j + P. Finally,
139 d_j = r_j + D, where D is the task's relative deadline.
Luca Abenie0deda82015-05-18 15:00:29 +0200140 Summing up, a real-time task can be described as
141 Task = (WCET, D, P)
142
Luca Abeni3a3a58d2015-05-18 15:00:25 +0200143 The utilization of a real-time task is defined as the ratio between its
Luca Abenib56bfc62014-09-09 10:57:14 +0100144 WCET and its period (or minimum inter-arrival time), and represents
145 the fraction of CPU time needed to execute the task.
146
Luca Abenic2a68492015-05-18 15:00:28 +0200147 If the total utilization U=sum(WCET_i/P_i) is larger than M (with M equal
Luca Abenib56bfc62014-09-09 10:57:14 +0100148 to the number of CPUs), then the scheduler is unable to respect all the
149 deadlines.
Luca Abeni3a3a58d2015-05-18 15:00:25 +0200150 Note that total utilization is defined as the sum of the utilizations
Luca Abenib56bfc62014-09-09 10:57:14 +0100151 WCET_i/P_i over all the real-time tasks in the system. When considering
152 multiple real-time tasks, the parameters of the i-th task are indicated
153 with the "_i" suffix.
Luca Abeni3a3a58d2015-05-18 15:00:25 +0200154 Moreover, if the total utilization is larger than M, then we risk starving
Luca Abenib56bfc62014-09-09 10:57:14 +0100155 non- real-time tasks by real-time tasks.
Luca Abeni3a3a58d2015-05-18 15:00:25 +0200156 If, instead, the total utilization is smaller than M, then non real-time
Luca Abenib56bfc62014-09-09 10:57:14 +0100157 tasks will not be starved and the system might be able to respect all the
158 deadlines.
159 As a matter of fact, in this case it is possible to provide an upper bound
160 for tardiness (defined as the maximum between 0 and the difference
161 between the finishing time of a job and its absolute deadline).
162 More precisely, it can be proven that using a global EDF scheduler the
163 maximum tardiness of each task is smaller or equal than
164 ((M − 1) · WCET_max − WCET_min)/(M − (M − 2) · U_max) + WCET_max
Luca Abenic2a68492015-05-18 15:00:28 +0200165 where WCET_max = max{WCET_i} is the maximum WCET, WCET_min=min{WCET_i}
Luca Abeni134136c2015-05-18 15:00:30 +0200166 is the minimum WCET, and U_max = max{WCET_i/P_i} is the maximum
167 utilization[12].
Luca Abenib56bfc62014-09-09 10:57:14 +0100168
169 If M=1 (uniprocessor system), or in case of partitioned scheduling (each
170 real-time task is statically assigned to one and only one CPU), it is
171 possible to formally check if all the deadlines are respected.
172 If D_i = P_i for all tasks, then EDF is able to respect all the deadlines
Luca Abeni3a3a58d2015-05-18 15:00:25 +0200173 of all the tasks executing on a CPU if and only if the total utilization
Luca Abenib56bfc62014-09-09 10:57:14 +0100174 of the tasks running on such a CPU is smaller or equal than 1.
175 If D_i != P_i for some task, then it is possible to define the density of
Luca Abeni48355c42015-05-18 15:00:27 +0200176 a task as WCET_i/min{D_i,P_i}, and EDF is able to respect all the deadlines
Luca Abenie0deda82015-05-18 15:00:29 +0200177 of all the tasks running on a CPU if the sum of the densities of the tasks
178 running on such a CPU is smaller or equal than 1:
179 sum(WCET_i / min{D_i, P_i}) <= 1
180 It is important to notice that this condition is only sufficient, and not
181 necessary: there are task sets that are schedulable, but do not respect the
182 condition. For example, consider the task set {Task_1,Task_2} composed by
183 Task_1=(50ms,50ms,100ms) and Task_2=(10ms,100ms,100ms).
184 EDF is clearly able to schedule the two tasks without missing any deadline
185 (Task_1 is scheduled as soon as it is released, and finishes just in time
186 to respect its deadline; Task_2 is scheduled immediately after Task_1, hence
187 its response time cannot be larger than 50ms + 10ms = 60ms) even if
188 50 / min{50,100} + 10 / min{100, 100} = 50 / 50 + 10 / 100 = 1.1
189 Of course it is possible to test the exact schedulability of tasks with
190 D_i != P_i (checking a condition that is both sufficient and necessary),
191 but this cannot be done by comparing the total utilization or density with
192 a constant. Instead, the so called "processor demand" approach can be used,
193 computing the total amount of CPU time h(t) needed by all the tasks to
194 respect all of their deadlines in a time interval of size t, and comparing
195 such a time with the interval size t. If h(t) is smaller than t (that is,
196 the amount of time needed by the tasks in a time interval of size t is
197 smaller than the size of the interval) for all the possible values of t, then
198 EDF is able to schedule the tasks respecting all of their deadlines. Since
199 performing this check for all possible values of t is impossible, it has been
200 proven[4,5,6] that it is sufficient to perform the test for values of t
201 between 0 and a maximum value L. The cited papers contain all of the
202 mathematical details and explain how to compute h(t) and L.
203 In any case, this kind of analysis is too complex as well as too
204 time-consuming to be performed on-line. Hence, as explained in Section
205 4 Linux uses an admission test based on the tasks' utilizations.
Luca Abenib56bfc62014-09-09 10:57:14 +0100206
207 On multiprocessor systems with global EDF scheduling (non partitioned
208 systems), a sufficient test for schedulability can not be based on the
Luca Abeni134136c2015-05-18 15:00:30 +0200209 utilizations or densities: it can be shown that even if D_i = P_i task
210 sets with utilizations slightly larger than 1 can miss deadlines regardless
211 of the number of CPUs.
212
213 Consider a set {Task_1,...Task_{M+1}} of M+1 tasks on a system with M
214 CPUs, with the first task Task_1=(P,P,P) having period, relative deadline
215 and WCET equal to P. The remaining M tasks Task_i=(e,P-1,P-1) have an
216 arbitrarily small worst case execution time (indicated as "e" here) and a
217 period smaller than the one of the first task. Hence, if all the tasks
218 activate at the same time t, global EDF schedules these M tasks first
219 (because their absolute deadlines are equal to t + P - 1, hence they are
220 smaller than the absolute deadline of Task_1, which is t + P). As a
221 result, Task_1 can be scheduled only at time t + e, and will finish at
222 time t + e + P, after its absolute deadline. The total utilization of the
223 task set is U = M · e / (P - 1) + P / P = M · e / (P - 1) + 1, and for small
224 values of e this can become very close to 1. This is known as "Dhall's
225 effect"[7]. Note: the example in the original paper by Dhall has been
226 slightly simplified here (for example, Dhall more correctly computed
227 lim_{e->0}U).
228
229 More complex schedulability tests for global EDF have been developed in
230 real-time literature[8,9], but they are not based on a simple comparison
231 between total utilization (or density) and a fixed constant. If all tasks
232 have D_i = P_i, a sufficient schedulability condition can be expressed in
233 a simple way:
234 sum(WCET_i / P_i) <= M - (M - 1) · U_max
235 where U_max = max{WCET_i / P_i}[10]. Notice that for U_max = 1,
236 M - (M - 1) · U_max becomes M - M + 1 = 1 and this schedulability condition
237 just confirms the Dhall's effect. A more complete survey of the literature
238 about schedulability tests for multi-processor real-time scheduling can be
239 found in [11].
240
241 As seen, enforcing that the total utilization is smaller than M does not
242 guarantee that global EDF schedules the tasks without missing any deadline
243 (in other words, global EDF is not an optimal scheduling algorithm). However,
244 a total utilization smaller than M is enough to guarantee that non real-time
245 tasks are not starved and that the tardiness of real-time tasks has an upper
246 bound[12] (as previously noted). Different bounds on the maximum tardiness
247 experienced by real-time tasks have been developed in various papers[13,14],
248 but the theoretical result that is important for SCHED_DEADLINE is that if
249 the total utilization is smaller or equal than M then the response times of
250 the tasks are limited.
Dario Faggioli712e5e32014-01-27 12:20:15 +0100251
Luca Abeni78740852015-05-18 15:00:31 +0200252 Finally, it is important to understand the relationship between the
253 SCHED_DEADLINE scheduling parameters described in Section 2 (runtime,
254 deadline and period) and the real-time task parameters (WCET, D, P)
255 described in this section. Note that the tasks' temporal constraints are
256 represented by its absolute deadlines d_j = r_j + D described above, while
257 SCHED_DEADLINE schedules the tasks according to scheduling deadlines (see
258 Section 2).
259 If an admission test is used to guarantee that the scheduling deadlines
260 are respected, then SCHED_DEADLINE can be used to schedule real-time tasks
261 guaranteeing that all the jobs' deadlines of a task are respected.
262 In order to do this, a task must be scheduled by setting:
Dario Faggioli712e5e32014-01-27 12:20:15 +0100263
264 - runtime >= WCET
265 - deadline = D
266 - period <= P
267
Luca Abeni3aa2dbe2015-05-18 15:00:26 +0200268 IOW, if runtime >= WCET and if period is <= P, then the scheduling deadlines
Dario Faggioli712e5e32014-01-27 12:20:15 +0100269 and the absolute deadlines (d_j) coincide, so a proper admission control
270 allows to respect the jobs' absolute deadlines for this task (this is what is
271 called "hard schedulability property" and is an extension of Lemma 1 of [2]).
Luca Abeniad67dc32014-09-09 10:57:12 +0100272 Notice that if runtime > deadline the admission control will surely reject
273 this task, as it is not possible to respect its temporal constraints.
Dario Faggioli712e5e32014-01-27 12:20:15 +0100274
275 References:
276 1 - C. L. Liu and J. W. Layland. Scheduling algorithms for multiprogram-
277 ming in a hard-real-time environment. Journal of the Association for
278 Computing Machinery, 20(1), 1973.
279 2 - L. Abeni , G. Buttazzo. Integrating Multimedia Applications in Hard
280 Real-Time Systems. Proceedings of the 19th IEEE Real-time Systems
281 Symposium, 1998. http://retis.sssup.it/~giorgio/paps/1998/rtss98-cbs.pdf
282 3 - L. Abeni. Server Mechanisms for Multimedia Applications. ReTiS Lab
Luca Abeniad67dc32014-09-09 10:57:12 +0100283 Technical Report. http://disi.unitn.it/~abeni/tr-98-01.pdf
Luca Abenie0deda82015-05-18 15:00:29 +0200284 4 - J. Y. Leung and M.L. Merril. A Note on Preemptive Scheduling of
285 Periodic, Real-Time Tasks. Information Processing Letters, vol. 11,
286 no. 3, pp. 115-118, 1980.
287 5 - S. K. Baruah, A. K. Mok and L. E. Rosier. Preemptively Scheduling
288 Hard-Real-Time Sporadic Tasks on One Processor. Proceedings of the
289 11th IEEE Real-time Systems Symposium, 1990.
290 6 - S. K. Baruah, L. E. Rosier and R. R. Howell. Algorithms and Complexity
291 Concerning the Preemptive Scheduling of Periodic Real-Time tasks on
292 One Processor. Real-Time Systems Journal, vol. 4, no. 2, pp 301-324,
293 1990.
Luca Abeni134136c2015-05-18 15:00:30 +0200294 7 - S. J. Dhall and C. L. Liu. On a real-time scheduling problem. Operations
295 research, vol. 26, no. 1, pp 127-140, 1978.
296 8 - T. Baker. Multiprocessor EDF and Deadline Monotonic Schedulability
297 Analysis. Proceedings of the 24th IEEE Real-Time Systems Symposium, 2003.
298 9 - T. Baker. An Analysis of EDF Schedulability on a Multiprocessor.
299 IEEE Transactions on Parallel and Distributed Systems, vol. 16, no. 8,
300 pp 760-768, 2005.
301 10 - J. Goossens, S. Funk and S. Baruah, Priority-Driven Scheduling of
302 Periodic Task Systems on Multiprocessors. Real-Time Systems Journal,
303 vol. 25, no. 2–3, pp. 187–205, 2003.
304 11 - R. Davis and A. Burns. A Survey of Hard Real-Time Scheduling for
305 Multiprocessor Systems. ACM Computing Surveys, vol. 43, no. 4, 2011.
306 http://www-users.cs.york.ac.uk/~robdavis/papers/MPSurveyv5.0.pdf
307 12 - U. C. Devi and J. H. Anderson. Tardiness Bounds under Global EDF
308 Scheduling on a Multiprocessor. Real-Time Systems Journal, vol. 32,
309 no. 2, pp 133-189, 2008.
310 13 - P. Valente and G. Lipari. An Upper Bound to the Lateness of Soft
311 Real-Time Tasks Scheduled by EDF on Multiprocessors. Proceedings of
312 the 26th IEEE Real-Time Systems Symposium, 2005.
313 14 - J. Erickson, U. Devi and S. Baruah. Improved tardiness bounds for
314 Global EDF. Proceedings of the 22nd Euromicro Conference on
315 Real-Time Systems, 2010.
316
Dario Faggioli712e5e32014-01-27 12:20:15 +0100317
3184. Bandwidth management
319=======================
320
Luca Abenib56bfc62014-09-09 10:57:14 +0100321 As previously mentioned, in order for -deadline scheduling to be
322 effective and useful (that is, to be able to provide "runtime" time units
323 within "deadline"), it is important to have some method to keep the allocation
324 of the available fractions of CPU time to the various tasks under control.
325 This is usually called "admission control" and if it is not performed, then
326 no guarantee can be given on the actual scheduling of the -deadline tasks.
Dario Faggioli712e5e32014-01-27 12:20:15 +0100327
Luca Abenib56bfc62014-09-09 10:57:14 +0100328 As already stated in Section 3, a necessary condition to be respected to
Luca Abeni3a3a58d2015-05-18 15:00:25 +0200329 correctly schedule a set of real-time tasks is that the total utilization
Luca Abenib56bfc62014-09-09 10:57:14 +0100330 is smaller than M. When talking about -deadline tasks, this requires that
331 the sum of the ratio between runtime and period for all tasks is smaller
Luca Abeni3a3a58d2015-05-18 15:00:25 +0200332 than M. Notice that the ratio runtime/period is equivalent to the utilization
Luca Abenib56bfc62014-09-09 10:57:14 +0100333 of a "traditional" real-time task, and is also often referred to as
334 "bandwidth".
335 The interface used to control the CPU bandwidth that can be allocated
336 to -deadline tasks is similar to the one already used for -rt
Juri Lelli0d9ba8b2014-09-09 10:57:13 +0100337 tasks with real-time group scheduling (a.k.a. RT-throttling - see
338 Documentation/scheduler/sched-rt-group.txt), and is based on readable/
339 writable control files located in procfs (for system wide settings).
340 Notice that per-group settings (controlled through cgroupfs) are still not
341 defined for -deadline tasks, because more discussion is needed in order to
342 figure out how we want to manage SCHED_DEADLINE bandwidth at the task group
343 level.
Dario Faggioli712e5e32014-01-27 12:20:15 +0100344
Juri Lelli0d9ba8b2014-09-09 10:57:13 +0100345 A main difference between deadline bandwidth management and RT-throttling
Dario Faggioli712e5e32014-01-27 12:20:15 +0100346 is that -deadline tasks have bandwidth on their own (while -rt ones don't!),
Juri Lelli0d9ba8b2014-09-09 10:57:13 +0100347 and thus we don't need a higher level throttling mechanism to enforce the
Luca Abenib56bfc62014-09-09 10:57:14 +0100348 desired bandwidth. In other words, this means that interface parameters are
349 only used at admission control time (i.e., when the user calls
350 sched_setattr()). Scheduling is then performed considering actual tasks'
351 parameters, so that CPU bandwidth is allocated to SCHED_DEADLINE tasks
352 respecting their needs in terms of granularity. Therefore, using this simple
353 interface we can put a cap on total utilization of -deadline tasks (i.e.,
354 \Sum (runtime_i / period_i) < global_dl_utilization_cap).
Dario Faggioli712e5e32014-01-27 12:20:15 +0100355
3564.1 System wide settings
357------------------------
358
359 The system wide settings are configured under the /proc virtual file system.
360
Juri Lelli0d9ba8b2014-09-09 10:57:13 +0100361 For now the -rt knobs are used for -deadline admission control and the
Luca Abeni3a3a58d2015-05-18 15:00:25 +0200362 -deadline runtime is accounted against the -rt runtime. We realize that this
Juri Lelli0d9ba8b2014-09-09 10:57:13 +0100363 isn't entirely desirable; however, it is better to have a small interface for
364 now, and be able to change it easily later. The ideal situation (see 5.) is to
365 run -rt tasks from a -deadline server; in which case the -rt bandwidth is a
366 direct subset of dl_bw.
Dario Faggioli712e5e32014-01-27 12:20:15 +0100367
368 This means that, for a root_domain comprising M CPUs, -deadline tasks
369 can be created while the sum of their bandwidths stays below:
370
371 M * (sched_rt_runtime_us / sched_rt_period_us)
372
373 It is also possible to disable this bandwidth management logic, and
374 be thus free of oversubscribing the system up to any arbitrary level.
375 This is done by writing -1 in /proc/sys/kernel/sched_rt_runtime_us.
376
377
3784.2 Task interface
379------------------
380
381 Specifying a periodic/sporadic task that executes for a given amount of
382 runtime at each instance, and that is scheduled according to the urgency of
383 its own timing constraints needs, in general, a way of declaring:
384 - a (maximum/typical) instance execution time,
385 - a minimum interval between consecutive instances,
386 - a time constraint by which each instance must be completed.
387
388 Therefore:
389 * a new struct sched_attr, containing all the necessary fields is
390 provided;
391 * the new scheduling related syscalls that manipulate it, i.e.,
392 sched_setattr() and sched_getattr() are implemented.
393
394
3954.3 Default behavior
396---------------------
397
398 The default value for SCHED_DEADLINE bandwidth is to have rt_runtime equal to
399 950000. With rt_period equal to 1000000, by default, it means that -deadline
400 tasks can use at most 95%, multiplied by the number of CPUs that compose the
401 root_domain, for each root_domain.
Luca Abenib56bfc62014-09-09 10:57:14 +0100402 This means that non -deadline tasks will receive at least 5% of the CPU time,
403 and that -deadline tasks will receive their runtime with a guaranteed
404 worst-case delay respect to the "deadline" parameter. If "deadline" = "period"
405 and the cpuset mechanism is used to implement partitioned scheduling (see
406 Section 5), then this simple setting of the bandwidth management is able to
407 deterministically guarantee that -deadline tasks will receive their runtime
408 in a period.
Dario Faggioli712e5e32014-01-27 12:20:15 +0100409
Luca Abenib56bfc62014-09-09 10:57:14 +0100410 Finally, notice that in order not to jeopardize the admission control a
411 -deadline task cannot fork.
Dario Faggioli712e5e32014-01-27 12:20:15 +0100412
4135. Tasks CPU affinity
414=====================
415
416 -deadline tasks cannot have an affinity mask smaller that the entire
417 root_domain they are created on. However, affinities can be specified
418 through the cpuset facility (Documentation/cgroups/cpusets.txt).
419
4205.1 SCHED_DEADLINE and cpusets HOWTO
421------------------------------------
422
423 An example of a simple configuration (pin a -deadline task to CPU0)
424 follows (rt-app is used to create a -deadline task).
425
426 mkdir /dev/cpuset
427 mount -t cgroup -o cpuset cpuset /dev/cpuset
428 cd /dev/cpuset
429 mkdir cpu0
430 echo 0 > cpu0/cpuset.cpus
431 echo 0 > cpu0/cpuset.mems
432 echo 1 > cpuset.cpu_exclusive
433 echo 0 > cpuset.sched_load_balance
434 echo 1 > cpu0/cpuset.cpu_exclusive
435 echo 1 > cpu0/cpuset.mem_exclusive
436 echo $$ > cpu0/tasks
437 rt-app -t 100000:10000:d:0 -D5 (it is now actually superfluous to specify
438 task affinity)
439
4406. Future plans
441===============
442
443 Still missing:
444
445 - refinements to deadline inheritance, especially regarding the possibility
446 of retaining bandwidth isolation among non-interacting tasks. This is
447 being studied from both theoretical and practical points of view, and
448 hopefully we should be able to produce some demonstrative code soon;
449 - (c)group based bandwidth management, and maybe scheduling;
450 - access control for non-root users (and related security concerns to
451 address), which is the best way to allow unprivileged use of the mechanisms
452 and how to prevent non-root users "cheat" the system?
453
454 As already discussed, we are planning also to merge this work with the EDF
455 throttling patches [https://lkml.org/lkml/2010/2/23/239] but we still are in
456 the preliminary phases of the merge and we really seek feedback that would
457 help us decide on the direction it should take.
Juri Lellif5801932014-09-09 10:57:15 +0100458
459Appendix A. Test suite
460======================
461
462 The SCHED_DEADLINE policy can be easily tested using two applications that
463 are part of a wider Linux Scheduler validation suite. The suite is
464 available as a GitHub repository: https://github.com/scheduler-tools.
465
466 The first testing application is called rt-app and can be used to
467 start multiple threads with specific parameters. rt-app supports
468 SCHED_{OTHER,FIFO,RR,DEADLINE} scheduling policies and their related
469 parameters (e.g., niceness, priority, runtime/deadline/period). rt-app
470 is a valuable tool, as it can be used to synthetically recreate certain
471 workloads (maybe mimicking real use-cases) and evaluate how the scheduler
472 behaves under such workloads. In this way, results are easily reproducible.
473 rt-app is available at: https://github.com/scheduler-tools/rt-app.
474
475 Thread parameters can be specified from the command line, with something like
476 this:
477
478 # rt-app -t 100000:10000:d -t 150000:20000:f:10 -D5
479
480 The above creates 2 threads. The first one, scheduled by SCHED_DEADLINE,
481 executes for 10ms every 100ms. The second one, scheduled at SCHED_FIFO
482 priority 10, executes for 20ms every 150ms. The test will run for a total
483 of 5 seconds.
484
485 More interestingly, configurations can be described with a json file that
486 can be passed as input to rt-app with something like this:
487
488 # rt-app my_config.json
489
490 The parameters that can be specified with the second method are a superset
491 of the command line options. Please refer to rt-app documentation for more
492 details (<rt-app-sources>/doc/*.json).
493
494 The second testing application is a modification of schedtool, called
495 schedtool-dl, which can be used to setup SCHED_DEADLINE parameters for a
496 certain pid/application. schedtool-dl is available at:
497 https://github.com/scheduler-tools/schedtool-dl.git.
498
499 The usage is straightforward:
500
501 # schedtool -E -t 10000000:100000000 -e ./my_cpuhog_app
502
503 With this, my_cpuhog_app is put to run inside a SCHED_DEADLINE reservation
504 of 10ms every 100ms (note that parameters are expressed in microseconds).
505 You can also use schedtool to create a reservation for an already running
506 application, given that you know its pid:
507
508 # schedtool -E -t 10000000:100000000 my_app_pid
Juri Lelli13924d22014-09-09 10:57:16 +0100509
510Appendix B. Minimal main()
511==========================
512
513 We provide in what follows a simple (ugly) self-contained code snippet
514 showing how SCHED_DEADLINE reservations can be created by a real-time
515 application developer.
516
517 #define _GNU_SOURCE
518 #include <unistd.h>
519 #include <stdio.h>
520 #include <stdlib.h>
521 #include <string.h>
522 #include <time.h>
523 #include <linux/unistd.h>
524 #include <linux/kernel.h>
525 #include <linux/types.h>
526 #include <sys/syscall.h>
527 #include <pthread.h>
528
529 #define gettid() syscall(__NR_gettid)
530
531 #define SCHED_DEADLINE 6
532
533 /* XXX use the proper syscall numbers */
534 #ifdef __x86_64__
535 #define __NR_sched_setattr 314
536 #define __NR_sched_getattr 315
537 #endif
538
539 #ifdef __i386__
540 #define __NR_sched_setattr 351
541 #define __NR_sched_getattr 352
542 #endif
543
544 #ifdef __arm__
545 #define __NR_sched_setattr 380
546 #define __NR_sched_getattr 381
547 #endif
548
549 static volatile int done;
550
551 struct sched_attr {
552 __u32 size;
553
554 __u32 sched_policy;
555 __u64 sched_flags;
556
557 /* SCHED_NORMAL, SCHED_BATCH */
558 __s32 sched_nice;
559
560 /* SCHED_FIFO, SCHED_RR */
561 __u32 sched_priority;
562
563 /* SCHED_DEADLINE (nsec) */
564 __u64 sched_runtime;
565 __u64 sched_deadline;
566 __u64 sched_period;
567 };
568
569 int sched_setattr(pid_t pid,
570 const struct sched_attr *attr,
571 unsigned int flags)
572 {
573 return syscall(__NR_sched_setattr, pid, attr, flags);
574 }
575
576 int sched_getattr(pid_t pid,
577 struct sched_attr *attr,
578 unsigned int size,
579 unsigned int flags)
580 {
581 return syscall(__NR_sched_getattr, pid, attr, size, flags);
582 }
583
584 void *run_deadline(void *data)
585 {
586 struct sched_attr attr;
587 int x = 0;
588 int ret;
589 unsigned int flags = 0;
590
591 printf("deadline thread started [%ld]\n", gettid());
592
593 attr.size = sizeof(attr);
594 attr.sched_flags = 0;
595 attr.sched_nice = 0;
596 attr.sched_priority = 0;
597
598 /* This creates a 10ms/30ms reservation */
599 attr.sched_policy = SCHED_DEADLINE;
600 attr.sched_runtime = 10 * 1000 * 1000;
601 attr.sched_period = attr.sched_deadline = 30 * 1000 * 1000;
602
603 ret = sched_setattr(0, &attr, flags);
604 if (ret < 0) {
605 done = 0;
606 perror("sched_setattr");
607 exit(-1);
608 }
609
610 while (!done) {
611 x++;
612 }
613
614 printf("deadline thread dies [%ld]\n", gettid());
615 return NULL;
616 }
617
618 int main (int argc, char **argv)
619 {
620 pthread_t thread;
621
622 printf("main thread [%ld]\n", gettid());
623
624 pthread_create(&thread, NULL, run_deadline, NULL);
625
626 sleep(10);
627
628 done = 1;
629 pthread_join(thread, NULL);
630
631 printf("main dies [%ld]\n", gettid());
632 return 0;
633 }