Skip to contentSkip to conversation

Rework workaround igt

PATCH In review Arun Siluvery 4 participants 9 messages Sep 1, 2014 – Sep 2, 2014

lore
Share & tools
lore
#0 lore raw

cover Rework workaround igt

Rework of the test as kernel patch is modified.

Arun Siluvery (1):
igt/gem_workarounds: rework igt to test workaround registers

Damien Lespiau (1):
gem_workarounds: intel_wa_registers is now prefixed with i915

 tests/gem_workarounds.c | 46 ++++++++++++++++++++++++----------------------
 1 file changed, 24 insertions(+), 22 deletions(-)
Signature · 1 line
2.0.4
#1 lore raw

PATCH 1/2 gem_workarounds: intel_wa_registers is now prefixed with i915

From: Damien Lespiau <[email protected]>

---
 tests/gem_workarounds.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tests/gem_workarounds.c +1 -1
index 6826562..32156d2 100644
@@ -184,7 +184,7 @@ igt_main
 		devid = intel_get_drm_devid(drm_fd);
 		batch = intel_batchbuffer_alloc(bufmgr, devid);
 
-		fd = igt_debugfs_open("intel_wa_registers", O_RDONLY);
+		fd = igt_debugfs_open("i915_wa_registers", O_RDONLY);
 		igt_assert(fd >= 0);
 
 		file = fdopen(fd, "r");
Signature · 1 line
2.0.4
#2 lore raw

PATCH 2/2 igt/gem_workarounds: rework igt to test workaround registers

In reply to Arun Siluvery

kernel patch that exports w/a data to debugfs is reworked so update igt accordingly.

Address review comments from Damien.
- if kernel is not exposing w/a data instead of failing just skip instead.
- if the platform is not exposing w/a table then no of workarounds applied are 0; we can use this data to skip platform checks.

---
 tests/gem_workarounds.c | 44 +++++++++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 21 deletions(-)
tests/gem_workarounds.c +23 -21
index 32156d2..fae4382 100644
@@ -62,7 +62,7 @@ int drm_fd;
 uint32_t devid;
 static drm_intel_bufmgr *bufmgr;
 struct intel_batchbuffer *batch;
-int num_wa_regs;
+int num_wa_regs = 0;
 struct intel_wa_reg *wa_regs;
 
 
@@ -153,7 +153,7 @@ static void check_workarounds(enum operation op, int num)
 	igt_info("Address\tbefore\t\tafter\t\tw/a mask\tresult\n");
 	for (i = 0; i < num; ++i) {
 		status = (current_wa[i].value & current_wa[i].mask) !=
-			(wa_regs[i].value & wa_regs[i].mask);
+			wa_regs[i].mask;
 		if (status)
 			++fail_count;
 
@@ -171,21 +171,15 @@ out:
 igt_main
 {
 	igt_fixture {
-		int i;
 		int fd;
 		int ret;
 		FILE *file;
 		char *line = NULL;
 		size_t line_size;
 
-		drm_fd = drm_open_any();
-
-		bufmgr = drm_intel_bufmgr_gem_init(drm_fd, 4096);
-		devid = intel_get_drm_devid(drm_fd);
-		batch = intel_batchbuffer_alloc(bufmgr, devid);
-
 		fd = igt_debugfs_open("i915_wa_registers", O_RDONLY);
-		igt_assert(fd >= 0);
+		if (fd < 0)
+			igt_skip_on("No Workaround table available !!\n");
 
 		file = fdopen(fd, "r");
 		igt_assert(file > 0);
@@ -193,32 +187,40 @@ igt_main
 		ret = getline(&line, &line_size, file);
 		igt_assert(ret > 0);
 		sscanf(line, "Workarounds applied: %d", &num_wa_regs);
-		igt_assert(num_wa_regs > 0);
 
-		wa_regs = malloc(num_wa_regs * sizeof(*wa_regs));
+		if (num_wa_regs) {
+			int i = 0;
 
-		i = 0;
-		while(getline(&line, &line_size, file) > 0) {
-			sscanf(line, "0x%X: 0x%08X, mask: 0x%08X",
-			       &wa_regs[i].addr, &wa_regs[i].value,
-			       &wa_regs[i].mask);
-			++i;
-		}
+			wa_regs = malloc(num_wa_regs * sizeof(*wa_regs));
+			while (getline(&line, &line_size, file) > 0) {
+				sscanf(line, "0x%X: 0x%08X, mask: 0x%08X",
+				       &wa_regs[i].addr, &wa_regs[i].value,
+				       &wa_regs[i].mask);
+				++i;
+			}
+		} else
+			igt_info("No workarounds exported\n");
 
 		free(line);
 		fclose(file);
 		close(fd);
+
+		drm_fd = drm_open_any();
+
+		bufmgr = drm_intel_bufmgr_gem_init(drm_fd, 4096);
+		devid = intel_get_drm_devid(drm_fd);
+		batch = intel_batchbuffer_alloc(bufmgr, devid);
 	}
 
 	igt_subtest("check-workaround-data-after-reset") {
-		if (IS_BROADWELL(devid))
+		if (num_wa_regs)
 			check_workarounds(GPU_RESET, num_wa_regs);
 		else
 			igt_skip_on("No Workaround table available!!\n");
 	}
 
 	igt_subtest("check-workaround-data-after-suspend-resume") {
-		if (IS_BROADWELL(devid))
+		if (num_wa_regs)
 			check_workarounds(SUSPEND_RESUME, num_wa_regs);
 		else
 			igt_skip_on("No Workaround table available!!\n");
Signature · 1 line
2.0.4
#3 lore raw

Re: [PATCH 2/2] igt/gem_workarounds: rework igt to test workaround registers

Quoted 27 lines · Arun Siluvery

kernel patch that exports w/a data to debugfs is reworked so update igt accordingly.

Address review comments from Damien.
- if kernel is not exposing w/a data instead of failing just skip instead.
- if the platform is not exposing w/a table then no of workarounds applied are 0; we can use this data to skip platform checks.

---
 tests/gem_workarounds.c | 44 +++++++++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 21 deletions(-)
tests/gem_workarounds.c +1 -1
index 32156d2..fae4382 100644
@@ -62,7 +62,7 @@ int drm_fd;
 uint32_t devid;
 static drm_intel_bufmgr *bufmgr;
 struct intel_batchbuffer *batch;
-int num_wa_regs;
+int num_wa_regs = 0;
 struct intel_wa_reg *wa_regs;
 
 

tests/gem_workarounds.c static void check_workarounds(enum operation op, int num) · line 156

Quoted 5 lines
tests/gem_workarounds.c +1 -1
@@ -153,7 +153,7 @@ static void check_workarounds(enum operation op, int num)
 	igt_info("Address\tbefore\t\tafter\t\tw/a mask\tresult\n");
 	for (i = 0; i < num; ++i) {
 		status = (current_wa[i].value & current_wa[i].mask) !=
-			(wa_regs[i].value & wa_regs[i].mask);
+			wa_regs[i].mask;

Hum. This looks so fishy it can't be right. The heart of the problem is that you're not clear what a mask or value should be.

To me:

- A mask selects bits
- value is the reference W/A value (containing only the correct bits for a single W/A, some of those bits can be 0, mask is telling us which bits we're interested about.
- read(reg) & mask is the W/A value read back from the register

Signature · 1 line
Damien
#4 lore raw

PATCH v2 1/1 igt/gem_workarounds: rework igt to test workaround registers

In reply to Arun Siluvery

kernel patch that exports w/a data to debugfs is reworked so update igt accordingly.

Address review comments from Damien.
- if kernel is not exposing w/a data instead of failing just skip instead.
- if the platform is not exposing w/a table then no of workarounds applied are 0, use this data to skip platform checks.

---
 tests/gem_workarounds.c | 45 +++++++++++++++++++++++----------------------
 1 file changed, 23 insertions(+), 22 deletions(-)
tests/gem_workarounds.c +23 -22
index 32156d2..18ded9a 100644
@@ -62,7 +62,7 @@ int drm_fd;
 uint32_t devid;
 static drm_intel_bufmgr *bufmgr;
 struct intel_batchbuffer *batch;
-int num_wa_regs;
+int num_wa_regs = 0;
 struct intel_wa_reg *wa_regs;
 
 
@@ -152,8 +152,7 @@ static void check_workarounds(enum operation op, int num)
 
 	igt_info("Address\tbefore\t\tafter\t\tw/a mask\tresult\n");
 	for (i = 0; i < num; ++i) {
-		status = (current_wa[i].value & current_wa[i].mask) !=
-			(wa_regs[i].value & wa_regs[i].mask);
+		status = (current_wa[i].value & wa_regs[i].mask) != wa_regs[i].value;
 		if (status)
 			++fail_count;
 
@@ -171,21 +170,15 @@ out:
 igt_main
 {
 	igt_fixture {
-		int i;
 		int fd;
 		int ret;
 		FILE *file;
 		char *line = NULL;
 		size_t line_size;
 
-		drm_fd = drm_open_any();
-
-		bufmgr = drm_intel_bufmgr_gem_init(drm_fd, 4096);
-		devid = intel_get_drm_devid(drm_fd);
-		batch = intel_batchbuffer_alloc(bufmgr, devid);
-
 		fd = igt_debugfs_open("i915_wa_registers", O_RDONLY);
-		igt_assert(fd >= 0);
+		if (fd < 0)
+			igt_skip_on("No Workaround table available !!\n");
 
 		file = fdopen(fd, "r");
 		igt_assert(file > 0);
@@ -193,32 +186,40 @@ igt_main
 		ret = getline(&line, &line_size, file);
 		igt_assert(ret > 0);
 		sscanf(line, "Workarounds applied: %d", &num_wa_regs);
-		igt_assert(num_wa_regs > 0);
 
-		wa_regs = malloc(num_wa_regs * sizeof(*wa_regs));
+		if (num_wa_regs) {
+			int i = 0;
 
-		i = 0;
-		while(getline(&line, &line_size, file) > 0) {
-			sscanf(line, "0x%X: 0x%08X, mask: 0x%08X",
-			       &wa_regs[i].addr, &wa_regs[i].value,
-			       &wa_regs[i].mask);
-			++i;
-		}
+			wa_regs = malloc(num_wa_regs * sizeof(*wa_regs));
+			while (getline(&line, &line_size, file) > 0) {
+				sscanf(line, "0x%X: 0x%08X, mask: 0x%08X",
+				       &wa_regs[i].addr, &wa_regs[i].value,
+				       &wa_regs[i].mask);
+				++i;
+			}
+		} else
+			igt_info("No workarounds exported\n");
 
 		free(line);
 		fclose(file);
 		close(fd);
+
+		drm_fd = drm_open_any();
+
+		bufmgr = drm_intel_bufmgr_gem_init(drm_fd, 4096);
+		devid = intel_get_drm_devid(drm_fd);
+		batch = intel_batchbuffer_alloc(bufmgr, devid);
 	}
 
 	igt_subtest("check-workaround-data-after-reset") {
-		if (IS_BROADWELL(devid))
+		if (num_wa_regs)
 			check_workarounds(GPU_RESET, num_wa_regs);
 		else
 			igt_skip_on("No Workaround table available!!\n");
 	}
 
 	igt_subtest("check-workaround-data-after-suspend-resume") {
-		if (IS_BROADWELL(devid))
+		if (num_wa_regs)
 			check_workarounds(SUSPEND_RESUME, num_wa_regs);
 		else
 			igt_skip_on("No Workaround table available!!\n");
Signature · 1 line
2.0.4
#5 lore raw

Re: [PATCH v2] igt/gem_workarounds: rework igt to test workaround registers

tests/gem_workarounds.c out: · line 181

Quoted 3 lines · Arun Siluvery
tests/gem_workarounds.c +2 -1
-		igt_assert(fd >= 0);
+		if (fd < 0)
+			igt_skip_on("No Workaround table available !!\n");

That's not quite a correct use of the API. The _on is there to signal the first argument is an expression. This will work only because the string is evaluated to true. You probably want to use igt_skip_on_f()

http://people.freedesktop.org/~danvet/igt/intel-gpu-tools-i-g-t-core.html#igt-skip-on-f

Quoted 18 lines
tests/gem_workarounds.c +2 -8
 		file = fdopen(fd, "r");
 		igt_assert(file > 0);
@@ -193,32 +186,40 @@ igt_main
 		ret = getline(&line, &line_size, file);
 		igt_assert(ret > 0);
 		sscanf(line, "Workarounds applied: %d", &num_wa_regs);
-		igt_assert(num_wa_regs > 0);
 
-		wa_regs = malloc(num_wa_regs * sizeof(*wa_regs));
+		if (num_wa_regs) {
+			int i = 0;
 
-		i = 0;
-		while(getline(&line, &line_size, file) > 0) {
-			sscanf(line, "0x%X: 0x%08X, mask: 0x%08X",
-			       &wa_regs[i].addr, &wa_regs[i].value,
-			       &wa_regs[i].mask);
-			++i;

tests/gem_workarounds.c igt_main · line 201

Quoted 10 lines
tests/gem_workarounds.c +9 -1
-		}
+			wa_regs = malloc(num_wa_regs * sizeof(*wa_regs));
+			while (getline(&line, &line_size, file) > 0) {
+				sscanf(line, "0x%X: 0x%08X, mask: 0x%08X",
+				       &wa_regs[i].addr, &wa_regs[i].value,
+				       &wa_regs[i].mask);
+				++i;
+			}
+		} else
+			igt_info("No workarounds exported\n");

It's a bit weird to just have an igt_info() here and skip in every single subtest after that. How about a:

  igt_skip_on_f(num_wa_regs == 0, "No workarounds exported\n");

and continue the rest of the test with the case (num_wa_regs == 0) out of the picture?

Signature · 1 line
Damien
#6 lore raw

Re: [PATCH v2] igt/gem_workarounds: rework igt to test workaround registers

Quoted 10 lines · Damien Lespiau

tests/gem_workarounds.c out: · line 181

Quoted 3 lines · Arun Siluvery
tests/gem_workarounds.c +2 -1
-		igt_assert(fd >= 0);
+		if (fd < 0)
+			igt_skip_on("No Workaround table available !!\n");

That's not quite a correct use of the API. The _on is there to signal the first argument is an expression. This will work only because the string is evaluated to true. You probably want to use igt_skip_on_f()

http://people.freedesktop.org/~danvet/igt/intel-gpu-tools-i-g-t-core.html#igt-skip-on-f

Or just igt_skip_on - we dump the expression that was tested, which should be fairly informational. At least when fd would have a better name ;-) -Daniel

Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
#7 lore raw

Re: [PATCH v2] igt/gem_workarounds: rework igt to test workaround registers

Quoted 10 lines · Daniel Vetter
Quoted 9 lines · Damien Lespiau

tests/gem_workarounds.c out: · line 181

Quoted 3 lines · Arun Siluvery
tests/gem_workarounds.c +2 -1
-		igt_assert(fd >= 0);
+		if (fd < 0)
+			igt_skip_on("No Workaround table available !!\n");

That's not quite a correct use of the API. The _on is there to signal the first argument is an expression. This will work only because the string is evaluated to true. You probably want to use igt_skip_on_f()

Quoted 4 lines
Quoted 1 line

http://people.freedesktop.org/~danvet/igt/intel-gpu-tools-i-g-t-core.html#igt-skip-on-f

Or just igt_skip_on - we dump the expression that was tested, which should be fairly informational. At least when fd would have a better name ;-)

Use igt_require(), it produces more natural phrasing in usage and output.
-Chris

Signature · 1 line
Chris Wilson, Intel Open Source Technology Centre
#8 lore raw

Re: [PATCH v2] igt/gem_workarounds: rework igt to test workaround registers

Quoted 11 lines · Chris Wilson
Quoted 10 lines · Daniel Vetter
Quoted 9 lines · Damien Lespiau

tests/gem_workarounds.c out: · line 181

Quoted 3 lines · Arun Siluvery
tests/gem_workarounds.c +2 -1
-		igt_assert(fd >= 0);
+		if (fd < 0)
+			igt_skip_on("No Workaround table available !!\n");

That's not quite a correct use of the API. The _on is there to signal the first argument is an expression. This will work only because the string is evaluated to true. You probably want to use igt_skip_on_f()

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

http://people.freedesktop.org/~danvet/igt/intel-gpu-tools-i-g-t-core.html#igt-skip-on-f

Or just igt_skip_on - we dump the expression that was tested, which should be fairly informational. At least when fd would have a better name ;-)

Use igt_require(), it produces more natural phrasing in usage and output.

Yeah, for new code I second this - we have too many macros ;-) But my practice has been to use igt_skip_on when changing existing code since I seem to be too incompetent to reliably invert boolean conditions ...

Cheers, Daniel

Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch