Skip to contentSkip to conversation

tests/gem_exec_pad_to_size: Test object padding at execbuf

RFC Superseded Tvrtko Ursulin 3 participants 22 messages Mar 25, 2015 – Apr 2, 2015

lore
Share & tools
lore
#0 lore raw

RFC 1/1 tests/gem_exec_pad_to_size: Test object padding at execbuf

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

It uses the fact DRM allocation policy is set as ABI and allocates space in order. That means that we should be able to easily get two bos mapped at adjacent GTT addresses and then test that the pad to size flag will move them apart.

---
 tests/Makefile.sources       |   1 +
 tests/gem_exec_pad_to_size.c | 276 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 277 insertions(+)
 create mode 100644 tests/gem_exec_pad_to_size.c
tests/Makefile.sources +1 -0
index a165978..e8b212a 100644
@@ -33,6 +33,7 @@ TESTS_progs_M = \
 	gem_exec_bad_domains \
 	gem_exec_faulting_reloc \
 	gem_exec_nop \
+	gem_exec_pad_to_size \
 	gem_exec_params \
 	gem_exec_parse \
 	gem_fenced_exec_thrash \
tests/gem_exec_pad_to_size.c new file +276 -0

276 lines not on this page · raw message

Signature · 6 lines
2.3.2

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#1 lore raw
Quoted 6 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

It uses the fact DRM allocation policy is set as ABI and allocates space in order.

Ssh. That's not what I meant to say. I meant that the policy is not ABI, and we abuse our internal knowledge to get a working test, as we do elsewhere in igt.

Quoted 17 lines

That means that we should be able to easily get
two bos mapped at adjacent GTT addresses and then test that the pad to size flag will move them apart.

tests/gem_exec_pad_to_size.c new file +13 -0
+	/* Try to get two buffer object next to each other in GTT space. */
+	for (try = 0, idx = 0; try < max_tries;) {
+		eb_handles[0] = handles[0];
+		eb_handles[1] = loc_handles[idx];
+		eb_handles[2] = loc_handles[idx + 1];
+
+		igt_assert(exec(fd, eb_handles, (uint32_t[2]){0, 0},
+				offsets) == 0);
+
+		if (offsets[1] > offsets[0]) {
+			distance = offsets[1] - offsets[0];
+			if (distance == PAGE_SIZE)
+				neighbours = true;

tests/gem_exec_pad_to_size.c line 208

Quoted 10 lines
tests/gem_exec_pad_to_size.c new file +10 -0
+			pad_to_size[0] = ALIGN(distance + PAGE_SIZE, PAGE_SIZE);
+		} else {
+			distance = offsets[0] - offsets[1];
+			if (distance == PAGE_SIZE)
+				neighbours = true;
+			pad_to_size[1] = ALIGN(distance + PAGE_SIZE, PAGE_SIZE);
+		}
+
+		if (neighbours)
+			break;

What's important to make this trick work is to allocate new handles every time. That way we fill up the GTT and thereby hope to skip over the fragmented part.
-Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#2 lore raw
Quoted 11 lines · Chris Wilson
Quoted 6 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

It uses the fact DRM allocation policy is set as ABI and allocates space in order.

Ssh. That's not what I meant to say. I meant that the policy is not ABI, and we abuse our internal knowledge to get a working test, as we do elsewhere in igt.

Ah, OK. :)

Quoted 23 lines
Quoted 23 lines

That means that we should be able to easily get
two bos mapped at adjacent GTT addresses and then test that the pad to size flag will move them apart.

tests/gem_exec_pad_to_size.c new file +19 -0
+	/* Try to get two buffer object next to each other in GTT space. */
+	for (try = 0, idx = 0; try < max_tries;) {
+		eb_handles[0] = handles[0];
+		eb_handles[1] = loc_handles[idx];
+		eb_handles[2] = loc_handles[idx + 1];
+
+		igt_assert(exec(fd, eb_handles, (uint32_t[2]){0, 0},
+				offsets) == 0);
+
+		if (offsets[1] > offsets[0]) {
+			distance = offsets[1] - offsets[0];
+			if (distance == PAGE_SIZE)
+				neighbours = true;
+			pad_to_size[0] = ALIGN(distance + PAGE_SIZE, PAGE_SIZE);
+		} else {
+			distance = offsets[0] - offsets[1];
+			if (distance == PAGE_SIZE)
+				neighbours = true;
+			pad_to_size[1] = ALIGN(distance + PAGE_SIZE, PAGE_SIZE);
Quoted 8 lines

tests/gem_exec_pad_to_size.c line 208

Quoted 4 lines
tests/gem_exec_pad_to_size.c new file +4 -0
+		}
+
+		if (neighbours)
+			break;

What's important to make this trick work is to allocate new handles every time. That way we fill up the GTT and thereby hope to skip over the fragmented part.

It does do that!

Only perhaps I need to make sure they are kept bound so maybe keep them mapped or something while trying new ones?

Regards,

Tvrtko

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#3 lore raw
Quoted 7 lines · Tvrtko Ursulin
Quoted 3 lines · Chris Wilson

What's important to make this trick work is to allocate new handles every time. That way we fill up the GTT and thereby hope to skip over the fragmented part.

It does do that!

I was just looking for some filler for the email!

Quoted 2 lines

Only perhaps I need to make sure they are kept bound so maybe keep them mapped or something while trying new ones?

What I was expecting to see were gem_create()s every loop. I only feel confident in say that a pair of freshly allocated and bound objects are likely to line up against each other (so long as space is not fragmented).

I would allocate a new device fd for the test, leak the individual handles on every try, then close the fd at the end of the test to avoid having to track all the allocations. That's the pattern I was looking for when I skimmed over your test.
-Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#4 lore raw
Quoted 10 lines · Chris Wilson
Quoted 7 lines · Tvrtko Ursulin
Quoted 3 lines · Chris Wilson

What's important to make this trick work is to allocate new handles every time. That way we fill up the GTT and thereby hope to skip over the fragmented part.

It does do that!

I was just looking for some filler for the email!

Try Reviewed-by? :D

Quoted 8 lines
Quoted 2 lines

Only perhaps I need to make sure they are kept bound so maybe keep them mapped or something while trying new ones?

What I was expecting to see were gem_create()s every loop. I only feel confident in say that a pair of freshly allocated and bound objects are likely to line up against each other (so long as space is not fragmented).

Quoted 4 lines

I would allocate a new device fd for the test, leak the individual handles on every try, then close the fd at the end of the test to avoid having to track all the allocations. That's the pattern I was looking for when I skimmed over your test.

Apart from reusing the fd, tracking the handles and allocating on all loops but the first one when it re-uses the passed in ones, it is exactly like that! :)

So far it always manages to get neighbouring BOs on my system on first try. Which is probably not unexpected since is is PPGTT.

One thing I wasn't sure about is max_tries = 1024. That will be 8MB of filling to avoid fragmentation. Will that be enough on GGTT systems?

Regards,

Tvrtko
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#5 lore raw

RFC v2 1/1 tests/gem_exec_pad_to_size: Test object padding at execbuf

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

Similar to some other tests, it uses knowledge of the DRM allocation policy in order to get two objects mapped adjacent to each other. It is then possible to verify that the pad to size flag will move them apart.

v2: Correct commit message. (Chris Wilson)

---
 tests/Makefile.sources       |   1 +
 tests/gem_exec_pad_to_size.c | 276 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 277 insertions(+)
 create mode 100644 tests/gem_exec_pad_to_size.c
tests/Makefile.sources +1 -0
index 0a974a6..5f21728 100644
@@ -34,6 +34,7 @@ TESTS_progs_M = \
 	gem_exec_bad_domains \
 	gem_exec_faulting_reloc \
 	gem_exec_nop \
+	gem_exec_pad_to_size \
 	gem_exec_params \
 	gem_exec_parse \
 	gem_fenced_exec_thrash \
tests/gem_exec_pad_to_size.c new file +276 -0

276 lines not on this page · raw message

Signature · 6 lines
2.3.2

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#6 lore raw
Quoted 4 lines · Tvrtko Ursulin
tests/gem_exec_pad_to_size.c new file +4 -0
+static int
+exec(int fd, uint32_t handles[3], uint32_t pad_to_size[2], uint64_t *offsets)
+{
+	struct drm_i915_gem_execbuffer2 execbuf;

tests/gem_exec_pad_to_size.c line 97

Quoted 10 lines
tests/gem_exec_pad_to_size.c new file +10 -0
+	struct local_drm_i915_gem_exec_object2 gem_exec[3];
+	int ret = 0;
+
+	memset(gem_exec, 0, sizeof(gem_exec));
+
+	gem_exec[0].handle = handles[1];
+	gem_exec[0].relocation_count = 0;
+	gem_exec[0].relocs_ptr = 0;
+	gem_exec[0].alignment = 0;
+	gem_exec[0].offset = 0;

Ignore the unused fields (they are explicitly memset(0)) so that we can focus on the important ones under test.

tests/gem_exec_pad_to_size.c line 102

Quoted 4 lines
tests/gem_exec_pad_to_size.c new file +4 -0
+	gem_exec[0].flags = pad_to_size[0] ?
+			    LOCAL_EXEC_OBJECT_PAD_TO_SIZE : 0;
+	gem_exec[0].pad_to_size = pad_to_size[0];
+

memset(execbuf) and skip boring fields

tests/gem_exec_pad_to_size.c line 130

Quoted 5 lines
tests/gem_exec_pad_to_size.c new file +5 -0
+	execbuf.buffers_ptr = (uintptr_t)gem_exec;
+	execbuf.buffer_count = 3;
+	execbuf.batch_start_offset = 0;
+	execbuf.batch_len = 8;
+	execbuf.flags = I915_EXEC_RENDER;

This can be just I915_EXEC_DEFAULT (i.e. 0);

tests/gem_exec_pad_to_size.c line 138

Quoted 5 lines
tests/gem_exec_pad_to_size.c new file +4 -0
+	if (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf))
+			ret = -errno;
 
+	if (ret == 0) {
+		gem_sync(fd, handles[0]);

Not required for this test. However... You probably want to do the gem_sync() first. (Yes, there is an amusing reason to do :)

Quoted 37 lines
tests/gem_exec_pad_to_size.c new file +37 -0
+		if (offsets) {
+			offsets[0] = gem_exec[0].offset;
+			offsets[1] = gem_exec[1].offset;
+		}
+	}
+
+	return ret;
+}
+
+static void
+require_pad_to_size(int fd, uint32_t handles[3])
+{
+	igt_require(exec(fd, handles, (uint32_t[2]){ PAGE_SIZE, PAGE_SIZE },
+			 NULL) == 0);
+}
+
+static void
+not_aligned(int fd, uint32_t handles[3])
+{
+	require_pad_to_size(fd, handles);
+
+	igt_require(exec(fd, handles, (uint32_t[2]){1 ,1},
+			 NULL) == -EINVAL);
+}
+
+static void
+padding(int fd, uint32_t handles[3])
+{
+	uint32_t pad_to_size[2] = {0, 0};
+	uint64_t offsets[2];
+	uint32_t distance;
+	bool neighbours = false;
+	unsigned int try, idx;
+	const unsigned int max_tries = 1024; /* Finger in the air. */
+	uint32_t *loc_handles;
+	uint32_t eb_handles[3];
+

tests/gem_exec_pad_to_size.c line 186

Quoted 10 lines
tests/gem_exec_pad_to_size.c new file +10 -0
+	require_pad_to_size(fd, handles);
+
+	loc_handles = calloc(max_tries * 2, sizeof(uint32_t));
+	igt_assert(loc_handles);
+
+	/* Try with passed in handles first. */
+	loc_handles[0] = handles[1];
+	loc_handles[1] = handles[2];
+
+	/* Try to get two buffer object next to each other in GTT space. */

/* Try to get two buffer object next to each other in GTT space.
* We presume that sequential reservations are likely to be aligned and
* try until we find a pair that is.
*/

Quoted 15 lines
tests/gem_exec_pad_to_size.c new file +15 -0
+	for (try = 0, idx = 0; try < max_tries;) {
+		eb_handles[0] = handles[0];
+		eb_handles[1] = loc_handles[idx];
+		eb_handles[2] = loc_handles[idx + 1];
+
+		igt_assert(exec(fd, eb_handles, (uint32_t[2]){0, 0},
+				offsets) == 0);
+
+		if (offsets[1] > offsets[0]) {
+			distance = offsets[1] - offsets[0];
+			if (distance == PAGE_SIZE)
+				neighbours = true;
+			pad_to_size[0] = ALIGN(distance + PAGE_SIZE, PAGE_SIZE);
+		} else {
+			distance = offsets[0] - offsets[1];

tests/gem_exec_pad_to_size.c line 211

Quoted 10 lines
tests/gem_exec_pad_to_size.c new file +10 -0
+			if (distance == PAGE_SIZE)
+				neighbours = true;
+			pad_to_size[1] = ALIGN(distance + PAGE_SIZE, PAGE_SIZE);
+		}
+
+		if (neighbours)
+			break;
+
+		try++;
+		idx +=2;

Just use idx++ here and allocate a new handle one at a time. Just as likely to be adjacent to the previous handle as the next one will be to us. For extra paranoia, you could even try an evict-everything pass :)

Otherwise looks fine.
-Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#7 lore raw
Quoted 3 lines · Chris Wilson

Just use idx++ here and allocate a new handle one at a time. Just as likely to be adjacent to the previous handle as the next one will be to us. For extra paranoia, you could even try an evict-everything pass :)

Which is as easy as igt_drop_caches_set(DROP_ALL); -Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#8 lore raw
In reply to Chris Wilson
Quoted 8 lines · Chris Wilson

tests/gem_exec_pad_to_size.c line 138

Quoted 5 lines · Tvrtko Ursulin
tests/gem_exec_pad_to_size.c new file +4 -0
+	if (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf))
+			ret = -errno;
 
+	if (ret == 0) {
+		gem_sync(fd, handles[0]);

Not required for this test. However... You probably want to do the gem_sync() first. (Yes, there is an amusing reason to do :)

What reason is that and what do you mean by "first"?

Quoted 20 lines
Quoted 20 lines
tests/gem_exec_pad_to_size.c new file +20 -0
+	for (try = 0, idx = 0; try < max_tries;) {
+		eb_handles[0] = handles[0];
+		eb_handles[1] = loc_handles[idx];
+		eb_handles[2] = loc_handles[idx + 1];
+
+		igt_assert(exec(fd, eb_handles, (uint32_t[2]){0, 0},
+				offsets) == 0);
+
+		if (offsets[1] > offsets[0]) {
+			distance = offsets[1] - offsets[0];
+			if (distance == PAGE_SIZE)
+				neighbours = true;
+			pad_to_size[0] = ALIGN(distance + PAGE_SIZE, PAGE_SIZE);
+		} else {
+			distance = offsets[0] - offsets[1];
+			if (distance == PAGE_SIZE)
+				neighbours = true;
+			pad_to_size[1] = ALIGN(distance + PAGE_SIZE, PAGE_SIZE);
+		}
+
Quoted 8 lines

tests/gem_exec_pad_to_size.c line 211

Quoted 5 lines
tests/gem_exec_pad_to_size.c new file +5 -0
+		if (neighbours)
+			break;
+
+		try++;
+		idx +=2;

Just use idx++ here and allocate a new handle one at a time. Just as likely to be adjacent to the previous handle as the next one will be to

Ah yes, didn't think of that!

Quoted 1 line

us. For extra paranoia, you could even try an evict-everything pass :)

You mean if the lightweight approach fails? Ok.

Regards,

Tvrtko
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#9 lore raw
Quoted 6 lines · Tvrtko Ursulin
Quoted 4 lines · Chris Wilson
Quoted 2 lines · Tvrtko Ursulin
tests/gem_exec_pad_to_size.c new file +2 -0
+	if (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf))
+			ret = -errno;
Quoted 6 lines
Quoted 4 lines

tests/gem_exec_pad_to_size.c line 138

Quoted 2 lines
tests/gem_exec_pad_to_size.c new file +2 -0
+	if (ret == 0) {
+		gem_sync(fd, handles[0]);

Not required for this test. However... You probably want to do the gem_sync() first. (Yes, there is an amusing reason to do :)

What reason is that and what do you mean by "first"?

When calling the test multiple times successive passes will have a busy batch, which could conceivably cause the relocations to fail, and the returned offsets to be -1. Calling gem_sync() before execbuf prevents that slowpath from affecting the test, without people wondering whether you need to call gem_sync() before the returned array is valid (which is why I did a double take here trying to work out what you meant the gem_sync() to do).

Quoted 8 lines
Quoted 2 lines

Just use idx++ here and allocate a new handle one at a time. Just as likely to be adjacent to the previous handle as the next one will be to

Ah yes, didn't think of that!

Quoted 1 line

us. For extra paranoia, you could even try an evict-everything pass :)

You mean if the lightweight approach fails? Ok.

Calling igt_drop_caches_set() is reasonable enough to in the preamble. -Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#10 lore raw
Quoted 14 lines · Chris Wilson
Quoted 6 lines · Tvrtko Ursulin
Quoted 4 lines · Chris Wilson
Quoted 2 lines · Tvrtko Ursulin
tests/gem_exec_pad_to_size.c new file +2 -0
+	if (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf))
+			ret = -errno;
Quoted 6 lines
Quoted 4 lines

tests/gem_exec_pad_to_size.c line 138

Quoted 2 lines
tests/gem_exec_pad_to_size.c new file +2 -0
+	if (ret == 0) {
+		gem_sync(fd, handles[0]);

Not required for this test. However... You probably want to do the gem_sync() first. (Yes, there is an amusing reason to do :)

What reason is that and what do you mean by "first"?

Quoted 7 lines

When calling the test multiple times successive passes will have a busy batch, which could conceivably cause the relocations to fail, and the returned offsets to be -1. Calling gem_sync() before execbuf prevents that slowpath from affecting the test, without people wondering whether you need to call gem_sync() before the returned array is valid (which is why I did a double take here trying to work out what you meant the gem_sync() to do).

How it may be busy if gem_sync after execbuf is supposed to wait until batch has been retired?

Regards,

Tvrtko
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#11 lore raw
Quoted 24 lines · Tvrtko Ursulin
Quoted 14 lines · Chris Wilson
Quoted 6 lines · Tvrtko Ursulin
Quoted 4 lines · Chris Wilson
Quoted 2 lines · Tvrtko Ursulin
tests/gem_exec_pad_to_size.c new file +2 -0
+	if (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf))
+			ret = -errno;
Quoted 6 lines
Quoted 4 lines

tests/gem_exec_pad_to_size.c line 138

Quoted 2 lines
tests/gem_exec_pad_to_size.c new file +2 -0
+	if (ret == 0) {
+		gem_sync(fd, handles[0]);

Not required for this test. However... You probably want to do the gem_sync() first. (Yes, there is an amusing reason to do :)

What reason is that and what do you mean by "first"?

Quoted 7 lines

When calling the test multiple times successive passes will have a busy batch, which could conceivably cause the relocations to fail, and the returned offsets to be -1. Calling gem_sync() before execbuf prevents that slowpath from affecting the test, without people wondering whether you need to call gem_sync() before the returned array is valid (which is why I did a double take here trying to work out what you meant the gem_sync() to do).

Quoted 2 lines

How it may be busy if gem_sync after execbuf is supposed to wait until batch has been retired?

It's not. I am trying to say that the placement of gem_sync() here suggests to me that you thought it was required to get valid offsets after an execbuf call. But in actualilty you do not need a gem_sync() in this test at all as you are not doing relocations.
-Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#12 lore raw

RFC v3 1/1 tests/gem_exec_pad_to_size: Test object padding at execbuf

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

Similar to some other tests, it uses knowledge of the DRM allocation policy in order to get two objects mapped adjacent to each other. It is then possible to verify that the pad to size flag will move them apart.

v2: Correct commit message. (Chris Wilson)
v3: Changes after code review by Chris Wilson.
* No need for gem_sync after execbuf.
* Drop caches before running.
* Allocate one additional bo per iteration.
* Don't explicitly set unused execbuf fields to zero.
* One improved comment.

---
 tests/Makefile.sources       |   1 +
 tests/gem_exec_pad_to_size.c | 252 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 253 insertions(+)
 create mode 100644 tests/gem_exec_pad_to_size.c
tests/Makefile.sources +1 -0
index 0a974a6..5f21728 100644
@@ -34,6 +34,7 @@ TESTS_progs_M = \
 	gem_exec_bad_domains \
 	gem_exec_faulting_reloc \
 	gem_exec_nop \
+	gem_exec_pad_to_size \
 	gem_exec_params \
 	gem_exec_parse \
 	gem_fenced_exec_thrash \
tests/gem_exec_pad_to_size.c new file +252 -0

252 lines not on this page · raw message

Signature · 6 lines
2.3.2

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#13 lore raw
Quoted 9 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

Similar to some other tests, it uses knowledge of the DRM allocation policy in order to get two objects mapped adjacent to each other. It is then possible to verify that the pad to size flag will move them apart.

Quoted 7 lines

v2: Correct commit message. (Chris Wilson)
v3: Changes after code review by Chris Wilson.
* No need for gem_sync after execbuf.
* Drop caches before running.
* Allocate one additional bo per iteration.
* Don't explicitly set unused execbuf fields to zero.
* One improved comment.

Ah, sorry to be a nuisance, I'm getting to the actual test finally!

tests/gem_exec_pad_to_size.c line 200

Quoted 2 lines
tests/gem_exec_pad_to_size.c new file +2 -0
+	/* Re-exec with padding set. */
+	igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);

The crux of the test is that we generate two objects such that

B_offset = A_offset + A_size

and then tell the kernel that A is actually 2*size (A_pad_to_size)

tests/gem_exec_pad_to_size.c line 205

Quoted 4 lines
tests/gem_exec_pad_to_size.c new file +4 -0
+	if (offsets[1] > offsets[0])
+		distance = offsets[1] - offsets[0];
+	else
+		distance = offsets[0] - offsets[1];

The assertion I feel should only be that

B_offset + B_size <= A_offset && B_offset >= A_offset + A_pad_to_size

i.e. that they are now disjoint.

Your test is valid nevertheless, it is the ordering of the objects that is confusing.

Hmm, can you loop until B_offset == A_offset + A_size such that we don't have the confusion with order? And even assert that A_offset is unchanged (though that smells like a little to much internal knowledge leaking through, it is a desirable property of the allocator though - no unnecessarily eviction) afterwards.

Do you agree that losing the handling of negative distances will make the test simpler to understand (at the expense of doing more work in the setup)?
-Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#14 lore raw
Quoted 10 lines · Chris Wilson

tests/gem_exec_pad_to_size.c line 200

Quoted 2 lines · Tvrtko Ursulin
tests/gem_exec_pad_to_size.c new file +2 -0
+	/* Re-exec with padding set. */
+	igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);

The crux of the test is that we generate two objects such that

B_offset = A_offset + A_size

and then tell the kernel that A is actually 2*size (A_pad_to_size)

Quoted 8 lines

tests/gem_exec_pad_to_size.c line 205

Quoted 4 lines
tests/gem_exec_pad_to_size.c new file +4 -0
+	if (offsets[1] > offsets[0])
+		distance = offsets[1] - offsets[0];
+	else
+		distance = offsets[0] - offsets[1];

The assertion I feel should only be that

B_offset + B_size <= A_offset && B_offset >= A_offset + A_pad_to_size

I don't get this. B starts after A + padding, but B ends before A?

Quoted 11 lines

i.e. that they are now disjoint.

Your test is valid nevertheless, it is the ordering of the objects that is confusing.

Hmm, can you loop until B_offset == A_offset + A_size such that we don't have the confusion with order? And even assert that A_offset is unchanged (though that smells like a little to much internal knowledge leaking through, it is a desirable property of the allocator though - no unnecessarily eviction) afterwards.

Quoted 3 lines

Do you agree that losing the handling of negative distances will make the test simpler to understand (at the expense of doing more work in the setup)?

I thought my test logic is pretty straightforward:

1. Find two objects next to each other.
2. Add padding on the "lower" (addressed) object.
3. Ensure objects are now apart at least what the padding is.

Regards,

Tvrtko
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#15 lore raw
Quoted 19 lines · Tvrtko Ursulin
Quoted 17 lines · Chris Wilson

tests/gem_exec_pad_to_size.c line 200

Quoted 2 lines · Tvrtko Ursulin
tests/gem_exec_pad_to_size.c new file +2 -0
+	/* Re-exec with padding set. */
+	igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);

The crux of the test is that we generate two objects such that

B_offset = A_offset + A_size

and then tell the kernel that A is actually 2*size (A_pad_to_size)

tests/gem_exec_pad_to_size.c line 205

Quoted 4 lines
tests/gem_exec_pad_to_size.c new file +4 -0
+	if (offsets[1] > offsets[0])
+		distance = offsets[1] - offsets[0];
+	else
+		distance = offsets[0] - offsets[1];

The assertion I feel should only be that

Quoted 3 lines
Quoted 1 line

B_offset + B_size <= A_offset && B_offset >= A_offset + A_pad_to_size

I don't get this. B starts after A + padding, but B ends before A?

s/&&/||/

Quoted 15 lines
Quoted 11 lines

i.e. that they are now disjoint.

Your test is valid nevertheless, it is the ordering of the objects that is confusing.

Hmm, can you loop until B_offset == A_offset + A_size such that we don't have the confusion with order? And even assert that A_offset is unchanged (though that smells like a little to much internal knowledge leaking through, it is a desirable property of the allocator though - no unnecessarily eviction) afterwards.

Quoted 3 lines

Do you agree that losing the handling of negative distances will make the test simpler to understand (at the expense of doing more work in the setup)?

Quoted 5 lines

I thought my test logic is pretty straightforward:

1. Find two objects next to each other.
2. Add padding on the "lower" (addressed) object.
3. Ensure objects are now apart at least what the padding is.

What should happen is:

Initial layout:

|    ||aa||bb|
batch A   B

(B_offset == A_offset + PAGE)

We then submit an execbuf with A_pad_to_size = 2*PAGE, the kernel will unbind A, keep B, then bind A (given an empty GTT):

|    |xxxx|bb||aaaaaa|
batch      B  A

but the distance here is just 1 PAGE. Then if B_pad_to_size is set to 2*PAGE:

|    |xxxxxxxx|aaaaaa||bbbbbb|
batch         A       B

If both are initially set to pad_to_size = 2*PAGE, we should see something like:

|    ||aaaaaa||bbbbbb|
batch A       B

Given that the assertion should just be that the new objects do not overlap assuming their size is now pad_to_size.
-Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#16 lore raw
Quoted 20 lines · Chris Wilson
Quoted 19 lines · Tvrtko Ursulin
Quoted 17 lines · Chris Wilson

tests/gem_exec_pad_to_size.c line 200

Quoted 2 lines · Tvrtko Ursulin
tests/gem_exec_pad_to_size.c new file +2 -0
+	/* Re-exec with padding set. */
+	igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);

The crux of the test is that we generate two objects such that

B_offset = A_offset + A_size

and then tell the kernel that A is actually 2*size (A_pad_to_size)

tests/gem_exec_pad_to_size.c line 205

Quoted 4 lines
tests/gem_exec_pad_to_size.c new file +4 -0
+	if (offsets[1] > offsets[0])
+		distance = offsets[1] - offsets[0];
+	else
+		distance = offsets[0] - offsets[1];

The assertion I feel should only be that

Quoted 5 lines
Quoted 3 lines
Quoted 1 line

B_offset + B_size <= A_offset && B_offset >= A_offset + A_pad_to_size

I don't get this. B starts after A + padding, but B ends before A?

s/&&/||/

Sorry &&. Gah, must be time for a coffee break.

The assertion is that the objects do not overlap based on the pad_to_size we expect the kernel to apply, rather than their natural size. If the kernel doesn't move the objects, they would it would fail. -Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#17 lore raw
Quoted 25 lines · Chris Wilson
Quoted 24 lines · Chris Wilson
Quoted 22 lines · Tvrtko Ursulin
Quoted 10 lines · Chris Wilson

tests/gem_exec_pad_to_size.c line 200

Quoted 2 lines · Tvrtko Ursulin
tests/gem_exec_pad_to_size.c new file +2 -0
+	/* Re-exec with padding set. */
+	igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);

The crux of the test is that we generate two objects such that

B_offset = A_offset + A_size

and then tell the kernel that A is actually 2*size (A_pad_to_size)

Quoted 8 lines

tests/gem_exec_pad_to_size.c line 205

Quoted 4 lines
tests/gem_exec_pad_to_size.c new file +4 -0
+	if (offsets[1] > offsets[0])
+		distance = offsets[1] - offsets[0];
+	else
+		distance = offsets[0] - offsets[1];

The assertion I feel should only be that

B_offset + B_size <= A_offset && B_offset >= A_offset + A_pad_to_size

I don't get this. B starts after A + padding, but B ends before A?

Quoted 7 lines
Quoted 1 line

s/&&/||/

Sorry &&. Gah, must be time for a coffee break.

The assertion is that the objects do not overlap based on the pad_to_size we expect the kernel to apply, rather than their natural size. If the kernel doesn't move the objects, they would it would fail.

You know all this time I didn't realize you were saying me check was broken, just that it was confusing. :)

Regards,

Tvrtko
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#18 lore raw

RFC v4 1/1 tests/gem_exec_pad_to_size: Test object padding at execbuf

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

Similar to some other tests, it uses knowledge of the DRM allocation policy in order to get two objects mapped adjacent to each other. It is then possible to verify that the pad to size flag will move them apart.

v2: Correct commit message. (Chris Wilson)
v3: Changes after code review by Chris Wilson.
* No need for gem_sync after execbuf.
* Drop caches before running.
* Allocate one additional bo per iteration.
* Don't explicitly set unused execbuf fields to zero.
* One improved comment.
v4: Require simpler object ordering and fixed overlap test. (Chris Wilson)

---
 tests/Makefile.sources       |   1 +
 tests/gem_exec_pad_to_size.c | 236 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 237 insertions(+)
 create mode 100644 tests/gem_exec_pad_to_size.c
tests/Makefile.sources +1 -0
index 0a974a6..5f21728 100644
@@ -34,6 +34,7 @@ TESTS_progs_M = \
 	gem_exec_bad_domains \
 	gem_exec_faulting_reloc \
 	gem_exec_nop \
+	gem_exec_pad_to_size \
 	gem_exec_params \
 	gem_exec_parse \
 	gem_fenced_exec_thrash \
tests/gem_exec_pad_to_size.c new file +236 -0

236 lines not on this page · raw message

Signature · 6 lines
2.3.2

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Reviewed-by on v4 1/1
#19 lore raw
Quoted 18 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

Similar to some other tests, it uses knowledge of the DRM allocation policy in order to get two objects mapped adjacent to each other. It is then possible to verify that the pad to size flag will move them apart.

v2: Correct commit message. (Chris Wilson)
v3: Changes after code review by Chris Wilson.
* No need for gem_sync after execbuf.
* Drop caches before running.
* Allocate one additional bo per iteration.
* Don't explicitly set unused execbuf fields to zero.
* One improved comment.
v4: Require simpler object ordering and fixed overlap test. (Chris Wilson)

Quoted 2 lines

Thanks, that reads really well.

Hah, just thought of one minor tweak I would do though:

		if ((offsets[1] - offsets[0]) == PAGE_SIZE) {
			neighbours = true;
			break;
		}
		....
	}

	/* Otherwise test can't confidently run. */
	if (neighbours) {
		/* Check the object don't move by themselves */
		igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);
		igt_assert(offsets[1] - offset[0] == PAGE_SIZE);

		/* Then re-exec with padding set, and now they should move. */
		pad_to_size[0] = 2*PAGE_SIZE;
		igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);

		/* Check that objects with padding do not overlap. */
		igt_assert(offsets[0] >= offsets[1] + PAGE_SIZE ||
			   offsets[0] + 2 * PAGE_SIZE <= offsets[1]);
	}

-Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#20 lore raw

RFC v5 1/1 tests/gem_exec_pad_to_size: Test object padding at execbuf

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

Similar to some other tests, it uses knowledge of the DRM allocation policy in order to get two objects mapped adjacent to each other. It is then possible to verify that the pad to size flag will move them apart.

v2: Correct commit message. (Chris Wilson)
v3: Changes after code review by Chris Wilson.
* No need for gem_sync after execbuf.
* Drop caches before running.
* Allocate one additional bo per iteration.
* Don't explicitly set unused execbuf fields to zero.
* One improved comment.
v4: Require simpler object ordering and fixed overlap test. (Chris Wilson)
v5: Check unpadded offsets once more before padding. (Chris Wilson)

---
 tests/Makefile.sources       |   1 +
 tests/gem_exec_pad_to_size.c | 240 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 241 insertions(+)
 create mode 100644 tests/gem_exec_pad_to_size.c
tests/Makefile.sources +1 -0
index 0a974a6..5f21728 100644
@@ -34,6 +34,7 @@ TESTS_progs_M = \
 	gem_exec_bad_domains \
 	gem_exec_faulting_reloc \
 	gem_exec_nop \
+	gem_exec_pad_to_size \
 	gem_exec_params \
 	gem_exec_parse \
 	gem_fenced_exec_thrash \
tests/gem_exec_pad_to_size.c new file +240 -0

240 lines not on this page · raw message

Signature · 6 lines
2.3.2

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#21 lore raw
Quoted 3 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This tests the new EXEC_OBJECT_PAD_TO_SIZE exec_object2 flag.

Just two things from an i-g-t perspective: the new binary needs adding to .gitignore and it would be good to include a short description of the test using the IGT_TEST_DESCRIPTION macro.

Quoted 286 lines

Similar to some other tests, it uses knowledge of the DRM allocation policy in order to get two objects mapped adjacent to each other. It is then possible to verify that the pad to size flag will move them apart.

v2: Correct commit message. (Chris Wilson)
v3: Changes after code review by Chris Wilson.
* No need for gem_sync after execbuf.
* Drop caches before running.
* Allocate one additional bo per iteration.
* Don't explicitly set unused execbuf fields to zero.
* One improved comment.
v4: Require simpler object ordering and fixed overlap test. (Chris Wilson)
v5: Check unpadded offsets once more before padding. (Chris Wilson)

---
 tests/Makefile.sources       |   1 +
 tests/gem_exec_pad_to_size.c | 240 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 241 insertions(+)
 create mode 100644 tests/gem_exec_pad_to_size.c
tests/Makefile.sources +1 -0
index 0a974a6..5f21728 100644
@@ -34,6 +34,7 @@ TESTS_progs_M = \
        gem_exec_bad_domains \
        gem_exec_faulting_reloc \
        gem_exec_nop \
+       gem_exec_pad_to_size \
        gem_exec_params \
        gem_exec_parse \
        gem_fenced_exec_thrash \
tests/gem_exec_pad_to_size.c new file +240 -1
new file mode 100644
index 0000000..87afe40
@@ -0,0 +1,240 @@
+/*
+ * Copyright © 2015 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Tvrtko Ursulin <[email protected]>
+ *
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include "drm.h"
+#include "ioctl_wrappers.h"
+#include "igt_core.h"
+#include "drmtest.h"
+#include "intel_reg.h"
+#include "igt_debugfs.h"
+
+#ifndef PAGE_SIZE
+#define PAGE_SIZE 4096
+#endif
+
+struct local_drm_i915_gem_exec_object2 {
+       /**
+        * User's handle for a buffer to be bound into the GTT for this
+        * operation.
+        */
+       __u32 handle;
+
+       /** Number of relocations to be performed on this buffer */
+       __u32 relocation_count;
+       /**
+        * Pointer to array of struct drm_i915_gem_relocation_entry containing
+        * the relocations to be performed in this buffer.
+        */
+       __u64 relocs_ptr;
+
+       /** Required alignment in graphics aperture */
+       __u64 alignment;
+
+       /**
+        * Returned value of the updated offset of the object, for future
+        * presumed_offset writes.
+        */
+       __u64 offset;
+
+#define LOCAL_EXEC_OBJECT_NEEDS_FENCE (1<<0)
+#define LOCAL_EXEC_OBJECT_NEEDS_GTT    (1<<1)
+#define LOCAL_EXEC_OBJECT_WRITE        (1<<2)
+#define LOCAL_EXEC_OBJECT_PAD_TO_SIZE (1<<3)
+#define __LOCAL_EXEC_OBJECT_UNKNOWN_FLAGS -(LOCAL_EXEC_OBJECT_PAD_TO_SIZE<<1)
+       __u64 flags;
+
+       __u64 pad_to_size;
+       __u64 rsvd2;
+};
+
+static int
+exec(int fd, uint32_t handles[3], uint32_t pad_to_size[2], uint64_t *offsets)
+{
+       struct drm_i915_gem_execbuffer2 execbuf;
+       struct local_drm_i915_gem_exec_object2 gem_exec[3];
+       int ret = 0;
+
+       memset(gem_exec, 0, sizeof(gem_exec));
+
+       gem_exec[0].handle = handles[1];
+       gem_exec[0].flags = pad_to_size[0] ?
+                           LOCAL_EXEC_OBJECT_PAD_TO_SIZE : 0;
+       gem_exec[0].pad_to_size = pad_to_size[0];
+
+       gem_exec[1].handle = handles[2];
+       gem_exec[1].flags = pad_to_size[1] ?
+                           LOCAL_EXEC_OBJECT_PAD_TO_SIZE : 0;
+       gem_exec[1].pad_to_size = pad_to_size[1];
+
+       gem_exec[2].handle = handles[0];
+
+       memset(&execbuf, 0, sizeof(execbuf));
+
+       execbuf.buffers_ptr = (uintptr_t)gem_exec;
+       execbuf.buffer_count = 3;
+       execbuf.batch_len = 8;
+
+       if (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf))
+                       ret = -errno;
+
+       if (ret == 0 && offsets) {
+               offsets[0] = gem_exec[0].offset;
+               offsets[1] = gem_exec[1].offset;
+       }
+
+       return ret;
+}
+
+static void
+require_pad_to_size(int fd, uint32_t handles[3])
+{
+       igt_require(exec(fd, handles, (uint32_t[2]){ PAGE_SIZE, PAGE_SIZE },
+                        NULL) == 0);
+}
+
+static void
+not_aligned(int fd, uint32_t handles[3])
+{
+       require_pad_to_size(fd, handles);
+
+       igt_require(exec(fd, handles, (uint32_t[2]){1 ,1},
+                        NULL) == -EINVAL);
+}
+
+static void
+padding(int fd, uint32_t handles[3])
+{
+       uint32_t pad_to_size[2] = {0, 0};
+       uint64_t offsets[2];
+       bool neighbours = false;
+       unsigned int try, i;
+       const unsigned int max_tries = 4096; /* Finger in the air. */
+       uint32_t *loc_handles;
+       uint32_t eb_handles[3];
+
+       require_pad_to_size(fd, handles);
+
+       igt_drop_caches_set(DROP_ALL);
+
+       loc_handles = calloc(max_tries * 2, sizeof(uint32_t));
+       igt_assert(loc_handles);
+
+       /* Try with passed in handles first. */
+       loc_handles[0] = handles[1];
+       loc_handles[1] = handles[2];
+
+       /* Try to get two buffer object next to each other in GTT space.
+        * We presume that sequential reservations are likely to be aligned and
+        * try until we find a pair that is.
+        */
+       for (try = 0; try < max_tries;) {
+               eb_handles[0] = handles[0];
+               eb_handles[1] = loc_handles[try];
+               eb_handles[2] = loc_handles[try + 1];
+
+               igt_assert(exec(fd, eb_handles, (uint32_t[2]){0, 0},
+                               offsets) == 0);
+
+               if ((offsets[1] - offsets[0]) == PAGE_SIZE) {
+                       neighbours = true;
+                       break;
+               }
+
+               try++;
+
+               loc_handles[try + 1] = gem_create(fd, PAGE_SIZE);
+               igt_assert(loc_handles[try + 1]);
+       }
+
+       /* Otherwise test can't confidently run. */
+       if (neighbours) {
+               /* Check the object don't move by themselves */
+               igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);
+               igt_assert((offsets[1] - offsets[0]) == PAGE_SIZE);
+
+               /* Re-exec with padding set. */
+               pad_to_size[0] = 2 * PAGE_SIZE;
+               igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);
+
+               /* Check that objects with padding do not overlap. */
+               igt_assert(offsets[0] >= offsets[1] + PAGE_SIZE ||
+                          offsets[0] + 2 * PAGE_SIZE <= offsets[1]);
+       }
+
+       /* Cleanup our bos. */
+       for (i = 0;  i < try; i++)
+               gem_close(fd, loc_handles[2 + i]);
+
+       free(loc_handles);
+
+       igt_require(neighbours);
+}
+
+uint32_t batch[2] = {MI_BATCH_BUFFER_END};
+uint32_t handles[3];
+int fd;
+
+igt_main
+{
+       igt_fixture {
+               fd = drm_open_any();
+
+               handles[0] = gem_create(fd, PAGE_SIZE);
+               gem_write(fd, handles[0], 0, batch, sizeof(batch));
+
+               handles[1] = gem_create(fd, PAGE_SIZE);
+               handles[2] = gem_create(fd, PAGE_SIZE);
+       }
+
+       igt_subtest("pad_to_size")
+               require_pad_to_size(fd, handles);
+
+       igt_subtest("not_aligned")
+               not_aligned(fd, handles);
+
+       igt_subtest("padding")
+               padding(fd, handles);
+
+       igt_fixture {
+               gem_close(fd, handles[0]);
+               gem_close(fd, handles[1]);
+               gem_close(fd, handles[2]);
+
+               close(fd);
+       }
+}
--

2.3.2

Quoted 4 lines

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx