SCHED_DEADLINE documentation fixes and improvements
v3 cover SCHED_DEADLINE documentation fixes and improvements
Hello everyone,
This is version 3 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!)
Changes since v2:
- fixed typos and rewrote paragraphs as suggested by Ingo (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 | 204 ++++++++++++++++++++++------- 1 file changed, 159 insertions(+), 45 deletions(-)
Signature · 1 line
2.0.4
PATCH v3 1/4 Documentation/scheduler/sched-deadline.txt: fix terminology and improve clarity
From: Luca Abeni <[email protected]>
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"
--- Documentation/scheduler/sched-deadline.txt | 32 ++++++++++++++++-------------- 1 file changed, 17 insertions(+), 15 deletions(-)
Documentation/scheduler/sched-deadline.txt +17 -15
@@ -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 =======================
Signature · 1 line
2.0.4
Re: [PATCH v3 1/4] Documentation/scheduler/sched-deadline.txt: fix terminology and improve clarity
Quoted 7 lines · Juri Lelli
From: Luca Abeni <[email protected]>
Several small changes regarding
SCHED_DEADLINEdocumentation that fix terminology and improve clarity and readability:- "current runtime" becomes "remaining runtime"
Quoted 7 lines
- 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"
I'm tempted to say "earliest" (being part of the algorithm's name and all ;)
Quoted 24 lines
Signed-off-by Luca Abeni <[email protected]>Signed-off-by Juri Lelli <[email protected]>Cc Randy Dunlap <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Henrik Austad <[email protected]>Cc Dario Faggioli <[email protected]>Cc Juri Lelli <[email protected]>--- Documentation/scheduler/sched-deadline.txt | 32 ++++++++++++++++-------------- 1 file changed, 17 insertions(+), 15 deletions(-)Documentation/scheduler/sched-deadline.txt +0
-1@@ -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
Documentation/scheduler/sched-deadline.txt CONTENTS · line 56
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +2
-1+ 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
s/first/next/
Also, next sentence does not make much sense, I would drop the also;
"Thanks to this feature, tasks that do not strictly comply with the ..."
Quoted 80 lines
Documentation/scheduler/sched-deadline.txt +15
-13strictly 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 =======================Signature · 1 line
2.0.4
Apart from the minor nitpick, it looks good!
Signature · 1 line
Henrik
Re: [PATCH v3 1/4] Documentation/scheduler/sched-deadline.txt: fix terminology and improve clarity
Hi,
Quoted 10 lines · Henrik Austad
Quoted 9 lines · Juri Lelli
From: Luca Abeni <[email protected]>
Several small changes regarding
SCHED_DEADLINEdocumentation that fix terminology and improve clarity and readability:- "current runtime" becomes "remaining runtime"
- readablity of an equation is improved by introducing more spacing
Quoted 8 lines
Quoted 5 lines
- clarify when admission control will certainly fail
- new URL for CBS technical report
- substitue "smallest" with "closest"
I'm tempted to say "earliest" (being part of the algorithm's name and all ;)
Well, AFAIR "closest" was suggested during the initial review some months ago... Anyway, if now there is agreement on "earliest" I can change to it; let me know.
[...]
Quoted 7 lines
Quoted 6 lines
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
Quoted 5 lines
s/first/next/
Also, next sentence does not make much sense, I would drop the also;
"Thanks to this feature, tasks that do not strictly comply with the ..."
I agree with these changes, but they are in text that is not changed by my patch, right?
What should I do? Add these changes to the patch, or send an additional incremental patch with these changes?
Thanks,
Luca
A message that is not in the archive (sent off-list or not yet received): CAM6o_m19T7OV=4_5rh_m1XSZKQmpKD0TaSSkiOxthNLz7uJ8Gw@mail.gmail.com
Re: [PATCH v3 1/4] Documentation/scheduler/sched-deadline.txt: fix terminology and improve clarity
On 09/03/2014 09:45 AM, Henrik Austad wrote:
[...]
Quoted 18 lines
Quoted 18 lines
Summing up, the CBS[2,3] algorithms assigns scheduling deadlines to
Quoted 17 lines
Quoted 10 lines
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 nots/first/next/
Also, next sentence does not make much sense, I would drop the also;
"Thanks to this feature, tasks that do not strictly comply with the ..."
Quoted 8 lines
Quoted 6 lines
I agree with these changes, but they are in text that is not changed by my patch, right?
What should I do? Add these changes to the patch, or send an additional incremental
patch with these changes?Patch is about clarity, right? I'd just add it to this patch.
Ok; I'll send an updated patch to Juri.
Thanks,
Luca
Re: [PATCH v3 1/4] Documentation/scheduler/sched-deadline.txt: fix terminology and improve clarity
In reply to Henrik AustadHi Henrik,
Quoted 136 lines · Henrik Austad
Quoted 7 lines · Juri Lelli
From: Luca Abeni <[email protected]>
Several small changes regarding
SCHED_DEADLINEdocumentation that fix terminology and improve clarity and readability:- "current runtime" becomes "remaining runtime"
Quoted 7 lines
- 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"
I'm tempted to say "earliest" (being part of the algorithm's name and all ;)
Quoted 24 lines
Signed-off-by Luca Abeni <[email protected]>Signed-off-by Juri Lelli <[email protected]>Cc Randy Dunlap <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Henrik Austad <[email protected]>Cc Dario Faggioli <[email protected]>Cc Juri Lelli <[email protected]>--- Documentation/scheduler/sched-deadline.txt | 32 ++++++++++++++++-------------- 1 file changed, 17 insertions(+), 15 deletions(-)Documentation/scheduler/sched-deadline.txt +0
-1@@ -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 thisDocumentation/scheduler/sched-deadline.txt CONTENTS · line 56
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +2
-1+ 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 nots/first/next/
Also, next sentence does not make much sense, I would drop the also;
"Thanks to this feature, tasks that do not strictly comply with the ..."
Quoted 76 lines
Documentation/scheduler/sched-deadline.txt +15
-13strictly 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
Quoted 7 lines
Quoted 4 lines
Documentation/scheduler/sched-deadline.txt +0
-04. Bandwidth management =======================Signature · 1 line
2.0.4Apart from the minor nitpick, it looks good!
Great! Nitpicks fixed.
Thanks,
- Juri
PATCH v3 2/4 Documentation/scheduler/sched-deadline.txt: Rewrite section 4 intro
In reply to Juri LelliSection 4 intro was still describing the old interface. Rewrite it.
--- Documentation/scheduler/sched-deadline.txt | 51 +++++++++++++++--------------- 1 file changed, 25 insertions(+), 26 deletions(-)
Documentation/scheduler/sched-deadline.txt +25 -26
@@ -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. + and thus we don't need a higher level throttling mechanism to enforce the + 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:
Signature · 1 line
2.0.4
Re: [PATCH v3 2/4] Documentation/scheduler/sched-deadline.txt: Rewrite section 4 intro
Quoted 54 lines · Juri Lelli
Section 4 intro was still describing the old interface. Rewrite it.
Signed-off-by Juri Lelli <[email protected]>Signed-off-by Luca Abeni <[email protected]>Cc Randy Dunlap <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Henrik Austad <[email protected]>Cc Dario Faggioli <[email protected]>Cc Juri Lelli <[email protected]>--- Documentation/scheduler/sched-deadline.txt | 51 +++++++++++++++--------------- 1 file changed, 25 insertions(+), 26 deletions(-)Documentation/scheduler/sched-deadline.txt +12
-18@@ -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
Documentation/scheduler/sched-deadline.txt CONTENTS · line 187
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +7
-2+ 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. + and thus we don't need a higher level throttling mechanism to enforce the + 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).
s/some_desired_value/global_dl_utilization_cap/ perhaps?
Quoted 7 lines
Documentation/scheduler/sched-deadline.txt +0
-24.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
Documentation/scheduler/sched-deadline.txt CONTENTS · line 199
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +6
-4- 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.
Isn't forking forbidden for _dl tasks? Or did I miss a memo somewhere?
Quoted 6 lines
Documentation/scheduler/sched-deadline.txt +0
-0This means that, for a root_domain comprising M CPUs, -deadline tasks can be created while the sum of their bandwidths stays below:Signature · 1 line
2.0.4
All in all, looks pretty good to me!
Signature · 1 line
Henrik
Re: [PATCH v3 2/4] Documentation/scheduler/sched-deadline.txt: Rewrite section 4 intro
Hi Henrik,
Quoted 59 lines · Henrik Austad
Quoted 58 lines · Juri Lelli
Section 4 intro was still describing the old interface. Rewrite it.
Signed-off-by Juri Lelli <[email protected]>Signed-off-by Luca Abeni <[email protected]>Cc Randy Dunlap <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Henrik Austad <[email protected]>Cc Dario Faggioli <[email protected]>Cc Juri Lelli <[email protected]>--- Documentation/scheduler/sched-deadline.txt | 51 +++++++++++++++--------------- 1 file changed, 25 insertions(+), 26 deletions(-)Documentation/scheduler/sched-deadline.txt +15
-18@@ -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!),
Quoted 9 lines
Documentation/scheduler/sched-deadline.txt CONTENTS · line 187
Quoted 6 lines
Documentation/scheduler/sched-deadline.txt +4
-2- and thus we don't need an higher level throttling mechanism to enforce the - desired bandwidth. + and thus we don't need a higher level throttling mechanism to enforce the + 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).s/some_desired_value/global_dl_utilization_cap/ perhaps?
Ok, fixed.
Quoted 18 lines
Quoted 7 lines
Documentation/scheduler/sched-deadline.txt +0
-24.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'tDocumentation/scheduler/sched-deadline.txt CONTENTS · line 199
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +6
-4- 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.
Quoted 2 lines
Isn't forking forbidden for
_dltasks? Or did I miss a memo somewhere?
Yes, forking is forbidden. But, that's mainly because it is not entirely clear how bandwidth has to be split between parent and child(ren). When we'll have -rt tasks running from a -deadline server this problem will disappear, as children will share bandwidth with other tasks in the same server.
Quoted 9 lines
Quoted 6 lines
Documentation/scheduler/sched-deadline.txt +0
-0This means that, for a root_domain comprising M CPUs, -deadline tasks can be created while the sum of their bandwidths stays below:Signature · 1 line
2.0.4All in all, looks pretty good to me!
Great!
Thanks,
- Juri
PATCH v3 3/4 Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits
In reply to Juri LelliFrom: Luca Abeni <[email protected]>
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.
--- Documentation/scheduler/sched-deadline.txt | 89 +++++++++++++++++++++++++----- 1 file changed, 75 insertions(+), 14 deletions(-)
Documentation/scheduler/sched-deadline.txt +75 -14
@@ -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,50 @@ 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) is larger than M (with M equal + to the number of CPUs), then the scheduler is unable to respect all the + deadlines. + 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 we risk starving + non- real-time tasks 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 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 proven 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), 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 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 + that the tardiness of real-time tasks 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 +208,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 -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 to 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 +285,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 =====================
Signature · 1 line
2.0.4
Re: [PATCH v3 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits
Quoted 87 lines · Juri Lelli
From: Luca Abeni <[email protected]>
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 <[email protected]>Signed-off-by Juri Lelli <[email protected]>Cc Randy Dunlap <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Henrik Austad <[email protected]>Cc Dario Faggioli <[email protected]>Cc Juri Lelli <[email protected]>--- Documentation/scheduler/sched-deadline.txt | 89 +++++++++++++++++++++++++----- 1 file changed, 75 insertions(+), 14 deletions(-)Documentation/scheduler/sched-deadline.txt +39
-4@@ -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,50 @@ 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) is larger than M (with M equal + to the number of CPUs), then the scheduler is unable to respect all the + deadlines. + 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 we risk starving + non- real-time tasks 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 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 proven 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), 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 the deadlines + of all the tasks running on a CPU if the sum sum_i C_i/min{D_i,T_i} of the
Documentation/scheduler/sched-deadline.txt CONTENTS · line 181
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +10
-0+ 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 + that the tardiness of real-time tasks has an upper bound.
I'd _really_ appreciate a link to a paper where all of this is presented and proved!
Quoted 16 lines
Documentation/scheduler/sched-deadline.txt +2
-8SCHED_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 +208,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 -deadline scheduling to be + effective and useful (that is, to be able to provide "runtime" time units
Documentation/scheduler/sched-deadline.txt CONTENTS · line 222
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +10
-0+ 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.
"This requires to impose that .." uhm, what? Drop 'to impose'.
Quoted 11 lines
[...] Notice that the ratio runtime/period is equivalent to
+ the utilisation of a "traditional" real-time task, and is also often
+ referred to 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 - seeDocumentation/scheduler/sched-rt-group.txt), and is based on readable/ writable control files located in procfs (for system wide settings).Documentation/scheduler/sched-deadline.txt +0
-0@@ -232,8 +285,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
Documentation/scheduler/sched-deadline.txt CONTENTS · line 294
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +7
-2root_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.
The whole 950000 / 1000000, is at least 50 *consecutive* ms given to non rt/dl tasks every second, or is this more finegrained now?
If the 50ms can be given in a single go, then I don't think you can guarantee that deadline-tasks will receive their runtime in a period - a period can be <50ms, no?
Documentation/scheduler/sched-deadline.txt CONTENTS · line 297
Quoted 3 lines
Documentation/scheduler/sched-deadline.txt +3
-0+ + Finally, notice that in order not to jeopardize this admission control a + -deadline task cannot fork.
s/this/the
(there aren't any other admission controls in the kernel)
Quoted 7 lines
Documentation/scheduler/sched-deadline.txt +0
-05. Tasks CPU affinity =====================Signature · 1 line
2.0.4
Signature · 1 line
Henrik
Re: [PATCH v3 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits
Hi,
On 09/02/2014 11:45 PM, Henrik Austad wrote:
[...]
Quoted 10 lines
Quoted 7 lines
+ 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
+ that the tardiness of real-time tasks has an upper bound.I'd _really_ appreciate a link to a paper where all of this is presented and proved!
Well, my original plan was to add the bibliography in the next round of patches... Is this ok?
[...]
Quoted 7 lines
Quoted 5 lines
+ 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."This requires to impose that .." uhm, what? Drop 'to impose'.
Ok. I'll send an updated patch to Juri in few days
Quoted 25 lines
Quoted 11 lines
[...] Notice that the ratio runtime/period is equivalent to
+ the utilisation of a "traditional" real-time task, and is also often
+ referred to 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 - seeDocumentation/scheduler/sched-rt-group.txt), and is based on readable/ writable control files located in procfs (for system wide settings).Documentation/scheduler/sched-deadline.txt +0
-0@@ -232,8 +285,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 theDocumentation/scheduler/sched-deadline.txt CONTENTS · line 294
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +7
-2root_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.The whole 950000 / 1000000, is at least 50 *consecutive* ms given to non rt/dl tasks every second, or is this more finegrained now?
Quoted 3 lines
If the 50ms can be given in a single go, then I don't think you can guarantee that deadline-tasks will receive their runtime in a period - a period can be <50ms, no?
Uhmm... Maybe there is something I am missing in how the SCHED_DEADLINE admission control is implemented, but I do not know about any "50 consecutive ms to non dl tasks" rule. I agree that if there is such a rule then deadline tasks are screwed. Juri?
Quoted 5 lines
Documentation/scheduler/sched-deadline.txt CONTENTS · line 297
Quoted 2 lines
Documentation/scheduler/sched-deadline.txt +2
-0+ Finally, notice that in order not to jeopardize this admission control a + -deadline task cannot fork.s/this/the
(there aren't any other admission controls in the kernel)
Ok; this will go in my updated patch
Thanks,
Luca
A message that is not in the archive (sent off-list or not yet received): CAM6o_m3VXiJO3ED_Rb-_Kfaw7mFyw_s4W0quQ_hSbpxgA_foLA@mail.gmail.com
Re: [PATCH v3 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits
Quoted 21 lines · Henrik Austad
Quoted 19 lines · Luca Abeni
Hi,
On 09/02/2014 11:45 PM, Henrik Austad wrote:
[...]+ On multiprocessor systems with global EDF scheduling (non partitioned
Quoted 13 lines
Quoted 9 lines
+ 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
+ that the tardiness of real-time tasks has an upper bound.I'd _really_ appreciate a link to a paper where all of this is presented and proved!
Quoted 6 lines
Quoted 4 lines
Well, my original plan was to add the bibliography in the next round of patches...
Is this ok?Sure, but I don't see why you cannot add this now
Well, there are multiple papers to be cited here: the one showing that in a pathological case you can have missed deadlines on M CPUs with utilisation slightly larger than 1 (Dhall's effect), one or more papers presenting a more advanced admission control for global EDF, one or more papers showing the tardiness bound, ...
So, I'd like to spend some time doing some research to properly cite the most appropriate references.
Quoted 1 line
you (or Juri?) did update one of the papers in this series, right?
In patch 1, I updated the URL for a publically available technical report I wrote in 1998 (the old URL was in a web site I cannot access anymore, so I changed the URL to point to a web site I can control).
Quoted 1 line
As long as an article with all the headache ends up here, I'm happy :)
As said, if possible I'd like to do it in the next batch of patches, so that these updates are not delayed... If this is not ok, I'll update the patch adding some references, but this will take some time.
Thanks,
Luca
Re: [PATCH v3 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits
In reply to Luca AbeniHi,
Quoted 53 lines · Luca Abeni
Hi,
On 09/02/2014 11:45 PM, Henrik Austad wrote:
[...]Quoted 10 lines
Quoted 7 lines
+ 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
+ that the tardiness of real-time tasks has an upper bound.I'd _really_ appreciate a link to a paper where all of this is presented and proved!
Well, my original plan was to add the bibliography in the next round of patches... Is this ok?
[...]
Quoted 7 lines
Quoted 5 lines
+ 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."This requires to impose that .." uhm, what? Drop 'to impose'.
Ok. I'll send an updated patch to Juri in few days
Quoted 25 lines
Quoted 11 lines
[...] Notice that the ratio runtime/period is equivalent to
+ the utilisation of a "traditional" real-time task, and is also often
+ referred to 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 - seeDocumentation/scheduler/sched-rt-group.txt), and is based on readable/ writable control files located in procfs (for system wide settings).Documentation/scheduler/sched-deadline.txt +0
-0@@ -232,8 +285,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 theDocumentation/scheduler/sched-deadline.txt CONTENTS · line 294
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +7
-2root_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.The whole 950000 / 1000000, is at least 50 *consecutive* ms given to non rt/dl tasks every second, or is this more finegrained now?
Quoted 9 lines
Quoted 3 lines
If the 50ms can be given in a single go, then I don't think you can guarantee that deadline-tasks will receive their runtime in a period - a period can be <50ms, no?
Uhmm... Maybe there is something I am missing in how the
SCHED_DEADLINEadmission control is implemented, but I do not know about any "50 consecutive ms to non dl tasks" rule. I agree that if there is such a rule then deadline tasks are screwed. Juri?
In SCHED_DEADLINE we use those values only at admission control time (when the user calls sched_setattr()). Then, at runtime, we use tasks' parameters to perform scheduling. So there is no consecutive 50ms time for !SCHED_DEADLINE tasks.
We could probably clarify this aspect in the previous patch with something like this:
[snip]
+ 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.
+ and thus we don't need a higher level throttling mechanism to enforce the ---->
+ desired bandwidth. In other words, this means that interface parameters are
+ only used at admission control time (i.e., when the user calls
+ sched_setattr()). Scheduling is then performed considering actual tasks'
+ parameters, so that CPU bandwidth is allocated to SCHED_DEADLINE tasks
+ respecting their needs in terms of granularity. 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).
[snip]
What you think?
Thanks,
- Juri
Quoted 12 lines
Quoted 5 lines
Documentation/scheduler/sched-deadline.txt CONTENTS · line 297
Quoted 2 lines
Documentation/scheduler/sched-deadline.txt +2
-0+ Finally, notice that in order not to jeopardize this admission control a + -deadline task cannot fork.s/this/the
(there aren't any other admission controls in the kernel)Ok; this will go in my updated patch
Thanks,
Luca
Re: [PATCH v3 3/4] Documentation/scheduler/sched-deadline.txt: improve and clarify AC bits
Hi,
Quoted 101 lines · Juri Lelli
Hi,
Quoted 53 lines · Luca Abeni
Hi,
On 09/02/2014 11:45 PM, Henrik Austad wrote:
[...]Quoted 10 lines
Quoted 7 lines
+ 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
+ that the tardiness of real-time tasks has an upper bound.I'd _really_ appreciate a link to a paper where all of this is presented and proved!
Well, my original plan was to add the bibliography in the next round of patches... Is this ok?
[...]
Quoted 7 lines
Quoted 5 lines
+ 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."This requires to impose that .." uhm, what? Drop 'to impose'.
Ok. I'll send an updated patch to Juri in few days
Quoted 25 lines
Quoted 11 lines
[...] Notice that the ratio runtime/period is equivalent to
+ the utilisation of a "traditional" real-time task, and is also often
+ referred to 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 - seeDocumentation/scheduler/sched-rt-group.txt), and is based on readable/ writable control files located in procfs (for system wide settings).Documentation/scheduler/sched-deadline.txt +0
-0@@ -232,8 +285,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 theDocumentation/scheduler/sched-deadline.txt CONTENTS · line 294
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +7
-2root_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.The whole 950000 / 1000000, is at least 50 *consecutive* ms given to non rt/dl tasks every second, or is this more finegrained now?
Quoted 9 lines
Quoted 3 lines
If the 50ms can be given in a single go, then I don't think you can guarantee that deadline-tasks will receive their runtime in a period - a period can be <50ms, no?
Uhmm... Maybe there is something I am missing in how the
SCHED_DEADLINEadmission control is implemented, but I do not know about any "50 consecutive ms to non dl tasks" rule. I agree that if there is such a rule then deadline tasks are screwed. Juri?In
SCHED_DEADLINEwe use those values only at admission control time (when the user callssched_setattr()). Then, at runtime, we use tasks' parameters to perform scheduling. So there is no consecutive 50ms time for !SCHED_DEADLINE tasks.We could probably clarify this aspect in the previous patch with something like this:
[snip]
+ 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 manageSCHED_DEADLINEbandwidth 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.
+ and thus we don't need a higher level throttling mechanism to enforce the ---->
+ desired bandwidth. In other words, this means that interface parameters are
+ only used at admission control time (i.e., when the user calls
+sched_setattr()). Scheduling is then performed considering actual tasks'
+ parameters, so that CPU bandwidth is allocated toSCHED_DEADLINEtasks
+ respecting their needs in terms of granularity. 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).
[snip]
Quoted 2 lines
What you think?
As agreed on IRC I fixed this, and the other typos.
Thanks,
- Juri
Quoted 14 lines
Quoted 12 lines
Quoted 5 lines
Documentation/scheduler/sched-deadline.txt CONTENTS · line 297
Quoted 2 lines
Documentation/scheduler/sched-deadline.txt +2
-0+ Finally, notice that in order not to jeopardize this admission control a + -deadline task cannot fork.s/this/the
(there aren't any other admission controls in the kernel)Ok; this will go in my updated patch
Thanks,
Luca
PATCH v3 4/4 Documentation/scheduler/sched-deadline.txt: add tests suite appendix
In reply to Juri LelliAdd 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.
--- Documentation/scheduler/sched-deadline.txt | 52 ++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+)
Documentation/scheduler/sched-deadline.txt +52 -0
@@ -15,6 +15,7 @@ CONTENTS 5. Tasks CPU affinity 5.1 SCHED_DEADLINE and cpusets HOWTO 6. Future plans + A. Test suite 0. WARNING
@@ -341,3 +342,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
Signature · 1 line
2.0.4
Re: [PATCH v3 4/4] Documentation/scheduler/sched-deadline.txt: add tests suite appendix
Quoted 49 lines · 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 <[email protected]>Cc Randy Dunlap <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Henrik Austad <[email protected]>Cc Dario Faggioli <[email protected]>Cc Juri Lelli <[email protected]>--- Documentation/scheduler/sched-deadline.txt | 52 ++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+)Documentation/scheduler/sched-deadline.txt +17
-0@@ -15,6 +15,7 @@ CONTENTS 5. Tasks CPU affinity 5.1 SCHED_DEADLINE and cpusets HOWTO 6. Future plans + A. Test suite 0. WARNING@@ -341,3 +342,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.
Documentation/scheduler/sched-deadline.txt CONTENTS · line 370
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +10
-0+ + 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.
I'd prefer
The above creates 2 threads, T1 and T2. T1 is scheduled by SCHED_DEADLINE with a 100ms period and 10ms WCET. T2 is handled by SCHED_FIFO priority 10, 150ms period and 20ms WCET. The test will run for a total of 5 seconds.
One can expect the eager reader to have at least a grasp of the terminology at this stage, using WCET should be acceptable.
Documentation/scheduler/sched-deadline.txt CONTENTS · line 379
Quoted 9 lines
Documentation/scheduler/sched-deadline.txt +9
-0+ + 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.
This can be found that this url: ....
Quoted 18 lines
Documentation/scheduler/sched-deadline.txt +16
-0+ + 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_pidSignature · 1 line
2.0.4
Would it make sense to add an appendix B with a minimal SCHED_DEADLINE main() ? I for one like to invent my own wheels.
Just my $0.02
Signature · 1 line
Henrik
Re: [PATCH v3 4/4] Documentation/scheduler/sched-deadline.txt: add tests suite appendix
Hi Henrik,
Quoted 63 lines · Henrik Austad
Quoted 49 lines · 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 <[email protected]>Cc Randy Dunlap <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Henrik Austad <[email protected]>Cc Dario Faggioli <[email protected]>Cc Juri Lelli <[email protected]>--- Documentation/scheduler/sched-deadline.txt | 52 ++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+)Documentation/scheduler/sched-deadline.txt +17
-0@@ -15,6 +15,7 @@ CONTENTS 5. Tasks CPU affinity 5.1 SCHED_DEADLINE and cpusets HOWTO 6. Future plans + A. Test suite 0. WARNING@@ -341,3 +342,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.Documentation/scheduler/sched-deadline.txt CONTENTS · line 370
Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +10
-0+ + 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.I'd prefer
Quoted 7 lines
The above creates 2 threads, T1 and T2. T1 is scheduled by
SCHED_DEADLINEwith a 100ms period and 10ms WCET. T2 is handled bySCHED_FIFOpriority 10, 150ms period and 20ms WCET. The test will run for a total of 5 seconds.One can expect the eager reader to have at least a grasp of the terminology at this stage, using WCET should be acceptable.
Not sure that naming the two threads T1 and T2 won't induce the reader to look for such names in the system when the test is running. And the actual comms are subject to change in future versions of rt-app. Also, giving the distinction between tasks WCET (and BCET in this case) and the runtime you choose to schedule them, I'd rather remain more general. So, what about this instead?
The above creates 2 threads. The first one, scheduled by SCHED_DEADLINE, executes for 10ms every 100ms. The second one, scheduled at SCHED_FIFO priority 10, executes for 20ms every 150ms. The test will run for a total of 5 seconds.
Quoted 12 lines
Documentation/scheduler/sched-deadline.txt CONTENTS · line 379
Quoted 9 lines
Documentation/scheduler/sched-deadline.txt +9
-0+ + 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.This can be found that this url: ....
There is not a url yet (apart from the github repo). But, I can add:
(doc/*.json)
Quoted 13 lines
Quoted 13 lines
Documentation/scheduler/sched-deadline.txt +13
-0+ + 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
Quoted 9 lines
Quoted 5 lines
Documentation/scheduler/sched-deadline.txt +3
-0+ application, given that you know its pid: + + # schedtool -E -t 10000000:100000000 my_app_pidSignature · 1 line
2.0.4Would it make sense to add an appendix B with a minimal
SCHED_DEADLINEmain()? I for one like to invent my own wheels.
Ok, that could look like what follows (in a separate patch). What you think?
Thanks,
- Juri
Appendix B. Minimal main()
==========================
We provide in what follows a simple (ugly) self-contained code snippet showing how SCHED_DEADLINE reservations can be created by a real-time application developer.
#define _GNU_SOURCE
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <linux/unistd.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <sys/syscall.h>
#include <pthread.h>
#define gettid() syscall(__NR_gettid)
#define SCHED_DEADLINE 6
/* XXX use the proper syscall numbers */
#ifdef __x86_64__
#define __NR_sched_setattr 314
#define __NR_sched_getattr 315
#endif
#ifdef __i386__
#define __NR_sched_setattr 351
#define __NR_sched_getattr 352
#endif
#ifdef __arm__
#define __NR_sched_setattr 380
#define __NR_sched_getattr 381
#endif
static volatile int done;
struct sched_attr {
__u32 size;
__u32 sched_policy;
__u64 sched_flags;
/* SCHED_NORMAL, SCHED_BATCH */
__s32 sched_nice;
/* SCHED_FIFO, SCHED_RR */
__u32 sched_priority;
/* SCHED_DEADLINE (nsec) */
__u64 sched_runtime;
__u64 sched_deadline;
__u64 sched_period;
};int sched_setattr(pid_t pid,
const struct sched_attr *attr,
unsigned int flags)
{
return syscall(__NR_sched_setattr, pid, attr, flags);
}int sched_getattr(pid_t pid,
struct sched_attr *attr,
unsigned int size,
unsigned int flags)
{
return syscall(__NR_sched_getattr, pid, attr, size, flags);
}void *run_deadline(void *data)
{
struct sched_attr attr;
int x = 0;
int ret;
unsigned int flags = 0;
printf("deadline thread started [%ld]\n", gettid());
attr.size = sizeof(attr);
attr.sched_flags = 0;
attr.sched_nice = 0;
attr.sched_priority = 0;
/* This creates a 10ms/30ms reservation */
attr.sched_policy = SCHED_DEADLINE;
attr.sched_runtime = 10 * 1000 * 1000;
attr.sched_period = attr.sched_deadline = 30 * 1000 * 1000;
ret = sched_setattr(0, &attr, flags);
if (ret < 0) {
done = 0;
perror("sched_setattr");
exit(-1);
}
while (!done) {
x++;
}
printf("deadline thread dies [%ld]\n", gettid());
return NULL;
}int main (int argc, char **argv)
{
pthread_t thread;
printf("main thread [%ld]\n", gettid());
pthread_create(&thread, NULL, run_deadline, NULL);
sleep(10);
done = 1;
pthread_join(thread, NULL);
printf("main dies [%ld]\n", gettid());
return 0;
}Quoted 9 lines · Juri Lelli
Hello everyone,
This is version 3 of a small patchset that fixes and improves
SCHED_DEADLINEdocumentation.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.
For patch 1 & 2, please consider adding a Reviewed-by from me (there's some nitpick, but nothing serious).
For patch 3 & 4 I have some comments, but again, nothing severe. I'd like a short feedback before adding a reviewed-by though.
All in all, nice work! :D
Quoted 29 lines
Changes since v1:
- fixed typos spotted by Randy and Peter (thanks!)
Changes since v2:
- fixed typos and rewrote paragraphs as suggested by Ingo (thanks!)
Best Regards,
- Juri
Juri Lelli (2):
Documentation/scheduler/sched-deadline.txt: Rewrite section 4 introDocumentation/scheduler/sched-deadline.txt: add tests suite appendixLuca Abeni (2):
Documentation/scheduler/sched-deadline.txt: fix terminology and
improve clarity
Documentation/scheduler/sched-deadline.txt: improve and clarify AC
bitsDocumentation/scheduler/sched-deadline.txt | 204 ++++++++++++++++++++++------- 1 file changed, 159 insertions(+), 45 deletions(-)Signature · 1 line
2.0.4
Signature · 1 line
Henrik
Quoted 11 lines · Henrik Austad
Quoted 9 lines · Juri Lelli
Hello everyone,
This is version 3 of a small patchset that fixes and improves
SCHED_DEADLINEdocumentation.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.
Quoted 6 lines
For patch 1 & 2, please consider adding a Reviewed-by from me (there's some nitpick, but nothing serious).
For patch 3 & 4 I have some comments, but again, nothing severe. I'd like a short feedback before adding a reviewed-by though.
I had these queued up, but I'll wait for the next round of patches before applying them.
Thanks,
Ingo