lkml.org 
[lkml]   [2023]   [May]   [31]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[PATCH 11/15] sched/eevdf: Better handle mixed slice length
    In the case where (due to latency-nice) there are different request
    sizes in the tree, the smaller requests tend to be dominated by the
    larger. Also note how the EEVDF lag limits are based on r_max.

    Therefore; add a heuristic that for the mixed request size case, moves
    smaller requests to placement strategy #2 which ensures they're
    immidiately eligible and and due to their smaller (virtual) deadline
    will cause preemption.

    NOTE: this relies on update_entity_lag() to impose lag limits above
    a single slice.

    Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
    ---
    kernel/sched/fair.c | 30 ++++++++++++++++++++++++++++++
    kernel/sched/features.h | 1 +
    kernel/sched/sched.h | 1 +
    3 files changed, 32 insertions(+)

    --- a/kernel/sched/fair.c
    +++ b/kernel/sched/fair.c
    @@ -642,6 +642,7 @@ avg_vruntime_add(struct cfs_rq *cfs_rq,
    s64 key = entity_key(cfs_rq, se);

    cfs_rq->avg_vruntime += key * weight;
    + cfs_rq->avg_slice += se->slice * weight;
    cfs_rq->avg_load += weight;
    }

    @@ -652,6 +653,7 @@ avg_vruntime_sub(struct cfs_rq *cfs_rq,
    s64 key = entity_key(cfs_rq, se);

    cfs_rq->avg_vruntime -= key * weight;
    + cfs_rq->avg_slice -= se->slice * weight;
    cfs_rq->avg_load -= weight;
    }

    @@ -4908,6 +4910,21 @@ static inline void update_misfit_status(

    #endif /* CONFIG_SMP */

    +static inline bool
    +entity_has_slept(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
    +{
    + u64 now;
    +
    + if (!(flags & ENQUEUE_WAKEUP))
    + return false;
    +
    + if (flags & ENQUEUE_MIGRATED)
    + return true;
    +
    + now = rq_clock_task(rq_of(cfs_rq));
    + return (s64)(se->exec_start - now) >= se->slice;
    +}
    +
    static void
    place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
    {
    @@ -4930,6 +4947,19 @@ place_entity(struct cfs_rq *cfs_rq, stru
    lag = se->vlag;

    /*
    + * For latency sensitive tasks; those that have a shorter than
    + * average slice and do not fully consume the slice, transition
    + * to EEVDF placement strategy #2.
    + */
    + if (sched_feat(PLACE_FUDGE) &&
    + (cfs_rq->avg_slice > se->slice * cfs_rq->avg_load) &&
    + entity_has_slept(cfs_rq, se, flags)) {
    + lag += vslice;
    + if (lag > 0)
    + lag = 0;
    + }
    +
    + /*
    * If we want to place a task and preserve lag, we have to
    * consider the effect of the new entity on the weighted
    * average and compensate for this, otherwise lag can quickly
    --- a/kernel/sched/features.h
    +++ b/kernel/sched/features.h
    @@ -5,6 +5,7 @@
    * sleep+wake cycles. EEVDF placement strategy #1, #2 if disabled.
    */
    SCHED_FEAT(PLACE_LAG, true)
    +SCHED_FEAT(PLACE_FUDGE, true)
    SCHED_FEAT(PLACE_DEADLINE_INITIAL, true)

    /*
    --- a/kernel/sched/sched.h
    +++ b/kernel/sched/sched.h
    @@ -555,6 +555,7 @@ struct cfs_rq {
    unsigned int idle_h_nr_running; /* SCHED_IDLE */

    s64 avg_vruntime;
    + u64 avg_slice;
    u64 avg_load;

    u64 exec_clock;

    \
     
     \ /
      Last update: 2023-05-31 14:50    [W:3.152 / U:1.108 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site