Skip to contentSkip to conversation

sched/deadline: fix runtime accounting in documentation

PATCH In review Claudio Scordino 5 participants 5 messages Nov 14, 2017 – Nov 16, 2017 Documentation

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 sched/deadline: fix runtime accounting in documentation

CC Jonathan Corbet <[email protected]>
CC "Peter Zijlstra (Intel)" <[email protected]>
CC Ingo Molnar <[email protected]>
Cc Tommaso Cucinotta <[email protected]>
Cc Mathieu Poirier <[email protected]>
---
 Documentation/scheduler/sched-deadline.txt | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
Documentation/scheduler/sched-deadline.txt +10 -3
index e89e36e..8ce78f8 100644
@@ -204,10 +204,17 @@ CONTENTS
  It does so by decrementing the runtime of the executing task Ti at a pace equal
  to
 
-           dq = -max{ Ui, (1 - Uinact) } dt
+           dq = -max{ Ui / Umax, (1 - Uinact - Uextra) } dt
 
- where Uinact is the inactive utilization, computed as (this_bq - running_bw),
- and Ui is the bandwidth of task Ti.
+ where:
+
+  - Ui is the bandwidth of task Ti;
+  - Umax is the maximum reclaimable utilization (subjected to RT throttling
+    limits);
+  - Uinact is the (per runqueue) inactive utilization, computed as
+    (this_bq - running_bw);
+  - Uextra is the (per runqueue) extra reclaimable utilization
+    (subjected to RT throttling limits).
 
 
  Let's now see a trivial example of two deadline tasks with runtime equal
Signature · 1 line
2.7.4
#1 lore raw

Hi Claudio,

Quoted 10 lines · Claudio Scordino
CC Jonathan Corbet <[email protected]>
CC "Peter Zijlstra (Intel)" <[email protected]>
CC Ingo Molnar <[email protected]>
Cc Tommaso Cucinotta <[email protected]>
Cc Mathieu Poirier <[email protected]>

---

Please add a short description for your change, even if it is trivial.

Quoted 15 lines
 Documentation/scheduler/sched-deadline.txt | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
Documentation/scheduler/sched-deadline.txt +1 -2
index e89e36e..8ce78f8 100644
@@ -204,10 +204,17 @@ CONTENTS
  It does so by decrementing the runtime of the executing task Ti at a pace equal
  to
 
-           dq = -max{ Ui, (1 - Uinact) } dt
+           dq = -max{ Ui / Umax, (1 - Uinact - Uextra) } dt
 
- where Uinact is the inactive utilization, computed as (this_bq - running_bw),

Documentation/scheduler/sched-deadline.txt CONTENTS · line 217

Quoted 10 lines
Documentation/scheduler/sched-deadline.txt +9 -1
- and Ui is the bandwidth of task Ti.
+ where:
+
+  - Ui is the bandwidth of task Ti;
+  - Umax is the maximum reclaimable utilization (subjected to RT throttling
+    limits);
+  - Uinact is the (per runqueue) inactive utilization, computed as
+    (this_bq - running_bw);
+  - Uextra is the (per runqueue) extra reclaimable utilization
+    (subjected to RT throttling limits).

I think there would be value in defining 'dq' and 'dt'. That way people know exactly what they are and it leaves no room for interpretation.

Thanks,
Mathieu

Quoted 6 lines
Documentation/scheduler/sched-deadline.txt +0 -1
  Let's now see a trivial example of two deadline tasks with runtime equal
--

2.7.4

#2 lore raw
In reply to Claudio Scordino
Quoted 9 lines · Claudio Scordino
CC Jonathan Corbet <[email protected]>
CC "Peter Zijlstra (Intel)" <[email protected]>
CC Ingo Molnar <[email protected]>
Cc Tommaso Cucinotta <[email protected]>
Cc Mathieu Poirier <[email protected]>

ACK, Ingo can you route this?

Quoted 32 lines
---
 Documentation/scheduler/sched-deadline.txt | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
Documentation/scheduler/sched-deadline.txt +10 -3
index e89e36e..8ce78f8 100644
@@ -204,10 +204,17 @@ CONTENTS
  It does so by decrementing the runtime of the executing task Ti at a pace equal
  to
 
-           dq = -max{ Ui, (1 - Uinact) } dt
+           dq = -max{ Ui / Umax, (1 - Uinact - Uextra) } dt
 
- where Uinact is the inactive utilization, computed as (this_bq - running_bw),
- and Ui is the bandwidth of task Ti.
+ where:
+
+  - Ui is the bandwidth of task Ti;
+  - Umax is the maximum reclaimable utilization (subjected to RT throttling
+    limits);
+  - Uinact is the (per runqueue) inactive utilization, computed as
+    (this_bq - running_bw);
+  - Uextra is the (per runqueue) extra reclaimable utilization
+    (subjected to RT throttling limits).
 
 
  Let's now see a trivial example of two deadline tasks with runtime equal
Signature · 1 line
2.7.4
#3 lore raw
Quoted 11 lines · Peter Zijlstra
Quoted 9 lines · Claudio Scordino
CC Jonathan Corbet <[email protected]>
CC "Peter Zijlstra (Intel)" <[email protected]>
CC Ingo Molnar <[email protected]>
Cc Tommaso Cucinotta <[email protected]>
Cc Mathieu Poirier <[email protected]>
Quoted 1 line

ACK, Ingo can you route this?

Yeah, I've applied it to tip:sched/urgent, should go upstream in a few days.

Thanks,

Ingo

#4 lore raw

[tip:sched/urgent] sched/deadline: Fix the description of runtime accounting in the documentation

In reply to Claudio Scordino
sched/deadline: Fix the description of runtime accounting in the documentation
Commit-ID:  5c0342ca7ef17220d8dd2da68d0d349c26ab19df
Gitweb:     https://git.kernel.org/tip/5c0342ca7ef17220d8dd2da68d0d349c26ab19df
Author:     Claudio Scordino <[email protected]>
AuthorDate: Tue, 14 Nov 2017 12:19:26 +0100
Committer:  Ingo Molnar <[email protected]>
CommitDate: Thu, 16 Nov 2017 09:00:35 +0100

sched/deadline: Fix the description of runtime accounting in the documentation

---
 Documentation/scheduler/sched-deadline.txt | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
Documentation/scheduler/sched-deadline.txt +10 -3
index e89e36e..8ce78f8 100644
@@ -204,10 +204,17 @@ CONTENTS
  It does so by decrementing the runtime of the executing task Ti at a pace equal
  to
 
-           dq = -max{ Ui, (1 - Uinact) } dt
+           dq = -max{ Ui / Umax, (1 - Uinact - Uextra) } dt
 
- where Uinact is the inactive utilization, computed as (this_bq - running_bw),
- and Ui is the bandwidth of task Ti.
+ where:
+
+  - Ui is the bandwidth of task Ti;
+  - Umax is the maximum reclaimable utilization (subjected to RT throttling
+    limits);
+  - Uinact is the (per runqueue) inactive utilization, computed as
+    (this_bq - running_bw);
+  - Uextra is the (per runqueue) extra reclaimable utilization
+    (subjected to RT throttling limits).
 
 
  Let's now see a trivial example of two deadline tasks with runtime equal