Skip to contentSkip to conversation

dma-fence: Deadline awareness

PATCH Superseded Rob Clark 5 participants 16 messages Aug 7, 2021 – Aug 17, 2021

Subsystems (9)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Rob Clark

author
#0 lore raw

v2 cover dma-fence: Deadline awareness

From: Rob Clark <[email protected]>

Based on discussion from a previous series[1] to add a "boost" mechanism when, for example, vblank deadlines are missed. Instead of a boost callback, this approach adds a way to set a deadline on the fence, by which the waiter would like to see the fence signalled.

I've not yet had a chance to re-work the drm/msm part of this, but wanted to send this out as an RFC in case I don't have a chance to finish the drm/msm part this week.

Original description:

In some cases, like double-buffered rendering, missing vblanks can trick the GPU into running at a lower frequence, when really we want to be running at a higher frequency to not miss the vblanks in the first place.

This is partially inspired by a trick i915 does, but implemented via dma-fence for a couple of reasons:

1) To continue to be able to use the atomic helpers
2) To support cases where display and gpu are different drivers

[1] https://patchwork.freedesktop.org/series/90331/

v1: https://patchwork.freedesktop.org/series/93035/
v2: Move filtering out of later deadlines to fence implementation
to avoid increasing the size of dma_fence

Rob Clark (5):
dma-fence: Add deadline awareness drm/vblank: Add helper to get next vblank time drm/atomic-helper: Set fence deadline for vblank drm/scheduler: Add fence deadline support drm/msm: Add deadline based boost support

 drivers/dma-buf/dma-fence.c             | 20 +++++++
 drivers/gpu/drm/drm_atomic_helper.c     | 36 ++++++++++++
 drivers/gpu/drm/drm_vblank.c            | 31 ++++++++++
 drivers/gpu/drm/msm/msm_fence.c         | 76 +++++++++++++++++++++++++
 drivers/gpu/drm/msm/msm_fence.h         | 20 +++++++
 drivers/gpu/drm/msm/msm_gpu.h           |  1 +
 drivers/gpu/drm/msm/msm_gpu_devfreq.c   | 20 +++++++
 drivers/gpu/drm/scheduler/sched_fence.c | 25 ++++++++
 drivers/gpu/drm/scheduler/sched_main.c  |  3 +
 include/drm/drm_vblank.h                |  1 +
 include/drm/gpu_scheduler.h             |  6 ++
 include/linux/dma-fence.h               | 16 ++++++
 12 files changed, 255 insertions(+)
Signature · 1 line
2.31.1
author
#1 lore raw

PATCH v2 1/5 dma-fence: Add deadline awareness

From: Rob Clark <[email protected]>

Add a way to hint to the fence signaler of an upcoming deadline, such as vblank, which the fence waiter would prefer not to miss. This is to aid the fence signaler in making power management decisions, like boosting frequency as the deadline approaches and awareness of missing deadlines so that can be factored in to the frequency scaling.

v2: Drop dma_fence::deadline and related logic to filter duplicate
deadlines, to avoid increasing dma_fence size. The fence-context implementation will need similar logic to track deadlines of all the fences on the same timeline. [ckoenig]

---
 drivers/dma-buf/dma-fence.c | 20 ++++++++++++++++++++
 include/linux/dma-fence.h   | 16 ++++++++++++++++
 2 files changed, 36 insertions(+)
drivers/dma-buf/dma-fence.c +20 -0
index ce0f5eff575d..1f444863b94d 100644
@@ -910,6 +910,26 @@ dma_fence_wait_any_timeout(struct dma_fence **fences, uint32_t count,
 }
 EXPORT_SYMBOL(dma_fence_wait_any_timeout);
 
+
+/**
+ * dma_fence_set_deadline - set desired fence-wait deadline
+ * @fence:    the fence that is to be waited on
+ * @deadline: the time by which the waiter hopes for the fence to be
+ *            signaled
+ *
+ * Inform the fence signaler of an upcoming deadline, such as vblank, by
+ * which point the waiter would prefer the fence to be signaled by.  This
+ * is intended to give feedback to the fence signaler to aid in power
+ * management decisions, such as boosting GPU frequency if a periodic
+ * vblank deadline is approaching.
+ */
+void dma_fence_set_deadline(struct dma_fence *fence, ktime_t deadline)
+{
+	if (fence->ops->set_deadline && !dma_fence_is_signaled(fence))
+		fence->ops->set_deadline(fence, deadline);
+}
+EXPORT_SYMBOL(dma_fence_set_deadline);
+
 /**
  * dma_fence_init - Initialize a custom fence.
  * @fence: the fence to initialize
include/linux/dma-fence.h +16 -0
index 6ffb4b2c6371..9c809f0d5d0a 100644
@@ -99,6 +99,7 @@ enum dma_fence_flag_bits {
 	DMA_FENCE_FLAG_SIGNALED_BIT,
 	DMA_FENCE_FLAG_TIMESTAMP_BIT,
 	DMA_FENCE_FLAG_ENABLE_SIGNAL_BIT,
+	DMA_FENCE_FLAG_HAS_DEADLINE_BIT,
 	DMA_FENCE_FLAG_USER_BITS, /* must always be last member */
 };
 
@@ -261,6 +262,19 @@ struct dma_fence_ops {
 	 */
 	void (*timeline_value_str)(struct dma_fence *fence,
 				   char *str, int size);
+
+	/**
+	 * @set_deadline:
+	 *
+	 * Callback to allow a fence waiter to inform the fence signaler of an
+	 * upcoming deadline, such as vblank, by which point the waiter would
+	 * prefer the fence to be signaled by.  This is intended to give feedback
+	 * to the fence signaler to aid in power management decisions, such as
+	 * boosting GPU frequency.
+	 *
+	 * This callback is optional.
+	 */
+	void (*set_deadline)(struct dma_fence *fence, ktime_t deadline);
 };
 
 void dma_fence_init(struct dma_fence *fence, const struct dma_fence_ops *ops,
@@ -586,6 +600,8 @@ static inline signed long dma_fence_wait(struct dma_fence *fence, bool intr)
 	return ret < 0 ? ret : 0;
 }
 
+void dma_fence_set_deadline(struct dma_fence *fence, ktime_t deadline);
+
 struct dma_fence *dma_fence_get_stub(void);
 struct dma_fence *dma_fence_allocate_private_stub(void);
 u64 dma_fence_context_alloc(unsigned num);
Signature · 1 line
2.31.1
reviewer Reviewed-by on v2 1/5
#2 lore raw

Re: [PATCH v2 1/5] dma-fence: Add deadline awareness

Am 07.08.21 um 20:37 schrieb Rob Clark:

Quoted 8 lines

From: Rob Clark <[email protected]>

Add a way to hint to the fence signaler of an upcoming deadline, such as vblank, which the fence waiter would prefer not to miss. This is to aid the fence signaler in making power management decisions, like boosting frequency as the deadline approaches and awareness of missing deadlines so that can be factored in to the frequency scaling.

Quoted 6 lines

v2: Drop dma_fence::deadline and related logic to filter duplicate
deadlines, to avoid increasing dma_fence size. The fence-context implementation will need similar logic to track deadlines of all the fences on the same timeline. [ckoenig]

Quoted 77 lines
---
  drivers/dma-buf/dma-fence.c | 20 ++++++++++++++++++++
  include/linux/dma-fence.h   | 16 ++++++++++++++++
  2 files changed, 36 insertions(+)
drivers/dma-buf/dma-fence.c +20 -0
index ce0f5eff575d..1f444863b94d 100644
@@ -910,6 +910,26 @@ dma_fence_wait_any_timeout(struct dma_fence **fences, uint32_t count,
  }
  EXPORT_SYMBOL(dma_fence_wait_any_timeout);
 
+
+/**
+ * dma_fence_set_deadline - set desired fence-wait deadline
+ * @fence:    the fence that is to be waited on
+ * @deadline: the time by which the waiter hopes for the fence to be
+ *            signaled
+ *
+ * Inform the fence signaler of an upcoming deadline, such as vblank, by
+ * which point the waiter would prefer the fence to be signaled by.  This
+ * is intended to give feedback to the fence signaler to aid in power
+ * management decisions, such as boosting GPU frequency if a periodic
+ * vblank deadline is approaching.
+ */
+void dma_fence_set_deadline(struct dma_fence *fence, ktime_t deadline)
+{
+	if (fence->ops->set_deadline && !dma_fence_is_signaled(fence))
+		fence->ops->set_deadline(fence, deadline);
+}
+EXPORT_SYMBOL(dma_fence_set_deadline);
+
  /**
   * dma_fence_init - Initialize a custom fence.
   * @fence: the fence to initialize
include/linux/dma-fence.h +16 -0
index 6ffb4b2c6371..9c809f0d5d0a 100644
@@ -99,6 +99,7 @@ enum dma_fence_flag_bits {
  	DMA_FENCE_FLAG_SIGNALED_BIT,
  	DMA_FENCE_FLAG_TIMESTAMP_BIT,
  	DMA_FENCE_FLAG_ENABLE_SIGNAL_BIT,
+	DMA_FENCE_FLAG_HAS_DEADLINE_BIT,
  	DMA_FENCE_FLAG_USER_BITS, /* must always be last member */
  };
 
@@ -261,6 +262,19 @@ struct dma_fence_ops {
  	 */
  	void (*timeline_value_str)(struct dma_fence *fence,
  				   char *str, int size);
+
+	/**
+	 * @set_deadline:
+	 *
+	 * Callback to allow a fence waiter to inform the fence signaler of an
+	 * upcoming deadline, such as vblank, by which point the waiter would
+	 * prefer the fence to be signaled by.  This is intended to give feedback
+	 * to the fence signaler to aid in power management decisions, such as
+	 * boosting GPU frequency.
+	 *
+	 * This callback is optional.
+	 */
+	void (*set_deadline)(struct dma_fence *fence, ktime_t deadline);
  };
 
  void dma_fence_init(struct dma_fence *fence, const struct dma_fence_ops *ops,
@@ -586,6 +600,8 @@ static inline signed long dma_fence_wait(struct dma_fence *fence, bool intr)
  	return ret < 0 ? ret : 0;
  }
 
+void dma_fence_set_deadline(struct dma_fence *fence, ktime_t deadline);
+
  struct dma_fence *dma_fence_get_stub(void);
  struct dma_fence *dma_fence_allocate_private_stub(void);
  u64 dma_fence_context_alloc(unsigned num);
author
#3 lore raw

PATCH v2 2/5 drm/vblank: Add helper to get next vblank time

In reply to Rob Clark

From: Rob Clark <[email protected]>

---
 drivers/gpu/drm/drm_vblank.c | 31 +++++++++++++++++++++++++++++++
 include/drm/drm_vblank.h     |  1 +
 2 files changed, 32 insertions(+)
drivers/gpu/drm/drm_vblank.c +31 -0
index 3417e1ac7918..88c824c294dc 100644
@@ -980,6 +980,37 @@ u64 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc,
 }
 EXPORT_SYMBOL(drm_crtc_vblank_count_and_time);
 
+/**
+ * drm_crtc_next_vblank_time - calculate the time of the next vblank
+ * @crtc: the crtc for which to calculate next vblank time
+ * @vblanktime: pointer to time to receive the next vblank timestamp.
+ *
+ * Calculate the expected time of the next vblank based on time of previous
+ * vblank and frame duration
+ */
+int drm_crtc_next_vblank_time(struct drm_crtc *crtc, ktime_t *vblanktime)
+{
+	unsigned int pipe = drm_crtc_index(crtc);
+	struct drm_vblank_crtc *vblank = &crtc->dev->vblank[pipe];
+	u64 count;
+
+	if (!vblank->framedur_ns)
+		return -EINVAL;
+
+	count = drm_vblank_count_and_time(crtc->dev, pipe, vblanktime);
+
+	/*
+	 * If we don't get a valid count, then we probably also don't
+	 * have a valid time:
+	 */
+	if (!count)
+		return -EINVAL;
+
+	*vblanktime = ktime_add(*vblanktime, ns_to_ktime(vblank->framedur_ns));
+
+	return 0;
+}
+
 static void send_vblank_event(struct drm_device *dev,
 		struct drm_pending_vblank_event *e,
 		u64 seq, ktime_t now)
include/drm/drm_vblank.h +1 -0
index 733a3e2d1d10..a63bc2c92f3c 100644
@@ -230,6 +230,7 @@ bool drm_dev_has_vblank(const struct drm_device *dev);
 u64 drm_crtc_vblank_count(struct drm_crtc *crtc);
 u64 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc,
 				   ktime_t *vblanktime);
+int drm_crtc_next_vblank_time(struct drm_crtc *crtc, ktime_t *vblanktime);
 void drm_crtc_send_vblank_event(struct drm_crtc *crtc,
 			       struct drm_pending_vblank_event *e);
 void drm_crtc_arm_vblank_event(struct drm_crtc *crtc,
Signature · 1 line
2.31.1
author
#4 lore raw

PATCH v2 3/5 drm/atomic-helper: Set fence deadline for vblank

In reply to Rob Clark

From: Rob Clark <[email protected]>

For an atomic commit updating a single CRTC (ie. a pageflip) calculate the next vblank time, and inform the fence(s) of that deadline.

---
 drivers/gpu/drm/drm_atomic_helper.c | 36 +++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
drivers/gpu/drm/drm_atomic_helper.c +36 -0
index bc3487964fb5..7caa2c3cc304 100644
@@ -1406,6 +1406,40 @@ void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
 }
 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
 
+/*
+ * For atomic updates which touch just a single CRTC, calculate the time of the
+ * next vblank, and inform all the fences of the of the deadline.
+ */
+static void set_fence_deadline(struct drm_device *dev,
+			       struct drm_atomic_state *state)
+{
+	struct drm_crtc *crtc, *wait_crtc = NULL;
+	struct drm_crtc_state *new_crtc_state;
+	struct drm_plane *plane;
+	struct drm_plane_state *new_plane_state;
+	ktime_t vbltime;
+	int i;
+
+	for_each_new_crtc_in_state (state, crtc, new_crtc_state, i) {
+		if (wait_crtc)
+			return;
+		wait_crtc = crtc;
+	}
+
+	/* If no CRTCs updated, then nothing to do: */
+	if (!wait_crtc)
+		return;
+
+	if (drm_crtc_next_vblank_time(wait_crtc, &vbltime))
+		return;
+
+	for_each_new_plane_in_state (state, plane, new_plane_state, i) {
+		if (!new_plane_state->fence)
+			continue;
+		dma_fence_set_deadline(new_plane_state->fence, vbltime);
+	}
+}
+
 /**
  * drm_atomic_helper_wait_for_fences - wait for fences stashed in plane state
  * @dev: DRM device
@@ -1435,6 +1469,8 @@ int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
 	struct drm_plane_state *new_plane_state;
 	int i, ret;
 
+	set_fence_deadline(dev, state);
+
 	for_each_new_plane_in_state(state, plane, new_plane_state, i) {
 		if (!new_plane_state->fence)
 			continue;
Signature · 1 line
2.31.1
#5 lore raw

Re: [PATCH v2 3/5] drm/atomic-helper: Set fence deadline for vblank

I love your patch! Yet something to improve:

Hi Rob,

I love your patch! Yet something to improve:

[auto build test ERROR on drm-tip/drm-tip]
[also build test ERROR on drm-exynos/exynos-drm-next tegra-drm/drm/tegra/for-next linus/master v5.14-rc4 next-20210806] [cannot apply to drm-intel/for-linux-next drm/drm-next]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Rob-Clark/dma-fence-Deadline-awareness/20210808-023531
base:   git://anongit.freedesktop.org/drm/drm-tip drm-tip
config: microblaze-randconfig-r033-20210808 (attached as .config)
compiler: microblaze-linux-gcc (GCC) 10.3.0

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/237392f7f3f215c77118b9bd985381ca70b7838a
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Rob-Clark/dma-fence-Deadline-awareness/20210808-023531 git checkout 237392f7f3f215c77118b9bd985381ca70b7838a
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-10.3.0 make.cross ARCH=microblaze

If you fix the issue, kindly add following tag as appropriate

All errors (new ones prefixed by >>, old ones prefixed by <<):

>> ERROR: modpost: "drm_crtc_next_vblank_time" [drivers/gpu/drm/drm_kms_helper.ko] undefined!

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#6 lore raw

Re: [PATCH v2 3/5] drm/atomic-helper: Set fence deadline for vblank

In reply to Rob Clark
Quoted 15 lines · Rob Clark

From: Rob Clark <[email protected]>

For an atomic commit updating a single CRTC (ie. a pageflip) calculate the next vblank time, and inform the fence(s) of that deadline.

---
 drivers/gpu/drm/drm_atomic_helper.c | 36 +++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
drivers/gpu/drm/drm_atomic_helper.c +0 -0
index bc3487964fb5..7caa2c3cc304 100644

drivers/gpu/drm/drm_atomic_helper.c void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev, · line 1411

Quoted 6 lines
drivers/gpu/drm/drm_atomic_helper.c +3 -0
@@ -1406,6 +1406,40 @@ void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
 }
 EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
 
+/*
+ * For atomic updates which touch just a single CRTC, calculate the time of the
+ * next vblank, and inform all the fences of the of the deadline.

s/of the//

Otherwise lgtm, Reviewed-by: Daniel Vetter <[email protected]>

Quoted 46 lines
drivers/gpu/drm/drm_atomic_helper.c +33 -0
+ */
+static void set_fence_deadline(struct drm_device *dev,
+			       struct drm_atomic_state *state)
+{
+	struct drm_crtc *crtc, *wait_crtc = NULL;
+	struct drm_crtc_state *new_crtc_state;
+	struct drm_plane *plane;
+	struct drm_plane_state *new_plane_state;
+	ktime_t vbltime;
+	int i;
+
+	for_each_new_crtc_in_state (state, crtc, new_crtc_state, i) {
+		if (wait_crtc)
+			return;
+		wait_crtc = crtc;
+	}
+
+	/* If no CRTCs updated, then nothing to do: */
+	if (!wait_crtc)
+		return;
+
+	if (drm_crtc_next_vblank_time(wait_crtc, &vbltime))
+		return;
+
+	for_each_new_plane_in_state (state, plane, new_plane_state, i) {
+		if (!new_plane_state->fence)
+			continue;
+		dma_fence_set_deadline(new_plane_state->fence, vbltime);
+	}
+}
+
 /**
  * drm_atomic_helper_wait_for_fences - wait for fences stashed in plane state
  * @dev: DRM device
@@ -1435,6 +1469,8 @@ int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
 	struct drm_plane_state *new_plane_state;
 	int i, ret;
 
+	set_fence_deadline(dev, state);
+
 	for_each_new_plane_in_state(state, plane, new_plane_state, i) {
 		if (!new_plane_state->fence)
 			continue;
Signature · 1 line
2.31.1
Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
author
#7 lore raw

PATCH v2 4/5 drm/scheduler: Add fence deadline support

In reply to Rob Clark

From: Rob Clark <[email protected]>

As the finished fence is the one that is exposed to userspace, and therefore the one that other operations, like atomic update, would block on, we need to propagate the deadline from from the finished fence to the actual hw fence.

---
 drivers/gpu/drm/scheduler/sched_fence.c | 25 +++++++++++++++++++++++++
 drivers/gpu/drm/scheduler/sched_main.c  |  3 +++
 include/drm/gpu_scheduler.h             |  6 ++++++
 3 files changed, 34 insertions(+)
drivers/gpu/drm/scheduler/sched_fence.c +25 -0
index 69de2c76731f..f389dca44185 100644
@@ -128,6 +128,30 @@ static void drm_sched_fence_release_finished(struct dma_fence *f)
 	dma_fence_put(&fence->scheduled);
 }
 
+static void drm_sched_fence_set_deadline_finished(struct dma_fence *f,
+						  ktime_t deadline)
+{
+	struct drm_sched_fence *fence = to_drm_sched_fence(f);
+	unsigned long flags;
+
+	spin_lock_irqsave(&fence->lock, flags);
+
+	/* If we already have an earlier deadline, keep it: */
+	if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags) &&
+	    ktime_before(fence->deadline, deadline)) {
+		spin_unlock_irqrestore(&fence->lock, flags);
+		return;
+	}
+
+	fence->deadline = deadline;
+	set_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags);
+
+	spin_unlock_irqrestore(&fence->lock, flags);
+
+	if (fence->parent)
+		dma_fence_set_deadline(fence->parent, deadline);
+}
+
 static const struct dma_fence_ops drm_sched_fence_ops_scheduled = {
 	.get_driver_name = drm_sched_fence_get_driver_name,
 	.get_timeline_name = drm_sched_fence_get_timeline_name,
@@ -138,6 +162,7 @@ static const struct dma_fence_ops drm_sched_fence_ops_finished = {
 	.get_driver_name = drm_sched_fence_get_driver_name,
 	.get_timeline_name = drm_sched_fence_get_timeline_name,
 	.release = drm_sched_fence_release_finished,
+	.set_deadline = drm_sched_fence_set_deadline_finished,
 };
 
 struct drm_sched_fence *to_drm_sched_fence(struct dma_fence *f)
drivers/gpu/drm/scheduler/sched_main.c +3 -0
index a2a953693b45..3ab0900d3596 100644
@@ -818,6 +818,9 @@ static int drm_sched_main(void *param)
 
 		if (!IS_ERR_OR_NULL(fence)) {
 			s_fence->parent = dma_fence_get(fence);
+			if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT,
+				     &s_fence->finished.flags))
+				dma_fence_set_deadline(fence, s_fence->deadline);
 			r = dma_fence_add_callback(fence, &sched_job->cb,
 						   drm_sched_job_done_cb);
 			if (r == -ENOENT)
include/drm/gpu_scheduler.h +6 -0
index d18af49fd009..0f08ade614ae 100644
@@ -144,6 +144,12 @@ struct drm_sched_fence {
          */
 	struct dma_fence		finished;
 
+	/**
+	 * @deadline: deadline set on &drm_sched_fence.finished which
+	 * potentially needs to be propagated to &drm_sched_fence.parent
+	 */
+	ktime_t				deadline;
+
         /**
          * @parent: the fence returned by &drm_sched_backend_ops.run_job
          * when scheduling the job on hardware. We signal the
Signature · 1 line
2.31.1
#8 lore raw

Re: [PATCH v2 4/5] drm/scheduler: Add fence deadline support

Am 07.08.21 um 20:37 schrieb Rob Clark:

Quoted 62 lines

From: Rob Clark <[email protected]>

As the finished fence is the one that is exposed to userspace, and therefore the one that other operations, like atomic update, would block on, we need to propagate the deadline from from the finished fence to the actual hw fence.

---
  drivers/gpu/drm/scheduler/sched_fence.c | 25 +++++++++++++++++++++++++
  drivers/gpu/drm/scheduler/sched_main.c  |  3 +++
  include/drm/gpu_scheduler.h             |  6 ++++++
  3 files changed, 34 insertions(+)
drivers/gpu/drm/scheduler/sched_fence.c +25 -0
index 69de2c76731f..f389dca44185 100644
@@ -128,6 +128,30 @@ static void drm_sched_fence_release_finished(struct dma_fence *f)
  	dma_fence_put(&fence->scheduled);
  }
 
+static void drm_sched_fence_set_deadline_finished(struct dma_fence *f,
+						  ktime_t deadline)
+{
+	struct drm_sched_fence *fence = to_drm_sched_fence(f);
+	unsigned long flags;
+
+	spin_lock_irqsave(&fence->lock, flags);
+
+	/* If we already have an earlier deadline, keep it: */
+	if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags) &&
+	    ktime_before(fence->deadline, deadline)) {
+		spin_unlock_irqrestore(&fence->lock, flags);
+		return;
+	}
+
+	fence->deadline = deadline;
+	set_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags);
+
+	spin_unlock_irqrestore(&fence->lock, flags);
+
+	if (fence->parent)
+		dma_fence_set_deadline(fence->parent, deadline);
+}
+
  static const struct dma_fence_ops drm_sched_fence_ops_scheduled = {
  	.get_driver_name = drm_sched_fence_get_driver_name,
  	.get_timeline_name = drm_sched_fence_get_timeline_name,
@@ -138,6 +162,7 @@ static const struct dma_fence_ops drm_sched_fence_ops_finished = {
  	.get_driver_name = drm_sched_fence_get_driver_name,
  	.get_timeline_name = drm_sched_fence_get_timeline_name,
  	.release = drm_sched_fence_release_finished,
+	.set_deadline = drm_sched_fence_set_deadline_finished,
  };
 
  struct drm_sched_fence *to_drm_sched_fence(struct dma_fence *f)
drivers/gpu/drm/scheduler/sched_main.c +0 -0
index a2a953693b45..3ab0900d3596 100644

drivers/gpu/drm/scheduler/sched_main.c static int drm_sched_main(void *param) · line 823

Quoted 6 lines
drivers/gpu/drm/scheduler/sched_main.c +3 -0
@@ -818,6 +818,9 @@ static int drm_sched_main(void *param)
 
  		if (!IS_ERR_OR_NULL(fence)) {
  			s_fence->parent = dma_fence_get(fence);
+			if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT,
+				     &s_fence->finished.flags))
+				dma_fence_set_deadline(fence, s_fence->deadline);

Maybe move this into a dma_sched_fence_set_parent() function.

Apart from that looks good to me.

Regards,
Christian.

Quoted 20 lines
drivers/gpu/drm/scheduler/sched_main.c +0 -0
  			r = dma_fence_add_callback(fence, &sched_job->cb,
  						   drm_sched_job_done_cb);
  			if (r == -ENOENT)
include/drm/gpu_scheduler.h +6 -0
index d18af49fd009..0f08ade614ae 100644
@@ -144,6 +144,12 @@ struct drm_sched_fence {
           */
  	struct dma_fence		finished;
 
+	/**
+	 * @deadline: deadline set on &drm_sched_fence.finished which
+	 * potentially needs to be propagated to &drm_sched_fence.parent
+	 */
+	ktime_t				deadline;
+
          /**
           * @parent: the fence returned by &drm_sched_backend_ops.run_job
           * when scheduling the job on hardware. We signal the
#9 lore raw

Re: [PATCH v2 4/5] drm/scheduler: Add fence deadline support

Quoted 9 lines · Christian König

Am 07.08.21 um 20:37 schrieb Rob Clark:

Quoted 8 lines

From: Rob Clark <[email protected]>

As the finished fence is the one that is exposed to userspace, and therefore the one that other operations, like atomic update, would block on, we need to propagate the deadline from from the finished fence to the actual hw fence.

I guess you're already letting the compositor run at a higher gpu priority so that your deadline'd drm_sched_job isn't stuck behind the app rendering the next frame?

I'm not sure whether you wire that one up as part of the conversion to drm/sched. Without that I think we might need to ponder how we can do a prio-boost for these, e.g. within a scheduling class we pick the jobs with the nearest deadline first, before we pick others.
-Daniel

Quoted 85 lines
Quoted 52 lines
---
  drivers/gpu/drm/scheduler/sched_fence.c | 25 +++++++++++++++++++++++++
  drivers/gpu/drm/scheduler/sched_main.c  |  3 +++
  include/drm/gpu_scheduler.h             |  6 ++++++
  3 files changed, 34 insertions(+)
drivers/gpu/drm/scheduler/sched_fence.c +25 -0
index 69de2c76731f..f389dca44185 100644
@@ -128,6 +128,30 @@ static void drm_sched_fence_release_finished(struct dma_fence *f)
  	dma_fence_put(&fence->scheduled);
  }
+static void drm_sched_fence_set_deadline_finished(struct dma_fence *f,
+						  ktime_t deadline)
+{
+	struct drm_sched_fence *fence = to_drm_sched_fence(f);
+	unsigned long flags;
+
+	spin_lock_irqsave(&fence->lock, flags);
+
+	/* If we already have an earlier deadline, keep it: */
+	if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags) &&
+	    ktime_before(fence->deadline, deadline)) {
+		spin_unlock_irqrestore(&fence->lock, flags);
+		return;
+	}
+
+	fence->deadline = deadline;
+	set_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags);
+
+	spin_unlock_irqrestore(&fence->lock, flags);
+
+	if (fence->parent)
+		dma_fence_set_deadline(fence->parent, deadline);
+}
+
  static const struct dma_fence_ops drm_sched_fence_ops_scheduled = {
  	.get_driver_name = drm_sched_fence_get_driver_name,
  	.get_timeline_name = drm_sched_fence_get_timeline_name,
@@ -138,6 +162,7 @@ static const struct dma_fence_ops drm_sched_fence_ops_finished = {
  	.get_driver_name = drm_sched_fence_get_driver_name,
  	.get_timeline_name = drm_sched_fence_get_timeline_name,
  	.release = drm_sched_fence_release_finished,
+	.set_deadline = drm_sched_fence_set_deadline_finished,
  };
  struct drm_sched_fence *to_drm_sched_fence(struct dma_fence *f)
drivers/gpu/drm/scheduler/sched_main.c +0 -0
index a2a953693b45..3ab0900d3596 100644

drivers/gpu/drm/scheduler/sched_main.c static int drm_sched_main(void *param) · line 822

Quoted 5 lines
drivers/gpu/drm/scheduler/sched_main.c +3 -0
@@ -818,6 +818,9 @@ static int drm_sched_main(void *param)
  		if (!IS_ERR_OR_NULL(fence)) {
  			s_fence->parent = dma_fence_get(fence);
+			if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT,
+				     &s_fence->finished.flags))
+				dma_fence_set_deadline(fence, s_fence->deadline);

Maybe move this into a dma_sched_fence_set_parent() function.

Apart from that looks good to me.

Regards,
Christian.

Quoted 19 lines
drivers/gpu/drm/scheduler/sched_main.c +0 -0
  			r = dma_fence_add_callback(fence, &sched_job->cb,
  						   drm_sched_job_done_cb);
  			if (r == -ENOENT)
include/drm/gpu_scheduler.h +6 -0
index d18af49fd009..0f08ade614ae 100644
@@ -144,6 +144,12 @@ struct drm_sched_fence {
           */
  	struct dma_fence		finished;
+	/**
+	 * @deadline: deadline set on &drm_sched_fence.finished which
+	 * potentially needs to be propagated to &drm_sched_fence.parent
+	 */
+	ktime_t				deadline;
+
          /**
           * @parent: the fence returned by &drm_sched_backend_ops.run_job
           * when scheduling the job on hardware. We signal the
Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
author
#10 lore raw

Re: [PATCH v2 4/5] drm/scheduler: Add fence deadline support

Quoted 10 lines · Daniel Vetter
Quoted 8 lines · Christian König

Am 07.08.21 um 20:37 schrieb Rob Clark:

Quoted 7 lines

From: Rob Clark <[email protected]>

As the finished fence is the one that is exposed to userspace, and therefore the one that other operations, like atomic update, would block on, we need to propagate the deadline from from the finished fence to the actual hw fence.

Quoted 5 lines
Quoted 1 line
Quoted 1 line

I guess you're already letting the compositor run at a higher gpu priority so that your deadline'd drm_sched_job isn't stuck behind the app rendering the next frame?

With the scheduler conversion we do have multiple priorities (provided by scheduler) for all generations.. but not yet preemption for all generations.

But the most common use-case where we need this ends up being display composition (either fullscreen app/game or foreground app/game composited via overlay) so I haven't thought too much about the next step of boosting job priority. I might leave that to someone who already has preemption wired up ;-)

BR,
-R

Quoted 96 lines

I'm not sure whether you wire that one up as part of the conversion to drm/sched. Without that I think we might need to ponder how we can do a prio-boost for these, e.g. within a scheduling class we pick the jobs with the nearest deadline first, before we pick others.
-Daniel

Quoted 76 lines
Quoted 52 lines
---
  drivers/gpu/drm/scheduler/sched_fence.c | 25 +++++++++++++++++++++++++
  drivers/gpu/drm/scheduler/sched_main.c  |  3 +++
  include/drm/gpu_scheduler.h             |  6 ++++++
  3 files changed, 34 insertions(+)
drivers/gpu/drm/scheduler/sched_fence.c +25 -0
index 69de2c76731f..f389dca44185 100644
@@ -128,6 +128,30 @@ static void drm_sched_fence_release_finished(struct dma_fence *f)
    dma_fence_put(&fence->scheduled);
  }
+static void drm_sched_fence_set_deadline_finished(struct dma_fence *f,
+                                             ktime_t deadline)
+{
+   struct drm_sched_fence *fence = to_drm_sched_fence(f);
+   unsigned long flags;
+
+   spin_lock_irqsave(&fence->lock, flags);
+
+   /* If we already have an earlier deadline, keep it: */
+   if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags) &&
+       ktime_before(fence->deadline, deadline)) {
+           spin_unlock_irqrestore(&fence->lock, flags);
+           return;
+   }
+
+   fence->deadline = deadline;
+   set_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags);
+
+   spin_unlock_irqrestore(&fence->lock, flags);
+
+   if (fence->parent)
+           dma_fence_set_deadline(fence->parent, deadline);
+}
+
  static const struct dma_fence_ops drm_sched_fence_ops_scheduled = {
    .get_driver_name = drm_sched_fence_get_driver_name,
    .get_timeline_name = drm_sched_fence_get_timeline_name,
@@ -138,6 +162,7 @@ static const struct dma_fence_ops drm_sched_fence_ops_finished = {
    .get_driver_name = drm_sched_fence_get_driver_name,
    .get_timeline_name = drm_sched_fence_get_timeline_name,
    .release = drm_sched_fence_release_finished,
+   .set_deadline = drm_sched_fence_set_deadline_finished,
  };
  struct drm_sched_fence *to_drm_sched_fence(struct dma_fence *f)
drivers/gpu/drm/scheduler/sched_main.c +0 -0
index a2a953693b45..3ab0900d3596 100644

drivers/gpu/drm/scheduler/sched_main.c static int drm_sched_main(void *param) · line 822

Quoted 5 lines
drivers/gpu/drm/scheduler/sched_main.c +3 -0
@@ -818,6 +818,9 @@ static int drm_sched_main(void *param)
            if (!IS_ERR_OR_NULL(fence)) {
                    s_fence->parent = dma_fence_get(fence);
+                   if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT,
+                                &s_fence->finished.flags))
+                           dma_fence_set_deadline(fence, s_fence->deadline);

Maybe move this into a dma_sched_fence_set_parent() function.

Apart from that looks good to me.

Regards,
Christian.

Quoted 11 lines
drivers/gpu/drm/scheduler/sched_main.c +0 -0
                    r = dma_fence_add_callback(fence, &sched_job->cb,
                                               drm_sched_job_done_cb);
                    if (r == -ENOENT)
include/drm/gpu_scheduler.h +1 -0
index d18af49fd009..0f08ade614ae 100644
@@ -144,6 +144,12 @@ struct drm_sched_fence {
           */
    struct dma_fence                finished;
+   /**
Quoted 9 lines

include/drm/gpu_scheduler.h struct drm_sched_fence { · line 155

Quoted 8 lines
include/drm/gpu_scheduler.h +5 -0
+    * @deadline: deadline set on &drm_sched_fence.finished which
+    * potentially needs to be propagated to &drm_sched_fence.parent
+    */
+   ktime_t                         deadline;
+
          /**
           * @parent: the fence returned by &drm_sched_backend_ops.run_job
           * when scheduling the job on hardware. We signal the

--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch

#11 lore raw

Re: [PATCH v2 4/5] drm/scheduler: Add fence deadline support

Quoted 21 lines · Rob Clark
Quoted 10 lines · Daniel Vetter
Quoted 8 lines · Christian König

Am 07.08.21 um 20:37 schrieb Rob Clark:

Quoted 7 lines

From: Rob Clark <[email protected]>

As the finished fence is the one that is exposed to userspace, and therefore the one that other operations, like atomic update, would block on, we need to propagate the deadline from from the finished fence to the actual hw fence.

Quoted 5 lines
Quoted 1 line
Quoted 1 line

I guess you're already letting the compositor run at a higher gpu priority so that your deadline'd drm_sched_job isn't stuck behind the app rendering the next frame?

With the scheduler conversion we do have multiple priorities (provided by scheduler) for all generations.. but not yet preemption for all generations.

Quoted 5 lines

But the most common use-case where we need this ends up being display composition (either fullscreen app/game or foreground app/game composited via overlay) so I haven't thought too much about the next step of boosting job priority. I might leave that to someone who already has preemption wired up ;-)

Atm no-one, drm/sched isn't really aware that's a concept. I was more thinking of just boosting that request as a first step. Maybe within the same priority class we pick jobs with deadlines first, or something like that.

Preempting is an entire can of worms on top.
-Daniel

Quoted 100 lines

BR,
-R

Quoted 96 lines

I'm not sure whether you wire that one up as part of the conversion to drm/sched. Without that I think we might need to ponder how we can do a prio-boost for these, e.g. within a scheduling class we pick the jobs with the nearest deadline first, before we pick others.
-Daniel

Quoted 76 lines
Quoted 52 lines
---
  drivers/gpu/drm/scheduler/sched_fence.c | 25 +++++++++++++++++++++++++
  drivers/gpu/drm/scheduler/sched_main.c  |  3 +++
  include/drm/gpu_scheduler.h             |  6 ++++++
  3 files changed, 34 insertions(+)
drivers/gpu/drm/scheduler/sched_fence.c +25 -0
index 69de2c76731f..f389dca44185 100644
@@ -128,6 +128,30 @@ static void drm_sched_fence_release_finished(struct dma_fence *f)
    dma_fence_put(&fence->scheduled);
  }
+static void drm_sched_fence_set_deadline_finished(struct dma_fence *f,
+                                             ktime_t deadline)
+{
+   struct drm_sched_fence *fence = to_drm_sched_fence(f);
+   unsigned long flags;
+
+   spin_lock_irqsave(&fence->lock, flags);
+
+   /* If we already have an earlier deadline, keep it: */
+   if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags) &&
+       ktime_before(fence->deadline, deadline)) {
+           spin_unlock_irqrestore(&fence->lock, flags);
+           return;
+   }
+
+   fence->deadline = deadline;
+   set_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT, &f->flags);
+
+   spin_unlock_irqrestore(&fence->lock, flags);
+
+   if (fence->parent)
+           dma_fence_set_deadline(fence->parent, deadline);
+}
+
  static const struct dma_fence_ops drm_sched_fence_ops_scheduled = {
    .get_driver_name = drm_sched_fence_get_driver_name,
    .get_timeline_name = drm_sched_fence_get_timeline_name,
@@ -138,6 +162,7 @@ static const struct dma_fence_ops drm_sched_fence_ops_finished = {
    .get_driver_name = drm_sched_fence_get_driver_name,
    .get_timeline_name = drm_sched_fence_get_timeline_name,
    .release = drm_sched_fence_release_finished,
+   .set_deadline = drm_sched_fence_set_deadline_finished,
  };
  struct drm_sched_fence *to_drm_sched_fence(struct dma_fence *f)
drivers/gpu/drm/scheduler/sched_main.c +0 -0
index a2a953693b45..3ab0900d3596 100644

drivers/gpu/drm/scheduler/sched_main.c static int drm_sched_main(void *param) · line 822

Quoted 5 lines
drivers/gpu/drm/scheduler/sched_main.c +3 -0
@@ -818,6 +818,9 @@ static int drm_sched_main(void *param)
            if (!IS_ERR_OR_NULL(fence)) {
                    s_fence->parent = dma_fence_get(fence);
+                   if (test_bit(DMA_FENCE_FLAG_HAS_DEADLINE_BIT,
+                                &s_fence->finished.flags))
+                           dma_fence_set_deadline(fence, s_fence->deadline);

Maybe move this into a dma_sched_fence_set_parent() function.

Apart from that looks good to me.

Regards,
Christian.

Quoted 11 lines
drivers/gpu/drm/scheduler/sched_main.c +0 -0
                    r = dma_fence_add_callback(fence, &sched_job->cb,
                                               drm_sched_job_done_cb);
                    if (r == -ENOENT)
include/drm/gpu_scheduler.h +1 -0
index d18af49fd009..0f08ade614ae 100644
@@ -144,6 +144,12 @@ struct drm_sched_fence {
           */
    struct dma_fence                finished;
+   /**
Quoted 9 lines

include/drm/gpu_scheduler.h struct drm_sched_fence { · line 155

Quoted 8 lines
include/drm/gpu_scheduler.h +5 -0
+    * @deadline: deadline set on &drm_sched_fence.finished which
+    * potentially needs to be propagated to &drm_sched_fence.parent
+    */
+   ktime_t                         deadline;
+
          /**
           * @parent: the fence returned by &drm_sched_backend_ops.run_job
           * when scheduling the job on hardware. We signal the

--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch

Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
author
#12 lore raw

PATCH v2 5/5 drm/msm: Add deadline based boost support

In reply to Rob Clark

From: Rob Clark <[email protected]>

---
 drivers/gpu/drm/msm/msm_fence.c       | 76 +++++++++++++++++++++++++++
 drivers/gpu/drm/msm/msm_fence.h       | 20 +++++++
 drivers/gpu/drm/msm/msm_gpu.h         |  1 +
 drivers/gpu/drm/msm/msm_gpu_devfreq.c | 20 +++++++
 4 files changed, 117 insertions(+)
drivers/gpu/drm/msm/msm_fence.c +76 -0
index f2cece542c3f..67c2a96e1c85 100644
@@ -8,6 +8,37 @@
 
 #include "msm_drv.h"
 #include "msm_fence.h"
+#include "msm_gpu.h"
+
+static inline bool fence_completed(struct msm_fence_context *fctx, uint32_t fence);
+
+static struct msm_gpu *fctx2gpu(struct msm_fence_context *fctx)
+{
+	struct msm_drm_private *priv = fctx->dev->dev_private;
+	return priv->gpu;
+}
+
+static enum hrtimer_restart deadline_timer(struct hrtimer *t)
+{
+	struct msm_fence_context *fctx = container_of(t,
+			struct msm_fence_context, deadline_timer);
+
+	kthread_queue_work(fctx2gpu(fctx)->worker, &fctx->deadline_work);
+
+	return HRTIMER_NORESTART;
+}
+
+static void deadline_work(struct kthread_work *work)
+{
+	struct msm_fence_context *fctx = container_of(work,
+			struct msm_fence_context, deadline_work);
+
+	/* If deadline fence has already passed, nothing to do: */
+	if (fence_completed(fctx, fctx->next_deadline_fence))
+		return;
+
+	msm_devfreq_boost(fctx2gpu(fctx), 2);
+}
 
 
 struct msm_fence_context *
@@ -26,6 +57,13 @@ msm_fence_context_alloc(struct drm_device *dev, volatile uint32_t *fenceptr,
 	fctx->fenceptr = fenceptr;
 	spin_lock_init(&fctx->spinlock);
 
+	hrtimer_init(&fctx->deadline_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+	fctx->deadline_timer.function = deadline_timer;
+
+	kthread_init_work(&fctx->deadline_work, deadline_work);
+
+	fctx->next_deadline = ktime_get();
+
 	return fctx;
 }
 
@@ -49,6 +87,8 @@ void msm_update_fence(struct msm_fence_context *fctx, uint32_t fence)
 {
 	spin_lock(&fctx->spinlock);
 	fctx->completed_fence = max(fence, fctx->completed_fence);
+	if (fence_completed(fctx, fctx->next_deadline_fence))
+		hrtimer_cancel(&fctx->deadline_timer);
 	spin_unlock(&fctx->spinlock);
 }
 
@@ -79,10 +119,46 @@ static bool msm_fence_signaled(struct dma_fence *fence)
 	return fence_completed(f->fctx, f->base.seqno);
 }
 
+static void msm_fence_set_deadline(struct dma_fence *fence, ktime_t deadline)
+{
+	struct msm_fence *f = to_msm_fence(fence);
+	struct msm_fence_context *fctx = f->fctx;
+	unsigned long flags;
+	ktime_t now;
+
+	spin_lock_irqsave(&fctx->spinlock, flags);
+	now = ktime_get();
+
+	if (ktime_after(now, fctx->next_deadline) ||
+			ktime_before(deadline, fctx->next_deadline)) {
+		fctx->next_deadline = deadline;
+		fctx->next_deadline_fence =
+			max(fctx->next_deadline_fence, (uint32_t)fence->seqno);
+
+		/*
+		 * Set timer to trigger boost 3ms before deadline, or
+		 * if we are already less than 3ms before the deadline
+		 * schedule boost work immediately.
+		 */
+		deadline = ktime_sub(deadline, ms_to_ktime(3));
+
+		if (ktime_after(now, deadline)) {
+			kthread_queue_work(fctx2gpu(fctx)->worker,
+					&fctx->deadline_work);
+		} else {
+			hrtimer_start(&fctx->deadline_timer, deadline,
+					HRTIMER_MODE_ABS);
+		}
+	}
+
+	spin_unlock_irqrestore(&fctx->spinlock, flags);
+}
+
 static const struct dma_fence_ops msm_fence_ops = {
 	.get_driver_name = msm_fence_get_driver_name,
 	.get_timeline_name = msm_fence_get_timeline_name,
 	.signaled = msm_fence_signaled,
+	.set_deadline = msm_fence_set_deadline,
 };
 
 struct dma_fence *
drivers/gpu/drm/msm/msm_fence.h +20 -0
index 4783db528bcc..d34e853c555a 100644
@@ -50,6 +50,26 @@ struct msm_fence_context {
 	volatile uint32_t *fenceptr;
 
 	spinlock_t spinlock;
+
+	/*
+	 * TODO this doesn't really deal with multiple deadlines, like
+	 * if userspace got multiple frames ahead.. OTOH atomic updates
+	 * don't queue, so maybe that is ok
+	 */
+
+	/** next_deadline: Time of next deadline */
+	ktime_t next_deadline;
+
+	/**
+	 * next_deadline_fence:
+	 *
+	 * Fence value for next pending deadline.  The deadline timer is
+	 * canceled when this fence is signaled.
+	 */
+	uint32_t next_deadline_fence;
+
+	struct hrtimer deadline_timer;
+	struct kthread_work deadline_work;
 };
 
 struct msm_fence_context * msm_fence_context_alloc(struct drm_device *dev,
drivers/gpu/drm/msm/msm_gpu.h +1 -0
index 0e4b45bff2e6..e031c9b495ed 100644
@@ -425,6 +425,7 @@ void msm_devfreq_init(struct msm_gpu *gpu);
 void msm_devfreq_cleanup(struct msm_gpu *gpu);
 void msm_devfreq_resume(struct msm_gpu *gpu);
 void msm_devfreq_suspend(struct msm_gpu *gpu);
+void msm_devfreq_boost(struct msm_gpu *gpu, unsigned factor);
 void msm_devfreq_active(struct msm_gpu *gpu);
 void msm_devfreq_idle(struct msm_gpu *gpu);
 
drivers/gpu/drm/msm/msm_gpu_devfreq.c +20 -0
index 0a1ee20296a2..8a8d7b9028a3 100644
@@ -144,6 +144,26 @@ void msm_devfreq_suspend(struct msm_gpu *gpu)
 	devfreq_suspend_device(gpu->devfreq.devfreq);
 }
 
+void msm_devfreq_boost(struct msm_gpu *gpu, unsigned factor)
+{
+	struct msm_gpu_devfreq *df = &gpu->devfreq;
+	unsigned long freq;
+
+	/*
+	 * Hold devfreq lock to synchronize with get_dev_status()/
+	 * target() callbacks
+	 */
+	mutex_lock(&df->devfreq->lock);
+
+	freq = get_freq(gpu);
+
+	freq *= factor;
+
+	msm_devfreq_target(&gpu->pdev->dev, &freq, 0);
+
+	mutex_unlock(&df->devfreq->lock);
+}
+
 void msm_devfreq_active(struct msm_gpu *gpu)
 {
 	struct msm_gpu_devfreq *df = &gpu->devfreq;
Signature · 1 line
2.31.1
maintainer
#13 lore raw
In reply to Rob Clark

The general approach seems to make sense now I think.

One minor thing which I'm missing is adding support for this to the dma_fence_array and dma_fence_chain containers.

Regards,
Christian.

Am 07.08.21 um 20:37 schrieb Rob Clark:

Quoted 51 lines

From: Rob Clark <[email protected]>

Based on discussion from a previous series[1] to add a "boost" mechanism when, for example, vblank deadlines are missed. Instead of a boost callback, this approach adds a way to set a deadline on the fence, by which the waiter would like to see the fence signalled.

I've not yet had a chance to re-work the drm/msm part of this, but wanted to send this out as an RFC in case I don't have a chance to finish the drm/msm part this week.

Original description:

In some cases, like double-buffered rendering, missing vblanks can trick the GPU into running at a lower frequence, when really we want to be running at a higher frequency to not miss the vblanks in the first place.

This is partially inspired by a trick i915 does, but implemented via dma-fence for a couple of reasons:

1) To continue to be able to use the atomic helpers
2) To support cases where display and gpu are different drivers

[1] https://patchwork.freedesktop.org/series/90331/

v1: https://patchwork.freedesktop.org/series/93035/
v2: Move filtering out of later deadlines to fence implementation
to avoid increasing the size of dma_fence

Rob Clark (5):
dma-fence: Add deadline awareness drm/vblank: Add helper to get next vblank time drm/atomic-helper: Set fence deadline for vblank drm/scheduler: Add fence deadline support drm/msm: Add deadline based boost support

  drivers/dma-buf/dma-fence.c             | 20 +++++++
  drivers/gpu/drm/drm_atomic_helper.c     | 36 ++++++++++++
  drivers/gpu/drm/drm_vblank.c            | 31 ++++++++++
  drivers/gpu/drm/msm/msm_fence.c         | 76 +++++++++++++++++++++++++
  drivers/gpu/drm/msm/msm_fence.h         | 20 +++++++
  drivers/gpu/drm/msm/msm_gpu.h           |  1 +
  drivers/gpu/drm/msm/msm_gpu_devfreq.c   | 20 +++++++
  drivers/gpu/drm/scheduler/sched_fence.c | 25 ++++++++
  drivers/gpu/drm/scheduler/sched_main.c  |  3 +
  include/drm/drm_vblank.h                |  1 +
  include/drm/gpu_scheduler.h             |  6 ++
  include/linux/dma-fence.h               | 16 ++++++
  12 files changed, 255 insertions(+)
author
#14 lore raw

dma_fence_array looks simple enough, just propagate the deadline to all children.

I guess dma_fence_chain is similar (ie. fence is signalled when all children are signalled), the difference being simply that children are added dynamically?

BR,
-R

Quoted 62 lines · Christian König

The general approach seems to make sense now I think.

One minor thing which I'm missing is adding support for this to the dma_fence_array and dma_fence_chain containers.

Regards,
Christian.

Am 07.08.21 um 20:37 schrieb Rob Clark:

Quoted 51 lines

From: Rob Clark <[email protected]>

Based on discussion from a previous series[1] to add a "boost" mechanism when, for example, vblank deadlines are missed. Instead of a boost callback, this approach adds a way to set a deadline on the fence, by which the waiter would like to see the fence signalled.

I've not yet had a chance to re-work the drm/msm part of this, but wanted to send this out as an RFC in case I don't have a chance to finish the drm/msm part this week.

Original description:

In some cases, like double-buffered rendering, missing vblanks can trick the GPU into running at a lower frequence, when really we want to be running at a higher frequency to not miss the vblanks in the first place.

This is partially inspired by a trick i915 does, but implemented via dma-fence for a couple of reasons:

1) To continue to be able to use the atomic helpers
2) To support cases where display and gpu are different drivers

[1] https://patchwork.freedesktop.org/series/90331/

v1: https://patchwork.freedesktop.org/series/93035/
v2: Move filtering out of later deadlines to fence implementation
to avoid increasing the size of dma_fence

Rob Clark (5):
dma-fence: Add deadline awareness drm/vblank: Add helper to get next vblank time drm/atomic-helper: Set fence deadline for vblank drm/scheduler: Add fence deadline support drm/msm: Add deadline based boost support

  drivers/dma-buf/dma-fence.c             | 20 +++++++
  drivers/gpu/drm/drm_atomic_helper.c     | 36 ++++++++++++
  drivers/gpu/drm/drm_vblank.c            | 31 ++++++++++
  drivers/gpu/drm/msm/msm_fence.c         | 76 +++++++++++++++++++++++++
  drivers/gpu/drm/msm/msm_fence.h         | 20 +++++++
  drivers/gpu/drm/msm/msm_gpu.h           |  1 +
  drivers/gpu/drm/msm/msm_gpu_devfreq.c   | 20 +++++++
  drivers/gpu/drm/scheduler/sched_fence.c | 25 ++++++++
  drivers/gpu/drm/scheduler/sched_main.c  |  3 +
  include/drm/drm_vblank.h                |  1 +
  include/drm/gpu_scheduler.h             |  6 ++
  include/linux/dma-fence.h               | 16 ++++++
  12 files changed, 255 insertions(+)
maintainer
#15 lore raw

Am 17.08.21 um 00:29 schrieb Rob Clark:

Quoted 6 lines

dma_fence_array looks simple enough, just propagate the deadline to all children.

I guess dma_fence_chain is similar (ie. fence is signalled when all children are signalled), the difference being simply that children are added dynamically?

No, new chain nodes are always added at the top.

So when you have a dma_fence_chain as a starting point the linked nodes after it will stay the same (except for garbage collection).

The tricky part is you can't use recursion, cause that would easily exceed the kernels stack depth. So you need something similar to dma_fence_chain_signaled().

Something like this should do it:

static bool dma_fence_chain_set_deadline(struct dma_fence *fence, ktime_t deadline) {
        dma_fence_chain_for_each(fence, fence) {
                struct dma_fence_chain *chain = to_dma_fence_chain(fence); struct dma_fence *f = chain ? chain->fence : fence;

                dma_fence_set_deadline(f, deadline); }
}

Regards,
Christian.

Quoted 66 lines

BR,
-R

Quoted 60 lines · Christian König

The general approach seems to make sense now I think.

One minor thing which I'm missing is adding support for this to the dma_fence_array and dma_fence_chain containers.

Regards,
Christian.

Am 07.08.21 um 20:37 schrieb Rob Clark:

Quoted 51 lines

From: Rob Clark <[email protected]>

Based on discussion from a previous series[1] to add a "boost" mechanism when, for example, vblank deadlines are missed. Instead of a boost callback, this approach adds a way to set a deadline on the fence, by which the waiter would like to see the fence signalled.

I've not yet had a chance to re-work the drm/msm part of this, but wanted to send this out as an RFC in case I don't have a chance to finish the drm/msm part this week.

Original description:

In some cases, like double-buffered rendering, missing vblanks can trick the GPU into running at a lower frequence, when really we want to be running at a higher frequency to not miss the vblanks in the first place.

This is partially inspired by a trick i915 does, but implemented via dma-fence for a couple of reasons:

1) To continue to be able to use the atomic helpers
2) To support cases where display and gpu are different drivers

[1] https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fpatchwork.freedesktop.org%2Fseries%2F90331%2F&amp;data=04%7C01%7Cchristian.koenig%40amd.com%7Cf34fa8c2316241f1516408d96104c2c7%7C3dd8961fe4884e608e11a82d994e183d%7C0%7C0%7C637647495930712007%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000&amp;sdata=4DoEsan2nW2cNwWrhnHsJF2h0MY1uCslRfOLmbYu6uw%3D&amp;reserved=0

v1: https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fpatchwork.freedesktop.org%2Fseries%2F93035%2F&amp;data=04%7C01%7Cchristian.koenig%40amd.com%7Cf34fa8c2316241f1516408d96104c2c7%7C3dd8961fe4884e608e11a82d994e183d%7C0%7C0%7C637647495930722002%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000&amp;sdata=3%2BRFE0nEgZXPZ50iVPila5CgzXErllBEK6YpL%2FOEGGc%3D&amp;reserved=0
v2: Move filtering out of later deadlines to fence implementation
to avoid increasing the size of dma_fence

Rob Clark (5):
dma-fence: Add deadline awareness drm/vblank: Add helper to get next vblank time drm/atomic-helper: Set fence deadline for vblank drm/scheduler: Add fence deadline support drm/msm: Add deadline based boost support

   drivers/dma-buf/dma-fence.c             | 20 +++++++
   drivers/gpu/drm/drm_atomic_helper.c     | 36 ++++++++++++
   drivers/gpu/drm/drm_vblank.c            | 31 ++++++++++
   drivers/gpu/drm/msm/msm_fence.c         | 76 +++++++++++++++++++++++++
   drivers/gpu/drm/msm/msm_fence.h         | 20 +++++++
   drivers/gpu/drm/msm/msm_gpu.h           |  1 +
   drivers/gpu/drm/msm/msm_gpu_devfreq.c   | 20 +++++++
   drivers/gpu/drm/scheduler/sched_fence.c | 25 ++++++++
   drivers/gpu/drm/scheduler/sched_main.c  |  3 +
   include/drm/drm_vblank.h                |  1 +
   include/drm/gpu_scheduler.h             |  6 ++
   include/linux/dma-fence.h               | 16 ++++++
   12 files changed, 255 insertions(+)