Skip to contentSkip to conversation

tests: New userptr test case

PATCH In review Tvrtko Ursulin 2 participants 7 messages Feb 3, 2014 – Feb 4, 2014

lore
Share & tools
lore
#0 lore raw

cover tests: New userptr test case

From: Tvrtko Ursulin <[email protected]>

This patch series replaces the old vmap with the new userptr test case.

Some refactoring precedes the actual introduction to pull out code from gem_evict_everything which is useful for both.

Test case at the moment tests dmabuf sharing of userptr objects which is not currently implemented in the latest kernel patch.

Tvrtko Ursulin (4):
tests/gem_evict_everything: Factor out eviction logic tests/eviction_common: Avoid submitting duplicate objects tests/gem_userptr_blits: Expanded userptr test cases tests/gem_vmap_blits: Remove obsolete test case

 tests/.gitignore             |    2 +-
 tests/Makefile.sources       |    2 +-
 tests/eviction_common.c      |  242 +++++++++
 tests/gem_evict_everything.c |  210 ++------
 tests/gem_userptr_blits.c    | 1185 ++++++++++++++++++++++++++++++++++++++++++
 tests/gem_vmap_blits.c       |  344 ------------
 6 files changed, 1470 insertions(+), 515 deletions(-)
 create mode 100644 tests/eviction_common.c
 create mode 100644 tests/gem_userptr_blits.c
 delete mode 100644 tests/gem_vmap_blits.c
Signature · 1 line
1.8.4.3
#1 lore raw

PATCH 1/4 tests/gem_evict_everything: Factor out eviction logic

From: Tvrtko Ursulin <[email protected]>

In preparation for userptr test we move the eviction logic into a common file so it can be used from both test cases.

---
 tests/eviction_common.c      | 235 +++++++++++++++++++++++++++++++++++++++++++
 tests/gem_evict_everything.c | 210 ++++++++------------------------------
 2 files changed, 276 insertions(+), 169 deletions(-)
 create mode 100644 tests/eviction_common.c
tests/eviction_common.c new file +235 -0
new file mode 100644
index 0000000..efe560c
@@ -0,0 +1,235 @@
+/*
+ * Copyright © 2007, 2011, 2013, 2014 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:
+ *    Eric Anholt <[email protected]>
+ *    Daniel Vetter <[email protected]>
+ *    Tvrtko Ursulin <[email protected]>
+ *
+ */
+
+#include <stdlib.h>
+
+#include "drmtest.h"
+
+struct igt_eviction_test_ops
+{
+	uint32_t (*create)(int fd, int size);
+	void	 (*close)(int fd, uint32_t bo);
+	void	 (*copy)(int fd, uint32_t dst, uint32_t src,
+			 uint32_t *all_bo, int nr_bos, int error);
+	void	 (*clear)(int fd, uint32_t bo, int size);
+};
+
+#define FORKING_EVICTIONS_INTERRUPTIBLE	  (1 << 0)
+#define FORKING_EVICTIONS_SWAPPING	  (1 << 1)
+#define FORKING_EVICTIONS_DUP_DRMFD	  (1 << 2)
+#define FORKING_EVICTIONS_MEMORY_PRESSURE (1 << 3)
+#define ALL_FORKING_EVICTIONS	(FORKING_EVICTIONS_INTERRUPTIBLE | \
+				 FORKING_EVICTIONS_SWAPPING | \
+				 FORKING_EVICTIONS_DUP_DRMFD | \
+				 FORKING_EVICTIONS_MEMORY_PRESSURE)
+
+static void exchange_uint32_t(void *array, unsigned i, unsigned j)
+{
+	uint32_t *i_arr = array;
+	uint32_t i_tmp;
+
+	i_tmp = i_arr[i];
+	i_arr[i] = i_arr[j];
+	i_arr[j] = i_tmp;
+}
+
+static int minor_evictions(int fd, struct igt_eviction_test_ops *ops,
+				int surface_size, int nr_surfaces)
+{
+	uint32_t *bo, *sel;
+	int n, m, pass, fail;
+
+	igt_require((uint64_t)nr_surfaces * surface_size / (1024 * 1024)
+			< intel_get_total_ram_mb() * 9 / 10);
+
+	bo = malloc(3*nr_surfaces*sizeof(*bo));
+	igt_assert(bo);
+
+	for (n = 0; n < 2*nr_surfaces; n++)
+		bo[n] = ops->create(fd, surface_size);
+
+	sel = bo + n;
+	for (fail = 0, m = 0; fail < 10; fail++) {
+		for (pass = 0; pass < 100; pass++) {
+			for (n = 0; n < nr_surfaces; n++, m += 7)
+				sel[n] = bo[m%(2*nr_surfaces)];
+			ops->copy(fd, sel[0], sel[1], sel, nr_surfaces, 0);
+		}
+		ops->copy(fd, bo[0], bo[0], bo, 2*nr_surfaces, ENOSPC);
+	}
+
+	for (n = 0; n < 2*nr_surfaces; n++)
+		ops->close(fd, bo[n]);
+	free(bo);
+
+	return 0;
+}
+
+static int major_evictions(int fd, struct igt_eviction_test_ops *ops,
+				int surface_size, int nr_surfaces)
+{
+	int n, m, loop;
+	uint32_t *bo;
+
+	igt_require((uint64_t)nr_surfaces * surface_size / (1024 * 1024)
+			< intel_get_total_ram_mb() * 9 / 10);
+
+	bo = malloc(nr_surfaces*sizeof(*bo));
+	igt_assert(bo);
+
+	for (n = 0; n < nr_surfaces; n++)
+		bo[n] = ops->create(fd, surface_size);
+
+	for (loop = 0, m = 0; loop < 100; loop++, m += 17) {
+		n = m % nr_surfaces;
+		ops->copy(fd, bo[n], bo[n], &bo[n], 1, 0);
+	}
+
+	for (n = 0; n < nr_surfaces; n++)
+		ops->close(fd, bo[n]);
+	free(bo);
+
+	return 0;
+}
+
+static int swapping_evictions(int fd, struct igt_eviction_test_ops *ops,
+				int surface_size,
+				int working_surfaces,
+				int trash_surfaces)
+{
+	uint32_t *bo;
+	int i, n, pass;
+
+	igt_require((uint64_t)working_surfaces * surface_size / (1024 * 1024)
+			< intel_get_total_ram_mb() * 9 / 10);
+
+	if (trash_surfaces < working_surfaces)
+		trash_surfaces = working_surfaces;
+
+	bo = malloc(trash_surfaces*sizeof(*bo));
+	igt_assert(bo);
+
+	for (n = 0; n < trash_surfaces; n++)
+		bo[n] = ops->create(fd, surface_size);
+
+	for (i = 0; i < trash_surfaces/32; i++) {
+		igt_permute_array(bo, trash_surfaces, exchange_uint32_t);
+
+		for (pass = 0; pass < 100; pass++) {
+			ops->copy(fd, bo[0], bo[1], bo, working_surfaces, 0);
+		}
+	}
+
+	for (n = 0; n < trash_surfaces; n++)
+		ops->close(fd, bo[n]);
+	free(bo);
+
+	return 0;
+}
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+
+static int forking_evictions(int fd, struct igt_eviction_test_ops *ops,
+				int surface_size, int working_surfaces,
+				int trash_surfaces, unsigned flags)
+{
+	uint32_t *bo;
+	int n, pass, l;
+	int num_threads = sysconf(_SC_NPROCESSORS_ONLN);
+	int bo_count;
+
+	igt_require((uint64_t)working_surfaces * surface_size / (1024 * 1024)
+			< intel_get_total_ram_mb() * 9 / 10);
+
+	if (flags & FORKING_EVICTIONS_SWAPPING) {
+		igt_require(intel_get_total_ram_mb() / 4
+				< intel_get_total_swap_mb());
+		bo_count = trash_surfaces;
+
+		if (bo_count < working_surfaces)
+			bo_count = working_surfaces;
+	} else
+		bo_count = working_surfaces;
+
+	bo = malloc(bo_count*sizeof(*bo));
+	igt_assert(bo);
+
+	for (n = 0; n < bo_count; n++)
+		bo[n] = ops->create(fd, surface_size);
+
+	igt_fork(i, min(num_threads * 4, 12)) {
+		int realfd = fd;
+		int num_passes = flags & FORKING_EVICTIONS_SWAPPING ? 10 : 100;
+
+		/* Every fork should have a different permutation! */
+		srand(i * 63);
+
+		if (flags & FORKING_EVICTIONS_INTERRUPTIBLE)
+			igt_fork_signal_helper();
+
+		igt_permute_array(bo, bo_count, exchange_uint32_t);
+
+		if (flags & FORKING_EVICTIONS_DUP_DRMFD) {
+			realfd = drm_open_any();
+
+			/* We can overwrite the bo array since we're forked. */
+			for (l = 0; l < bo_count; l++) {
+				uint32_t flink;
+
+				flink = gem_flink(fd, bo[l]);
+				bo[l] = gem_open(realfd, flink);
+			}
+		}
+
+		for (pass = 0; pass < num_passes; pass++) {
+			ops->copy(realfd, bo[0], bo[1], bo, working_surfaces, 0);
+
+			for (l = 0; l < working_surfaces &&
+			  (flags & FORKING_EVICTIONS_MEMORY_PRESSURE);
+			    l++) {
+				ops->clear(realfd, bo[l], surface_size);
+			}
+		}
+
+		if (flags & FORKING_EVICTIONS_INTERRUPTIBLE)
+			igt_stop_signal_helper();
+
+		/* drmfd closing will take care of additional bo refs */
+		if (flags & FORKING_EVICTIONS_DUP_DRMFD)
+			close(realfd);
+	}
+
+	igt_waitchildren();
+
+	for (n = 0; n < bo_count; n++)
+		ops->close(fd, bo[n]);
+	free(bo);
+
+	return 0;
+}
tests/gem_evict_everything.c +41 -169

276 lines not on this page · raw message

Signature · 6 lines
1.8.4.3

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

PATCH 2/4 tests/eviction_common: Avoid submitting duplicate objects

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Make sure selection loop does not generate duplicates when it picks a subset of objects for a single exec buffer.

---
 tests/eviction_common.c | 7 +++++++
 1 file changed, 7 insertions(+)
tests/eviction_common.c +7 -0
index efe560c..91fb2df 100644
@@ -65,6 +65,13 @@ static int minor_evictions(int fd, struct igt_eviction_test_ops *ops,
 	uint32_t *bo, *sel;
 	int n, m, pass, fail;
 
+	/* Make sure nr_surfaces is not divisible by seven
+	 * to avoid duplicates in the selection loop below.
+	 */
+	nr_surfaces /= 7;
+	nr_surfaces *= 7;
+	nr_surfaces += 3;
+
 	igt_require((uint64_t)nr_surfaces * surface_size / (1024 * 1024)
 			< intel_get_total_ram_mb() * 9 / 10);
 
Signature · 1 line
1.8.4.3
#3 lore raw

Re: [PATCH 2/4] tests/eviction_common: Avoid submitting duplicate objects

Quoted 6 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Make sure selection loop does not generate duplicates when it picks a subset of objects for a single exec buffer.

I've pulled in the first two patches and also fixed up make distcheck - eviction_common.c wasn't included in the tarballs.
-Daniel

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

PATCH 3/4 tests/gem_userptr_blits: Expanded userptr test cases

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

A set of userptr test cases to support the new feature.

For the eviction and swapping stress testing I have extracted some common behaviour from gem_evict_everything and made both test cases use it to avoid duplicating the code.

Both unsynchronized and synchronized userptr objects are tested but the latter set of tests will be skipped if kernel is compiled without MMU_NOTIFIERS.

Also, with 32-bit userspace swapping tests are skipped if the system has a lot more RAM than process address space. Forking swapping tests are not skipped since they can still trigger swapping by cumulative effect.

---
 tests/.gitignore          |    1 +
 tests/Makefile.sources    |    1 +
 tests/gem_userptr_blits.c | 1185 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 1187 insertions(+)
 create mode 100644 tests/gem_userptr_blits.c
tests/.gitignore +1 -0
index 7377275..77ab34e 100644
@@ -92,6 +92,7 @@ gem_tiling_max_stride
 gem_unfence_active_buffers
 gem_unref_active_buffers
 gem_vmap_blits
+gem_userptr_blits
 gem_wait_render_timeout
 gem_write_read_ring_switch
 gen3_mixed_blits
tests/Makefile.sources +1 -0
index a8c0c96..7699a84 100644
@@ -116,6 +116,7 @@ TESTS_progs = \
 	gem_unfence_active_buffers \
 	gem_unref_active_buffers \
 	gem_vmap_blits \
+	gem_userptr_blits \
 	gem_wait_render_timeout \
 	gen3_mixed_blits \
 	gen3_render_linear_blits \
tests/gem_userptr_blits.c new file +1185 -0

1,185 lines not on this page · raw message

Signature · 6 lines
1.8.4.3

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

Re: [PATCH 3/4] tests/gem_userptr_blits: Expanded userptr test cases

Quoted 12 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

A set of userptr test cases to support the new feature.

For the eviction and swapping stress testing I have extracted some common behaviour from gem_evict_everything and made both test cases use it to avoid duplicating the code.

Both unsynchronized and synchronized userptr objects are tested but the latter set of tests will be skipped if kernel is compiled without MMU_NOTIFIERS.

Quoted 6 lines

Also, with 32-bit userspace swapping tests are skipped if the system has a lot more RAM than process address space. Forking swapping tests are not skipped since they can still trigger swapping by cumulative effect.

Nitpick on process: Please keep in per-patch changelog in the commit message and update it every time you resend the patches (only if something changed in that patch ofc). Makes it easier to keep track of things. -Daniel

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

PATCH 4/4 tests/gem_vmap_blits: Remove obsolete test case

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

No need for the old test case once the new one was added.

---
 tests/.gitignore       |   1 -
 tests/Makefile.sources |   1 -
 tests/gem_vmap_blits.c | 344 -------------------------------------------------
 3 files changed, 346 deletions(-)
 delete mode 100644 tests/gem_vmap_blits.c
tests/.gitignore +0 -1
index 77ab34e..798eeed 100644
@@ -91,7 +91,6 @@ gem_tiled_swapping
 gem_tiling_max_stride
 gem_unfence_active_buffers
 gem_unref_active_buffers
-gem_vmap_blits
 gem_userptr_blits
 gem_wait_render_timeout
 gem_write_read_ring_switch
tests/Makefile.sources +0 -1
index 7699a84..2d42a18 100644
@@ -115,7 +115,6 @@ TESTS_progs = \
 	gem_tiling_max_stride \
 	gem_unfence_active_buffers \
 	gem_unref_active_buffers \
-	gem_vmap_blits \
 	gem_userptr_blits \
 	gem_wait_render_timeout \
 	gen3_mixed_blits \
tests/gem_vmap_blits.c deleted +0 -344

344 lines not on this page · raw message

Signature · 6 lines
1.8.4.3

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