Skip to contentSkip to conversation

drm/vc4: Add a debugfs entry to disable/enable the load tracker

PATCH Superseded Paul Kocialkowski 3 participants 7 messages Nov 30, 2018 – Dec 3, 2018

Subsystems (3)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 drm/vc4: Add a debugfs entry to disable/enable the load tracker

In order to test whether the load tracker is working as expected, we need the ability to compare the commit result with the underrun indication. With the load tracker always enabled, commits that are expected to trigger an underrun are always rejected, so userspace cannot get the actual underrun indication from the hardware.

Add a debugfs entry to disable/enable the load tracker, so that a DRM commit expected to trigger an underrun can go through with the load tracker disabled. The underrun indication is then available to userspace and can be checked against the commit result with the load tracker enabled.

---

Changes since v1:
* Moved all the debugfs-related functions and structure to vc4_debugfs.c.

 drivers/gpu/drm/vc4/vc4_debugfs.c | 58 +++++++++++++++++++++++++++++++
 drivers/gpu/drm/vc4/vc4_drv.c     |  2 ++
 drivers/gpu/drm/vc4/vc4_drv.h     |  2 ++
 drivers/gpu/drm/vc4/vc4_kms.c     |  6 +++-
 4 files changed, 67 insertions(+), 1 deletion(-)
drivers/gpu/drm/vc4/vc4_debugfs.c +58 -0
index 7a0003de71ab..8f4d7fadb226 100644
@@ -32,9 +32,67 @@ static const struct drm_info_list vc4_debugfs_list[] = {
 
 #define VC4_DEBUGFS_ENTRIES ARRAY_SIZE(vc4_debugfs_list)
 
+static int vc4_debugfs_load_tracker_get(struct seq_file *m, void *data)
+{
+	struct drm_device *dev = m->private;
+	struct vc4_dev *vc4 = to_vc4_dev(dev);
+
+	if (vc4->load_tracker_enabled)
+		seq_printf(m, "enabled\n");
+	else
+		seq_printf(m, "disabled\n");
+
+	return 0;
+}
+
+static ssize_t vc4_debugfs_load_tracker_set(struct file *file,
+					    const char __user *ubuf,
+					    size_t len, loff_t *offp)
+{
+	struct seq_file *m = file->private_data;
+	struct drm_device *dev = m->private;
+	struct vc4_dev *vc4 = to_vc4_dev(dev);
+	char buf[32] = {};
+
+	if (len >= sizeof(buf))
+		return -EINVAL;
+
+	if (copy_from_user(buf, ubuf, len))
+		return -EFAULT;
+
+	if (!strncasecmp(buf, "enable", 6))
+		vc4->load_tracker_enabled = true;
+	else if (!strncasecmp(buf, "disable", 7))
+		vc4->load_tracker_enabled = false;
+	else
+		return -EINVAL;
+
+	return len;
+}
+
+static int vc4_debugfs_load_tracker_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, vc4_debugfs_load_tracker_get, inode->i_private);
+}
+
+static const struct file_operations vc4_debugfs_load_tracker_fops = {
+	.owner = THIS_MODULE,
+	.open = vc4_debugfs_load_tracker_open,
+	.read = seq_read,
+	.write = vc4_debugfs_load_tracker_set,
+};
+
 int
 vc4_debugfs_init(struct drm_minor *minor)
 {
+	struct dentry *dentry;
+
+	dentry = debugfs_create_file("load_tracker", S_IRUGO | S_IWUSR,
+				     minor->debugfs_root, minor->dev,
+				     &vc4_debugfs_load_tracker_fops);
+	if (!dentry)
+		return -ENOMEM;
+
 	return drm_debugfs_create_files(vc4_debugfs_list, VC4_DEBUGFS_ENTRIES,
 					minor->debugfs_root, minor);
 }
drivers/gpu/drm/vc4/vc4_drv.c +2 -0
index 7195a0bcceb3..12ac971d24d6 100644
@@ -290,6 +290,8 @@ static int vc4_drm_bind(struct device *dev)
 
 	drm_fbdev_generic_setup(drm, 32);
 
+	vc4->load_tracker_enabled = true;
+
 	return 0;
 
 unbind_all:
drivers/gpu/drm/vc4/vc4_drv.h +2 -0
index 11369da944b6..8d0f2f16a9e8 100644
@@ -188,6 +188,8 @@ struct vc4_dev {
 
 	int power_refcount;
 
+	bool load_tracker_enabled;
+
 	/* Mutex controlling the power refcount. */
 	struct mutex power_lock;
 
drivers/gpu/drm/vc4/vc4_kms.c +5 -1
index b905a19c1470..4b2509b1b8ed 100644
@@ -473,6 +473,7 @@ static const struct drm_private_state_funcs vc4_load_tracker_state_funcs = {
 static int
 vc4_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
 {
+	struct vc4_dev *vc4 = to_vc4_dev(dev);
 	int ret;
 
 	ret = vc4_ctm_atomic_check(dev, state);
@@ -483,7 +484,10 @@ vc4_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
 	if (ret)
 		return ret;
 
-	return vc4_load_tracker_atomic_check(state);
+	if (vc4->load_tracker_enabled)
+		return vc4_load_tracker_atomic_check(state);
+
+	return 0;
 }
 
 static const struct drm_mode_config_funcs vc4_mode_funcs = {
Signature · 6 lines
2.19.1

_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#1 lore raw
Quoted 82 lines · On Fri, 30 Nov 2018 17:11:04 +0100 Paul Kocialkowski…

In order to test whether the load tracker is working as expected, we need the ability to compare the commit result with the underrun indication. With the load tracker always enabled, commits that are expected to trigger an underrun are always rejected, so userspace cannot get the actual underrun indication from the hardware.

Add a debugfs entry to disable/enable the load tracker, so that a DRM commit expected to trigger an underrun can go through with the load tracker disabled. The underrun indication is then available to userspace and can be checked against the commit result with the load tracker enabled.

---

Changes since v1:
* Moved all the debugfs-related functions and structure to vc4_debugfs.c.

 drivers/gpu/drm/vc4/vc4_debugfs.c | 58 +++++++++++++++++++++++++++++++
 drivers/gpu/drm/vc4/vc4_drv.c     |  2 ++
 drivers/gpu/drm/vc4/vc4_drv.h     |  2 ++
 drivers/gpu/drm/vc4/vc4_kms.c     |  6 +++-
 4 files changed, 67 insertions(+), 1 deletion(-)
drivers/gpu/drm/vc4/vc4_debugfs.c +50 -0
index 7a0003de71ab..8f4d7fadb226 100644
@@ -32,9 +32,67 @@ static const struct drm_info_list vc4_debugfs_list[] = {
 
 #define VC4_DEBUGFS_ENTRIES ARRAY_SIZE(vc4_debugfs_list)
 
+static int vc4_debugfs_load_tracker_get(struct seq_file *m, void *data)
+{
+	struct drm_device *dev = m->private;
+	struct vc4_dev *vc4 = to_vc4_dev(dev);
+
+	if (vc4->load_tracker_enabled)
+		seq_printf(m, "enabled\n");
+	else
+		seq_printf(m, "disabled\n");
+
+	return 0;
+}
+
+static ssize_t vc4_debugfs_load_tracker_set(struct file *file,
+					    const char __user *ubuf,
+					    size_t len, loff_t *offp)
+{
+	struct seq_file *m = file->private_data;
+	struct drm_device *dev = m->private;
+	struct vc4_dev *vc4 = to_vc4_dev(dev);
+	char buf[32] = {};
+
+	if (len >= sizeof(buf))
+		return -EINVAL;
+
+	if (copy_from_user(buf, ubuf, len))
+		return -EFAULT;
+
+	if (!strncasecmp(buf, "enable", 6))
+		vc4->load_tracker_enabled = true;
+	else if (!strncasecmp(buf, "disable", 7))
+		vc4->load_tracker_enabled = false;
+	else
+		return -EINVAL;
+
+	return len;
+}
+
+static int vc4_debugfs_load_tracker_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, vc4_debugfs_load_tracker_get, inode->i_private);
+}
+
+static const struct file_operations vc4_debugfs_load_tracker_fops = {
+	.owner = THIS_MODULE,
+	.open = vc4_debugfs_load_tracker_open,
+	.read = seq_read,
+	.write = vc4_debugfs_load_tracker_set,
+};
+

drivers/gpu/drm/vc4/vc4_debugfs.c static const struct drm_info_list vc4_debugfs_list[] = { · line 94

Quoted 10 lines
drivers/gpu/drm/vc4/vc4_debugfs.c +7 -0
 int
 vc4_debugfs_init(struct drm_minor *minor)
 {
+	struct dentry *dentry;
+
+	dentry = debugfs_create_file("load_tracker", S_IRUGO | S_IWUSR,
+				     minor->debugfs_root, minor->dev,
+				     &vc4_debugfs_load_tracker_fops);
+	if (!dentry)
+		return -ENOMEM;

Hm, maybe you could use debugfs_create_bool() instead of re-implementing it. The values won't be enabled/disabled though (IIRC, it's Y or N).

Quoted 54 lines
drivers/gpu/drm/vc4/vc4_debugfs.c +1 -0
+
 	return drm_debugfs_create_files(vc4_debugfs_list, VC4_DEBUGFS_ENTRIES,
 					minor->debugfs_root, minor);
 }
drivers/gpu/drm/vc4/vc4_drv.c +2 -0
index 7195a0bcceb3..12ac971d24d6 100644
@@ -290,6 +290,8 @@ static int vc4_drm_bind(struct device *dev)
 
 	drm_fbdev_generic_setup(drm, 32);
 
+	vc4->load_tracker_enabled = true;
+
 	return 0;
 
 unbind_all:
drivers/gpu/drm/vc4/vc4_drv.h +2 -0
index 11369da944b6..8d0f2f16a9e8 100644
@@ -188,6 +188,8 @@ struct vc4_dev {
 
 	int power_refcount;
 
+	bool load_tracker_enabled;
+
 	/* Mutex controlling the power refcount. */
 	struct mutex power_lock;
 
drivers/gpu/drm/vc4/vc4_kms.c +5 -1
index b905a19c1470..4b2509b1b8ed 100644
@@ -473,6 +473,7 @@ static const struct drm_private_state_funcs vc4_load_tracker_state_funcs = {
 static int
 vc4_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
 {
+	struct vc4_dev *vc4 = to_vc4_dev(dev);
 	int ret;
 
 	ret = vc4_ctm_atomic_check(dev, state);
@@ -483,7 +484,10 @@ vc4_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
 	if (ret)
 		return ret;
 
-	return vc4_load_tracker_atomic_check(state);
+	if (vc4->load_tracker_enabled)
+		return vc4_load_tracker_atomic_check(state);
+
+	return 0;
 }
 
 static const struct drm_mode_config_funcs vc4_mode_funcs = {
#2 lore raw

Hi Boris,

Quoted 91 lines · Boris Brezillon
Quoted 88 lines · On Fri, 30 Nov 2018 17:11:04 +0100 Paul Kocialkowski…

In order to test whether the load tracker is working as expected, we need the ability to compare the commit result with the underrun indication. With the load tracker always enabled, commits that are expected to trigger an underrun are always rejected, so userspace cannot get the actual underrun indication from the hardware.

Add a debugfs entry to disable/enable the load tracker, so that a DRM commit expected to trigger an underrun can go through with the load tracker disabled. The underrun indication is then available to userspace and can be checked against the commit result with the load tracker enabled.

---

Changes since v1:
* Moved all the debugfs-related functions and structure to vc4_debugfs.c.

 drivers/gpu/drm/vc4/vc4_debugfs.c | 58 +++++++++++++++++++++++++++++++
 drivers/gpu/drm/vc4/vc4_drv.c     |  2 ++
 drivers/gpu/drm/vc4/vc4_drv.h     |  2 ++
 drivers/gpu/drm/vc4/vc4_kms.c     |  6 +++-
 4 files changed, 67 insertions(+), 1 deletion(-)
drivers/gpu/drm/vc4/vc4_debugfs.c +53 -0
index 7a0003de71ab..8f4d7fadb226 100644
@@ -32,9 +32,67 @@ static const struct drm_info_list vc4_debugfs_list[] = {
 
 #define VC4_DEBUGFS_ENTRIES ARRAY_SIZE(vc4_debugfs_list)
 
+static int vc4_debugfs_load_tracker_get(struct seq_file *m, void *data)
+{
+	struct drm_device *dev = m->private;
+	struct vc4_dev *vc4 = to_vc4_dev(dev);
+
+	if (vc4->load_tracker_enabled)
+		seq_printf(m, "enabled\n");
+	else
+		seq_printf(m, "disabled\n");
+
+	return 0;
+}
+
+static ssize_t vc4_debugfs_load_tracker_set(struct file *file,
+					    const char __user *ubuf,
+					    size_t len, loff_t *offp)
+{
+	struct seq_file *m = file->private_data;
+	struct drm_device *dev = m->private;
+	struct vc4_dev *vc4 = to_vc4_dev(dev);
+	char buf[32] = {};
+
+	if (len >= sizeof(buf))
+		return -EINVAL;
+
+	if (copy_from_user(buf, ubuf, len))
+		return -EFAULT;
+
+	if (!strncasecmp(buf, "enable", 6))
+		vc4->load_tracker_enabled = true;
+	else if (!strncasecmp(buf, "disable", 7))
+		vc4->load_tracker_enabled = false;
+	else
+		return -EINVAL;
+
+	return len;
+}
+
+static int vc4_debugfs_load_tracker_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, vc4_debugfs_load_tracker_get, inode->i_private);
+}
+
+static const struct file_operations vc4_debugfs_load_tracker_fops = {
+	.owner = THIS_MODULE,
+	.open = vc4_debugfs_load_tracker_open,
+	.read = seq_read,
+	.write = vc4_debugfs_load_tracker_set,
+};
+
 int
 vc4_debugfs_init(struct drm_minor *minor)
 {
+	struct dentry *dentry;
+
+	dentry = debugfs_create_file("load_tracker", S_IRUGO | S_IWUSR,
Quoted 8 lines

drivers/gpu/drm/vc4/vc4_debugfs.c static const struct drm_info_list vc4_debugfs_list[] = { · line 94

Quoted 4 lines
drivers/gpu/drm/vc4/vc4_debugfs.c +4 -0
+				     minor->debugfs_root, minor->dev,
+				     &vc4_debugfs_load_tracker_fops);
+	if (!dentry)
+		return -ENOMEM;

Hm, maybe you could use debugfs_create_bool() instead of re-implementing it. The values won't be enabled/disabled though (IIRC, it's Y or N).

Oh, I didn't know about that! It definitely makes more sense yes.

Thanks,

Paul

Quoted 54 lines
Quoted 54 lines
drivers/gpu/drm/vc4/vc4_debugfs.c +1 -0
+
 	return drm_debugfs_create_files(vc4_debugfs_list, VC4_DEBUGFS_ENTRIES,
 					minor->debugfs_root, minor);
 }
drivers/gpu/drm/vc4/vc4_drv.c +2 -0
index 7195a0bcceb3..12ac971d24d6 100644
@@ -290,6 +290,8 @@ static int vc4_drm_bind(struct device *dev)
 
 	drm_fbdev_generic_setup(drm, 32);
 
+	vc4->load_tracker_enabled = true;
+
 	return 0;
 
 unbind_all:
drivers/gpu/drm/vc4/vc4_drv.h +2 -0
index 11369da944b6..8d0f2f16a9e8 100644
@@ -188,6 +188,8 @@ struct vc4_dev {
 
 	int power_refcount;
 
+	bool load_tracker_enabled;
+
 	/* Mutex controlling the power refcount. */
 	struct mutex power_lock;
 
drivers/gpu/drm/vc4/vc4_kms.c +5 -1
index b905a19c1470..4b2509b1b8ed 100644
@@ -473,6 +473,7 @@ static const struct drm_private_state_funcs vc4_load_tracker_state_funcs = {
 static int
 vc4_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
 {
+	struct vc4_dev *vc4 = to_vc4_dev(dev);
 	int ret;
 
 	ret = vc4_ctm_atomic_check(dev, state);
@@ -483,7 +484,10 @@ vc4_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
 	if (ret)
 		return ret;
 
-	return vc4_load_tracker_atomic_check(state);
+	if (vc4->load_tracker_enabled)
+		return vc4_load_tracker_atomic_check(state);
+
+	return 0;
 }
 
 static const struct drm_mode_config_funcs vc4_mode_funcs = {
#3 lore raw
In reply to Paul Kocialkowski
Quoted 6 lines · Paul Kocialkowski

In order to test whether the load tracker is working as expected, we need the ability to compare the commit result with the underrun indication. With the load tracker always enabled, commits that are expected to trigger an underrun are always rejected, so userspace cannot get the actual underrun indication from the hardware.

Quoted 7 lines

Add a debugfs entry to disable/enable the load tracker, so that a DRM commit expected to trigger an underrun can go through with the load tracker disabled. The underrun indication is then available to userspace and can be checked against the commit result with the load tracker enabled.

Given that the load tracker is going to be conservative and say things will underrun even when they might not in practice, will this actually be useful for automated testing? Or is the intent to make it easier to tune the load tracker by disabling it so that you can experiment freely?

#4 lore raw

Hi Eric,

Quoted 14 lines · Eric Anholt
Quoted 12 lines · Paul Kocialkowski

In order to test whether the load tracker is working as expected, we need the ability to compare the commit result with the underrun indication. With the load tracker always enabled, commits that are expected to trigger an underrun are always rejected, so userspace cannot get the actual underrun indication from the hardware.

Add a debugfs entry to disable/enable the load tracker, so that a DRM commit expected to trigger an underrun can go through with the load tracker disabled. The underrun indication is then available to userspace and can be checked against the commit result with the load tracker enabled.

Quoted 6 lines
Quoted 1 line

Given that the load tracker is going to be conservative and say things will underrun even when they might not in practice, will this actually be useful for automated testing? Or is the intent to make it easier to tune the load tracker by disabling it so that you can experiment freely?

The intent here is to be able to compare the load tracker's result with the underrun indication from the HVS.

The idea is to have the following testing scheme:
1. enable the load tracker
2. try a commit and get the errno if it fails
3. disable the load tracker
4. do the commit
5. wait for vblank and get the underrun indication
6. check that the underrun occurs when errno == -ENOSPC

This way, we can find out when the load tracker gave us a false positive and refine the load calculation.

Cheers,

Paul

#5 lore raw
In reply to Eric Anholt
Quoted 14 lines · On Fri, 30 Nov 2018 12:30:52 -0800 Eric Anholt <[email protected]> wrote:
Quoted 12 lines · Paul Kocialkowski

In order to test whether the load tracker is working as expected, we need the ability to compare the commit result with the underrun indication. With the load tracker always enabled, commits that are expected to trigger an underrun are always rejected, so userspace cannot get the actual underrun indication from the hardware.

Add a debugfs entry to disable/enable the load tracker, so that a DRM commit expected to trigger an underrun can go through with the load tracker disabled. The underrun indication is then available to userspace and can be checked against the commit result with the load tracker enabled.

Quoted 6 lines
Quoted 1 line

Given that the load tracker is going to be conservative and say things will underrun even when they might not in practice, will this actually be useful for automated testing? Or is the intent to make it easier to tune the load tracker by disabling it so that you can experiment freely?

Yes, that's one goal, though I'm not sure IGT is supposed to contain such debugging tools. But the main benefit is being able to track regressions in the load tracking algo that makes it more (too?) conservative. I think people won't like this sort of regressions. The idea would be to settle on an acceptable load tracking algo (maybe after refining the proposed one), record the results (both good and too conservative predictions) and use that as a reference for the IGT test.
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel

#6 lore raw
Quoted 24 lines · Boris Brezillon
Quoted 14 lines · On Fri, 30 Nov 2018 12:30:52 -0800 Eric Anholt <[email protected]> wrote:
Quoted 12 lines · Paul Kocialkowski

In order to test whether the load tracker is working as expected, we need the ability to compare the commit result with the underrun indication. With the load tracker always enabled, commits that are expected to trigger an underrun are always rejected, so userspace cannot get the actual underrun indication from the hardware.

Add a debugfs entry to disable/enable the load tracker, so that a DRM commit expected to trigger an underrun can go through with the load tracker disabled. The underrun indication is then available to userspace and can be checked against the commit result with the load tracker enabled.

Quoted 6 lines
Quoted 1 line

Given that the load tracker is going to be conservative and say things will underrun even when they might not in practice, will this actually be useful for automated testing? Or is the intent to make it easier to tune the load tracker by disabling it so that you can experiment freely?

Quoted 8 lines

Yes, that's one goal, though I'm not sure IGT is supposed to contain such debugging tools. But the main benefit is being able to track regressions in the load tracking algo that makes it more (too?) conservative. I think people won't like this sort of regressions. The idea would be to settle on an acceptable load tracking algo (maybe after refining the proposed one), record the results (both good and too conservative predictions) and use that as a reference for the IGT test.

Yeah, I think I'm sold on it at this point -- having a tool that isn't an automated regression test, but an automated thing that can help a developer see how accurate the estimate is, would be useful and is worth a bit of kernel code to support.