Commit 3a7a92ab authored by Chris Wilson's avatar Chris Wilson
Browse files

drm/i915/execlists: Force preemption 



If the preempted context takes too long to relinquish control, e.g. it
is stuck inside a shader with arbitration disabled, evict that context
with an engine reset. This ensures that preemptions are reasonably
responsive, providing a tighter QoS for the more important context at
the cost of flagging unresponsive contexts more frequently (i.e. instead
of using an ~10s hangcheck, we now evict at ~100ms).  The challenge of
lies in picking a timeout that can be reasonably serviced by HW for
typical workloads, balancing the existing clients against the needs for
responsiveness.

Note that coupled with timeslicing, this will lead to rapid GPU "hang"
detection with multiple active contexts vying for GPU time.

The forced preemption mechanism can be compiled out with

	./scripts/config --set-val DRM_I915_PREEMPT_TIMEOUT 0

Signed-off-by: default avatarChris Wilson <chris@chris-wilson.co.uk>
Cc: Mika Kuoppala <mika.kuoppala@linux.intel.com>
Cc: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
Reviewed-by: default avatarMika Kuoppala <mika.kuoppala@linux.intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20191023133108.21401-2-chris@chris-wilson.co.uk
parent a8c51ed2

drivers/gpu/drm/i915/Kconfig.profile

+12 −0
Original line number Diff line number Diff line
@@ -12,6 +12,18 @@ config DRM_I915_USERFAULT_AUTOSUSPEND 
	  May be 0 to disable the extra delay and solely use the device level

	  runtime pm autosuspend delay tunable.



config DRM_I915_PREEMPT_TIMEOUT

	int "Preempt timeout (ms, jiffy granularity)"

	default 100 # milliseconds

	help

	  How long to wait (in milliseconds) for a preemption event to occur

	  when submitting a new context via execlists. If the current context

	  does not hit an arbitration point and yield to HW before the timer

	  expires, the HW will be reset to allow the more important context

	  to execute.



	  May be 0 to disable the timeout.



config DRM_I915_SPIN_REQUEST

	int "Busywait for request completion (us)"

	default 5 # microseconds

drivers/gpu/drm/i915/gt/intel_engine.h

+9 −0
Original line number Diff line number Diff line
@@ -527,4 +527,13 @@ void intel_engine_init_active(struct intel_engine_cs *engine, 
#define ENGINE_MOCK	1

#define ENGINE_VIRTUAL	2



static inline bool

intel_engine_has_preempt_reset(const struct intel_engine_cs *engine)

{

	if (!CONFIG_DRM_I915_PREEMPT_TIMEOUT)

		return 0;



	return intel_engine_has_preemption(engine);

}



#endif /* _INTEL_RINGBUFFER_H_ */

drivers/gpu/drm/i915/gt/intel_engine_cs.c

+4 −1
Original line number Diff line number Diff line
@@ -308,6 +308,8 @@ static int intel_engine_setup(struct intel_gt *gt, enum intel_engine_id id) 
	engine->instance = info->instance;

	__sprint_engine_name(engine);



	engine->props.preempt_timeout_ms =

		CONFIG_DRM_I915_PREEMPT_TIMEOUT;

	engine->props.stop_timeout_ms =

		CONFIG_DRM_I915_STOP_TIMEOUT;
@@ -1338,10 +1340,11 @@ static void intel_engine_print_registers(struct intel_engine_cs *engine, 
		unsigned int idx;

		u8 read, write;



		drm_printf(m, "\tExeclist tasklet queued? %s (%s), timeslice? %s\n",

		drm_printf(m, "\tExeclist tasklet queued? %s (%s), preempt? %s, timeslice? %s\n",

			   yesno(test_bit(TASKLET_STATE_SCHED,

					  &engine->execlists.tasklet.state)),

			   enableddisabled(!atomic_read(&engine->execlists.tasklet.count)),

			   repr_timer(&engine->execlists.preempt),

			   repr_timer(&engine->execlists.timer));



		read = execlists->csb_head;

drivers/gpu/drm/i915/gt/intel_engine_types.h

+6 −0
Original line number Diff line number Diff line
@@ -174,6 +174,11 @@ struct intel_engine_execlists { 
	 */

	struct timer_list timer;



	/**

	 * @preempt: reset the current context if it fails to give way

	 */

	struct timer_list preempt;



	/**

	 * @default_priolist: priority list for I915_PRIORITY_NORMAL

	 */
@@ -544,6 +549,7 @@ struct intel_engine_cs { 
	} stats;



	struct {

		unsigned long preempt_timeout_ms;

		unsigned long stop_timeout_ms;

	} props;

};

drivers/gpu/drm/i915/gt/intel_lrc.c

+85 −8
Original line number Diff line number Diff line
@@ -1372,6 +1372,26 @@ static void record_preemption(struct intel_engine_execlists *execlists) 
	(void)I915_SELFTEST_ONLY(execlists->preempt_hang.count++);

}



static unsigned long active_preempt_timeout(struct intel_engine_cs *engine)

{

	struct i915_request *rq;



	rq = last_active(&engine->execlists);

	if (!rq)

		return 0;



	return READ_ONCE(engine->props.preempt_timeout_ms);

}



static void set_preempt_timeout(struct intel_engine_cs *engine)

{

	if (!intel_engine_has_preempt_reset(engine))

		return;



	set_timer_ms(&engine->execlists.preempt,

		     active_preempt_timeout(engine));

}



static void execlists_dequeue(struct intel_engine_cs *engine)

{

	struct intel_engine_execlists * const execlists = &engine->execlists;
@@ -1747,6 +1767,8 @@ done: 


		memset(port + 1, 0, (last_port - port) * sizeof(*port));

		execlists_submit_ports(engine);



		set_preempt_timeout(engine);

	} else {

skip_submit:

		ring_set_paused(engine, 0);
@@ -1987,6 +2009,43 @@ static void __execlists_submission_tasklet(struct intel_engine_cs *const engine) 
	}

}



static noinline void preempt_reset(struct intel_engine_cs *engine)

{

	const unsigned int bit = I915_RESET_ENGINE + engine->id;

	unsigned long *lock = &engine->gt->reset.flags;



	if (i915_modparams.reset < 3)

		return;



	if (test_and_set_bit(bit, lock))

		return;



	/* Mark this tasklet as disabled to avoid waiting for it to complete */

	tasklet_disable_nosync(&engine->execlists.tasklet);



	GEM_TRACE("%s: preempt timeout %lu+%ums\n",

		  engine->name,

		  READ_ONCE(engine->props.preempt_timeout_ms),

		  jiffies_to_msecs(jiffies - engine->execlists.preempt.expires));

	intel_engine_reset(engine, "preemption time out");



	tasklet_enable(&engine->execlists.tasklet);

	clear_and_wake_up_bit(bit, lock);

}



static bool preempt_timeout(const struct intel_engine_cs *const engine)

{

	const struct timer_list *t = &engine->execlists.preempt;



	if (!CONFIG_DRM_I915_PREEMPT_TIMEOUT)

		return false;



	if (!timer_expired(t))

		return false;



	return READ_ONCE(engine->execlists.pending[0]);

}



/*

 * Check the unread Context Status Buffers and manage the submission of new

 * contexts to the ELSP accordingly.
@@ -1994,23 +2053,39 @@ static void __execlists_submission_tasklet(struct intel_engine_cs *const engine) 
static void execlists_submission_tasklet(unsigned long data)

{

	struct intel_engine_cs * const engine = (struct intel_engine_cs *)data;

	unsigned long flags;

	bool timeout = preempt_timeout(engine);



	process_csb(engine);

	if (!READ_ONCE(engine->execlists.pending[0])) {

	if (!READ_ONCE(engine->execlists.pending[0]) || timeout) {

		unsigned long flags;



		spin_lock_irqsave(&engine->active.lock, flags);

		__execlists_submission_tasklet(engine);

		spin_unlock_irqrestore(&engine->active.lock, flags);



		/* Recheck after serialising with direct-submission */

		if (timeout && preempt_timeout(engine))

			preempt_reset(engine);

	}

}



static void execlists_submission_timer(struct timer_list *timer)

static void __execlists_kick(struct intel_engine_execlists *execlists)

{

	struct intel_engine_cs *engine =

		from_timer(engine, timer, execlists.timer);



	/* Kick the tasklet for some interrupt coalescing and reset handling */

	tasklet_hi_schedule(&engine->execlists.tasklet);

	tasklet_hi_schedule(&execlists->tasklet);

}



#define execlists_kick(t, member) \

	__execlists_kick(container_of(t, struct intel_engine_execlists, member))



static void execlists_timeslice(struct timer_list *timer)

{

	execlists_kick(timer, timer);

}



static void execlists_preempt(struct timer_list *timer)

{

	execlists_kick(timer, preempt);

}



static void queue_request(struct intel_engine_cs *engine,
@@ -3455,6 +3530,7 @@ gen12_emit_fini_breadcrumb_rcs(struct i915_request *request, u32 *cs) 
static void execlists_park(struct intel_engine_cs *engine)

{

	cancel_timer(&engine->execlists.timer);

	cancel_timer(&engine->execlists.preempt);

}



void intel_execlists_set_default_submission(struct intel_engine_cs *engine)
@@ -3572,7 +3648,8 @@ int intel_execlists_submission_setup(struct intel_engine_cs *engine) 
{

	tasklet_init(&engine->execlists.tasklet,

		     execlists_submission_tasklet, (unsigned long)engine);

	timer_setup(&engine->execlists.timer, execlists_submission_timer, 0);

	timer_setup(&engine->execlists.timer, execlists_timeslice, 0);

	timer_setup(&engine->execlists.preempt, execlists_preempt, 0);



	logical_ring_default_vfuncs(engine);

	logical_ring_default_irqs(engine);

CRA Git | Maintained and supported by SUSTech CRA and CCSE