Re: [Intel-gfx] [PATCH 50/51] drm/i915/guc: Implement GuC priority management

Matthew Brost
2021-07-22T21:38:42Z

On Thu, Jul 22, 2021 at 01:26:30PM -0700, Daniele Ceraolo Spurio wrote:
>
>
> On 7/16/2021 1:17 PM, Matthew Brost wrote:
> > Implement a simple static mapping algorithm of the i915 priority levels
> > (int, -1k to 1k exposed to user) to the 4 GuC levels. Mapping is as
> > follows:
> >
> > i915 level < 0 -> GuC low level (3)
> > i915 level == 0 -> GuC normal level (2)
> > i915 level < INT_MAX -> GuC high level (1)
> > i915 level == INT_MAX -> GuC highest level (0)
> >
> > We believe this mapping should cover the UMD use cases (3 distinct user
> > levels + 1 kernel level).
> >
> > In addition to static mapping, a simple counter system is attached to
> > each context tracking the number of requests inflight on the context at
> > each level. This is needed as the GuC levels are per context while in
> > the i915 levels are per request.
>
> As a general note on this patch, IMO we could do a better job of integrating
> context-level priority with request-level prio. However, I'm aware that this
> code is going to be overhauled again for drm scheduler so I'm not going to
> comment in that direction and I'll review the result again once the drm
> scheduler patches are available.
>

This will change a bit with DRM scheduler.

> >
> > Signed-off-by: Matthew Brost <matthew.brost@intel.com>
> > Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> > ---
> > drivers/gpu/drm/i915/gt/intel_breadcrumbs.c | 3 +
> > drivers/gpu/drm/i915/gt/intel_context_types.h | 9 +-
> > drivers/gpu/drm/i915/gt/intel_engine_user.c | 4 +
> > .../gpu/drm/i915/gt/uc/intel_guc_submission.c | 207 +++++++++++++++++-
> > drivers/gpu/drm/i915/i915_request.c | 5 +
> > drivers/gpu/drm/i915/i915_request.h | 8 +
> > drivers/gpu/drm/i915/i915_scheduler.c | 7 +
> > drivers/gpu/drm/i915/i915_scheduler_types.h | 12 +
> > drivers/gpu/drm/i915/i915_trace.h | 16 +-
> > include/uapi/drm/i915_drm.h | 9 +
> > 10 files changed, 274 insertions(+), 6 deletions(-)
> >
> > diff --git a/drivers/gpu/drm/i915/gt/intel_breadcrumbs.c b/drivers/gpu/drm/i915/gt/intel_breadcrumbs.c
> > index 2007dc6f6b99..209cf265bf74 100644
> > --- a/drivers/gpu/drm/i915/gt/intel_breadcrumbs.c
> > +++ b/drivers/gpu/drm/i915/gt/intel_breadcrumbs.c
> > @@ -245,6 +245,9 @@ static void signal_irq_work(struct irq_work *work)
> > llist_entry(signal, typeof(*rq), signal_node);
> > struct list_head cb_list;
> > + if (rq->engine->sched_engine->retire_inflight_request_prio)
> > + rq->engine->sched_engine->retire_inflight_request_prio(rq);
> > +
> > spin_lock(&rq->lock);
> > list_replace(&rq->fence.cb_list, &cb_list);
> > __dma_fence_signal__timestamp(&rq->fence, timestamp);
> > diff --git a/drivers/gpu/drm/i915/gt/intel_context_types.h b/drivers/gpu/drm/i915/gt/intel_context_types.h
> > index 005a64f2afa7..fe555551c2d2 100644
> > --- a/drivers/gpu/drm/i915/gt/intel_context_types.h
> > +++ b/drivers/gpu/drm/i915/gt/intel_context_types.h
> > @@ -18,8 +18,9 @@
> > #include "intel_engine_types.h"
> > #include "intel_sseu.h"
> > -#define CONTEXT_REDZONE POISON_INUSE
> > +#include "uc/intel_guc_fwif.h"
> > +#define CONTEXT_REDZONE POISON_INUSE
> > DECLARE_EWMA(runtime, 3, 8);
> > struct i915_gem_context;
> > @@ -191,6 +192,12 @@ struct intel_context {
> > /* GuC context blocked fence */
> > struct i915_sw_fence guc_blocked;
> > +
> > + /*
> > + * GuC priority management
> > + */
> > + u8 guc_prio;
> > + u32 guc_prio_count[GUC_CLIENT_PRIORITY_NUM];
> > };
> > #endif /* __INTEL_CONTEXT_TYPES__ */
> > diff --git a/drivers/gpu/drm/i915/gt/intel_engine_user.c b/drivers/gpu/drm/i915/gt/intel_engine_user.c
> > index 84142127ebd8..8f8bea08e734 100644
> > --- a/drivers/gpu/drm/i915/gt/intel_engine_user.c
> > +++ b/drivers/gpu/drm/i915/gt/intel_engine_user.c
> > @@ -11,6 +11,7 @@
> > #include "intel_engine.h"
> > #include "intel_engine_user.h"
> > #include "intel_gt.h"
> > +#include "uc/intel_guc_submission.h"
> > struct intel_engine_cs *
> > intel_engine_lookup_user(struct drm_i915_private *i915, u8 class, u8 instance)
> > @@ -115,6 +116,9 @@ static void set_scheduler_caps(struct drm_i915_private *i915)
> > disabled |= (I915_SCHEDULER_CAP_ENABLED |
> > I915_SCHEDULER_CAP_PRIORITY);
> > + if (intel_uc_uses_guc_submission(&i915->gt.uc))
> > + enabled |= I915_SCHEDULER_CAP_STATIC_PRIORITY_MAP;
> > +
> > for (i = 0; i < ARRAY_SIZE(map); i++) {
> > if (engine->flags & BIT(map[i].engine))
> > enabled |= BIT(map[i].sched);
> > diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c
> > index 536fdbc406c6..263ad6a9e4a9 100644
> > --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c
> > +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c
> > @@ -81,7 +81,8 @@ guc_create_virtual(struct intel_engine_cs **siblings, unsigned int count);
> > */
> > #define SCHED_STATE_NO_LOCK_ENABLED BIT(0)
> > #define SCHED_STATE_NO_LOCK_PENDING_ENABLE BIT(1)
> > -#define SCHED_STATE_NO_LOCK_BLOCKED_SHIFT 2
> > +#define SCHED_STATE_NO_LOCK_REGISTERED BIT(2)
> > +#define SCHED_STATE_NO_LOCK_BLOCKED_SHIFT 3
> > #define SCHED_STATE_NO_LOCK_BLOCKED \
> > BIT(SCHED_STATE_NO_LOCK_BLOCKED_SHIFT)
> > #define SCHED_STATE_NO_LOCK_BLOCKED_MASK \
> > @@ -142,6 +143,24 @@ static inline void decr_context_blocked(struct intel_context *ce)
> > &ce->guc_sched_state_no_lock);
> > }
> > +static inline bool context_registered(struct intel_context *ce)
> > +{
> > + return (atomic_read(&ce->guc_sched_state_no_lock) &
> > + SCHED_STATE_NO_LOCK_REGISTERED);
> > +}
> > +
> > +static inline void set_context_registered(struct intel_context *ce)
> > +{
> > + atomic_or(SCHED_STATE_NO_LOCK_REGISTERED,
> > + &ce->guc_sched_state_no_lock);
> > +}
> > +
> > +static inline void clr_context_registered(struct intel_context *ce)
> > +{
> > + atomic_and((u32)~SCHED_STATE_NO_LOCK_REGISTERED,
> > + &ce->guc_sched_state_no_lock);
> > +}
> > +
> > /*
> > * Below is a set of functions which control the GuC scheduling state which
> > * require a lock, aside from the special case where the functions are called
> > @@ -1080,6 +1099,7 @@ static int steal_guc_id(struct intel_guc *guc)
> > list_del_init(&ce->guc_id_link);
> > guc_id = ce->guc_id;
> > + clr_context_registered(ce);
> > set_context_guc_id_invalid(ce);
> > return guc_id;
> > } else {
> > @@ -1184,10 +1204,13 @@ static int register_context(struct intel_context *ce, bool loop)
> > struct intel_guc *guc = ce_to_guc(ce);
> > u32 offset = intel_guc_ggtt_offset(guc, guc->lrc_desc_pool) +
> > ce->guc_id * sizeof(struct guc_lrc_desc);
> > + int ret;
> > trace_intel_context_register(ce);
> > - return __guc_action_register_context(guc, ce->guc_id, offset, loop);
> > + ret = __guc_action_register_context(guc, ce->guc_id, offset, loop);
> > + set_context_registered(ce);
>
> Should this setting be conditional to ret == 0 ?
>

Yep.

> > + return ret;
> > }
> > static int __guc_action_deregister_context(struct intel_guc *guc,
> > @@ -1243,6 +1266,8 @@ static void guc_context_policy_init(struct intel_engine_cs *engine,
> > desc->preemption_timeout = engine->props.preempt_timeout_ms * 1000;
> > }
> > +static inline u8 map_i915_prio_to_guc_prio(int prio);
> > +
> > static int guc_lrc_desc_pin(struct intel_context *ce, bool loop)
> > {
> > struct intel_runtime_pm *runtime_pm =
> > @@ -1251,6 +1276,8 @@ static int guc_lrc_desc_pin(struct intel_context *ce, bool loop)
> > struct intel_guc *guc = &engine->gt->uc.guc;
> > u32 desc_idx = ce->guc_id;
> > struct guc_lrc_desc *desc;
> > + const struct i915_gem_context *ctx;
> > + int prio = I915_CONTEXT_DEFAULT_PRIORITY;
> > bool context_registered;
> > intel_wakeref_t wakeref;
> > int ret = 0;
> > @@ -1266,6 +1293,12 @@ static int guc_lrc_desc_pin(struct intel_context *ce, bool loop)
> > context_registered = lrc_desc_registered(guc, desc_idx);
> > + rcu_read_lock();
> > + ctx = rcu_dereference(ce->gem_context);
> > + if (ctx)
> > + prio = ctx->sched.priority;
> > + rcu_read_unlock();
> > +
> > reset_lrc_desc(guc, desc_idx);
> > set_lrc_desc_registered(guc, desc_idx, ce);
> > @@ -1274,7 +1307,8 @@ static int guc_lrc_desc_pin(struct intel_context *ce, bool loop)
> > desc->engine_submit_mask = adjust_engine_mask(engine->class,
> > engine->mask);
> > desc->hw_context_desc = ce->lrc.lrca;
> > - desc->priority = GUC_CLIENT_PRIORITY_KMD_NORMAL;
> > + ce->guc_prio = map_i915_prio_to_guc_prio(prio);
> > + desc->priority = ce->guc_prio;
> > desc->context_flags = CONTEXT_REGISTRATION_FLAG_KMD;
> > guc_context_policy_init(engine, desc);
> > init_sched_state(ce);
> > @@ -1659,11 +1693,17 @@ static inline void guc_lrc_desc_unpin(struct intel_context *ce)
> > GEM_BUG_ON(ce != __get_context(guc, ce->guc_id));
> > GEM_BUG_ON(context_enabled(ce));
> > + clr_context_registered(ce);
> > deregister_context(ce, ce->guc_id, true);
> > }
> > static void __guc_context_destroy(struct intel_context *ce)
> > {
> > + GEM_BUG_ON(ce->guc_prio_count[GUC_CLIENT_PRIORITY_KMD_HIGH] ||
> > + ce->guc_prio_count[GUC_CLIENT_PRIORITY_HIGH] ||
> > + ce->guc_prio_count[GUC_CLIENT_PRIORITY_KMD_NORMAL] ||
> > + ce->guc_prio_count[GUC_CLIENT_PRIORITY_NORMAL]);
> > +
> > lrc_fini(ce);
> > intel_context_fini(ce);
> > @@ -1756,15 +1796,119 @@ static int guc_context_alloc(struct intel_context *ce)
> > return lrc_alloc(ce, ce->engine);
> > }
> > +static void guc_context_set_prio(struct intel_guc *guc,
> > + struct intel_context *ce,
> > + u8 prio)
> > +{
> > + u32 action[] = {
> > + INTEL_GUC_ACTION_SET_CONTEXT_PRIORITY,
> > + ce->guc_id,
> > + prio,
> > + };
> > +
> > + GEM_BUG_ON(prio < GUC_CLIENT_PRIORITY_KMD_HIGH ||
> > + prio > GUC_CLIENT_PRIORITY_NORMAL);
> > +
> > + if (ce->guc_prio == prio || submission_disabled(guc) ||
> > + !context_registered(ce))
> > + return;
> > +
> > + guc_submission_send_busy_loop(guc, action, ARRAY_SIZE(action), 0, true);
> > +
> > + ce->guc_prio = prio;
> > + trace_intel_context_set_prio(ce);
> > +}
> > +
> > +static inline u8 map_i915_prio_to_guc_prio(int prio)
> > +{
> > + if (prio == I915_PRIORITY_NORMAL)
> > + return GUC_CLIENT_PRIORITY_KMD_NORMAL;
> > + else if (prio < I915_PRIORITY_NORMAL)
> > + return GUC_CLIENT_PRIORITY_NORMAL;
> > + else if (prio != I915_PRIORITY_BARRIER)
>
> Shouldn't this be I915_PRIORITY_UNPREEMPTABLE?
>

No, I915_PRIORITY_UNPREEMPTABLE is an execlists only concept.

> > + return GUC_CLIENT_PRIORITY_HIGH;
> > + else
> > + return GUC_CLIENT_PRIORITY_KMD_HIGH;
> > +}
> > +
> > +static inline void add_context_inflight_prio(struct intel_context *ce,
> > + u8 guc_prio)
> > +{
> > + lockdep_assert_held(&ce->guc_active.lock);
> > + GEM_BUG_ON(guc_prio >= ARRAY_SIZE(ce->guc_prio_count));
> > +
> > + ++ce->guc_prio_count[guc_prio];
> > +
> > + /* Overflow protection */
> > + GEM_WARN_ON(!ce->guc_prio_count[guc_prio]);
> > +}
> > +
> > +static inline void sub_context_inflight_prio(struct intel_context *ce,
> > + u8 guc_prio)
> > +{
> > + lockdep_assert_held(&ce->guc_active.lock);
> > + GEM_BUG_ON(guc_prio >= ARRAY_SIZE(ce->guc_prio_count));
> > +
> > + /* Underflow protection */
> > + GEM_WARN_ON(!ce->guc_prio_count[guc_prio]);
> > +
> > + --ce->guc_prio_count[guc_prio];
> > +}
> > +
> > +static inline void update_context_prio(struct intel_context *ce)
> > +{
> > + struct intel_guc *guc = &ce->engine->gt->uc.guc;
> > + int i;
> > +
> > + lockdep_assert_held(&ce->guc_active.lock);
> > +
> > + for (i = 0; i < ARRAY_SIZE(ce->guc_prio_count); ++i) {
>
> This amd other loops/checks rely on the prios going from highest to lowest
> starting from zero. Maybe add a build check somewhere?
>
> BUILD_BUG_ON(GUC_PRIO_KMD_HIGH != 0);
> BUILD_BUG_ON(GUC_PRIO_KMD_HIGH > GUC_PRIO_LOW);
>

Good idea.

> > + if (ce->guc_prio_count[i]) {
> > + guc_context_set_prio(guc, ce, i);
> > + break;
> > + }
> > + }
> > +}
> > +
> > +static inline bool new_guc_prio_higher(u8 old_guc_prio, u8 new_guc_prio)
> > +{
> > + /* Lower value is higher priority */
> > + return new_guc_prio < old_guc_prio;
> > +}
> > +
> > static void add_to_context(struct i915_request *rq)
> > {
> > struct intel_context *ce = rq->context;
> > + u8 new_guc_prio = map_i915_prio_to_guc_prio(rq_prio(rq));
> > +
> > + GEM_BUG_ON(rq->guc_prio == GUC_PRIO_FINI);
> > spin_lock(&ce->guc_active.lock);
> > list_move_tail(&rq->sched.link, &ce->guc_active.requests);
> > +
> > + if (rq->guc_prio == GUC_PRIO_INIT) {
> > + rq->guc_prio = new_guc_prio;
> > + add_context_inflight_prio(ce, rq->guc_prio);
> > + } else if (new_guc_prio_higher(rq->guc_prio, new_guc_prio)) {
> > + sub_context_inflight_prio(ce, rq->guc_prio);
> > + rq->guc_prio = new_guc_prio;
> > + add_context_inflight_prio(ce, rq->guc_prio);
> > + }
> > + update_context_prio(ce);
> > +
> > spin_unlock(&ce->guc_active.lock);
> > }
> > +static void guc_prio_fini(struct i915_request *rq, struct intel_context *ce)
> > +{
>
> assert_spin_lock_held(&ce->guc_active.lock) ?
>

Why not.

> > + if (rq->guc_prio != GUC_PRIO_INIT &&
> > + rq->guc_prio != GUC_PRIO_FINI) {
> > + sub_context_inflight_prio(ce, rq->guc_prio);
> > + update_context_prio(ce);
> > + }
> > + rq->guc_prio = GUC_PRIO_FINI;
> > +}
> > +
> > static void remove_from_context(struct i915_request *rq)
> > {
> > struct intel_context *ce = rq->context;
> > @@ -1777,6 +1921,8 @@ static void remove_from_context(struct i915_request *rq)
> > /* Prevent further __await_execution() registering a cb, then flush */
> > set_bit(I915_FENCE_FLAG_ACTIVE, &rq->fence.flags);
> > + guc_prio_fini(rq, ce);
> > +
> > spin_unlock_irq(&ce->guc_active.lock);
> > atomic_dec(&ce->guc_id_ref);
> > @@ -2058,6 +2204,39 @@ static void guc_init_breadcrumbs(struct intel_engine_cs *engine)
> > }
> > }
> > +static void guc_bump_inflight_request_prio(struct i915_request *rq,
> > + int prio)
> > +{
> > + struct intel_context *ce = rq->context;
> > + u8 new_guc_prio = map_i915_prio_to_guc_prio(prio);
> > +
> > + /* Short circuit function */
> > + if (prio < I915_PRIORITY_NORMAL ||
> > + (rq->guc_prio == GUC_PRIO_FINI) ||
> > + (rq->guc_prio != GUC_PRIO_INIT &&
> > + !new_guc_prio_higher(rq->guc_prio, new_guc_prio)))
> > + return;
> > +
> > + spin_lock(&ce->guc_active.lock);
> > + if (rq->guc_prio != GUC_PRIO_FINI) {
> > + if (rq->guc_prio != GUC_PRIO_INIT)
> > + sub_context_inflight_prio(ce, rq->guc_prio);
> > + rq->guc_prio = new_guc_prio;
> > + add_context_inflight_prio(ce, rq->guc_prio);
> > + update_context_prio(ce);
> > + }
> > + spin_unlock(&ce->guc_active.lock);
> > +}
> > +
> > +static void guc_retire_inflight_request_prio(struct i915_request *rq)
> > +{
> > + struct intel_context *ce = rq->context;
> > +
> > + spin_lock(&ce->guc_active.lock);
> > + guc_prio_fini(rq, ce);
> > + spin_unlock(&ce->guc_active.lock);
> > +}
> > +
> > static void sanitize_hwsp(struct intel_engine_cs *engine)
> > {
> > struct intel_timeline *tl;
> > @@ -2293,6 +2472,10 @@ int intel_guc_submission_setup(struct intel_engine_cs *engine)
> > guc->sched_engine->disabled = guc_sched_engine_disabled;
> > guc->sched_engine->private_data = guc;
> > guc->sched_engine->destroy = guc_sched_engine_destroy;
> > + guc->sched_engine->bump_inflight_request_prio =
> > + guc_bump_inflight_request_prio;
> > + guc->sched_engine->retire_inflight_request_prio =
> > + guc_retire_inflight_request_prio;
> > tasklet_setup(&guc->sched_engine->tasklet,
> > guc_submission_tasklet);
> > }
> > @@ -2670,6 +2853,22 @@ void intel_guc_submission_print_info(struct intel_guc *guc,
> > drm_printf(p, "\n");
> > }
> > +static inline void guc_log_context_priority(struct drm_printer *p,
> > + struct intel_context *ce)
> > +{
> > + int i;
> > +
> > + drm_printf(p, "\t\tPriority: %d\n",
> > + ce->guc_prio);
> > + drm_printf(p, "\t\tNumber Requests (lower index == higher priority)\n");
> > + for (i = GUC_CLIENT_PRIORITY_KMD_HIGH;
> > + i < GUC_CLIENT_PRIORITY_NUM; ++i) {
> > + drm_printf(p, "\t\tNumber requests in priority band[%d]: %d\n",
> > + i, ce->guc_prio_count[i]);
> > + }
> > + drm_printf(p, "\n");
> > +}
> > +
> > void intel_guc_submission_print_context_info(struct intel_guc *guc,
> > struct drm_printer *p)
> > {
> > @@ -2692,6 +2891,8 @@ void intel_guc_submission_print_context_info(struct intel_guc *guc,
> > drm_printf(p, "\t\tSchedule State: 0x%x, 0x%x\n\n",
> > ce->guc_state.sched_state,
> > atomic_read(&ce->guc_sched_state_no_lock));
> > +
> > + guc_log_context_priority(p, ce);
> > }
> > }
> > diff --git a/drivers/gpu/drm/i915/i915_request.c b/drivers/gpu/drm/i915/i915_request.c
> > index f3552642b8a1..3fdfada99ba0 100644
> > --- a/drivers/gpu/drm/i915/i915_request.c
> > +++ b/drivers/gpu/drm/i915/i915_request.c
> > @@ -114,6 +114,9 @@ static void i915_fence_release(struct dma_fence *fence)
> > {
> > struct i915_request *rq = to_request(fence);
> > + GEM_BUG_ON(rq->guc_prio != GUC_PRIO_INIT &&
> > + rq->guc_prio != GUC_PRIO_FINI);
> > +
> > /*
> > * The request is put onto a RCU freelist (i.e. the address
> > * is immediately reused), mark the fences as being freed now.
> > @@ -922,6 +925,8 @@ __i915_request_create(struct intel_context *ce, gfp_t gfp)
> > rq->rcustate = get_state_synchronize_rcu(); /* acts as smp_mb() */
> > + rq->guc_prio = GUC_PRIO_INIT;
> > +
> > /* We bump the ref for the fence chain */
> > i915_sw_fence_reinit(&i915_request_get(rq)->submit);
> > i915_sw_fence_reinit(&i915_request_get(rq)->semaphore);
> > diff --git a/drivers/gpu/drm/i915/i915_request.h b/drivers/gpu/drm/i915/i915_request.h
> > index a3d4728ea06c..f0463d19c712 100644
> > --- a/drivers/gpu/drm/i915/i915_request.h
> > +++ b/drivers/gpu/drm/i915/i915_request.h
> > @@ -293,6 +293,14 @@ struct i915_request {
> > */
> > struct list_head guc_fence_link;
> > + /**
> > + * Priority level while the request is inflight. Differs slightly than
> > + * i915 scheduler priority.
>
> I'd say it differs quite a bit. Maybe refer to the comment above
> I915_SCHEDULER_CAP_STATIC_PRIORITY_MAP?
>

Sure.

Matt

> Daniele
>
> > + */
> > +#define GUC_PRIO_INIT 0xff
> > +#define GUC_PRIO_FINI 0xfe
> > + u8 guc_prio;
> > +
> > I915_SELFTEST_DECLARE(struct {
> > struct list_head link;
> > unsigned long delay;
> > diff --git a/drivers/gpu/drm/i915/i915_scheduler.c b/drivers/gpu/drm/i915/i915_scheduler.c
> > index 8766a8643469..3fccae3672c1 100644
> > --- a/drivers/gpu/drm/i915/i915_scheduler.c
> > +++ b/drivers/gpu/drm/i915/i915_scheduler.c
> > @@ -241,6 +241,9 @@ static void __i915_schedule(struct i915_sched_node *node,
> > /* Fifo and depth-first replacement ensure our deps execute before us */
> > sched_engine = lock_sched_engine(node, sched_engine, &cache);
> > list_for_each_entry_safe_reverse(dep, p, &dfs, dfs_link) {
> > + struct i915_request *from = container_of(dep->signaler,
> > + struct i915_request,
> > + sched);
> > INIT_LIST_HEAD(&dep->dfs_link);
> > node = dep->signaler;
> > @@ -254,6 +257,10 @@ static void __i915_schedule(struct i915_sched_node *node,
> > GEM_BUG_ON(node_to_request(node)->engine->sched_engine !=
> > sched_engine);
> > + /* Must be called before changing the nodes priority */
> > + if (sched_engine->bump_inflight_request_prio)
> > + sched_engine->bump_inflight_request_prio(from, prio);
> > +
> > WRITE_ONCE(node->attr.priority, prio);
> > /*
> > diff --git a/drivers/gpu/drm/i915/i915_scheduler_types.h b/drivers/gpu/drm/i915/i915_scheduler_types.h
> > index eaef233e9080..b0a1b58c7893 100644
> > --- a/drivers/gpu/drm/i915/i915_scheduler_types.h
> > +++ b/drivers/gpu/drm/i915/i915_scheduler_types.h
> > @@ -179,6 +179,18 @@ struct i915_sched_engine {
> > void (*kick_backend)(const struct i915_request *rq,
> > int prio);
> > + /**
> > + * @bump_inflight_request_prio: update priority of an inflight request
> > + */
> > + void (*bump_inflight_request_prio)(struct i915_request *rq,
> > + int prio);
> > +
> > + /**
> > + * @retire_inflight_request_prio: indicate request is retired to
> > + * priority tracking
> > + */
> > + void (*retire_inflight_request_prio)(struct i915_request *rq);
> > +
> > /**
> > * @schedule: adjust priority of request
> > *
> > diff --git a/drivers/gpu/drm/i915/i915_trace.h b/drivers/gpu/drm/i915/i915_trace.h
> > index 937d3706af9b..9d2cd14ed882 100644
> > --- a/drivers/gpu/drm/i915/i915_trace.h
> > +++ b/drivers/gpu/drm/i915/i915_trace.h
> > @@ -914,6 +914,7 @@ DECLARE_EVENT_CLASS(intel_context,
> > __field(int, pin_count)
> > __field(u32, sched_state)
> > __field(u32, guc_sched_state_no_lock)
> > + __field(u8, guc_prio)
> > ),
> > TP_fast_assign(
> > @@ -922,11 +923,17 @@ DECLARE_EVENT_CLASS(intel_context,
> > __entry->sched_state = ce->guc_state.sched_state;
> > __entry->guc_sched_state_no_lock =
> > atomic_read(&ce->guc_sched_state_no_lock);
> > + __entry->guc_prio = ce->guc_prio;
> > ),
> > - TP_printk("guc_id=%d, pin_count=%d sched_state=0x%x,0x%x",
> > + TP_printk("guc_id=%d, pin_count=%d sched_state=0x%x,0x%x, guc_prio=%u",
> > __entry->guc_id, __entry->pin_count, __entry->sched_state,
> > - __entry->guc_sched_state_no_lock)
> > + __entry->guc_sched_state_no_lock, __entry->guc_prio)
> > +);
> > +
> > +DEFINE_EVENT(intel_context, intel_context_set_prio,
> > + TP_PROTO(struct intel_context *ce),
> > + TP_ARGS(ce)
> > );
> > DEFINE_EVENT(intel_context, intel_context_reset,
> > @@ -1036,6 +1043,11 @@ trace_i915_request_out(struct i915_request *rq)
> > {
> > }
> > +static inline void
> > +trace_intel_context_set_prio(struct intel_context *ce)
> > +{
> > +}
> > +
> > static inline void
> > trace_intel_context_reset(struct intel_context *ce)
> > {
> > diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
> > index e54f9efaead0..cb0a5396e655 100644
> > --- a/include/uapi/drm/i915_drm.h
> > +++ b/include/uapi/drm/i915_drm.h
> > @@ -572,6 +572,15 @@ typedef struct drm_i915_irq_wait {
> > #define I915_SCHEDULER_CAP_PREEMPTION (1ul << 2)
> > #define I915_SCHEDULER_CAP_SEMAPHORES (1ul << 3)
> > #define I915_SCHEDULER_CAP_ENGINE_BUSY_STATS (1ul << 4)
> > +/*
> > + * Indicates the 2k user priority levels are statically mapped into 3 buckets as
> > + * follows:
> > + *
> > + * -1k to -1 Low priority
> > + * 0 Normal priority
> > + * 1 to 1k Highest priority
> > + */
> > +#define I915_SCHEDULER_CAP_STATIC_PRIORITY_MAP (1ul << 5)
> > #define I915_PARAM_HUC_STATUS 42