Re: [RFC PATCH v2 0/6] SCHED_DEADLINE server infrastructure

From: luca abeni
Date: Fri Aug 07 2020 - 10:16:50 EST

Hi Juri,

thanks for sharing the v2 patchset!

In the next days I'll have a look at it, and try some tests...

In the meanwhile, I have some questions/comments after a first quick

If I understand well, the patchset does not apply deadline servers to
FIFO and RR tasks, right? How does this patchset interact with RT

If I understand well, patch 6/6 does something like "use deadline
servers for SCHED_OTHER only if FIFO/RR tasks risk to starve
SCHED_OTHER tasks"... Right? I understand this is because you do not
want to delay RT tasks if they are not starving other tasks. But then,
maybe what you want is not deadline-based scheduling. Maybe a
reservation-based scheduler based on fixed priorities is what you want?
(with SCHED_DEADLINE, you could provide exact performance guarantees to
SCHED_OTHER tasks, but I suspect patch 6/6 breaks these guarantees?)


On Fri, 7 Aug 2020 11:50:45 +0200
Juri Lelli <juri.lelli@xxxxxxxxxx> wrote:

> Hi,
> This is RFC v2 of Peter's SCHED_DEADLINE server infrastructure
> implementation [1].
> SCHED_DEADLINE servers can help fixing starvation issues of low
> priority tasks (e.g., SCHED_OTHER) when higher priority tasks
> monopolize CPU cycles. Today we have RT Throttling; DEADLINE servers
> should be able to replace and improve that.
> I rebased Peter's patches (adding changelogs where needed) on
> tip/sched/core as of today and incorporated fixes to issues discussed
> during RFC v1. Current set seems to even boot on real HW! :-)
> While playing with RFC v1 set (and discussing it further offline with
> Daniel) it has emerged the need to slightly change the behavior. Patch
> 6/6 is a (cumbersome?) attempt to show what's probably needed.
> The problem with "original" implementation is that FIFO tasks might
> suffer preemption from NORMAL even when spare CPU cycles are
> available. In fact, fair deadline server is enqueued right away when
> NORMAL tasks wake up and they are first scheduled by the server, thus
> potentially preempting a well behaving FIFO task. This is of course
> not ideal. So, in patch 6/6 I propose to use some kind of starvation
> monitor/ watchdog that delays enqueuing of deadline servers to the
> point when fair tasks might start to actually suffer from starvation
> (just randomly picked HZ/2 for now). One problem I already see with
> the current implementation is that it adds overhead to fair paths, so
> I'm pretty sure there are better ways to implement the idea (e.g.,
> Daniel already suggested using a starvation monitor kthread sort of
> thing).
> Receiving comments and suggestions is the sole purpose of this posting
> at this stage. Hopefully we can further discuss the idea at Plumbers
> in a few weeks. So, please don't focus too much into actual
> implementation (which I plan to revise anyway after I'm back from pto
> :), but try to see if this might actually fly. The feature seems to
> be very much needed.
> Thanks!
> Juri
> 1 -
> Juri Lelli (1):
> sched/fair: Implement starvation monitor
> Peter Zijlstra (5):
> sched: Unify runtime accounting across classes
> sched/deadline: Collect sched_dl_entity initialization
> sched/deadline: Move bandwidth accounting into
> {en,de}queue_dl_entity sched/deadline: Introduce deadline servers
> sched/fair: Add trivial fair server
> include/linux/sched.h | 28 ++-
> kernel/sched/core.c | 23 +-
> kernel/sched/deadline.c | 483
> ++++++++++++++++++++++++--------------- kernel/sched/fair.c |
> 136 ++++++++++- kernel/sched/rt.c | 17 +-
> kernel/sched/sched.h | 50 +++-
> kernel/sched/stop_task.c | 16 +-
> 7 files changed, 522 insertions(+), 231 deletions(-)