[PATCH v2 0/4] SCHED_DEADLINE documentation fixes and improvements

[PATCH v2 0/4] SCHED_DEADLINE documentation fixes and improvements

[Juri Lelli]

Hello everyone,

This is version 2 of a small patchset that fixes and improves SCHED_DEADLINE
documentation.

Patch 1/4 fixes and clarifies terminology; patch 2/4 aligns Section 4 to
the current interface; patch 3/4 improves and clarifies what admission
control means on UP an SMP systems; patch 4/4 introduces an appendix about
testing.

Changes since v1:

 - fixed typos spotted by Randy and Peter (thanks!)

Best Regards,

- Juri

Juri Lelli (2):
  Documentation/scheduler/sched-deadline.txt: Rewrite section 4 intro
  Documentation/scheduler/sched-deadline.txt: add tests suite appendix

Luca Abeni (2):
  Documentation/scheduler/sched-deadline.txt: fix terminology and
    improve clarity
  Documentation/scheduler/sched-deadline.txt: improve and clarify AC
    bits

 Documentation/scheduler/sched-deadline.txt | 200 ++++++++++++++++++++++-------
 1 file changed, 156 insertions(+), 44 deletions(-)

-- 
2.0.4

[PATCH v2 1/4] Documentation/scheduler/sched-deadline.txt: fix terminology and improve clarity

[Juri Lelli]

From: Luca Abeni <luca.abeni@unitn.it>

Several small changes regarding SCHED_DEADLINE documentation that fix
terminology and improve clarity and readability:

 - "current runtime" becomes "remaining runtime"

 - readablity of an equation is improved by introducing more spacing

 - clarify when admission control will certainly fail

 - new URL for CBS technical report

 - substitue "smallest" with "closest"

Signed-off-by: Luca Abeni <luca.abeni@unitn.it>
Signed-off-by: Juri Lelli <juri.lelli@arm.com>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Henrik Austad <henrik@austad.us>
Cc: Dario Faggioli <raistlin@linux.it>
Cc: Juri Lelli <juri.lelli@gmail.com>
Cc: linux-doc@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
---
 Documentation/scheduler/sched-deadline.txt | 32 ++++++++++++++++--------------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/Documentation/scheduler/sched-deadline.txt b/Documentation/scheduler/sched-deadline.txt
index 18adc92..dce6d63 100644
--- a/Documentation/scheduler/sched-deadline.txt
+++ b/Documentation/scheduler/sched-deadline.txt
@@ -45,14 +45,14 @@ CONTENTS
  every time the task wakes up, the scheduler computes a "scheduling deadline"
  consistent with the guarantee (using the CBS[2,3] algorithm). Tasks are then
  scheduled using EDF[1] on these scheduling deadlines (the task with the
- smallest scheduling deadline is selected for execution). Notice that this
+ closest scheduling deadline is selected for execution). Notice that this
  guaranteed is respected if a proper "admission control" strategy (see Section
  "4. Bandwidth management") is used.
 
  Summing up, the CBS[2,3] algorithms assigns scheduling deadlines to tasks so
  that each task runs for at most its runtime every period, avoiding any
  interference between different tasks (bandwidth isolation), while the EDF[1]
- algorithm selects the task with the smallest scheduling deadline as the one
+ algorithm selects the task with the closest scheduling deadline as the one
  to be executed first.  Thanks to this feature, also tasks that do not
  strictly comply with the "traditional" real-time task model (see Section 3)
  can effectively use the new policy.
@@ -64,45 +64,45 @@ CONTENTS
     "deadline", and "period" parameters;
 
   - The state of the task is described by a "scheduling deadline", and
-    a "current runtime". These two parameters are initially set to 0;
+    a "remaining runtime". These two parameters are initially set to 0;
 
   - When a SCHED_DEADLINE task wakes up (becomes ready for execution),
     the scheduler checks if
 
-                    current runtime                runtime
-         ---------------------------------- > ----------------
-         scheduling deadline - current time         period
+                 remaining runtime                  runtime
+        ----------------------------------    >    ---------
+        scheduling deadline - current time           period
 
     then, if the scheduling deadline is smaller than the current time, or
     this condition is verified, the scheduling deadline and the
-    current budget are re-initialised as
+    remaining runtime are re-initialised as
 
          scheduling deadline = current time + deadline
-         current runtime = runtime
+         remaining runtime = runtime
 
-    otherwise, the scheduling deadline and the current runtime are
+    otherwise, the scheduling deadline and the remaining runtime are
     left unchanged;
 
   - When a SCHED_DEADLINE task executes for an amount of time t, its
-    current runtime is decreased as
+    remaining runtime is decreased as
 
-         current runtime = current runtime - t
+         remaining runtime = remaining runtime - t
 
     (technically, the runtime is decreased at every tick, or when the
     task is descheduled / preempted);
 
-  - When the current runtime becomes less or equal than 0, the task is
+  - When the remaining runtime becomes less or equal than 0, the task is
     said to be "throttled" (also known as "depleted" in real-time literature)
     and cannot be scheduled until its scheduling deadline. The "replenishment
     time" for this task (see next item) is set to be equal to the current
     value of the scheduling deadline;
 
   - When the current time is equal to the replenishment time of a
-    throttled task, the scheduling deadline and the current runtime are
+    throttled task, the scheduling deadline and the remaining runtime are
     updated as
 
          scheduling deadline = scheduling deadline + period
-         current runtime = current runtime + runtime
+         remaining runtime = remaining runtime + runtime
 
 
 3. Scheduling Real-Time Tasks
@@ -147,6 +147,8 @@ CONTENTS
  and the absolute deadlines (d_j) coincide, so a proper admission control
  allows to respect the jobs' absolute deadlines for this task (this is what is
  called "hard schedulability property" and is an extension of Lemma 1 of [2]).
+ Notice that if runtime > deadline the admission control will surely reject
+ this task, as it is not possible to respect its temporal constraints.
 
  References:
   1 - C. L. Liu and J. W. Layland. Scheduling algorithms for multiprogram-
@@ -156,7 +158,7 @@ CONTENTS
       Real-Time Systems. Proceedings of the 19th IEEE Real-time Systems
       Symposium, 1998. http://retis.sssup.it/~giorgio/paps/1998/rtss98-cbs.pdf
   3 - L. Abeni. Server Mechanisms for Multimedia Applications. ReTiS Lab
-      Technical Report. http://xoomer.virgilio.it/lucabe72/pubs/tr-98-01.ps
+      Technical Report. http://disi.unitn.it/~abeni/tr-98-01.pdf
 
 4. Bandwidth management
 =======================
-- 
2.0.4

[PATCH v2 2/4] Documentation/scheduler/sched-deadline.txt: Rewrite section 4 intro

[Juri Lelli]

Section 4 intro was still describing the old interface. Rewrite it.

Signed-off-by: Juri Lelli <juri.lelli@arm.com>
Signed-off-by: Luca Abeni <luca.abeni@unitn.it>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Henrik Austad <henrik@austad.us>
Cc: Dario Faggioli <raistlin@linux.it>
Cc: Juri Lelli <juri.lelli@gmail.com>
Cc: linux-doc@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
---
 Documentation/scheduler/sched-deadline.txt | 49 +++++++++++++++---------------
 1 file changed, 24 insertions(+), 25 deletions(-)

diff --git a/Documentation/scheduler/sched-deadline.txt b/Documentation/scheduler/sched-deadline.txt
index dce6d63..8372c3d 100644
--- a/Documentation/scheduler/sched-deadline.txt
+++ b/Documentation/scheduler/sched-deadline.txt
@@ -165,39 +165,38 @@ CONTENTS
 
  In order for the -deadline scheduling to be effective and useful, it is
  important to have some method to keep the allocation of the available CPU
- bandwidth to the tasks under control.
- This is usually called "admission control" and if it is not performed at all,
- no guarantee can be given on the actual scheduling of the -deadline tasks.
-
- Since when RT-throttling has been introduced each task group has a bandwidth
- associated, calculated as a certain amount of runtime over a period.
- Moreover, to make it possible to manipulate such bandwidth, readable/writable
- controls have been added to both procfs (for system wide settings) and cgroupfs
- (for per-group settings).
- Therefore, the same interface is being used for controlling the bandwidth
- distrubution to -deadline tasks.
-
- However, more discussion is needed in order to figure out how we want to manage
- SCHED_DEADLINE bandwidth at the task group level. Therefore, SCHED_DEADLINE
- uses (for now) a less sophisticated, but actually very sensible, mechanism to
- ensure that a certain utilization cap is not overcome per each root_domain.
-
- Another main difference between deadline bandwidth management and RT-throttling
+ bandwidth to the tasks under control. This is usually called "admission
+ control" and if it is not performed at all, no guarantee can be given on
+ the actual scheduling of the -deadline tasks.
+
+ The interface used to control the fraction of CPU bandwidth that can be
+ allocated to -deadline tasks is similar to the one already used for -rt
+ tasks with real-time group scheduling (a.k.a. RT-throttling - see
+ Documentation/scheduler/sched-rt-group.txt), and is based on readable/
+ writable control files located in procfs (for system wide settings).
+ Notice that per-group settings (controlled through cgroupfs) are still not
+ defined for -deadline tasks, because more discussion is needed in order to
+ figure out how we want to manage SCHED_DEADLINE bandwidth at the task group
+ level.
+
+ A main difference between deadline bandwidth management and RT-throttling
  is that -deadline tasks have bandwidth on their own (while -rt ones don't!),
  and thus we don't need an higher level throttling mechanism to enforce the
- desired bandwidth.
+ desired bandwidth. Therefore, using this simple interface, we can put a cap
+ on total utilization of -deadline tasks (i.e., \Sum (runtime_i / period_i) <
+ some_desired_value).
 
 4.1 System wide settings
 ------------------------
 
  The system wide settings are configured under the /proc virtual file system.
 
- For now the -rt knobs are used for dl admission control and the -deadline
- runtime is accounted against the -rt runtime. We realise that this isn't
- entirely desirable; however, it is better to have a small interface for now,
- and be able to change it easily later. The ideal situation (see 5.) is to run
- -rt tasks from a -deadline server; in which case the -rt bandwidth is a direct
- subset of dl_bw.
+ For now the -rt knobs are used for -deadline admission control and the
+ -deadline runtime is accounted against the -rt runtime. We realise that this
+ isn't entirely desirable; however, it is better to have a small interface for
+ now, and be able to change it easily later. The ideal situation (see 5.) is to
+ run -rt tasks from a -deadline server; in which case the -rt bandwidth is a
+ direct subset of dl_bw.
 
  This means that, for a root_domain comprising M CPUs, -deadline tasks
  can be created while the sum of their bandwidths stays below:
-- 
2.0.4

Re: [PATCH v2 2/4] Documentation/scheduler/sched-deadline.txt: Rewrite section 4 intro

[Ingo Molnar]

* Juri Lelli <juri.lelli@arm.com> wrote:

> Section 4 intro was still describing the old interface. Rewrite it.
> 
> Signed-off-by: Juri Lelli <juri.lelli@arm.com>
> Signed-off-by: Luca Abeni <luca.abeni@unitn.it>
> Cc: Randy Dunlap <rdunlap@infradead.org>
> Cc: Peter Zijlstra <peterz@infradead.org>
> Cc: Ingo Molnar <mingo@redhat.com>
> Cc: Henrik Austad <henrik@austad.us>
> Cc: Dario Faggioli <raistlin@linux.it>
> Cc: Juri Lelli <juri.lelli@gmail.com>
> Cc: linux-doc@vger.kernel.org
> Cc: linux-kernel@vger.kernel.org
> ---
>  Documentation/scheduler/sched-deadline.txt | 49 +++++++++++++++---------------
>  1 file changed, 24 insertions(+), 25 deletions(-)
> 
> diff --git a/Documentation/scheduler/sched-deadline.txt b/Documentation/scheduler/sched-deadline.txt
> index dce6d63..8372c3d 100644
> --- a/Documentation/scheduler/sched-deadline.txt
> +++ b/Documentation/scheduler/sched-deadline.txt
> @@ -165,39 +165,38 @@ CONTENTS
>  
>   In order for the -deadline scheduling to be effective and useful, it is
>   important to have some method to keep the allocation of the available CPU
> - bandwidth to the tasks under control.
> - This is usually called "admission control" and if it is not performed at all,
> - no guarantee can be given on the actual scheduling of the -deadline tasks.
> -
> - Since when RT-throttling has been introduced each task group has a bandwidth
> - associated, calculated as a certain amount of runtime over a period.
> - Moreover, to make it possible to manipulate such bandwidth, readable/writable
> - controls have been added to both procfs (for system wide settings) and cgroupfs
> - (for per-group settings).
> - Therefore, the same interface is being used for controlling the bandwidth
> - distrubution to -deadline tasks.
> -
> - However, more discussion is needed in order to figure out how we want to manage
> - SCHED_DEADLINE bandwidth at the task group level. Therefore, SCHED_DEADLINE
> - uses (for now) a less sophisticated, but actually very sensible, mechanism to
> - ensure that a certain utilization cap is not overcome per each root_domain.
> -
> - Another main difference between deadline bandwidth management and RT-throttling
> + bandwidth to the tasks under control. This is usually called "admission
> + control" and if it is not performed at all, no guarantee can be given on
> + the actual scheduling of the -deadline tasks.
> +
> + The interface used to control the fraction of CPU bandwidth that can be
> + allocated to -deadline tasks is similar to the one already used for -rt
> + tasks with real-time group scheduling (a.k.a. RT-throttling - see
> + Documentation/scheduler/sched-rt-group.txt), and is based on readable/
> + writable control files located in procfs (for system wide settings).
> + Notice that per-group settings (controlled through cgroupfs) are still not
> + defined for -deadline tasks, because more discussion is needed in order to
> + figure out how we want to manage SCHED_DEADLINE bandwidth at the task group
> + level.
> +
> + A main difference between deadline bandwidth management and RT-throttling
>   is that -deadline tasks have bandwidth on their own (while -rt ones don't!),
>   and thus we don't need an higher level throttling mechanism to enforce the

s/an higher/a higher

> - desired bandwidth.
> + desired bandwidth. Therefore, using this simple interface, we can put a cap

s/interface, we/interface we

> + on total utilization of -deadline tasks (i.e., \Sum (runtime_i / period_i) <
> + some_desired_value).

Thanks,

	Ingo

Re: [PATCH v2 2/4] Documentation/scheduler/sched-deadline.txt: Rewrite section 4 intro

[Juri Lelli]

On 21/08/14 14:46, Ingo Molnar wrote:
> * Juri Lelli <juri.lelli@arm.com> wrote:
> 
>> Section 4 intro was still describing the old interface. Rewrite it.
>>
>> Signed-off-by: Juri Lelli <juri.lelli@arm.com>
>> Signed-off-by: Luca Abeni <luca.abeni@unitn.it>
>> Cc: Randy Dunlap <rdunlap@infradead.org>
>> Cc: Peter Zijlstra <peterz@infradead.org>
>> Cc: Ingo Molnar <mingo@redhat.com>
>> Cc: Henrik Austad <henrik@austad.us>
>> Cc: Dario Faggioli <raistlin@linux.it>
>> Cc: Juri Lelli <juri.lelli@gmail.com>
>> Cc: linux-doc@vger.kernel.org
>> Cc: linux-kernel@vger.kernel.org
>> ---
>>  Documentation/scheduler/sched-deadline.txt | 49 +++++++++++++++---------------
>>  1 file changed, 24 insertions(+), 25 deletions(-)
>>
>> diff --git a/Documentation/scheduler/sched-deadline.txt b/Documentation/scheduler/sched-deadline.txt
>> index dce6d63..8372c3d 100644
>> --- a/Documentation/scheduler/sched-deadline.txt
>> +++ b/Documentation/scheduler/sched-deadline.txt
>> @@ -165,39 +165,38 @@ CONTENTS
>>  
>>   In order for the -deadline scheduling to be effective and useful, it is
>>   important to have some method to keep the allocation of the available CPU
>> - bandwidth to the tasks under control.
>> - This is usually called "admission control" and if it is not performed at all,
>> - no guarantee can be given on the actual scheduling of the -deadline tasks.
>> -
>> - Since when RT-throttling has been introduced each task group has a bandwidth
>> - associated, calculated as a certain amount of runtime over a period.
>> - Moreover, to make it possible to manipulate such bandwidth, readable/writable
>> - controls have been added to both procfs (for system wide settings) and cgroupfs
>> - (for per-group settings).
>> - Therefore, the same interface is being used for controlling the bandwidth
>> - distrubution to -deadline tasks.
>> -
>> - However, more discussion is needed in order to figure out how we want to manage
>> - SCHED_DEADLINE bandwidth at the task group level. Therefore, SCHED_DEADLINE
>> - uses (for now) a less sophisticated, but actually very sensible, mechanism to
>> - ensure that a certain utilization cap is not overcome per each root_domain.
>> -
>> - Another main difference between deadline bandwidth management and RT-throttling
>> + bandwidth to the tasks under control. This is usually called "admission
>> + control" and if it is not performed at all, no guarantee can be given on
>> + the actual scheduling of the -deadline tasks.
>> +
>> + The interface used to control the fraction of CPU bandwidth that can be
>> + allocated to -deadline tasks is similar to the one already used for -rt
>> + tasks with real-time group scheduling (a.k.a. RT-throttling - see
>> + Documentation/scheduler/sched-rt-group.txt), and is based on readable/
>> + writable control files located in procfs (for system wide settings).
>> + Notice that per-group settings (controlled through cgroupfs) are still not
>> + defined for -deadline tasks, because more discussion is needed in order to
>> + figure out how we want to manage SCHED_DEADLINE bandwidth at the task group
>> + level.
>> +
>> + A main difference between deadline bandwidth management and RT-throttling
>>   is that -deadline tasks have bandwidth on their own (while -rt ones don't!),
>>   and thus we don't need an higher level throttling mechanism to enforce the
> 
> s/an higher/a higher
> 
>> - desired bandwidth.
>> + desired bandwidth. Therefore, using this simple interface, we can put a cap
> 
> s/interface, we/interface we
> 
>> + on total utilization of -deadline tasks (i.e., \Sum (runtime_i / period_i) <
>> + some_desired_value).
>

Fixed.

Thanks a lot,

- Juri

[PATCH v2 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits

[Juri Lelli]

From: Luca Abeni <luca.abeni@unitn.it>

Admission control is of key importance for SCHED_DEADLINE, since it guarantees
system schedulability (or tells us something about the degree of guarantees
we can provide to the user).

This patch improves and clarifies bits and pieces regarding AC, both for UP
and SMP systems.

Signed-off-by: Luca Abeni <luca.abeni@unitn.it>
Signed-off-by: Juri Lelli <juri.lelli@arm.com>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Henrik Austad <henrik@austad.us>
Cc: Dario Faggioli <raistlin@linux.it>
Cc: Juri Lelli <juri.lelli@gmail.com>
Cc: linux-doc@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
---
 Documentation/scheduler/sched-deadline.txt | 87 +++++++++++++++++++++++++-----
 1 file changed, 73 insertions(+), 14 deletions(-)

diff --git a/Documentation/scheduler/sched-deadline.txt b/Documentation/scheduler/sched-deadline.txt
index 8372c3d..10fc4c4 100644
--- a/Documentation/scheduler/sched-deadline.txt
+++ b/Documentation/scheduler/sched-deadline.txt
@@ -38,16 +38,17 @@ CONTENTS
 ==================
 
  SCHED_DEADLINE uses three parameters, named "runtime", "period", and
- "deadline" to schedule tasks. A SCHED_DEADLINE task is guaranteed to receive
+ "deadline" to schedule tasks. A SCHED_DEADLINE task should receive
  "runtime" microseconds of execution time every "period" microseconds, and
  these "runtime" microseconds are available within "deadline" microseconds
  from the beginning of the period.  In order to implement this behaviour,
  every time the task wakes up, the scheduler computes a "scheduling deadline"
  consistent with the guarantee (using the CBS[2,3] algorithm). Tasks are then
  scheduled using EDF[1] on these scheduling deadlines (the task with the
- closest scheduling deadline is selected for execution). Notice that this
- guaranteed is respected if a proper "admission control" strategy (see Section
- "4. Bandwidth management") is used.
+ closest scheduling deadline is selected for execution). Notice that the
+ task actually receives "runtime" time units within "deadline" if a proper
+ "admission control" strategy (see Section "4. Bandwidth management") is used
+ (clearly, if the system is overloaded this guarantee cannot be respected).
 
  Summing up, the CBS[2,3] algorithms assigns scheduling deadlines to tasks so
  that each task runs for at most its runtime every period, avoiding any
@@ -134,6 +135,48 @@ CONTENTS
  A real-time task can be periodic with period P if r_{j+1} = r_j + P, or
  sporadic with minimum inter-arrival time P is r_{j+1} >= r_j + P. Finally,
  d_j = r_j + D, where D is the task's relative deadline.
+ The utilisation of a real-time task is defined as the ratio between its
+ WCET and its period (or minimum inter-arrival time), and represents
+ the fraction of CPU time needed to execute the task.
+
+ If the total utilisation sum_i(WCET_i/P_i) (sum of the utilisations
+ WCET_i/P_i of all the tasks in the system - notice that when considering
+ multiple tasks, the parameters of the i-th one are indicated with the "_i"
+ suffix) is larger than M (with M equal to the number of CPUs), then the
+ system will surely not be able to respect all of the deadlines, and no
+ execution time is guaranteed for non real-time tasks, which risk to be
+ starved by real-time tasks.
+ If, instead, the total utilisation is smaller than M, then non real-time
+ tasks will not be starved and the system might be able to respect all the
+ deadlines.
+ As a matter of fact, in this case it is possible to provide an upper bound
+ for the tardiness (defined as the maximum between 0 and the difference
+ between the finishing time of a job and its absolute deadline).
+ More precisely, it can be proved that using a global EDF scheduler the
+ maximum tardiness of each task is smaller or equal than
+	((M − 1) · WCET_max − WCET_min)/(M − (M − 2) · U_max) + WCET_max
+ where WCET_max = max_i{WCET_i} is the maximum WCET, WCET_min=min_i{WCET_i}
+ is the minimum WCET, and U_max = max_i{WCET_i/P_i} is the maximum utilisation.
+
+ If M=1 (uniprocessor system), or in case of partitioned scheduling (each
+ real-time task is statically assigned to one and only one CPU), then it is
+ possible to formally check if all the deadlines are respected.
+ If D_i = P_i for all tasks, then EDF is able to respect all the deadlines
+ of all the tasks executing on a CPU if and only if the total utilisation
+ of the tasks running on such a CPU is smaller or equal than 1.
+ If D_i != P_i for some task, then it is possible to define the density of
+ a task as C_i/min{D_i,T_i}, and EDF is able to respect all of the deadlines
+ of all the tasks running on a CPU if the sum sum_i C_i/min{D_i,T_i} of the
+ densities of the tasks running on such a CPU is smaller or equal than 1
+ (notice that this condition is only sufficient, and not necessary).
+
+ On multiprocessor systems with global EDF scheduling (non partitioned
+ systems), a sufficient test for schedulability can not be based on the
+ utilisations (it can be shown that task sets with utilisations slightly
+ larger than 1 can miss deadlines regardless of the number of CPUs M).
+ However, as previously stated enforcing that the total utilisation is smaller
+ than M is enough to guarantee that non real-time tasks are not starved and
+ the real-time tasks tardiness has an upper bound.
 
  SCHED_DEADLINE can be used to schedule real-time tasks guaranteeing that
  the jobs' deadlines of a task are respected. In order to do this, a task
@@ -163,14 +206,22 @@ CONTENTS
 4. Bandwidth management
 =======================
 
- In order for the -deadline scheduling to be effective and useful, it is
- important to have some method to keep the allocation of the available CPU
- bandwidth to the tasks under control. This is usually called "admission
- control" and if it is not performed at all, no guarantee can be given on
- the actual scheduling of the -deadline tasks.
-
- The interface used to control the fraction of CPU bandwidth that can be
- allocated to -deadline tasks is similar to the one already used for -rt
+ As previously mentioned, in order for the -deadline scheduling to be
+ effective and useful (that is, to be able to provide "runtime" time units
+ within "deadline"), it is important to have some method to keep the allocation
+ of the available fractions of CPU time to the various tasks under control.
+ This is usually called "admission control" and if it is not performed, then
+ no guarantee can be given on the actual scheduling of the -deadline tasks.
+
+ As already stated in Section 3, a necessary condition to be respected to
+ correctly schedule a set of real-time tasks is that the total utilisation
+ is smaller than M. When talking about -deadline tasks, this requires to
+ impose that the sum of the ratio between runtime and period for all tasks
+ is smaller than M. Notice that the ratio runtime/period is equivalent to
+ the utilisation of a "traditional" real-time task, and is also often
+ referred as "bandwidth".
+ The interface used to control the CPU bandwidth that can be allocated
+ to -deadline tasks is similar to the one already used for -rt
  tasks with real-time group scheduling (a.k.a. RT-throttling - see
  Documentation/scheduler/sched-rt-group.txt), and is based on readable/
  writable control files located in procfs (for system wide settings).
@@ -232,8 +283,16 @@ CONTENTS
  950000. With rt_period equal to 1000000, by default, it means that -deadline
  tasks can use at most 95%, multiplied by the number of CPUs that compose the
  root_domain, for each root_domain.
-
- A -deadline task cannot fork.
+ This means that non -deadline tasks will receive at least 5% of the CPU time,
+ and that -deadline tasks will receive their runtime with a guaranteed
+ worst-case delay respect to the "deadline" parameter. If "deadline" = "period"
+ and the cpuset mechanism is used to implement partitioned scheduling (see
+ Section 5), then this simple setting of the bandwidth management is able to
+ deterministically guarantee that -deadline tasks will receive their runtime
+ in a period.
+
+ Finally, notice that in order not to jeopardize this admission control a
+ -deadline task cannot fork.
 
 5. Tasks CPU affinity
 =====================
-- 
2.0.4

Re: [PATCH v2 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits

[Ingo Molnar]

some speling fixes:

* Juri Lelli <juri.lelli@arm.com> wrote:

> From: Luca Abeni <luca.abeni@unitn.it>
> 
> Admission control is of key importance for SCHED_DEADLINE, since it guarantees
> system schedulability (or tells us something about the degree of guarantees
> we can provide to the user).
> 
> This patch improves and clarifies bits and pieces regarding AC, both for UP
> and SMP systems.
> 
> Signed-off-by: Luca Abeni <luca.abeni@unitn.it>
> Signed-off-by: Juri Lelli <juri.lelli@arm.com>
> Cc: Randy Dunlap <rdunlap@infradead.org>
> Cc: Peter Zijlstra <peterz@infradead.org>
> Cc: Ingo Molnar <mingo@redhat.com>
> Cc: Henrik Austad <henrik@austad.us>
> Cc: Dario Faggioli <raistlin@linux.it>
> Cc: Juri Lelli <juri.lelli@gmail.com>
> Cc: linux-doc@vger.kernel.org
> Cc: linux-kernel@vger.kernel.org
> ---
>  Documentation/scheduler/sched-deadline.txt | 87 +++++++++++++++++++++++++-----
>  1 file changed, 73 insertions(+), 14 deletions(-)
> 
> diff --git a/Documentation/scheduler/sched-deadline.txt b/Documentation/scheduler/sched-deadline.txt
> index 8372c3d..10fc4c4 100644
> --- a/Documentation/scheduler/sched-deadline.txt
> +++ b/Documentation/scheduler/sched-deadline.txt
> @@ -38,16 +38,17 @@ CONTENTS
>  ==================
>  
>   SCHED_DEADLINE uses three parameters, named "runtime", "period", and
> - "deadline" to schedule tasks. A SCHED_DEADLINE task is guaranteed to receive
> + "deadline" to schedule tasks. A SCHED_DEADLINE task should receive

Comma before 'to'?

>   "runtime" microseconds of execution time every "period" microseconds, and
>   these "runtime" microseconds are available within "deadline" microseconds
>   from the beginning of the period.  In order to implement this behaviour,
>   every time the task wakes up, the scheduler computes a "scheduling deadline"
>   consistent with the guarantee (using the CBS[2,3] algorithm). Tasks are then
>   scheduled using EDF[1] on these scheduling deadlines (the task with the
> - closest scheduling deadline is selected for execution). Notice that this
> - guaranteed is respected if a proper "admission control" strategy (see Section
> - "4. Bandwidth management") is used.
> + closest scheduling deadline is selected for execution). Notice that the
> + task actually receives "runtime" time units within "deadline" if a proper
> + "admission control" strategy (see Section "4. Bandwidth management") is used
> + (clearly, if the system is overloaded this guarantee cannot be respected).
>  
>   Summing up, the CBS[2,3] algorithms assigns scheduling deadlines to tasks so
>   that each task runs for at most its runtime every period, avoiding any
> @@ -134,6 +135,48 @@ CONTENTS
>   A real-time task can be periodic with period P if r_{j+1} = r_j + P, or
>   sporadic with minimum inter-arrival time P is r_{j+1} >= r_j + P. Finally,
>   d_j = r_j + D, where D is the task's relative deadline.
> + The utilisation of a real-time task is defined as the ratio between its
> + WCET and its period (or minimum inter-arrival time), and represents
> + the fraction of CPU time needed to execute the task.
> +
> + If the total utilisation sum_i(WCET_i/P_i) (sum of the utilisations
> + WCET_i/P_i of all the tasks in the system - notice that when considering
> + multiple tasks, the parameters of the i-th one are indicated with the "_i"
> + suffix) is larger than M (with M equal to the number of CPUs), then the
> + system will surely not be able to respect all of the deadlines, and no
> + execution time is guaranteed for non real-time tasks, which risk to be
> + starved by real-time tasks.

The last part doesn't really parse as correct English for me - 
maybe also split this overly long sentence into two or three 
sentences, to make it easier to understand?

> + If, instead, the total utilisation is smaller than M, then non real-time
> + tasks will not be starved and the system might be able to respect all the
> + deadlines.
> + As a matter of fact, in this case it is possible to provide an upper bound
> + for the tardiness (defined as the maximum between 0 and the difference
> + between the finishing time of a job and its absolute deadline).

s/the tardiness/tardiness ?

> + More precisely, it can be proved that using a global EDF scheduler the

s/proved/proven

> + maximum tardiness of each task is smaller or equal than
> +	((M − 1) · WCET_max − WCET_min)/(M − (M − 2) · U_max) + WCET_max
> + where WCET_max = max_i{WCET_i} is the maximum WCET, WCET_min=min_i{WCET_i}
> + is the minimum WCET, and U_max = max_i{WCET_i/P_i} is the maximum utilisation.
> +
> + If M=1 (uniprocessor system), or in case of partitioned scheduling (each
> + real-time task is statically assigned to one and only one CPU), then it is
> + possible to formally check if all the deadlines are respected.

s/then it is possible/it is possible ?
 
> + If D_i = P_i for all tasks, then EDF is able to respect all the deadlines
> + of all the tasks executing on a CPU if and only if the total utilisation
> + of the tasks running on such a CPU is smaller or equal than 1.
> + If D_i != P_i for some task, then it is possible to define the density of
> + a task as C_i/min{D_i,T_i}, and EDF is able to respect all of the deadlines

s/all of the deadlines/all the deadlines ?

> + of all the tasks running on a CPU if the sum sum_i C_i/min{D_i,T_i} of the
> + densities of the tasks running on such a CPU is smaller or equal than 1
> + (notice that this condition is only sufficient, and not necessary).
> +
> + On multiprocessor systems with global EDF scheduling (non partitioned
> + systems), a sufficient test for schedulability can not be based on the
> + utilisations (it can be shown that task sets with utilisations slightly
> + larger than 1 can miss deadlines regardless of the number of CPUs M).
> + However, as previously stated enforcing that the total utilisation is smaller

Comma after 'stated'.

> + than M is enough to guarantee that non real-time tasks are not starved and
> + the real-time tasks tardiness has an upper bound.
>

s/and the real-time/and that the real-time

s/the real-time tasks tardiness/the tardiness of real-time tasks

>   SCHED_DEADLINE can be used to schedule real-time tasks guaranteeing that
>   the jobs' deadlines of a task are respected. In order to do this, a task
> @@ -163,14 +206,22 @@ CONTENTS
>  4. Bandwidth management
>  =======================
>  
> - In order for the -deadline scheduling to be effective and useful, it is
> - important to have some method to keep the allocation of the available CPU
> - bandwidth to the tasks under control. This is usually called "admission
> - control" and if it is not performed at all, no guarantee can be given on
> - the actual scheduling of the -deadline tasks.
> -
> - The interface used to control the fraction of CPU bandwidth that can be
> - allocated to -deadline tasks is similar to the one already used for -rt
> + As previously mentioned, in order for the -deadline scheduling to be

s/the -deadline scheduling/-deadline scheduling

> + effective and useful (that is, to be able to provide "runtime" time units
> + within "deadline"), it is important to have some method to keep the allocation
> + of the available fractions of CPU time to the various tasks under control.
> + This is usually called "admission control" and if it is not performed, then
> + no guarantee can be given on the actual scheduling of the -deadline tasks.
> +
> + As already stated in Section 3, a necessary condition to be respected to
> + correctly schedule a set of real-time tasks is that the total utilisation
> + is smaller than M. When talking about -deadline tasks, this requires to
> + impose that the sum of the ratio between runtime and period for all tasks
> + is smaller than M. Notice that the ratio runtime/period is equivalent to
> + the utilisation of a "traditional" real-time task, and is also often
> + referred as "bandwidth".

s/referred as/referred to as ?

Thanks,

	Ingo

Re: [PATCH v2 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits

[Luca Abeni]

Hi Ingo,

On Thu, 21 Aug 2014 15:38:37 +0200
Ingo Molnar <mingo@kernel.org> wrote:
[...]
> > + If the total utilisation sum_i(WCET_i/P_i) (sum of the
> > utilisations
> > + WCET_i/P_i of all the tasks in the system - notice that when
> > considering
> > + multiple tasks, the parameters of the i-th one are indicated with
> > the "_i"
> > + suffix) is larger than M (with M equal to the number of CPUs),
> > then the
> > + system will surely not be able to respect all of the deadlines,
> > and no
> > + execution time is guaranteed for non real-time tasks, which risk
> > to be
> > + starved by real-time tasks.
> 
> The last part doesn't really parse as correct English for me - 
> maybe also split this overly long sentence into two or three 
> sentences, to make it easier to understand?
Sorry about this; after re-reading the sentence, I agree it looks
confusing. What about:
"
If the total utilisation sum_i(WCET_i/P_i) is larger than M (with M
equal to the number of CPUs), then the scheduler can not be able to
respect all of the deadlines.
Note that the total utilisation is defined as the sum of the
utilisations WCET_i/P_i of all the real-time tasks in the system (when
considering multiple real-time tasks, the parameters of the i-th one are
indicated with the "_i" suffix).
Moreover, if the total utilisation is larger than M, then non real-time
tasks risk to be starved by real-time tasks.
"
Does this look more clear / acceptable?


				Thanks,
					Luca

Re: [PATCH v2 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits

[Ingo Molnar]

* Luca Abeni <luca.abeni@unitn.it> wrote:

> Hi Ingo,
> 
> On Thu, 21 Aug 2014 15:38:37 +0200
> Ingo Molnar <mingo@kernel.org> wrote:
> [...]
> > > + If the total utilisation sum_i(WCET_i/P_i) (sum of the
> > > utilisations
> > > + WCET_i/P_i of all the tasks in the system - notice that when
> > > considering
> > > + multiple tasks, the parameters of the i-th one are indicated with
> > > the "_i"
> > > + suffix) is larger than M (with M equal to the number of CPUs),
> > > then the
> > > + system will surely not be able to respect all of the deadlines,
> > > and no
> > > + execution time is guaranteed for non real-time tasks, which risk
> > > to be
> > > + starved by real-time tasks.
> > 
> > The last part doesn't really parse as correct English for me - 
> > maybe also split this overly long sentence into two or three 
> > sentences, to make it easier to understand?
> Sorry about this; after re-reading the sentence, I agree it looks
> confusing. What about:

Looks good to me, with a few details:

> "
> If the total utilisation sum_i(WCET_i/P_i) is larger than M (with M
> equal to the number of CPUs), then the scheduler can not be able to
> respect all of the deadlines.

s/can not be able to respect/is unable to respect

> Note that the total utilisation is defined as the sum of the
> utilisations WCET_i/P_i of all the real-time tasks in the system (when
> considering multiple real-time tasks, the parameters of the i-th one are
> indicated with the "_i" suffix).

The parentheses are a bit confusing here - they come after a 
half finished sentence - which at the end turns out to have 
ended.

How about something like:

> Note that total utilisation is defined as the sum of the 
> utilisations WCET_i/P_i over all the real-time tasks in the 
> system. When considering multiple real-time tasks, the 
> parameters of the i-th task are indicated with the "_i" 
> suffix.

?

> Moreover, if the total utilisation is larger than M, then non real-time
> tasks risk to be starved by real-time tasks.

How about:

> Moreover, if the total utilisation is larger than M, then we 
> risk starving non- real-time tasks by real-time tasks.

?

Thanks,

	Ingo

Re: [PATCH v2 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits

[Luca Abeni]

Hi,

On Fri, 22 Aug 2014 10:31:11 +0200
Ingo Molnar <mingo@kernel.org> wrote:
[...]
> > > > + execution time is guaranteed for non real-time tasks, which
> > > > risk to be
> > > > + starved by real-time tasks.
> > > 
> > > The last part doesn't really parse as correct English for me - 
> > > maybe also split this overly long sentence into two or three 
> > > sentences, to make it easier to understand?
> > Sorry about this; after re-reading the sentence, I agree it looks
> > confusing. What about:
> 
> Looks good to me, with a few details:
[...]
Thanks for the suggestions, and sorry about my bad English; I will send
a new patch to Juri in few days.


			Thanks,
				Luca

[PATCH v2 4/4] Documentation/scheduler/sched-deadline.txt: add tests suite appendix

[Juri Lelli]

Add an appendix briefly describing tools that can be used to test SCHED_DEADLINE
(and the scheduler in general). Links to where source code of the tools is hosted
are also provided.

Signed-off-by: Juri Lelli <juri.lelli@arm.com>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Henrik Austad <henrik@austad.us>
Cc: Dario Faggioli <raistlin@linux.it>
Cc: Juri Lelli <juri.lelli@gmail.com>
Cc: linux-doc@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
---
 Documentation/scheduler/sched-deadline.txt | 52 ++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/Documentation/scheduler/sched-deadline.txt b/Documentation/scheduler/sched-deadline.txt
index 10fc4c4..6ca2940 100644
--- a/Documentation/scheduler/sched-deadline.txt
+++ b/Documentation/scheduler/sched-deadline.txt
@@ -15,6 +15,7 @@ CONTENTS
  5. Tasks CPU affinity
    5.1 SCHED_DEADLINE and cpusets HOWTO
  6. Future plans
+ A. Test suite
 
 
 0. WARNING
@@ -339,3 +340,54 @@ CONTENTS
  throttling patches [https://lkml.org/lkml/2010/2/23/239] but we still are in
  the preliminary phases of the merge and we really seek feedback that would
  help us decide on the direction it should take.
+
+Appendix A. Test suite
+======================
+
+ The SCHED_DEADLINE policy can be easily tested using two applications that
+ are part of a wider Linux Scheduler validation suite. The suite is
+ available as a GitHub repository: https://github.com/scheduler-tools.
+
+ The first testing application is called rt-app and can be used to
+ start multiple threads with specific parameters. rt-app supports
+ SCHED_{OTHER,FIFO,RR,DEADLINE} scheduling policies and their related
+ parameters (e.g., niceness, priority, runtime/deadline/period). rt-app
+ is a valuable tool, as it can be used to synthetically recreate certain
+ workloads (maybe mimicking real use-cases) and evaluate how the scheduler
+ behaves under such workloads. In this way, results are easily reproducible.
+ rt-app is available at: https://github.com/scheduler-tools/rt-app.
+
+ Thread parameters can be specified from the command line, with something like
+ this:
+
+  # rt-app -t 100000:10000:d -t 150000:20000:f:10 -D5
+
+ The above creates two threads. The first one, scheduled by SCHED_DEADLINE,
+ executes for 10ms every 100ms and the second one, scheduled at RT priority 10
+ with SCHED_FIFO, executes for 20ms every 150ms. The configuration runs
+ for 5 seconds.
+
+ More interestingly, configurations can be described with a json file that
+ can be passed as input to rt-app with something like this:
+
+  # rt-app my_config.json
+
+ The parameters that can be specified with the second method are a superset
+ of the command line options. Please refer to rt-app documentation for more
+ details.
+
+ The second testing application is a modification of schedtool, called
+ schedtool-dl, which can be used to setup SCHED_DEADLINE parameters for a
+ certain pid/application. schedtool-dl is available at:
+ https://github.com/scheduler-tools/schedtool-dl.git.
+
+ The usage is straightforward:
+
+  # schedtool -E -t 10000000:100000000 -e ./my_cpuhog_app
+
+ With this, my_cpuhog_app is put to run inside a SCHED_DEADLINE reservation
+ of 10ms every 100ms (note that parameters are expressed in microseconds).
+ You can also use schedtool to create a reservation for an already running
+ application, given that you know its pid:
+
+  # schedtool -E -t 10000000:100000000 my_app_pid
-- 
2.0.4