tests/gem_reg_read: Extend and check for valid 36b counter

Commit Message

Michał Winiarski July 16, 2015, 9:06 a.m. UTC

When reading the timestamp register with single 64b read, we're observing
invalid values on x86_64:

[f = valid counter value | X = garbage]

i386:   0x0000000fffffffff
x86_64: 0xffffffffXXXXXXXX

Test checks if the counter is moving and increasing.
Add a check to see if we can use (reg | 1) flag to get a proper 36b timestamp,
shifting the value on x86_64 if we can't.

Cc: Chris Wilson <[e-mail]>
Signed-off-by: Micha? Winiarski <[e-mail]>
---
 tests/gem_reg_read.c | 123 ++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 103 insertions(+), 20 deletions(-)

Comments

Chris Wilson July 16, 2015, 9:53 a.m. UTC | #1

On Thu, Jul 16, 2015 at 11:06:59AM +0200, Micha? Winiarski wrote:
> When reading the timestamp register with single 64b read, we're observing
> invalid values on x86_64:
> 
> [f = valid counter value | X = garbage]
> 
> i386:   0x0000000fffffffff
> x86_64: 0xffffffffXXXXXXXX
> 
> Test checks if the counter is moving and increasing.
> Add a check to see if we can use (reg | 1) flag to get a proper 36b timestamp,
> shifting the value on x86_64 if we can't.
> 
> Cc: Chris Wilson <[e-mail]>
> Signed-off-by: Micha? Winiarski <[e-mail]>
> ---

> +static bool check_timestamp(int fd)
> +{
> +	int ret;
> +	uint64_t val;
> +
> +	ret = read_register(fd, RENDER_RING_TIMESTAMP | 1, &val);
> +	if (ret != 0 && errno == EINVAL)
> +		return false;

I would have said return ret == 0; would be safer rather than only
returning false if it matched the expected error.

> +	return true;
> +}
> +
> +static uint64_t timer_query(int fd, uint64_t * val)
> +{
> +	uint64_t offset;
> +	int ret;
> +
> +	offset = RENDER_RING_TIMESTAMP;
> +	if (has_proper_timestamp)
> +		offset |= 1;
> +
> +	ret = read_register(fd, offset, val);
> +

/*
 * When reading the timestamp register with single 64b read, we're observing
 * invalid values on x86_64:
 *
 *	[f = valid counter value | X = garbage]
 *
 *	i386:   0x0000000fffffffff
 *	x86_64: 0xffffffffXXXXXXXX
 *
 * In the absence of a corrected register read ioctl, attempt
 * to fix up the return value to be vaguely useful.
 */

> +	if (is_x86_64 && !has_proper_timestamp)
> +		*val >>= 32;
>  
> -	reg_read.val = timer_query(fd);
> +	return ret;
> +}
> +
> +static void test_timestamp_monotonic(int fd)
> +{
> +	uint64_t first_val, second_val;
> +	bool retry = true;
>  
> -	igt_assert(ret != 0 && errno == EINVAL);
> +	igt_fail_on(timer_query(fd, &first_val) != 0);
>  
> +retry:
> +	sleep(1);
> +	igt_fail_on(timer_query(fd, &second_val) != 0);
> +	if (second_val <= first_val && retry) {
> +		retry = false;
> +		first_val = second_val;
> +		goto retry;
> +	}

Hmm, I expected a few more iterations for a monotonic test.

Something like:
	start = gettime();
	first_val = timer_query(fd);
	do {
		second_val = timer_query(fd);
		igt_assert_gte(second_val, first_val);
		first_val = second_val;
		
		elapsed = getreltime(&start);
	} while (elapsed < 5);
> +
> +	igt_assert(second_val > first_val);
> +}
> +
> +igt_main
> +{
> +	uint64_t val = 0;
> +	int fd = -1;
> +
> +	fd = drm_open_any();
> +	is_x86_64 = check_kernel_x86_64();
> +	has_proper_timestamp = check_timestamp(fd);
>  	close(fd);

Just do this in the fixture I guess.

> +
> +	igt_fixture {
> +		fd = drm_open_any();
> +	}
-Chris

Patch

diff --git a/tests/gem_reg_read.c b/tests/gem_reg_read.c
index d3e68d9..ba12fb1 100644
--- a/tests/gem_reg_read.c
+++ b/tests/gem_reg_read.c
@@ -28,10 +28,14 @@ 
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
+#include <sys/utsname.h>
 
 #include "ioctl_wrappers.h"
 #include "drmtest.h"
 
+static bool is_x86_64;
+static bool has_proper_timestamp;
+
 struct local_drm_i915_reg_read {
 	__u64 offset;
 	__u64 val; /* Return value */
@@ -39,39 +43,118 @@  struct local_drm_i915_reg_read {
 
 #define REG_READ_IOCTL DRM_IOWR(DRM_COMMAND_BASE + 0x31, struct local_drm_i915_reg_read)
 
-static uint64_t timer_query(int fd)
+#define RENDER_RING_TIMESTAMP 0x2358
+
+static int read_register(int fd, uint64_t offset, uint64_t * val)
 {
+	int ret;
 	struct local_drm_i915_reg_read reg_read;
+	reg_read.offset = offset;
 
-	reg_read.offset = 0x2358;
-	igt_fail_on_f(drmIoctl(fd, REG_READ_IOCTL, &reg_read),
-		      "positive test case failed: ");
+	ret = drmIoctl(fd, REG_READ_IOCTL, &reg_read);
 
-	return reg_read.val;
+	*val = reg_read.val;
+
+	return ret;
 }
 
-igt_simple_main
+static bool check_kernel_x86_64(void)
 {
-	struct local_drm_i915_reg_read reg_read;
-	int fd, ret;
+	int ret;
+	struct utsname uts;
 
-	fd = drm_open_any();
+	ret = uname(&uts);
+	igt_assert(ret == 0);
 
-	reg_read.offset = 0x2358;
-	ret = drmIoctl(fd, REG_READ_IOCTL, &reg_read);
-	igt_assert(ret == 0 || errno == EINVAL);
-	igt_require(ret == 0);
+	if (!strcmp(uts.machine, "x86_64"))
+		return true;
+
+	return false;
+}
+
+static bool check_timestamp(int fd)
+{
+	int ret;
+	uint64_t val;
+
+	ret = read_register(fd, RENDER_RING_TIMESTAMP | 1, &val);
+	if (ret != 0 && errno == EINVAL)
+		return false;
+
+	return true;
+}
+
+static uint64_t timer_query(int fd, uint64_t * val)
+{
+	uint64_t offset;
+	int ret;
+
+	offset = RENDER_RING_TIMESTAMP;
+	if (has_proper_timestamp)
+		offset |= 1;
+
+	ret = read_register(fd, offset, val);
+
+	if (is_x86_64 && !has_proper_timestamp)
+		*val >>= 32;
 
-	reg_read.val = timer_query(fd);
+	return ret;
+}
+
+static void test_timestamp_moving(int fd)
+{
+	uint64_t first_val, second_val;
+
+	igt_fail_on(timer_query(fd, &first_val) != 0);
 	sleep(1);
-	/* Check that timer is moving and isn't busted. */
-	igt_assert(timer_query(fd) != reg_read.val);
+	igt_fail_on(timer_query(fd, &second_val) != 0);
+	igt_assert(second_val != first_val);
+}
 
-	/* bad reg */
-	reg_read.offset = 0x12345678;
-	ret = drmIoctl(fd, REG_READ_IOCTL, &reg_read);
+static void test_timestamp_monotonic(int fd)
+{
+	uint64_t first_val, second_val;
+	bool retry = true;
 
-	igt_assert(ret != 0 && errno == EINVAL);
+	igt_fail_on(timer_query(fd, &first_val) != 0);
 
+retry:
+	sleep(1);
+	igt_fail_on(timer_query(fd, &second_val) != 0);
+	if (second_val <= first_val && retry) {
+		retry = false;
+		first_val = second_val;
+		goto retry;
+	}
+
+	igt_assert(second_val > first_val);
+}
+
+igt_main
+{
+	uint64_t val = 0;
+	int fd = -1;
+
+	fd = drm_open_any();
+	is_x86_64 = check_kernel_x86_64();
+	has_proper_timestamp = check_timestamp(fd);
 	close(fd);
+
+	igt_fixture {
+		fd = drm_open_any();
+	}
+
+	igt_subtest("bad-register")
+		igt_assert(read_register(fd, 0x12345678, &val) == -1 &&
+				errno == EINVAL);
+
+	igt_subtest("timestamp-moving")
+		test_timestamp_moving(fd);
+
+	igt_subtest("timestamp-monotonic")
+		test_timestamp_monotonic(fd);
+
+	igt_fixture {
+		close(fd);
+	}
 }