| Message ID | 20200715115147.11866-6-chris@chris-wilson.co.uk (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | [01/66] drm/i915: Reduce i915_request.lock contention for i915_request_wait | expand |
On 15/07/2020 12:50, Chris Wilson wrote: > Sometimes we have to be very careful not to allocate underneath a mutex > (or spinlock) and yet still want to track activity. Enter > i915_active_acquire_for_context(). This raises the activity counter on > i915_active prior to use and ensures that the fence-tree contains a slot > for the context. Changelog? > Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk> > --- > .../gpu/drm/i915/gem/i915_gem_execbuffer.c | 2 +- > drivers/gpu/drm/i915/gt/intel_timeline.c | 4 +- > drivers/gpu/drm/i915/i915_active.c | 136 +++++++++++++++--- > drivers/gpu/drm/i915/i915_active.h | 12 +- > 4 files changed, 126 insertions(+), 28 deletions(-) > > diff --git a/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c b/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c > index 6b4ec66cb558..719ba9fe3e85 100644 > --- a/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c > +++ b/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c > @@ -1729,7 +1729,7 @@ __parser_mark_active(struct i915_vma *vma, > { > struct intel_gt_buffer_pool_node *node = vma->private; > > - return i915_active_ref(&node->active, tl, fence); > + return i915_active_ref(&node->active, tl->fence_context, fence); > } > > static int > diff --git a/drivers/gpu/drm/i915/gt/intel_timeline.c b/drivers/gpu/drm/i915/gt/intel_timeline.c > index 46d20f5f3ddc..acb43aebd669 100644 > --- a/drivers/gpu/drm/i915/gt/intel_timeline.c > +++ b/drivers/gpu/drm/i915/gt/intel_timeline.c > @@ -484,7 +484,9 @@ __intel_timeline_get_seqno(struct intel_timeline *tl, > * free it after the current request is retired, which ensures that > * all writes into the cacheline from previous requests are complete. > */ > - err = i915_active_ref(&tl->hwsp_cacheline->active, tl, &rq->fence); > + err = i915_active_ref(&tl->hwsp_cacheline->active, > + tl->fence_context, > + &rq->fence); > if (err) > goto err_cacheline; > > diff --git a/drivers/gpu/drm/i915/i915_active.c b/drivers/gpu/drm/i915/i915_active.c > index 841b5c30950a..799282fb1bb9 100644 > --- a/drivers/gpu/drm/i915/i915_active.c > +++ b/drivers/gpu/drm/i915/i915_active.c > @@ -28,12 +28,14 @@ static struct i915_global_active { > } global; > > struct active_node { > + struct rb_node node; > struct i915_active_fence base; > struct i915_active *ref; > - struct rb_node node; > u64 timeline; > }; > > +#define fetch_node(x) rb_entry(READ_ONCE(x), typeof(struct active_node), node) > + > static inline struct active_node * > node_from_active(struct i915_active_fence *active) > { > @@ -216,12 +218,40 @@ excl_retire(struct dma_fence *fence, struct dma_fence_cb *cb) > active_retire(container_of(cb, struct i915_active, excl.cb)); > } > > +static struct active_node *__active_lookup(struct i915_active *ref, u64 idx) > +{ > + struct active_node *it; > + > + it = READ_ONCE(ref->cache); > + if (it && it->timeline == idx) > + return it; > + > + BUILD_BUG_ON(offsetof(typeof(*it), node)); > + > + /* While active, the tree can only be built; not destroyed */ > + GEM_BUG_ON(i915_active_is_idle(ref)); > + > + it = fetch_node(ref->tree.rb_node); > + while (it) { > + if (it->timeline < idx) { > + it = fetch_node(it->node.rb_right); > + } else if (it->timeline > idx) { > + it = fetch_node(it->node.rb_left); > + } else { > + WRITE_ONCE(ref->cache, it); > + break; > + } > + } > + > + /* NB: If the tree rotated beneath us, we may miss our target. */ > + return it; > +} > + > static struct i915_active_fence * > -active_instance(struct i915_active *ref, struct intel_timeline *tl) > +active_instance(struct i915_active *ref, u64 idx) > { > struct active_node *node, *prealloc; > struct rb_node **p, *parent; > - u64 idx = tl->fence_context; > > /* > * We track the most recently used timeline to skip a rbtree search > @@ -230,8 +260,8 @@ active_instance(struct i915_active *ref, struct intel_timeline *tl) > * after the previous activity has been retired, or if it matches the > * current timeline. > */ > - node = READ_ONCE(ref->cache); > - if (node && node->timeline == idx) > + node = __active_lookup(ref, idx); > + if (likely(node)) > return &node->base; > > /* Preallocate a replacement, just in case */ > @@ -268,10 +298,9 @@ active_instance(struct i915_active *ref, struct intel_timeline *tl) > rb_insert_color(&node->node, &ref->tree); > > out: > - ref->cache = node; > + WRITE_ONCE(ref->cache, node); > spin_unlock_irq(&ref->tree_lock); > > - BUILD_BUG_ON(offsetof(typeof(*node), base)); > return &node->base; > } > > @@ -353,21 +382,17 @@ __active_del_barrier(struct i915_active *ref, struct active_node *node) > return ____active_del_barrier(ref, node, barrier_to_engine(node)); > } > > -int i915_active_ref(struct i915_active *ref, > - struct intel_timeline *tl, > - struct dma_fence *fence) > +int i915_active_ref(struct i915_active *ref, u64 idx, struct dma_fence *fence) > { > struct i915_active_fence *active; > int err; > > - lockdep_assert_held(&tl->mutex); > - > /* Prevent reaping in case we malloc/wait while building the tree */ > err = i915_active_acquire(ref); > if (err) > return err; > > - active = active_instance(ref, tl); > + active = active_instance(ref, idx); > if (!active) { > err = -ENOMEM; > goto out; > @@ -384,32 +409,81 @@ int i915_active_ref(struct i915_active *ref, > atomic_dec(&ref->count); > } > if (!__i915_active_fence_set(active, fence)) > - atomic_inc(&ref->count); > + __i915_active_acquire(ref); > > out: > i915_active_release(ref); > return err; > } > > -struct dma_fence * > -i915_active_set_exclusive(struct i915_active *ref, struct dma_fence *f) > +static struct dma_fence * > +__i915_active_set_fence(struct i915_active *ref, > + struct i915_active_fence *active, > + struct dma_fence *fence) > { > struct dma_fence *prev; > > - /* We expect the caller to manage the exclusive timeline ordering */ > - GEM_BUG_ON(i915_active_is_idle(ref)); > + if (is_barrier(active)) { /* proto-node used by our idle barrier */ > + /* > + * This request is on the kernel_context timeline, and so > + * we can use it to substitute for the pending idle-barrer > + * request that we want to emit on the kernel_context. > + */ > + __active_del_barrier(ref, node_from_active(active)); > + RCU_INIT_POINTER(active->fence, fence); There is still some duplication between i915_active_ref and here. Maybe something like: static bool __active_check_delete_barrier(active, fence) { if (is_barrier(active)) { /* proto-node used by our idle barrier */ /* * This request is on the kernel_context timeline, and so * we can use it to substitute for the pending idle-barrer * request that we want to emit on the kernel_context. */ __active_del_barrier(ref, node_from_active(active)); RCU_INIT_POINTER(active->fence, NULL); return true; } else { return false } } And then here: if (__active_check_delete_barrier(active, fence)) return NULL; And in i915_active_ref: if (__active_check_delete_barrier(active, fence)) atomic_dec(&ref->count); ? > + return NULL; > + } > > rcu_read_lock(); > - prev = __i915_active_fence_set(&ref->excl, f); > + prev = __i915_active_fence_set(active, fence); > if (prev) > prev = dma_fence_get_rcu(prev); > else > - atomic_inc(&ref->count); > + __i915_active_acquire(ref); > rcu_read_unlock(); > > return prev; > } > > +static struct i915_active_fence *__active_fence(struct i915_active *ref, u64 idx) > +{ > + struct active_node *it; > + > + it = __active_lookup(ref, idx); > + if (unlikely(!it)) { /* Contention with parallel tree builders! */ > + spin_lock_irq(&ref->tree_lock); > + it = fetch_node(ref->tree.rb_node); > + while (it) { > + if (it->timeline < idx) { > + it = fetch_node(it->node.rb_right); > + } else if (it->timeline > idx) { > + it = fetch_node(it->node.rb_left); > + } else { > + WRITE_ONCE(ref->cache, it); > + break; > + } > + } The part between the spinlocks is the same as the lookup in __active_lookup. Even if you add three underscores I'd share it for readability. > + spin_unlock_irq(&ref->tree_lock); > + } > + GEM_BUG_ON(!it); /* slot must be preallocated */ > + > + return &it->base; > +} > + > +struct dma_fence * > +__i915_active_ref(struct i915_active *ref, u64 idx, struct dma_fence *fence) > +{ > + /* Only valid while active, see i915_active_acquire_for_context() */ > + return __i915_active_set_fence(ref, __active_fence(ref, idx), fence); > +} What is the difference between i915_active_ref and __i915_active_ref? > + > +struct dma_fence * > +i915_active_set_exclusive(struct i915_active *ref, struct dma_fence *f) > +{ > + /* We expect the caller to manage the exclusive timeline ordering */ > + return __i915_active_set_fence(ref, &ref->excl, f); > +} > + > bool i915_active_acquire_if_busy(struct i915_active *ref) > { > debug_active_assert(ref); > @@ -450,6 +524,24 @@ int i915_active_acquire(struct i915_active *ref) > return err; > } > > +int i915_active_acquire_for_context(struct i915_active *ref, u64 idx) > +{ > + struct i915_active_fence *active; > + int err; > + > + err = i915_active_acquire(ref); > + if (err) > + return err; > + > + active = active_instance(ref, idx); > + if (!active) { > + i915_active_release(ref); > + return -ENOMEM; > + } > + > + return 0; /* return with active ref */ > +} > + > void i915_active_release(struct i915_active *ref) > { > debug_active_assert(ref); > @@ -753,7 +845,7 @@ static struct active_node *reuse_idle_barrier(struct i915_active *ref, u64 idx) > match: > rb_erase(p, &ref->tree); /* Hide from waits and sibling allocations */ > if (p == &ref->cache->node) > - ref->cache = NULL; > + WRITE_ONCE(ref->cache, NULL); > spin_unlock_irq(&ref->tree_lock); > > return rb_entry(p, struct active_node, node); > @@ -811,7 +903,7 @@ int i915_active_acquire_preallocate_barrier(struct i915_active *ref, > */ > RCU_INIT_POINTER(node->base.fence, ERR_PTR(-EAGAIN)); > node->base.cb.node.prev = (void *)engine; > - atomic_inc(&ref->count); > + __i915_active_acquire(ref); > } > GEM_BUG_ON(rcu_access_pointer(node->base.fence) != ERR_PTR(-EAGAIN)); > > diff --git a/drivers/gpu/drm/i915/i915_active.h b/drivers/gpu/drm/i915/i915_active.h > index cf4058150966..73ded3c52a04 100644 > --- a/drivers/gpu/drm/i915/i915_active.h > +++ b/drivers/gpu/drm/i915/i915_active.h > @@ -163,14 +163,16 @@ void __i915_active_init(struct i915_active *ref, > __i915_active_init(ref, active, retire, &__mkey, &__wkey); \ > } while (0) > > -int i915_active_ref(struct i915_active *ref, > - struct intel_timeline *tl, > - struct dma_fence *fence); > +struct dma_fence * > +__i915_active_ref(struct i915_active *ref, u64 idx, struct dma_fence *fence); > +int i915_active_ref(struct i915_active *ref, u64 idx, struct dma_fence *fence); > > static inline int > i915_active_add_request(struct i915_active *ref, struct i915_request *rq) > { > - return i915_active_ref(ref, i915_request_timeline(rq), &rq->fence); > + return i915_active_ref(ref, > + i915_request_timeline(rq)->fence_context, > + &rq->fence); > } > > struct dma_fence * > @@ -198,7 +200,9 @@ int i915_request_await_active(struct i915_request *rq, > #define I915_ACTIVE_AWAIT_BARRIER BIT(2) > > int i915_active_acquire(struct i915_active *ref); > +int i915_active_acquire_for_context(struct i915_active *ref, u64 idx); > bool i915_active_acquire_if_busy(struct i915_active *ref); > + > void i915_active_release(struct i915_active *ref); > > static inline void __i915_active_acquire(struct i915_active *ref) > Regards, Tvrtko
Quoting Tvrtko Ursulin (2020-07-17 13:21:54) > > On 15/07/2020 12:50, Chris Wilson wrote: > > Sometimes we have to be very careful not to allocate underneath a mutex > > (or spinlock) and yet still want to track activity. Enter > > i915_active_acquire_for_context(). This raises the activity counter on > > i915_active prior to use and ensures that the fence-tree contains a slot > > for the context. > > Changelog? "Time spent with perf trying to reduce holdtime of certain mutexes we will introduce, in particular focusing on reducing the number of atomics required for typical i915_active lookups" -Chris
On 17/07/2020 13:45, Chris Wilson wrote: > Quoting Tvrtko Ursulin (2020-07-17 13:21:54) >> >> On 15/07/2020 12:50, Chris Wilson wrote: >>> Sometimes we have to be very careful not to allocate underneath a mutex >>> (or spinlock) and yet still want to track activity. Enter >>> i915_active_acquire_for_context(). This raises the activity counter on >>> i915_active prior to use and ensures that the fence-tree contains a slot >>> for the context. >> >> Changelog? > > "Time spent with perf trying to reduce holdtime of certain mutexes we > will introduce, in particular focusing on reducing the number of atomics > required for typical i915_active lookups" Why not, then I would had at least known nothing from my previous round feedback so easier review. Regards, Tvrtko
On 2020-07-15 13:50, Chris Wilson wrote: > Sometimes we have to be very careful not to allocate underneath a mutex > (or spinlock) and yet still want to track activity. Enter > i915_active_acquire_for_context(). This raises the activity counter on > i915_active prior to use and ensures that the fence-tree contains a slot > for the context. > > Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk> > --- > .../gpu/drm/i915/gem/i915_gem_execbuffer.c | 2 +- > drivers/gpu/drm/i915/gt/intel_timeline.c | 4 +- > drivers/gpu/drm/i915/i915_active.c | 136 +++++++++++++++--- > drivers/gpu/drm/i915/i915_active.h | 12 +- > 4 files changed, 126 insertions(+), 28 deletions(-) > ... > /* > * We track the most recently used timeline to skip a rbtree search > @@ -230,8 +260,8 @@ active_instance(struct i915_active *ref, struct intel_timeline *tl) > * after the previous activity has been retired, or if it matches the > * current timeline. > */ In addition to Tvrtko's comments, Should this comment be moved to __active_lookup() ? /Thomas
diff --git a/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c b/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c index 6b4ec66cb558..719ba9fe3e85 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c @@ -1729,7 +1729,7 @@ __parser_mark_active(struct i915_vma *vma, { struct intel_gt_buffer_pool_node *node = vma->private; - return i915_active_ref(&node->active, tl, fence); + return i915_active_ref(&node->active, tl->fence_context, fence); } static int diff --git a/drivers/gpu/drm/i915/gt/intel_timeline.c b/drivers/gpu/drm/i915/gt/intel_timeline.c index 46d20f5f3ddc..acb43aebd669 100644 --- a/drivers/gpu/drm/i915/gt/intel_timeline.c +++ b/drivers/gpu/drm/i915/gt/intel_timeline.c @@ -484,7 +484,9 @@ __intel_timeline_get_seqno(struct intel_timeline *tl, * free it after the current request is retired, which ensures that * all writes into the cacheline from previous requests are complete. */ - err = i915_active_ref(&tl->hwsp_cacheline->active, tl, &rq->fence); + err = i915_active_ref(&tl->hwsp_cacheline->active, + tl->fence_context, + &rq->fence); if (err) goto err_cacheline; diff --git a/drivers/gpu/drm/i915/i915_active.c b/drivers/gpu/drm/i915/i915_active.c index 841b5c30950a..799282fb1bb9 100644 --- a/drivers/gpu/drm/i915/i915_active.c +++ b/drivers/gpu/drm/i915/i915_active.c @@ -28,12 +28,14 @@ static struct i915_global_active { } global; struct active_node { + struct rb_node node; struct i915_active_fence base; struct i915_active *ref; - struct rb_node node; u64 timeline; }; +#define fetch_node(x) rb_entry(READ_ONCE(x), typeof(struct active_node), node) + static inline struct active_node * node_from_active(struct i915_active_fence *active) { @@ -216,12 +218,40 @@ excl_retire(struct dma_fence *fence, struct dma_fence_cb *cb) active_retire(container_of(cb, struct i915_active, excl.cb)); } +static struct active_node *__active_lookup(struct i915_active *ref, u64 idx) +{ + struct active_node *it; + + it = READ_ONCE(ref->cache); + if (it && it->timeline == idx) + return it; + + BUILD_BUG_ON(offsetof(typeof(*it), node)); + + /* While active, the tree can only be built; not destroyed */ + GEM_BUG_ON(i915_active_is_idle(ref)); + + it = fetch_node(ref->tree.rb_node); + while (it) { + if (it->timeline < idx) { + it = fetch_node(it->node.rb_right); + } else if (it->timeline > idx) { + it = fetch_node(it->node.rb_left); + } else { + WRITE_ONCE(ref->cache, it); + break; + } + } + + /* NB: If the tree rotated beneath us, we may miss our target. */ + return it; +} + static struct i915_active_fence * -active_instance(struct i915_active *ref, struct intel_timeline *tl) +active_instance(struct i915_active *ref, u64 idx) { struct active_node *node, *prealloc; struct rb_node **p, *parent; - u64 idx = tl->fence_context; /* * We track the most recently used timeline to skip a rbtree search @@ -230,8 +260,8 @@ active_instance(struct i915_active *ref, struct intel_timeline *tl) * after the previous activity has been retired, or if it matches the * current timeline. */ - node = READ_ONCE(ref->cache); - if (node && node->timeline == idx) + node = __active_lookup(ref, idx); + if (likely(node)) return &node->base; /* Preallocate a replacement, just in case */ @@ -268,10 +298,9 @@ active_instance(struct i915_active *ref, struct intel_timeline *tl) rb_insert_color(&node->node, &ref->tree); out: - ref->cache = node; + WRITE_ONCE(ref->cache, node); spin_unlock_irq(&ref->tree_lock); - BUILD_BUG_ON(offsetof(typeof(*node), base)); return &node->base; } @@ -353,21 +382,17 @@ __active_del_barrier(struct i915_active *ref, struct active_node *node) return ____active_del_barrier(ref, node, barrier_to_engine(node)); } -int i915_active_ref(struct i915_active *ref, - struct intel_timeline *tl, - struct dma_fence *fence) +int i915_active_ref(struct i915_active *ref, u64 idx, struct dma_fence *fence) { struct i915_active_fence *active; int err; - lockdep_assert_held(&tl->mutex); - /* Prevent reaping in case we malloc/wait while building the tree */ err = i915_active_acquire(ref); if (err) return err; - active = active_instance(ref, tl); + active = active_instance(ref, idx); if (!active) { err = -ENOMEM; goto out; @@ -384,32 +409,81 @@ int i915_active_ref(struct i915_active *ref, atomic_dec(&ref->count); } if (!__i915_active_fence_set(active, fence)) - atomic_inc(&ref->count); + __i915_active_acquire(ref); out: i915_active_release(ref); return err; } -struct dma_fence * -i915_active_set_exclusive(struct i915_active *ref, struct dma_fence *f) +static struct dma_fence * +__i915_active_set_fence(struct i915_active *ref, + struct i915_active_fence *active, + struct dma_fence *fence) { struct dma_fence *prev; - /* We expect the caller to manage the exclusive timeline ordering */ - GEM_BUG_ON(i915_active_is_idle(ref)); + if (is_barrier(active)) { /* proto-node used by our idle barrier */ + /* + * This request is on the kernel_context timeline, and so + * we can use it to substitute for the pending idle-barrer + * request that we want to emit on the kernel_context. + */ + __active_del_barrier(ref, node_from_active(active)); + RCU_INIT_POINTER(active->fence, fence); + return NULL; + } rcu_read_lock(); - prev = __i915_active_fence_set(&ref->excl, f); + prev = __i915_active_fence_set(active, fence); if (prev) prev = dma_fence_get_rcu(prev); else - atomic_inc(&ref->count); + __i915_active_acquire(ref); rcu_read_unlock(); return prev; } +static struct i915_active_fence *__active_fence(struct i915_active *ref, u64 idx) +{ + struct active_node *it; + + it = __active_lookup(ref, idx); + if (unlikely(!it)) { /* Contention with parallel tree builders! */ + spin_lock_irq(&ref->tree_lock); + it = fetch_node(ref->tree.rb_node); + while (it) { + if (it->timeline < idx) { + it = fetch_node(it->node.rb_right); + } else if (it->timeline > idx) { + it = fetch_node(it->node.rb_left); + } else { + WRITE_ONCE(ref->cache, it); + break; + } + } + spin_unlock_irq(&ref->tree_lock); + } + GEM_BUG_ON(!it); /* slot must be preallocated */ + + return &it->base; +} + +struct dma_fence * +__i915_active_ref(struct i915_active *ref, u64 idx, struct dma_fence *fence) +{ + /* Only valid while active, see i915_active_acquire_for_context() */ + return __i915_active_set_fence(ref, __active_fence(ref, idx), fence); +} + +struct dma_fence * +i915_active_set_exclusive(struct i915_active *ref, struct dma_fence *f) +{ + /* We expect the caller to manage the exclusive timeline ordering */ + return __i915_active_set_fence(ref, &ref->excl, f); +} + bool i915_active_acquire_if_busy(struct i915_active *ref) { debug_active_assert(ref); @@ -450,6 +524,24 @@ int i915_active_acquire(struct i915_active *ref) return err; } +int i915_active_acquire_for_context(struct i915_active *ref, u64 idx) +{ + struct i915_active_fence *active; + int err; + + err = i915_active_acquire(ref); + if (err) + return err; + + active = active_instance(ref, idx); + if (!active) { + i915_active_release(ref); + return -ENOMEM; + } + + return 0; /* return with active ref */ +} + void i915_active_release(struct i915_active *ref) { debug_active_assert(ref); @@ -753,7 +845,7 @@ static struct active_node *reuse_idle_barrier(struct i915_active *ref, u64 idx) match: rb_erase(p, &ref->tree); /* Hide from waits and sibling allocations */ if (p == &ref->cache->node) - ref->cache = NULL; + WRITE_ONCE(ref->cache, NULL); spin_unlock_irq(&ref->tree_lock); return rb_entry(p, struct active_node, node); @@ -811,7 +903,7 @@ int i915_active_acquire_preallocate_barrier(struct i915_active *ref, */ RCU_INIT_POINTER(node->base.fence, ERR_PTR(-EAGAIN)); node->base.cb.node.prev = (void *)engine; - atomic_inc(&ref->count); + __i915_active_acquire(ref); } GEM_BUG_ON(rcu_access_pointer(node->base.fence) != ERR_PTR(-EAGAIN)); diff --git a/drivers/gpu/drm/i915/i915_active.h b/drivers/gpu/drm/i915/i915_active.h index cf4058150966..73ded3c52a04 100644 --- a/drivers/gpu/drm/i915/i915_active.h +++ b/drivers/gpu/drm/i915/i915_active.h @@ -163,14 +163,16 @@ void __i915_active_init(struct i915_active *ref, __i915_active_init(ref, active, retire, &__mkey, &__wkey); \ } while (0) -int i915_active_ref(struct i915_active *ref, - struct intel_timeline *tl, - struct dma_fence *fence); +struct dma_fence * +__i915_active_ref(struct i915_active *ref, u64 idx, struct dma_fence *fence); +int i915_active_ref(struct i915_active *ref, u64 idx, struct dma_fence *fence); static inline int i915_active_add_request(struct i915_active *ref, struct i915_request *rq) { - return i915_active_ref(ref, i915_request_timeline(rq), &rq->fence); + return i915_active_ref(ref, + i915_request_timeline(rq)->fence_context, + &rq->fence); } struct dma_fence * @@ -198,7 +200,9 @@ int i915_request_await_active(struct i915_request *rq, #define I915_ACTIVE_AWAIT_BARRIER BIT(2) int i915_active_acquire(struct i915_active *ref); +int i915_active_acquire_for_context(struct i915_active *ref, u64 idx); bool i915_active_acquire_if_busy(struct i915_active *ref); + void i915_active_release(struct i915_active *ref); static inline void __i915_active_acquire(struct i915_active *ref)
Sometimes we have to be very careful not to allocate underneath a mutex (or spinlock) and yet still want to track activity. Enter i915_active_acquire_for_context(). This raises the activity counter on i915_active prior to use and ensures that the fence-tree contains a slot for the context. Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk> --- .../gpu/drm/i915/gem/i915_gem_execbuffer.c | 2 +- drivers/gpu/drm/i915/gt/intel_timeline.c | 4 +- drivers/gpu/drm/i915/i915_active.c | 136 +++++++++++++++--- drivers/gpu/drm/i915/i915_active.h | 12 +- 4 files changed, 126 insertions(+), 28 deletions(-)