1 Deadline Task Scheduling
2 ------------------------
9 2. Scheduling algorithm
10 3. Scheduling Real-Time Tasks
11 4. Bandwidth management
12 4.1 System-wide settings
16 5.1 SCHED_DEADLINE and cpusets HOWTO
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.
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.
39 2. Scheduling algorithm
42 SCHED_DEADLINE uses three parameters, named "runtime", "period", and
43 "deadline", to schedule tasks. A SCHED_DEADLINE task should receive
44 "runtime" microseconds of execution time every "period" microseconds, and
45 these "runtime" microseconds are available within "deadline" microseconds
46 from the beginning of the period. In order to implement this behavior,
47 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
50 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).
55 Summing up, the CBS[2,3] algorithm assigns scheduling deadlines to tasks so
56 that each task runs for at most its runtime every period, avoiding any
57 interference between different tasks (bandwidth isolation), while the EDF[1]
58 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
63 In more details, the CBS algorithm assigns scheduling deadlines to
64 tasks in the following way:
66 - Each SCHED_DEADLINE task is characterized by the "runtime",
67 "deadline", and "period" parameters;
69 - The state of the task is described by a "scheduling deadline", and
70 a "remaining runtime". These two parameters are initially set to 0;
72 - When a SCHED_DEADLINE task wakes up (becomes ready for execution),
73 the scheduler checks if
75 remaining runtime runtime
76 ---------------------------------- > ---------
77 scheduling deadline - current time period
79 then, if the scheduling deadline is smaller than the current time, or
80 this condition is verified, the scheduling deadline and the
81 remaining runtime are re-initialized as
83 scheduling deadline = current time + deadline
84 remaining runtime = runtime
86 otherwise, the scheduling deadline and the remaining runtime are
89 - When a SCHED_DEADLINE task executes for an amount of time t, its
90 remaining runtime is decreased as
92 remaining runtime = remaining runtime - t
94 (technically, the runtime is decreased at every tick, or when the
95 task is descheduled / preempted);
97 - When the remaining runtime becomes less or equal than 0, the task is
98 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;
103 - When the current time is equal to the replenishment time of a
104 throttled task, the scheduling deadline and the remaining runtime are
107 scheduling deadline = scheduling deadline + period
108 remaining runtime = remaining runtime + runtime
111 3. Scheduling Real-Time Tasks
112 =============================
114 * BIG FAT WARNING ******************************************************
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 ************************************************************************
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.
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
132 Each job J_j (where J_j is the j^th job of the task) is characterized by an
133 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
136 time max{c_j} is called "Worst Case Execution Time" (WCET) for the task.
137 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.
140 Summing up, a real-time task can be described as
143 The utilization of a real-time task is defined as the ratio between its
144 WCET and its period (or minimum inter-arrival time), and represents
145 the fraction of CPU time needed to execute the task.
147 If the total utilization U=sum(WCET_i/P_i) is larger than M (with M equal
148 to the number of CPUs), then the scheduler is unable to respect all the
150 Note that total utilization is defined as the sum of the utilizations
151 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.
154 Moreover, if the total utilization is larger than M, then we risk starving
155 non- real-time tasks by real-time tasks.
156 If, instead, the total utilization is smaller than M, then non real-time
157 tasks will not be starved and the system might be able to respect all the
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
165 where WCET_max = max{WCET_i} is the maximum WCET, WCET_min=min{WCET_i}
166 is the minimum WCET, and U_max = max{WCET_i/P_i} is the maximum utilization.
168 If M=1 (uniprocessor system), or in case of partitioned scheduling (each
169 real-time task is statically assigned to one and only one CPU), it is
170 possible to formally check if all the deadlines are respected.
171 If D_i = P_i for all tasks, then EDF is able to respect all the deadlines
172 of all the tasks executing on a CPU if and only if the total utilization
173 of the tasks running on such a CPU is smaller or equal than 1.
174 If D_i != P_i for some task, then it is possible to define the density of
175 a task as WCET_i/min{D_i,P_i}, and EDF is able to respect all the deadlines
176 of all the tasks running on a CPU if the sum of the densities of the tasks
177 running on such a CPU is smaller or equal than 1:
178 sum(WCET_i / min{D_i, P_i}) <= 1
179 It is important to notice that this condition is only sufficient, and not
180 necessary: there are task sets that are schedulable, but do not respect the
181 condition. For example, consider the task set {Task_1,Task_2} composed by
182 Task_1=(50ms,50ms,100ms) and Task_2=(10ms,100ms,100ms).
183 EDF is clearly able to schedule the two tasks without missing any deadline
184 (Task_1 is scheduled as soon as it is released, and finishes just in time
185 to respect its deadline; Task_2 is scheduled immediately after Task_1, hence
186 its response time cannot be larger than 50ms + 10ms = 60ms) even if
187 50 / min{50,100} + 10 / min{100, 100} = 50 / 50 + 10 / 100 = 1.1
188 Of course it is possible to test the exact schedulability of tasks with
189 D_i != P_i (checking a condition that is both sufficient and necessary),
190 but this cannot be done by comparing the total utilization or density with
191 a constant. Instead, the so called "processor demand" approach can be used,
192 computing the total amount of CPU time h(t) needed by all the tasks to
193 respect all of their deadlines in a time interval of size t, and comparing
194 such a time with the interval size t. If h(t) is smaller than t (that is,
195 the amount of time needed by the tasks in a time interval of size t is
196 smaller than the size of the interval) for all the possible values of t, then
197 EDF is able to schedule the tasks respecting all of their deadlines. Since
198 performing this check for all possible values of t is impossible, it has been
199 proven[4,5,6] that it is sufficient to perform the test for values of t
200 between 0 and a maximum value L. The cited papers contain all of the
201 mathematical details and explain how to compute h(t) and L.
202 In any case, this kind of analysis is too complex as well as too
203 time-consuming to be performed on-line. Hence, as explained in Section
204 4 Linux uses an admission test based on the tasks' utilizations.
206 On multiprocessor systems with global EDF scheduling (non partitioned
207 systems), a sufficient test for schedulability can not be based on the
208 utilizations (it can be shown that task sets with utilizations slightly
209 larger than 1 can miss deadlines regardless of the number of CPUs M).
210 However, as previously stated, enforcing that the total utilization is smaller
211 than M is enough to guarantee that non real-time tasks are not starved and
212 that the tardiness of real-time tasks has an upper bound.
214 SCHED_DEADLINE can be used to schedule real-time tasks guaranteeing that
215 the jobs' deadlines of a task are respected. In order to do this, a task
216 must be scheduled by setting:
222 IOW, if runtime >= WCET and if period is <= P, then the scheduling deadlines
223 and the absolute deadlines (d_j) coincide, so a proper admission control
224 allows to respect the jobs' absolute deadlines for this task (this is what is
225 called "hard schedulability property" and is an extension of Lemma 1 of [2]).
226 Notice that if runtime > deadline the admission control will surely reject
227 this task, as it is not possible to respect its temporal constraints.
230 1 - C. L. Liu and J. W. Layland. Scheduling algorithms for multiprogram-
231 ming in a hard-real-time environment. Journal of the Association for
232 Computing Machinery, 20(1), 1973.
233 2 - L. Abeni , G. Buttazzo. Integrating Multimedia Applications in Hard
234 Real-Time Systems. Proceedings of the 19th IEEE Real-time Systems
235 Symposium, 1998. http://retis.sssup.it/~giorgio/paps/1998/rtss98-cbs.pdf
236 3 - L. Abeni. Server Mechanisms for Multimedia Applications. ReTiS Lab
237 Technical Report. http://disi.unitn.it/~abeni/tr-98-01.pdf
238 4 - J. Y. Leung and M.L. Merril. A Note on Preemptive Scheduling of
239 Periodic, Real-Time Tasks. Information Processing Letters, vol. 11,
240 no. 3, pp. 115-118, 1980.
241 5 - S. K. Baruah, A. K. Mok and L. E. Rosier. Preemptively Scheduling
242 Hard-Real-Time Sporadic Tasks on One Processor. Proceedings of the
243 11th IEEE Real-time Systems Symposium, 1990.
244 6 - S. K. Baruah, L. E. Rosier and R. R. Howell. Algorithms and Complexity
245 Concerning the Preemptive Scheduling of Periodic Real-Time tasks on
246 One Processor. Real-Time Systems Journal, vol. 4, no. 2, pp 301-324,
249 4. Bandwidth management
250 =======================
252 As previously mentioned, in order for -deadline scheduling to be
253 effective and useful (that is, to be able to provide "runtime" time units
254 within "deadline"), it is important to have some method to keep the allocation
255 of the available fractions of CPU time to the various tasks under control.
256 This is usually called "admission control" and if it is not performed, then
257 no guarantee can be given on the actual scheduling of the -deadline tasks.
259 As already stated in Section 3, a necessary condition to be respected to
260 correctly schedule a set of real-time tasks is that the total utilization
261 is smaller than M. When talking about -deadline tasks, this requires that
262 the sum of the ratio between runtime and period for all tasks is smaller
263 than M. Notice that the ratio runtime/period is equivalent to the utilization
264 of a "traditional" real-time task, and is also often referred to as
266 The interface used to control the CPU bandwidth that can be allocated
267 to -deadline tasks is similar to the one already used for -rt
268 tasks with real-time group scheduling (a.k.a. RT-throttling - see
269 Documentation/scheduler/sched-rt-group.txt), and is based on readable/
270 writable control files located in procfs (for system wide settings).
271 Notice that per-group settings (controlled through cgroupfs) are still not
272 defined for -deadline tasks, because more discussion is needed in order to
273 figure out how we want to manage SCHED_DEADLINE bandwidth at the task group
276 A main difference between deadline bandwidth management and RT-throttling
277 is that -deadline tasks have bandwidth on their own (while -rt ones don't!),
278 and thus we don't need a higher level throttling mechanism to enforce the
279 desired bandwidth. In other words, this means that interface parameters are
280 only used at admission control time (i.e., when the user calls
281 sched_setattr()). Scheduling is then performed considering actual tasks'
282 parameters, so that CPU bandwidth is allocated to SCHED_DEADLINE tasks
283 respecting their needs in terms of granularity. Therefore, using this simple
284 interface we can put a cap on total utilization of -deadline tasks (i.e.,
285 \Sum (runtime_i / period_i) < global_dl_utilization_cap).
287 4.1 System wide settings
288 ------------------------
290 The system wide settings are configured under the /proc virtual file system.
292 For now the -rt knobs are used for -deadline admission control and the
293 -deadline runtime is accounted against the -rt runtime. We realize that this
294 isn't entirely desirable; however, it is better to have a small interface for
295 now, and be able to change it easily later. The ideal situation (see 5.) is to
296 run -rt tasks from a -deadline server; in which case the -rt bandwidth is a
297 direct subset of dl_bw.
299 This means that, for a root_domain comprising M CPUs, -deadline tasks
300 can be created while the sum of their bandwidths stays below:
302 M * (sched_rt_runtime_us / sched_rt_period_us)
304 It is also possible to disable this bandwidth management logic, and
305 be thus free of oversubscribing the system up to any arbitrary level.
306 This is done by writing -1 in /proc/sys/kernel/sched_rt_runtime_us.
312 Specifying a periodic/sporadic task that executes for a given amount of
313 runtime at each instance, and that is scheduled according to the urgency of
314 its own timing constraints needs, in general, a way of declaring:
315 - a (maximum/typical) instance execution time,
316 - a minimum interval between consecutive instances,
317 - a time constraint by which each instance must be completed.
320 * a new struct sched_attr, containing all the necessary fields is
322 * the new scheduling related syscalls that manipulate it, i.e.,
323 sched_setattr() and sched_getattr() are implemented.
327 ---------------------
329 The default value for SCHED_DEADLINE bandwidth is to have rt_runtime equal to
330 950000. With rt_period equal to 1000000, by default, it means that -deadline
331 tasks can use at most 95%, multiplied by the number of CPUs that compose the
332 root_domain, for each root_domain.
333 This means that non -deadline tasks will receive at least 5% of the CPU time,
334 and that -deadline tasks will receive their runtime with a guaranteed
335 worst-case delay respect to the "deadline" parameter. If "deadline" = "period"
336 and the cpuset mechanism is used to implement partitioned scheduling (see
337 Section 5), then this simple setting of the bandwidth management is able to
338 deterministically guarantee that -deadline tasks will receive their runtime
341 Finally, notice that in order not to jeopardize the admission control a
342 -deadline task cannot fork.
344 5. Tasks CPU affinity
345 =====================
347 -deadline tasks cannot have an affinity mask smaller that the entire
348 root_domain they are created on. However, affinities can be specified
349 through the cpuset facility (Documentation/cgroups/cpusets.txt).
351 5.1 SCHED_DEADLINE and cpusets HOWTO
352 ------------------------------------
354 An example of a simple configuration (pin a -deadline task to CPU0)
355 follows (rt-app is used to create a -deadline task).
358 mount -t cgroup -o cpuset cpuset /dev/cpuset
361 echo 0 > cpu0/cpuset.cpus
362 echo 0 > cpu0/cpuset.mems
363 echo 1 > cpuset.cpu_exclusive
364 echo 0 > cpuset.sched_load_balance
365 echo 1 > cpu0/cpuset.cpu_exclusive
366 echo 1 > cpu0/cpuset.mem_exclusive
368 rt-app -t 100000:10000:d:0 -D5 (it is now actually superfluous to specify
376 - refinements to deadline inheritance, especially regarding the possibility
377 of retaining bandwidth isolation among non-interacting tasks. This is
378 being studied from both theoretical and practical points of view, and
379 hopefully we should be able to produce some demonstrative code soon;
380 - (c)group based bandwidth management, and maybe scheduling;
381 - access control for non-root users (and related security concerns to
382 address), which is the best way to allow unprivileged use of the mechanisms
383 and how to prevent non-root users "cheat" the system?
385 As already discussed, we are planning also to merge this work with the EDF
386 throttling patches [https://lkml.org/lkml/2010/2/23/239] but we still are in
387 the preliminary phases of the merge and we really seek feedback that would
388 help us decide on the direction it should take.
390 Appendix A. Test suite
391 ======================
393 The SCHED_DEADLINE policy can be easily tested using two applications that
394 are part of a wider Linux Scheduler validation suite. The suite is
395 available as a GitHub repository: https://github.com/scheduler-tools.
397 The first testing application is called rt-app and can be used to
398 start multiple threads with specific parameters. rt-app supports
399 SCHED_{OTHER,FIFO,RR,DEADLINE} scheduling policies and their related
400 parameters (e.g., niceness, priority, runtime/deadline/period). rt-app
401 is a valuable tool, as it can be used to synthetically recreate certain
402 workloads (maybe mimicking real use-cases) and evaluate how the scheduler
403 behaves under such workloads. In this way, results are easily reproducible.
404 rt-app is available at: https://github.com/scheduler-tools/rt-app.
406 Thread parameters can be specified from the command line, with something like
409 # rt-app -t 100000:10000:d -t 150000:20000:f:10 -D5
411 The above creates 2 threads. The first one, scheduled by SCHED_DEADLINE,
412 executes for 10ms every 100ms. The second one, scheduled at SCHED_FIFO
413 priority 10, executes for 20ms every 150ms. The test will run for a total
416 More interestingly, configurations can be described with a json file that
417 can be passed as input to rt-app with something like this:
419 # rt-app my_config.json
421 The parameters that can be specified with the second method are a superset
422 of the command line options. Please refer to rt-app documentation for more
423 details (<rt-app-sources>/doc/*.json).
425 The second testing application is a modification of schedtool, called
426 schedtool-dl, which can be used to setup SCHED_DEADLINE parameters for a
427 certain pid/application. schedtool-dl is available at:
428 https://github.com/scheduler-tools/schedtool-dl.git.
430 The usage is straightforward:
432 # schedtool -E -t 10000000:100000000 -e ./my_cpuhog_app
434 With this, my_cpuhog_app is put to run inside a SCHED_DEADLINE reservation
435 of 10ms every 100ms (note that parameters are expressed in microseconds).
436 You can also use schedtool to create a reservation for an already running
437 application, given that you know its pid:
439 # schedtool -E -t 10000000:100000000 my_app_pid
441 Appendix B. Minimal main()
442 ==========================
444 We provide in what follows a simple (ugly) self-contained code snippet
445 showing how SCHED_DEADLINE reservations can be created by a real-time
446 application developer.
454 #include <linux/unistd.h>
455 #include <linux/kernel.h>
456 #include <linux/types.h>
457 #include <sys/syscall.h>
460 #define gettid() syscall(__NR_gettid)
462 #define SCHED_DEADLINE 6
464 /* XXX use the proper syscall numbers */
466 #define __NR_sched_setattr 314
467 #define __NR_sched_getattr 315
471 #define __NR_sched_setattr 351
472 #define __NR_sched_getattr 352
476 #define __NR_sched_setattr 380
477 #define __NR_sched_getattr 381
480 static volatile int done;
488 /* SCHED_NORMAL, SCHED_BATCH */
491 /* SCHED_FIFO, SCHED_RR */
492 __u32 sched_priority;
494 /* SCHED_DEADLINE (nsec) */
496 __u64 sched_deadline;
500 int sched_setattr(pid_t pid,
501 const struct sched_attr *attr,
504 return syscall(__NR_sched_setattr, pid, attr, flags);
507 int sched_getattr(pid_t pid,
508 struct sched_attr *attr,
512 return syscall(__NR_sched_getattr, pid, attr, size, flags);
515 void *run_deadline(void *data)
517 struct sched_attr attr;
520 unsigned int flags = 0;
522 printf("deadline thread started [%ld]\n", gettid());
524 attr.size = sizeof(attr);
525 attr.sched_flags = 0;
527 attr.sched_priority = 0;
529 /* This creates a 10ms/30ms reservation */
530 attr.sched_policy = SCHED_DEADLINE;
531 attr.sched_runtime = 10 * 1000 * 1000;
532 attr.sched_period = attr.sched_deadline = 30 * 1000 * 1000;
534 ret = sched_setattr(0, &attr, flags);
537 perror("sched_setattr");
545 printf("deadline thread dies [%ld]\n", gettid());
549 int main (int argc, char **argv)
553 printf("main thread [%ld]\n", gettid());
555 pthread_create(&thread, NULL, run_deadline, NULL);
560 pthread_join(thread, NULL);
562 printf("main dies [%ld]\n", gettid());