Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ce476c80 authored by Chris Wilson's avatar Chris Wilson
Browse files

drm/i915: Keep contexts pinned until after the next kernel context switch 



We need to keep the context image pinned in memory until after the GPU
has finished writing into it. Since it continues to write as we signal
the final breadcrumb, we need to keep it pinned until the request after
it is complete. Currently we know the order in which requests execute on
each engine, and so to remove that presumption we need to identify a
request/context-switch we know must occur after our completion. Any
request queued after the signal must imply a context switch, for
simplicity we use a fresh request from the kernel context.

The sequence of operations for keeping the context pinned until saved is:

 - On context activation, we preallocate a node for each physical engine
   the context may operate on. This is to avoid allocations during
   unpinning, which may be from inside FS_RECLAIM context (aka the
   shrinker)

 - On context deactivation on retirement of the last active request (which
   is before we know the context has been saved), we add the
   preallocated node onto a barrier list on each engine

 - On engine idling, we emit a switch to kernel context. When this
   switch completes, we know that all previous contexts must have been
   saved, and so on retiring this request we can finally unpin all the
   contexts that were marked as deactivated prior to the switch.

We can enhance this in future by flushing all the idle contexts on a
regular heartbeat pulse of a switch to kernel context, which will also
be used to check for hung engines.

v2: intel_context_active_acquire/_release

Signed-off-by: default avatarChris Wilson <chris@chris-wilson.co.uk>
Cc: Mika Kuoppala <mika.kuoppala@linux.intel.com>
Reviewed-by: default avatarMika Kuoppala <mika.kuoppala@linux.intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20190614164606.15633-1-chris@chris-wilson.co.uk
parent 58a111f0

drivers/gpu/drm/i915/gem/i915_gem_context.c

+6 −18
Original line number Diff line number Diff line
@@ -692,17 +692,6 @@ int i915_gem_contexts_init(struct drm_i915_private *dev_priv) 
	return 0;

}



void i915_gem_contexts_lost(struct drm_i915_private *dev_priv)

{

	struct intel_engine_cs *engine;

	enum intel_engine_id id;



	lockdep_assert_held(&dev_priv->drm.struct_mutex);



	for_each_engine(engine, dev_priv, id)

		intel_engine_lost_context(engine);

}



void i915_gem_contexts_fini(struct drm_i915_private *i915)

{

	lockdep_assert_held(&i915->drm.struct_mutex);
@@ -1203,10 +1192,6 @@ gen8_modify_rpcs(struct intel_context *ce, struct intel_sseu sseu) 
	if (ret)

		goto out_add;



	ret = gen8_emit_rpcs_config(rq, ce, sseu);

	if (ret)

		goto out_add;



	/*

	 * Guarantee context image and the timeline remains pinned until the

	 * modifying request is retired by setting the ce activity tracker.
@@ -1214,9 +1199,12 @@ gen8_modify_rpcs(struct intel_context *ce, struct intel_sseu sseu) 
	 * But we only need to take one pin on the account of it. Or in other

	 * words transfer the pinned ce object to tracked active request.

	 */

	if (!i915_active_request_isset(&ce->active_tracker))

		__intel_context_pin(ce);

	__i915_active_request_set(&ce->active_tracker, rq);

	GEM_BUG_ON(i915_active_is_idle(&ce->active));

	ret = i915_active_ref(&ce->active, rq->fence.context, rq);

	if (ret)

		goto out_add;



	ret = gen8_emit_rpcs_config(rq, ce, sseu);



out_add:

	i915_request_add(rq);

drivers/gpu/drm/i915/gem/i915_gem_context.h

+0 −1
Original line number Diff line number Diff line
@@ -134,7 +134,6 @@ static inline bool i915_gem_context_is_kernel(struct i915_gem_context *ctx) 


/* i915_gem_context.c */

int __must_check i915_gem_contexts_init(struct drm_i915_private *dev_priv);

void i915_gem_contexts_lost(struct drm_i915_private *dev_priv);

void i915_gem_contexts_fini(struct drm_i915_private *dev_priv);



int i915_gem_context_open(struct drm_i915_private *i915,

drivers/gpu/drm/i915/gem/i915_gem_pm.c

+19 −1
Original line number Diff line number Diff line
@@ -10,6 +10,22 @@ 
#include "i915_drv.h"

#include "i915_globals.h"



static void call_idle_barriers(struct intel_engine_cs *engine)

{

	struct llist_node *node, *next;



	llist_for_each_safe(node, next, llist_del_all(&engine->barrier_tasks)) {

		struct i915_active_request *active =

			container_of((struct list_head *)node,

				     typeof(*active), link);



		INIT_LIST_HEAD(&active->link);

		RCU_INIT_POINTER(active->request, NULL);



		active->retire(active, NULL);

	}

}



static void i915_gem_park(struct drm_i915_private *i915)

{

	struct intel_engine_cs *engine;
@@ -17,8 +33,10 @@ static void i915_gem_park(struct drm_i915_private *i915) 


	lockdep_assert_held(&i915->drm.struct_mutex);



	for_each_engine(engine, i915, id)

	for_each_engine(engine, i915, id) {

		call_idle_barriers(engine); /* cleanup after wedging */

		i915_gem_batch_pool_fini(&engine->batch_pool);

	}



	i915_timelines_park(i915);

	i915_vma_parked(i915);

drivers/gpu/drm/i915/gem/i915_gem_shrinker.c

+6 −11
Original line number Diff line number Diff line
@@ -160,18 +160,13 @@ i915_gem_shrink(struct drm_i915_private *i915, 
		return 0;



	/*

	 * When shrinking the active list, also consider active contexts.

	 * Active contexts are pinned until they are retired, and so can

	 * not be simply unbound to retire and unpin their pages. To shrink

	 * the contexts, we must wait until the gpu is idle.

	 *

	 * We don't care about errors here; if we cannot wait upon the GPU,

	 * we will free as much as we can and hope to get a second chance.

	 * When shrinking the active list, we should also consider active

	 * contexts. Active contexts are pinned until they are retired, and

	 * so can not be simply unbound to retire and unpin their pages. To

	 * shrink the contexts, we must wait until the gpu is idle and

	 * completed its switch to the kernel context. In short, we do

	 * not have a good mechanism for idling a specific context.

	 */

	if (shrink & I915_SHRINK_ACTIVE)

		i915_gem_wait_for_idle(i915,

				       I915_WAIT_LOCKED,

				       MAX_SCHEDULE_TIMEOUT);



	trace_i915_gem_shrink(i915, target, shrink);

	i915_retire_requests(i915);

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

+71 −9
Original line number Diff line number Diff line
@@ -61,7 +61,6 @@ int __intel_context_do_pin(struct intel_context *ce) 


		i915_gem_context_get(ce->gem_context); /* for ctx->ppgtt */



		intel_context_get(ce);

		smp_mb__before_atomic(); /* flush pin before it is visible */

	}
@@ -89,20 +88,45 @@ void intel_context_unpin(struct intel_context *ce) 
		ce->ops->unpin(ce);



		i915_gem_context_put(ce->gem_context);

		intel_context_put(ce);

		intel_context_active_release(ce);

	}



	mutex_unlock(&ce->pin_mutex);

	intel_context_put(ce);

}



static void intel_context_retire(struct i915_active_request *active,

				 struct i915_request *rq)

static int __context_pin_state(struct i915_vma *vma, unsigned long flags)

{

	struct intel_context *ce =

		container_of(active, typeof(*ce), active_tracker);

	int err;



	intel_context_unpin(ce);

	err = i915_vma_pin(vma, 0, 0, flags | PIN_GLOBAL);

	if (err)

		return err;



	/*

	 * And mark it as a globally pinned object to let the shrinker know

	 * it cannot reclaim the object until we release it.

	 */

	vma->obj->pin_global++;

	vma->obj->mm.dirty = true;



	return 0;

}



static void __context_unpin_state(struct i915_vma *vma)

{

	vma->obj->pin_global--;

	__i915_vma_unpin(vma);

}



static void intel_context_retire(struct i915_active *active)

{

	struct intel_context *ce = container_of(active, typeof(*ce), active);



	if (ce->state)

		__context_unpin_state(ce->state);



	intel_context_put(ce);

}



void
@@ -125,8 +149,46 @@ intel_context_init(struct intel_context *ce, 


	mutex_init(&ce->pin_mutex);



	i915_active_request_init(&ce->active_tracker,

				 NULL, intel_context_retire);

	i915_active_init(ctx->i915, &ce->active, intel_context_retire);

}



int intel_context_active_acquire(struct intel_context *ce, unsigned long flags)

{

	int err;



	if (!i915_active_acquire(&ce->active))

		return 0;



	intel_context_get(ce);



	if (!ce->state)

		return 0;



	err = __context_pin_state(ce->state, flags);

	if (err) {

		i915_active_cancel(&ce->active);

		intel_context_put(ce);

		return err;

	}



	/* Preallocate tracking nodes */

	if (!i915_gem_context_is_kernel(ce->gem_context)) {

		err = i915_active_acquire_preallocate_barrier(&ce->active,

							      ce->engine);

		if (err) {

			i915_active_release(&ce->active);

			return err;

		}

	}



	return 0;

}



void intel_context_active_release(struct intel_context *ce)

{

	/* Nodes preallocated in intel_context_active() */

	i915_active_acquire_barrier(&ce->active);

	i915_active_release(&ce->active);

}



static void i915_global_context_shrink(void)