Skip to contentSkip to conversation

tests: New userptr test case

PATCH In review Tvrtko Ursulin 4 participants 28 messages Feb 26, 2014 – Apr 24, 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 and also adds a benchmark for the new feature.

Tested against version 20 of the kernel patch.

Tvrtko Ursulin (3):
tests/gem_userptr_blits: Expanded userptr test cases tests/gem_vmap_blits: Remove obsolete test case tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

 Android.mk                         |    3 +-
 benchmarks/.gitignore              |    1 +
 benchmarks/Android.mk              |   36 ++
 benchmarks/Makefile.am             |    7 +-
 benchmarks/Makefile.sources        |    6 +
 benchmarks/gem_userptr_benchmark.c |  513 +++++++++++++++
 tests/.gitignore                   |    2 +-
 tests/Makefile.sources             |    2 +-
 tests/gem_userptr_blits.c          | 1230 ++++++++++++++++++++++++++++++++++++
 tests/gem_vmap_blits.c             |  344 ----------
 10 files changed, 1790 insertions(+), 354 deletions(-)
 create mode 100644 benchmarks/Android.mk
 create mode 100644 benchmarks/Makefile.sources
 create mode 100644 benchmarks/gem_userptr_benchmark.c
 create mode 100644 tests/gem_userptr_blits.c
 delete mode 100644 tests/gem_vmap_blits.c
Signature · 1 line
1.9.0
#1 lore raw

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

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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

---
 tests/.gitignore          |    1 +
 tests/Makefile.sources    |    1 +
 tests/gem_userptr_blits.c | 1230 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 1232 insertions(+)
 create mode 100644 tests/gem_userptr_blits.c
tests/.gitignore +1 -0
index cb548a8..a369c8d 100644
@@ -94,6 +94,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 afb2582..d9d39db 100644
@@ -119,6 +119,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 +1230 -0

1,230 lines not on this page · raw message

Signature · 6 lines
1.9.0

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

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

Quoted 27 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.

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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

---

tests/gem_userptr_blits.c new file +3 -0
+static void
+copy(int fd, uint32_t dst, uint32_t src, unsigned int error)
+{

tests/gem_userptr_blits.c line 128

Quoted 10 lines
tests/gem_userptr_blits.c new file +10 -0
+	uint32_t batch[10];
+	struct drm_i915_gem_relocation_entry reloc[2];
+	struct drm_i915_gem_exec_object2 obj[3];
+	struct drm_i915_gem_execbuffer2 exec;
+	uint32_t handle;
+	int ret;
+
+	batch[0] = XY_SRC_COPY_BLT_CMD |
+		  XY_SRC_COPY_BLT_WRITE_ALPHA |
+		  XY_SRC_COPY_BLT_WRITE_RGB | 6;

Hmm, you made blit() bdw-aware, but not this copy() routine?

As for the rest, I think we have good coverage.

What I would like to see exercised as well is mmap(fd), shm_open() and sysv shmem.

Another thing to test is transfering our device fd over a unix socket to another process and checking that we can continue to access the memory. (That should just be the same as forking and continuing to use the parent fd.)

I can think of more wacky vma to use, but I haven't thought of any corner cases in the code that need exercising.
-Chris

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

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

Quoted 32 lines · Chris Wilson
Quoted 31 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.

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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

---

tests/gem_userptr_blits.c new file +7 -0
+static void
+copy(int fd, uint32_t dst, uint32_t src, unsigned int error)
+{
+	uint32_t batch[10];
+	struct drm_i915_gem_relocation_entry reloc[2];
+	struct drm_i915_gem_exec_object2 obj[3];
+	struct drm_i915_gem_execbuffer2 exec;
Quoted 8 lines

tests/gem_userptr_blits.c line 128

Quoted 6 lines
tests/gem_userptr_blits.c new file +6 -0
+	uint32_t handle;
+	int ret;
+
+	batch[0] = XY_SRC_COPY_BLT_CMD |
+		  XY_SRC_COPY_BLT_WRITE_ALPHA |
+		  XY_SRC_COPY_BLT_WRITE_RGB | 6;

Hmm, you made blit() bdw-aware, but not this copy() routine?

You give me too much credit, it is all c&p from other tests. :)

Quoted 4 lines

As for the rest, I think we have good coverage.

What I would like to see exercised as well is mmap(fd), shm_open() and sysv shmem.

What do you mean by mmap(fd), what fd?

And for shared memory flavours - you mean just creating userptr objects from them or something more perverse?

Quoted 4 lines

Another thing to test is transfering our device fd over a unix socket to another process and checking that we can continue to access the memory. (That should just be the same as forking and continuing to use the parent fd.)

Not sure I follow - transfer drm fd to a new process and then what?

Regards,

Tvrtko

#4 lore raw

PATCH 1/3 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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

v3:
* Use ALIGN macro.
* Catchup with big lib/ reorganization.
* Fixed up some warnings.

---
 tests/.gitignore          |    1 +
 tests/Makefile.sources    |    1 +
 tests/gem_userptr_blits.c | 1247 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 1249 insertions(+)
 create mode 100644 tests/gem_userptr_blits.c
tests/.gitignore +1 -0
index 146bab0..ff193bd 100644
@@ -95,6 +95,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 c957ace..09d6aa3 100644
@@ -121,6 +121,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 +1247 -0

1,247 lines not on this page · raw message

Signature · 6 lines
1.9.1

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

PATCH 2/3 tests/gem_vmap_blits: Remove obsolete test case

From: Tvrtko Ursulin <[email protected]>

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

v2:
* Just rebase for lib/ reorganization.

---
 tests/.gitignore       |   1 -
 tests/Makefile.sources |   1 -
 tests/gem_vmap_blits.c | 345 -------------------------------------------------
 3 files changed, 347 deletions(-)
 delete mode 100644 tests/gem_vmap_blits.c
tests/.gitignore +0 -1
index ff193bd..d192bb9 100644
@@ -94,7 +94,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 09d6aa3..57a0da2 100644
@@ -120,7 +120,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 -345

345 lines not on this page · raw message

Signature · 6 lines
1.9.1

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

Re: [PATCH 2/3] tests/gem_vmap_blits: Remove obsolete test case

Quoted 393 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

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

v2:
* Just rebase for lib/ reorganization.

---
 tests/.gitignore       |   1 -
 tests/Makefile.sources |   1 -
 tests/gem_vmap_blits.c | 345 -------------------------------------------------
 3 files changed, 347 deletions(-)
 delete mode 100644 tests/gem_vmap_blits.c
tests/.gitignore +0 -1
index ff193bd..d192bb9 100644
@@ -94,7 +94,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 09d6aa3..57a0da2 100644
@@ -120,7 +120,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 -345
deleted file mode 100644
index 430338b..0000000
@@ -1,345 +0,0 @@
-/*
- * Copyright © 2009,2011 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]>
- *    Chris Wilson <[email protected]>
- *
- */
-
-/** @file gem_vmap_blits.c
- *
- * This is a test of doing many blits using a mixture of normal system pages
- * and uncached linear buffers, with a working set larger than the
- * aperture size.
- *
- * The goal is to simply ensure the basics work.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-
-#include "drm.h"
-#include "ioctl_wrappers.h"
-#include "drmtest.h"
-#include "intel_bufmgr.h"
-#include "intel_batchbuffer.h"
-#include "intel_io.h"
-
-#if !defined(I915_PARAM_HAS_VMAP)
-#pragma message("No vmap support in drm, skipping")
-int main(int argc, char **argv)
-{
-	fprintf(stderr, "No vmap support in drm.\n");
-	return 77;
-}
-#else
-
-#define WIDTH 512
-#define HEIGHT 512
-
-static uint32_t linear[WIDTH*HEIGHT];
-
-static uint32_t gem_vmap(int fd, void *ptr, int size, int read_only)
-{
-	struct drm_i915_gem_vmap vmap;
-
-	vmap.user_ptr = (uintptr_t)ptr;
-	vmap.user_size = size;
-	vmap.flags = 0;
-	if (read_only)
-		vmap.flags |= I915_VMAP_READ_ONLY;
-
-	if (drmIoctl(fd, DRM_IOCTL_I915_GEM_VMAP, &vmap))
-		return 0;
-
-	return vmap.handle;
-}
-
-
-static void gem_vmap_sync(int fd, uint32_t handle)
-{
-	gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
-}
-
-static void
-copy(int fd, uint32_t dst, uint32_t src)
-{
-	uint32_t batch[10];
-	struct drm_i915_gem_relocation_entry reloc[2];
-	struct drm_i915_gem_exec_object2 obj[3];
-	struct drm_i915_gem_execbuffer2 exec;
-	uint32_t handle;
-	int ret;
-
-	batch[0] = XY_SRC_COPY_BLT_CMD |
-		  XY_SRC_COPY_BLT_WRITE_ALPHA |
-		  XY_SRC_COPY_BLT_WRITE_RGB | 6;
-	batch[1] = (3 << 24) | /* 32 bits */
-		  (0xcc << 16) | /* copy ROP */
-		  WIDTH*4;
-	batch[2] = 0; /* dst x1,y1 */
-	batch[3] = (HEIGHT << 16) | WIDTH; /* dst x2,y2 */
-	batch[4] = 0; /* dst reloc */
-	batch[5] = 0; /* src x1,y1 */
-	batch[6] = WIDTH*4;
-	batch[7] = 0; /* src reloc */
-	batch[8] = MI_BATCH_BUFFER_END;
-	batch[9] = MI_NOOP;
-
-	handle = gem_create(fd, 4096);
-	gem_write(fd, handle, 0, batch, sizeof(batch));
-
-	reloc[0].target_handle = dst;
-	reloc[0].delta = 0;
-	reloc[0].offset = 4 * sizeof(batch[0]);
-	reloc[0].presumed_offset = 0;
-	reloc[0].read_domains = I915_GEM_DOMAIN_RENDER;;
-	reloc[0].write_domain = I915_GEM_DOMAIN_RENDER;
-
-	reloc[1].target_handle = src;
-	reloc[1].delta = 0;
-	reloc[1].offset = 7 * sizeof(batch[0]);
-	reloc[1].presumed_offset = 0;
-	reloc[1].read_domains = I915_GEM_DOMAIN_RENDER;;
-	reloc[1].write_domain = 0;
-
-	obj[0].handle = dst;
-	obj[0].relocation_count = 0;
-	obj[0].relocs_ptr = 0;
-	obj[0].alignment = 0;
-	obj[0].offset = 0;
-	obj[0].flags = 0;
-	obj[0].rsvd1 = 0;
-	obj[0].rsvd2 = 0;
-
-	obj[1].handle = src;
-	obj[1].relocation_count = 0;
-	obj[1].relocs_ptr = 0;
-	obj[1].alignment = 0;
-	obj[1].offset = 0;
-	obj[1].flags = 0;
-	obj[1].rsvd1 = 0;
-	obj[1].rsvd2 = 0;
-
-	obj[2].handle = handle;
-	obj[2].relocation_count = 2;
-	obj[2].relocs_ptr = (uintptr_t)reloc;
-	obj[2].alignment = 0;
-	obj[2].offset = 0;
-	obj[2].flags = 0;
-	obj[2].rsvd1 = obj[2].rsvd2 = 0;
-
-	exec.buffers_ptr = (uintptr_t)obj;
-	exec.buffer_count = 3;
-	exec.batch_start_offset = 0;
-	exec.batch_len = sizeof(batch);
-	exec.DR1 = exec.DR4 = 0;
-	exec.num_cliprects = 0;
-	exec.cliprects_ptr = 0;
-	exec.flags = HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0;
-	exec.rsvd1 = exec.rsvd2 = 0;
-
-	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
-	while (ret && errno == EBUSY) {
-		drmCommandNone(fd, DRM_I915_GEM_THROTTLE);
-		ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
-	}
-	igt_assert(ret == 0);
-
-	gem_close(fd, handle);
-}
-
-static uint32_t
-create_vmap(int fd, uint32_t val, uint32_t *ptr)
-{
-	uint32_t handle;
-	int i;
-
-	handle = gem_vmap(fd, ptr, sizeof(linear), 0);
-
-	/* Fill the BO with dwords starting at val */
-	for (i = 0; i < WIDTH*HEIGHT; i++)
-		ptr[i] = val++;
-
-	return handle;
-}
-
-static uint32_t
-create_bo(int fd, uint32_t val)
-{
-	uint32_t handle;
-	int i;
-
-	handle = gem_create(fd, sizeof(linear));
-
-	/* Fill the BO with dwords starting at val */
-	for (i = 0; i < WIDTH*HEIGHT; i++)
-		linear[i] = val++;
-	gem_write(fd, handle, 0, linear, sizeof(linear));
-
-	return handle;
-}
-
-static void
-check_cpu(uint32_t *ptr, uint32_t val)
-{
-	int i;
-
-	for (i = 0; i < WIDTH*HEIGHT; i++) {
-		if (ptr[i] != val) {
-			fprintf(stderr, "Expected 0x%08x, found 0x%08x "
-				"at offset 0x%08x\n",
-				val, ptr[i], i * 4);
-			abort();
-		}
-		val++;
-	}
-}
-
-static void
-check_gpu(int fd, uint32_t handle, uint32_t val)
-{
-	gem_read(fd, handle, 0, linear, sizeof(linear));
-	check_cpu(linear, val);
-}
-
-static int has_vmap(int fd)
-{
-	drm_i915_getparam_t gp;
-	int i;
-
-	gp.param = I915_PARAM_HAS_VMAP;
-	gp.value = &i;
-
-	return drmIoctl(fd, DRM_IOCTL_I915_GETPARAM, &gp) == 0 && i > 0;
-}
-
-int main(int argc, char **argv)
-{
-	uint32_t *memory;
-	uint32_t *cpu, *cpu_val;
-	uint32_t *gpu, *gpu_val;
-	uint32_t start = 0;
-	int i, fd, count;
-
-	igt_simple_init();
-
-	igt_skip_on_simulation();
-
-	fd = drm_open_any();
-
-	if (!has_vmap(fd)) {
-		fprintf(stderr, "No vmap support, ignoring.\n");
-		return 77;
-	}
-
-	count = 0;
-	if (argc > 1)
-		count = atoi(argv[1]);
-	if (count == 0)
-		count = 3 * gem_aperture_size(fd) / (1024*1024) / 4;
-	printf("Using 2x%d 1MiB buffers\n", count);
-
-	memory = malloc(count*sizeof(linear));
-	if (memory == NULL) {
-		fprintf(stderr, "Unable to allocate %lld bytes\n",
-			(long long)count*sizeof(linear));
-		return 1;
-	}
-
-	gpu = malloc(sizeof(uint32_t)*count*4);
-	gpu_val = gpu + count;
-	cpu = gpu_val + count;
-	cpu_val = cpu + count;
-
-	for (i = 0; i < count; i++) {
-		gpu[i] = create_bo(fd, start);
-		gpu_val[i] = start;
-		start += WIDTH*HEIGHT;
-	}
-
-	for (i = 0; i < count; i++) {
-		cpu[i] = create_vmap(fd, start, memory+i*WIDTH*HEIGHT);
-		cpu_val[i] = start;
-		start += WIDTH*HEIGHT;;
-	}
-
-	printf("Verifying initialisation...\n");
-	for (i = 0; i < count; i++) {
-		check_gpu(fd, gpu[i], gpu_val[i]);
-		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
-	}
-
-	printf("Cyclic blits cpu->gpu, forward...\n");
-	for (i = 0; i < count * 4; i++) {
-		int src = i % count;
-		int dst = (i + 1) % count;
-
-		copy(fd, gpu[dst], cpu[src]);
-		gpu_val[dst] = cpu_val[src];
-	}
-	for (i = 0; i < count; i++)
-		check_gpu(fd, gpu[i], gpu_val[i]);
-
-	printf("Cyclic blits gpu->cpu, backward...\n");
-	for (i = 0; i < count * 4; i++) {
-		int src = (i + 1) % count;
-		int dst = i % count;
-
-		copy(fd, cpu[dst], gpu[src]);
-		cpu_val[dst] = gpu_val[src];
-	}
-	for (i = 0; i < count; i++) {
-		gem_vmap_sync(fd, cpu[i]);
-		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
-	}
-
-	printf("Random blits...\n");
-	for (i = 0; i < count * 4; i++) {
-		int src = random() % count;
-		int dst = random() % count;
-
-		if (random() & 1) {
-			copy(fd, gpu[dst], cpu[src]);
-			gpu_val[dst] = cpu_val[src];
-		} else {
-			copy(fd, cpu[dst], gpu[src]);
-			cpu_val[dst] = gpu_val[src];
-		}
-	}
-	for (i = 0; i < count; i++) {
-		check_gpu(fd, gpu[i], gpu_val[i]);
-		gem_vmap_sync(fd, cpu[i]);
-		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
-	}
-
-	return 0;
-}
-
-#endif
Signature · 1 line
1.9.1
#7 lore raw

PATCH 3/3 tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This adds a small benchmark for the new userptr functionality.

Apart from basic surface creation and destruction, also tested is the impact of having userptr surfaces in the process address space. Reason for that is the impact of MMU notifiers on common address space operations like munmap() which is per process.

v2:
* Moved to benchmarks.
* Added pointer read/write tests.
* Changed output to say iterations per second instead of operations per second.
* Multiply result by batch size for multi-create* tests for a more comparable number with create-destroy test.

v3:
* Use ALIGN macro.
* Catchup with big lib/ reorganization.
* Removed unused code and one global variable.
* Fixed up some warnings.

---
 benchmarks/.gitignore              |   1 +
 benchmarks/Makefile.sources        |   3 +-
 benchmarks/gem_userptr_benchmark.c | 497 +++++++++++++++++++++++++++++++++++++
 3 files changed, 500 insertions(+), 1 deletion(-)
 create mode 100644 benchmarks/gem_userptr_benchmark.c
benchmarks/.gitignore +1 -0
index ddea6f7..09e5bd8 100644
@@ -1,3 +1,4 @@
+gem_userptr_benchmark
 intel_upload_blit_large
 intel_upload_blit_large_gtt
 intel_upload_blit_large_map
benchmarks/Makefile.sources +2 -1
index f9da579..60bdae2 100644
@@ -2,4 +2,5 @@ bin_PROGRAMS =                          \
 	intel_upload_blit_large         \
 	intel_upload_blit_large_gtt     \
 	intel_upload_blit_large_map     \
-	intel_upload_blit_small
+	intel_upload_blit_small		\
+	gem_userptr_benchmark
benchmarks/gem_userptr_benchmark.c new file +497 -0

497 lines not on this page · raw message

Signature · 6 lines
1.9.1

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Reviewed-by on v1 3/3
#8 lore raw

Re: [PATCH 3/3] tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

Quoted 147 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This adds a small benchmark for the new userptr functionality.

Apart from basic surface creation and destruction, also tested is the impact of having userptr surfaces in the process address space. Reason for that is the impact of MMU notifiers on common address space operations like munmap() which is per process.

v2:
* Moved to benchmarks.
* Added pointer read/write tests.
* Changed output to say iterations per second instead of operations per second.
* Multiply result by batch size for multi-create* tests for a more comparable number with create-destroy test.

v3:
* Use ALIGN macro.
* Catchup with big lib/ reorganization.
* Removed unused code and one global variable.
* Fixed up some warnings.

---
 benchmarks/.gitignore              |   1 +
 benchmarks/Makefile.sources        |   3 +-
 benchmarks/gem_userptr_benchmark.c | 497 +++++++++++++++++++++++++++++++++++++
 3 files changed, 500 insertions(+), 1 deletion(-)
 create mode 100644 benchmarks/gem_userptr_benchmark.c
benchmarks/.gitignore +1 -0
index ddea6f7..09e5bd8 100644
@@ -1,3 +1,4 @@
+gem_userptr_benchmark
 intel_upload_blit_large
 intel_upload_blit_large_gtt
 intel_upload_blit_large_map
benchmarks/Makefile.sources +2 -1
index f9da579..60bdae2 100644
@@ -2,4 +2,5 @@ bin_PROGRAMS =                          \
 	intel_upload_blit_large         \
 	intel_upload_blit_large_gtt     \
 	intel_upload_blit_large_map     \
-	intel_upload_blit_small
+	intel_upload_blit_small		\
+	gem_userptr_benchmark
benchmarks/gem_userptr_benchmark.c new file +89 -0
new file mode 100644
index 0000000..a51201c
@@ -0,0 +1,497 @@
+/*
+ * Copyright © 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:
+ *    Tvrtko Ursulin <[email protected]>
+ *
+ */
+
+/** @file gem_userptr_benchmark.c
+ *
+ * Benchmark the userptr code and impact of having userptr surfaces
+ * in process address space on some normal operations.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include "drm.h"
+#include "i915_drm.h"
+#include "drmtest.h"
+#include "intel_bufmgr.h"
+#include "intel_batchbuffer.h"
+#include "intel_chipset.h"
+#include "ioctl_wrappers.h"
+#include "igt_aux.h"
+
+#ifndef PAGE_SIZE
+  #define PAGE_SIZE 4096
+#endif
+
+#define LOCAL_I915_GEM_USERPTR       0x34
+#define LOCAL_IOCTL_I915_GEM_USERPTR DRM_IOWR (DRM_COMMAND_BASE + LOCAL_I915_GEM_USERPTR, struct local_i915_gem_userptr)
+struct local_i915_gem_userptr {
+	uint64_t user_ptr;
+	uint64_t user_size;
+	uint32_t flags;
+#define LOCAL_I915_USERPTR_READ_ONLY (1<<0)
+#define LOCAL_I915_USERPTR_UNSYNCHRONIZED (1<<31)
+	uint32_t handle;
+};
+
+static uint32_t userptr_flags = LOCAL_I915_USERPTR_UNSYNCHRONIZED;
+
+#define BO_SIZE (65536)
+
+static void gem_userptr_test_unsynchronized(void)
+{
+	userptr_flags = LOCAL_I915_USERPTR_UNSYNCHRONIZED;
+}
+
+static void gem_userptr_test_synchronized(void)
+{
+	userptr_flags = 0;
+}
+
+static int gem_userptr(int fd, void *ptr, int size, int read_only, uint32_t *handle)
+{
+	struct local_i915_gem_userptr userptr;
+	int ret;
+
+	userptr.user_ptr = (uintptr_t)ptr;
+	userptr.user_size = size;

benchmarks/gem_userptr_benchmark.c line 99

Quoted 10 lines
benchmarks/gem_userptr_benchmark.c new file +10 -0
+	userptr.flags = userptr_flags;
+	if (read_only)
+		userptr.flags |= LOCAL_I915_USERPTR_READ_ONLY;
+
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	if (ret)
+		ret = errno;
+	igt_skip_on_f(ret == ENODEV &&
+		      (userptr_flags & LOCAL_I915_USERPTR_UNSYNCHRONIZED) == 0,
+		      "Skipping, synchronized mappings with no kernel CONFIG_MMU_NOTIFIER?");

I missed it the first time around, but the condition here doesn't match the other test; it's missing the '&& !read_only'. It looks like read_only will always be 0 in this test though, so probably not an issue.

Quoted 401 lines
benchmarks/gem_userptr_benchmark.c new file +398 -0
+	if (ret == 0)
+		*handle = userptr.handle;
+
+	return ret;
+}
+
+static void **handle_ptr_map;
+static unsigned int num_handle_ptr_map;
+
+static void add_handle_ptr(uint32_t handle, void *ptr)
+{
+	if (handle >= num_handle_ptr_map) {
+		handle_ptr_map = realloc(handle_ptr_map,
+					 (handle + 1000) * sizeof(void*));
+		num_handle_ptr_map = handle + 1000;
+	}
+
+	handle_ptr_map[handle] = ptr;
+}
+
+static void *get_handle_ptr(uint32_t handle)
+{
+	return handle_ptr_map[handle];
+}
+
+static void free_handle_ptr(uint32_t handle)
+{
+	igt_assert(handle < num_handle_ptr_map);
+	igt_assert(handle_ptr_map[handle]);
+
+	free(handle_ptr_map[handle]);
+	handle_ptr_map[handle] = NULL;
+}
+
+static uint32_t create_userptr_bo(int fd, int size)
+{
+	void *ptr;
+	uint32_t handle;
+	int ret;
+
+	ret = posix_memalign(&ptr, PAGE_SIZE, size);
+	igt_assert(ret == 0);
+
+	ret = gem_userptr(fd, (uint32_t *)ptr, size, 0, &handle);
+	igt_assert(ret == 0);
+	add_handle_ptr(handle, ptr);
+
+	return handle;
+}
+
+static void free_userptr_bo(int fd, uint32_t handle)
+{
+	gem_close(fd, handle);
+	free_handle_ptr(handle);
+}
+
+static int has_userptr(int fd)
+{
+	uint32_t handle = 0;
+	void *ptr;
+	uint32_t oldflags;
+	int ret;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+	oldflags = userptr_flags;
+	gem_userptr_test_unsynchronized();
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	userptr_flags = oldflags;
+	if (ret != 0) {
+		free(ptr);
+		return 0;
+	}
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return handle != 0;
+}
+
+static const unsigned int nr_bos[] = {0, 1, 10, 100, 1000};
+static const unsigned int test_duration_sec = 3;
+
+static volatile unsigned int run_test;
+
+static void alarm_handler(int sig)
+{
+	assert(run_test == 1);
+	run_test = 0;
+}
+
+static void start_test(unsigned int duration)
+{
+	run_test = 1;
+	if (duration == 0)
+		duration = test_duration_sec;
+	signal(SIGALRM, alarm_handler);
+	alarm(duration);
+}
+
+static void exchange_ptr(void *array, unsigned i, unsigned j)
+{
+	void **arr, *tmp;
+	arr = (void **)array;
+
+	tmp = arr[i];
+	arr[i] = arr[j];
+	arr[j] = tmp;
+}
+
+static void test_malloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_malloc_realloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++) {
+			ptr[i] = realloc(ptr[i], 2000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_mmap_unmap(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = mmap(NULL, 1000, PROT_READ | PROT_WRITE,
+					MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+			assert(ptr[i] != MAP_FAILED);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			munmap(ptr[i], 1000);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_ptr_read(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	unsigned long i, loops;
+	register unsigned long v;
+
+	loops = BO_SIZE / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			v = *p++;
+			v = *p++;
+			v = *p++;
+			v = *p++;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * BO_SIZE / 1000000);
+}
+
+static void test_ptr_write(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	register unsigned long i, loops;
+
+	loops = BO_SIZE / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * BO_SIZE / 1000000);
+}
+
+static void test_impact(int fd)
+{
+	unsigned int total = sizeof(nr_bos) / sizeof(nr_bos[0]);
+	unsigned int subtest, i;
+	uint32_t handles[nr_bos[total-1]];
+	void *ptr;
+	char buffer[BO_SIZE];
+
+	for (subtest = 0; subtest < total; subtest++) {
+		for (i = 0; i < nr_bos[subtest]; i++)
+			handles[i] = create_userptr_bo(fd, BO_SIZE);
+
+		if (nr_bos[subtest] > 0)
+			ptr = get_handle_ptr(handles[0]);
+		else
+			ptr = buffer;
+
+		printf("ptr-read,                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_read(ptr);
+
+		printf("ptr-write                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_write(ptr);
+
+		printf("malloc-free,                %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(0);
+		printf("malloc-free-random          %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(1);
+
+		printf("malloc-realloc-free,        %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(0);
+		printf("malloc-realloc-free-random, %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(1);
+
+		printf("mmap-unmap,                 %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(0);
+		printf("mmap-unmap-random,          %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(1);
+
+		for (i = 0; i < nr_bos[subtest]; i++)
+			free_userptr_bo(fd, handles[i]);
+	}
+}
+
+static void test_single(int fd)
+{
+	char *ptr, *bo_ptr;
+	uint32_t handle = 0;
+	unsigned long iter = 0;
+	int ret;
+	unsigned long map_size = BO_SIZE + PAGE_SIZE - 1;
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		ret = gem_userptr(fd, bo_ptr, BO_SIZE, 0, &handle);
+		assert(ret == 0);
+		gem_close(fd, handle);
+		iter++;
+	}
+
+	munmap(ptr, map_size);
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_multiple(int fd, unsigned int batch, int random)
+{
+	char *ptr, *bo_ptr;
+	uint32_t handles[10000];
+	int map[10000];
+	unsigned long iter = 0;
+	int ret;
+	int i;
+	unsigned long map_size = batch * BO_SIZE + PAGE_SIZE - 1;
+
+	assert(batch < (sizeof(handles) / sizeof(handles[0])));
+	assert(batch < (sizeof(map) / sizeof(map[0])));
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
+
+	for (i = 0; i < batch; i++)
+		map[i] = i;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		if (random)
+			igt_permute_array(map, batch, igt_exchange_int);
+		for (i = 0; i < batch; i++) {
+			ret = gem_userptr(fd, bo_ptr + map[i] * BO_SIZE,
+						BO_SIZE,
+						0, &handles[i]);
+			assert(ret == 0);
+		}
+		if (random)
+			igt_permute_array(map, batch, igt_exchange_int);
+		for (i = 0; i < batch; i++)
+			gem_close(fd, handles[map[i]]);
+		iter++;
+	}
+
+	munmap(ptr, map_size);
+
+	printf("%8lu iter/s\n", iter * batch / test_duration_sec);
+}
+
+static void test_userptr(int fd)
+{
+	printf("create-destroy                = ");
+	test_single(fd);
+
+	printf("multi-create-destroy          = ");
+	test_multiple(fd, 100, 0);
+
+	printf("multi-create-destroy-random   = ");
+	test_multiple(fd, 100, 1);
+}
+
+int main(int argc, char **argv)
+{
+	int fd = -1, ret;
+
+	igt_skip_on_simulation();
+
+	igt_subtest_init(argc, argv);
+
+	fd = drm_open_any();
+	igt_assert(fd >= 0);
+
+	ret = has_userptr(fd);
+	igt_skip_on_f(ret == 0, "No userptr support - %s (%d)\n",
+			strerror(errno), ret);
+
+
+	gem_userptr_test_unsynchronized();
+
+	igt_subtest("userptr-unsync")
+		test_userptr(fd);
+
+	igt_subtest("userptr-impact-unsync")
+		test_impact(fd);
+
+	gem_userptr_test_synchronized();
+
+	igt_subtest("userptr-sync")
+		test_userptr(fd);
+
+	igt_subtest("userptr-impact-sync")
+		test_impact(fd);
+
+	igt_exit();
+
+	return 0;
+}
Signature · 1 line
1.9.1
#9 lore raw

Re: [PATCH 3/3] tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

On 04/23/2014 06:17 PM, Volkin, Bradley D wrote:
[snip]

Quoted 23 lines
Quoted 7 lines
benchmarks/gem_userptr_benchmark.c new file +7 -0
+static int gem_userptr(int fd, void *ptr, int size, int read_only, uint32_t *handle)
+{
+	struct local_i915_gem_userptr userptr;
+	int ret;
+
+	userptr.user_ptr = (uintptr_t)ptr;
+	userptr.user_size = size;

benchmarks/gem_userptr_benchmark.c line 99

Quoted 10 lines
benchmarks/gem_userptr_benchmark.c new file +10 -0
+	userptr.flags = userptr_flags;
+	if (read_only)
+		userptr.flags |= LOCAL_I915_USERPTR_READ_ONLY;
+
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	if (ret)
+		ret = errno;
+	igt_skip_on_f(ret == ENODEV &&
+		      (userptr_flags & LOCAL_I915_USERPTR_UNSYNCHRONIZED) == 0,
+		      "Skipping, synchronized mappings with no kernel CONFIG_MMU_NOTIFIER?");

I missed it the first time around, but the condition here doesn't match the other test; it's missing the '&& !read_only'. It looks like read_only will always be 0 in this test though, so probably not an issue.

Quoted 1 line

Good catch! It does not matter in the benchmark but I've sent a respin for consistency and clarity.

Thanks,

Tvrtko

Reviewed-by on v1 1/3
#10 lore raw

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

In reply to Tvrtko Ursulin
Quoted 1,315 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.

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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

v3:
* Use ALIGN macro.
* Catchup with big lib/ reorganization.
* Fixed up some warnings.

---
 tests/.gitignore          |    1 +
 tests/Makefile.sources    |    1 +
 tests/gem_userptr_blits.c | 1247 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 1249 insertions(+)
 create mode 100644 tests/gem_userptr_blits.c
tests/.gitignore +1 -0
index 146bab0..ff193bd 100644
@@ -95,6 +95,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 c957ace..09d6aa3 100644
@@ -121,6 +121,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 +1247 -0
new file mode 100644
index 0000000..03af58e
@@ -0,0 +1,1247 @@
+/*
+ * Copyright © 2009-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]>
+ *    Chris Wilson <[email protected]>
+ *    Tvrtko Ursulin <[email protected]>
+ *
+ */
+
+/** @file gem_userptr_blits.c
+ *
+ * This is a test of doing many blits using a mixture of normal system pages
+ * and uncached linear buffers, with a working set larger than the
+ * aperture size.
+ *
+ * The goal is to simply ensure the basics work.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include "drm.h"
+#include "i915_drm.h"
+#include "drmtest.h"
+#include "intel_bufmgr.h"
+#include "intel_batchbuffer.h"
+#include "intel_chipset.h"
+#include "ioctl_wrappers.h"
+
+#include "eviction_common.c"
+
+#ifndef PAGE_SIZE
+#define PAGE_SIZE 4096
+#endif
+
+#define LOCAL_I915_GEM_USERPTR       0x34
+#define LOCAL_IOCTL_I915_GEM_USERPTR DRM_IOWR (DRM_COMMAND_BASE + LOCAL_I915_GEM_USERPTR, struct local_i915_gem_userptr)
+struct local_i915_gem_userptr {
+	uint64_t user_ptr;
+	uint64_t user_size;
+	uint32_t flags;
+#define LOCAL_I915_USERPTR_READ_ONLY (1<<0)
+#define LOCAL_I915_USERPTR_UNSYNCHRONIZED (1<<31)
+	uint32_t handle;
+};
+
+static uint32_t userptr_flags = LOCAL_I915_USERPTR_UNSYNCHRONIZED;
+
+#define WIDTH 512
+#define HEIGHT 512
+
+static uint32_t linear[WIDTH*HEIGHT];
+
+static void gem_userptr_test_unsynchronized(void)
+{
+	userptr_flags = LOCAL_I915_USERPTR_UNSYNCHRONIZED;
+}
+
+static void gem_userptr_test_synchronized(void)
+{
+	userptr_flags = 0;
+}
+
+static int gem_userptr(int fd, void *ptr, int size, int read_only, uint32_t *handle)
+{
+	struct local_i915_gem_userptr userptr;
+	int ret;
+
+	userptr.user_ptr = (uintptr_t)ptr;
+	userptr.user_size = size;
+	userptr.flags = userptr_flags;
+	if (read_only)
+		userptr.flags |= LOCAL_I915_USERPTR_READ_ONLY;
+
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	if (ret)
+		ret = errno;
+	igt_skip_on_f(ret == ENODEV &&
+		      (userptr_flags & LOCAL_I915_USERPTR_UNSYNCHRONIZED) == 0 &&
+		      !read_only,
+		      "Skipping, synchronized mappings with no kernel CONFIG_MMU_NOTIFIER?");
+	if (ret == 0)
+		*handle = userptr.handle;
+
+	return ret;
+}
+
+
+static void gem_userptr_sync(int fd, uint32_t handle)
+{
+	gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
+}
+
+static void
+copy(int fd, uint32_t dst, uint32_t src, unsigned int error)
+{
+	uint32_t batch[12];
+	struct drm_i915_gem_relocation_entry reloc[2];
+	struct drm_i915_gem_exec_object2 obj[3];
+	struct drm_i915_gem_execbuffer2 exec;
+	uint32_t handle;
+	int ret, i=0;
+
+	batch[i++] = XY_SRC_COPY_BLT_CMD |
+		  XY_SRC_COPY_BLT_WRITE_ALPHA |
+		  XY_SRC_COPY_BLT_WRITE_RGB;
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i - 1] |= 8;
+	else
+		batch[i - 1] |= 6;
+
+	batch[i++] = (3 << 24) | /* 32 bits */
+		  (0xcc << 16) | /* copy ROP */
+		  WIDTH*4;
+	batch[i++] = 0; /* dst x1,y1 */
+	batch[i++] = (HEIGHT << 16) | WIDTH; /* dst x2,y2 */
+	batch[i++] = 0; /* dst reloc */
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i++] = 0;
+	batch[i++] = 0; /* src x1,y1 */
+	batch[i++] = WIDTH*4;
+	batch[i++] = 0; /* src reloc */
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i++] = 0;
+	batch[i++] = MI_BATCH_BUFFER_END;
+	batch[i++] = MI_NOOP;
+
+	handle = gem_create(fd, 4096);
+	gem_write(fd, handle, 0, batch, sizeof(batch));
+
+	reloc[0].target_handle = dst;
+	reloc[0].delta = 0;
+	reloc[0].offset = 4 * sizeof(batch[0]);
+	reloc[0].presumed_offset = 0;
+	reloc[0].read_domains = I915_GEM_DOMAIN_RENDER;;
+	reloc[0].write_domain = I915_GEM_DOMAIN_RENDER;
+
+	reloc[1].target_handle = src;
+	reloc[1].delta = 0;
+	reloc[1].offset = 7 * sizeof(batch[0]);
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		reloc[1].offset += sizeof(batch[0]);
+	reloc[1].presumed_offset = 0;
+	reloc[1].read_domains = I915_GEM_DOMAIN_RENDER;;
+	reloc[1].write_domain = 0;
+
+	obj[0].handle = dst;
+	obj[0].relocation_count = 0;
+	obj[0].relocs_ptr = 0;
+	obj[0].alignment = 0;
+	obj[0].offset = 0;
+	obj[0].flags = 0;
+	obj[0].rsvd1 = 0;
+	obj[0].rsvd2 = 0;
+
+	obj[1].handle = src;
+	obj[1].relocation_count = 0;
+	obj[1].relocs_ptr = 0;
+	obj[1].alignment = 0;
+	obj[1].offset = 0;
+	obj[1].flags = 0;
+	obj[1].rsvd1 = 0;
+	obj[1].rsvd2 = 0;
+
+	obj[2].handle = handle;
+	obj[2].relocation_count = 2;
+	obj[2].relocs_ptr = (uintptr_t)reloc;
+	obj[2].alignment = 0;
+	obj[2].offset = 0;
+	obj[2].flags = 0;
+	obj[2].rsvd1 = obj[2].rsvd2 = 0;
+
+	exec.buffers_ptr = (uintptr_t)obj;
+	exec.buffer_count = 3;
+	exec.batch_start_offset = 0;
+	exec.batch_len = i * 4;
+	exec.DR1 = exec.DR4 = 0;
+	exec.num_cliprects = 0;
+	exec.cliprects_ptr = 0;
+	exec.flags = HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0;
+	i915_execbuffer2_set_context_id(exec, 0);
+	exec.rsvd2 = 0;
+
+	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
+	if (ret)
+		ret = errno;
+
+	if (error == ~0)
+		igt_assert(ret != 0);
+	else
+		igt_assert(ret == error);
+
+	gem_close(fd, handle);
+}
+
+static void
+blit(int fd, uint32_t dst, uint32_t src, uint32_t *all_bo, int n_bo, int error)
+{
+	uint32_t batch[12];
+	struct drm_i915_gem_relocation_entry reloc[2];
+	struct drm_i915_gem_exec_object2 *obj;
+	struct drm_i915_gem_execbuffer2 exec;
+	uint32_t handle;
+	int n, ret, i=0;
+
+	batch[i++] = XY_SRC_COPY_BLT_CMD |
+		  XY_SRC_COPY_BLT_WRITE_ALPHA |
+		  XY_SRC_COPY_BLT_WRITE_RGB;
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i - 1] |= 8;
+	else
+		batch[i - 1] |= 6;
+	batch[i++] = (3 << 24) | /* 32 bits */
+		  (0xcc << 16) | /* copy ROP */
+		  WIDTH*4;
+	batch[i++] = 0; /* dst x1,y1 */
+	batch[i++] = (HEIGHT << 16) | WIDTH; /* dst x2,y2 */
+	batch[i++] = 0; /* dst reloc */
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i++] = 0;
+	batch[i++] = 0; /* src x1,y1 */
+	batch[i++] = WIDTH*4;
+	batch[i++] = 0; /* src reloc */
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i++] = 0;
+	batch[i++] = MI_BATCH_BUFFER_END;
+	batch[i++] = MI_NOOP;
+
+	handle = gem_create(fd, 4096);
+	gem_write(fd, handle, 0, batch, sizeof(batch));
+
+	reloc[0].target_handle = dst;
+	reloc[0].delta = 0;
+	reloc[0].offset = 4 * sizeof(batch[0]);
+	reloc[0].presumed_offset = 0;
+	reloc[0].read_domains = I915_GEM_DOMAIN_RENDER;
+	reloc[0].write_domain = I915_GEM_DOMAIN_RENDER;
+
+	reloc[1].target_handle = src;
+	reloc[1].delta = 0;
+	reloc[1].offset = 7 * sizeof(batch[0]);
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		reloc[1].offset += sizeof(batch[0]);
+	reloc[1].presumed_offset = 0;
+	reloc[1].read_domains = I915_GEM_DOMAIN_RENDER;
+	reloc[1].write_domain = 0;
+
+	obj = calloc(n_bo + 1, sizeof(*obj));
+	for (n = 0; n < n_bo; n++)
+		obj[n].handle = all_bo[n];
+	obj[n].handle = handle;
+	obj[n].relocation_count = 2;
+	obj[n].relocs_ptr = (uintptr_t)reloc;
+
+	exec.buffers_ptr = (uintptr_t)obj;
+	exec.buffer_count = n_bo + 1;
+	exec.batch_start_offset = 0;
+	exec.batch_len = i * 4;
+	exec.DR1 = exec.DR4 = 0;
+	exec.num_cliprects = 0;
+	exec.cliprects_ptr = 0;
+	exec.flags = HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0;
+	i915_execbuffer2_set_context_id(exec, 0);
+	exec.rsvd2 = 0;
+
+	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
+	if (ret)
+		ret = errno;
+
+	igt_assert(ret == error);
+
+	gem_close(fd, handle);
+	free(obj);
+}
+
+static uint32_t
+create_userptr(int fd, uint32_t val, uint32_t *ptr)
+{
+	uint32_t handle;
+	int i, ret;
+
+	ret = gem_userptr(fd, ptr, sizeof(linear), 0, &handle);
+	igt_assert(ret == 0);
+	igt_assert(handle != 0);
+
+	/* Fill the BO with dwords starting at val */
+	for (i = 0; i < WIDTH*HEIGHT; i++)
+		ptr[i] = val++;
+
+	return handle;
+}
+
+static void **handle_ptr_map;
+static unsigned int num_handle_ptr_map;
+
+static void add_handle_ptr(uint32_t handle, void *ptr)
+{
+	if (handle >= num_handle_ptr_map) {
+		handle_ptr_map = realloc(handle_ptr_map,
+					 (handle + 1000) * sizeof(void*));
+		num_handle_ptr_map = handle + 1000;
+	}
+
+	handle_ptr_map[handle] = ptr;
+}
+
+static void *get_handle_ptr(uint32_t handle)
+{
+	return handle_ptr_map[handle];
+}
+
+static void free_handle_ptr(uint32_t handle)
+{
+	igt_assert(handle < num_handle_ptr_map);
+	igt_assert(handle_ptr_map[handle]);
+
+	free(handle_ptr_map[handle]);
+	handle_ptr_map[handle] = NULL;
+}
+
+static uint32_t create_userptr_bo(int fd, int size)
+{
+	void *ptr;
+	uint32_t handle;
+	int ret;
+
+	ret = posix_memalign(&ptr, PAGE_SIZE, size);
+	igt_assert(ret == 0);
+
+	ret = gem_userptr(fd, (uint32_t *)ptr, size, 0, &handle);
+	igt_assert(ret == 0);
+	add_handle_ptr(handle, ptr);
+
+	return handle;
+}
+
+static void clear(int fd, uint32_t handle, int size)
+{
+	void *ptr = get_handle_ptr(handle);
+
+	igt_assert(ptr != NULL);
+
+	memset(ptr, 0, size);
+}
+
+static void free_userptr_bo(int fd, uint32_t handle)
+{
+	gem_close(fd, handle);
+	free_handle_ptr(handle);
+}
+
+static uint32_t
+create_bo(int fd, uint32_t val)
+{
+	uint32_t handle;
+	int i;
+
+	handle = gem_create(fd, sizeof(linear));
+
+	/* Fill the BO with dwords starting at val */
+	for (i = 0; i < WIDTH*HEIGHT; i++)
+		linear[i] = val++;
+	gem_write(fd, handle, 0, linear, sizeof(linear));
+
+	return handle;
+}
+
+static void
+check_cpu(uint32_t *ptr, uint32_t val)
+{
+	int i;
+
+	for (i = 0; i < WIDTH*HEIGHT; i++) {
+		if (ptr[i] != val) {
+			fprintf(stderr, "Expected 0x%08x, found 0x%08x "
+				"at offset 0x%08x\n",
+				val, ptr[i], i * 4);
+			abort();
+		}
+		val++;
+	}
+}
+
+static void
+check_gpu(int fd, uint32_t handle, uint32_t val)
+{
+	gem_read(fd, handle, 0, linear, sizeof(linear));
+	check_cpu(linear, val);
+}
+
+static int has_userptr(int fd)
+{
+	uint32_t handle = 0;
+	void *ptr;
+	uint32_t oldflags;
+	int ret;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+	oldflags = userptr_flags;
+	gem_userptr_test_unsynchronized();
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	userptr_flags = oldflags;
+	if (ret != 0) {
+		free(ptr);
+		return 0;
+	}
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return handle != 0;
+}
+
+static int test_input_checking(int fd)
+{
+	struct local_i915_gem_userptr userptr;
+	int ret;
+
+	/* Invalid flags. */
+	userptr.user_ptr = 0;
+	userptr.user_size = 0;
+	userptr.flags = ~0;
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	igt_assert(ret != 0);
+
+	/* Too big. */
+	userptr.user_ptr = 0;
+	userptr.user_size = ~0;
+	userptr.flags = 0;
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	igt_assert(ret != 0);
+
+	/* Both wrong. */
+	userptr.user_ptr = 0;
+	userptr.user_size = ~0;
+	userptr.flags = ~0;
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	igt_assert(ret != 0);
+
+	return 0;
+}
+
+static int test_access_control(int fd)
+{
+	igt_fork(child, 1) {
+		void *ptr;
+		int ret;
+		uint32_t handle;
+
+		igt_drop_root();
+
+		/* CAP_SYS_ADMIN is needed for UNSYNCHRONIZED mappings. */
+		gem_userptr_test_unsynchronized();
+
+		igt_assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+
+		ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+		if (ret == 0)
+			gem_close(fd, handle);
+		free(ptr);
+		igt_assert(ret == EPERM);
+	}
+
+	igt_waitchildren();
+
+	return 0;
+}
+
+static int test_invalid_mapping(int fd)
+{
+	int ret;
+	uint32_t handle, handle2;
+	void *ptr;
+
+	/* NULL pointer. */
+	ret = gem_userptr(fd, NULL, PAGE_SIZE, 0, &handle);
+	igt_assert(ret == 0);
+	copy(fd, handle, handle, ~0); /* QQQ Precise errno? */
+	gem_close(fd, handle);
+
+	/* GTT mapping */
+	handle = create_bo(fd, 0);
+	ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	if (ptr == NULL)
+		gem_close(fd, handle);
+	assert(ptr != NULL);
+	assert(((unsigned long)ptr & (PAGE_SIZE - 1)) == 0);
+	assert((sizeof(linear) & (PAGE_SIZE - 1)) == 0);
+	ret = gem_userptr(fd, ptr, sizeof(linear), 0, &handle2);
+	igt_assert(ret == 0);
+	copy(fd, handle, handle, ~0); /* QQQ Precise errno? */
+	gem_close(fd, handle2);
+	munmap(ptr, sizeof(linear));
+	gem_close(fd, handle);
+
+	return 0;
+}
+
+static int test_forbidden_ops(int fd)
+{
+	void *ptr;
+	int ret;
+	uint32_t handle;
+	char buf[PAGE_SIZE];
+	struct drm_i915_gem_pread gem_pread;
+	struct drm_i915_gem_pwrite gem_pwrite;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	igt_assert(ret == 0);
+
+	gem_pread.handle = handle;
+	gem_pread.offset = 0;
+	gem_pread.size = PAGE_SIZE;
+	gem_pread.data_ptr = (uintptr_t)buf;
+	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_PREAD, &gem_pread);
+	if (ret == 0) {
+		gem_close(fd, handle);
+		free(ptr);
+	}
+	igt_assert(ret != 0);
+
+	gem_pwrite.handle = handle;
+	gem_pwrite.offset = 0;
+	gem_pwrite.size = PAGE_SIZE;
+	gem_pwrite.data_ptr = (uintptr_t)buf;
+	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_PWRITE, &gem_pwrite);
+	if (ret == 0) {
+		gem_close(fd, handle);
+		free(ptr);
+	}
+	igt_assert(ret != 0);
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return 0;
+}
+
+static char counter;
+
+static void (*orig_sigbus)(int sig, siginfo_t *info, void *param);
+static unsigned long sigbus_start;
+static long sigbus_cnt = -1;
+
+static void
+check_bo(int fd1, uint32_t handle1, int is_userptr, int fd2, uint32_t handle2)
+{
+	char *ptr1, *ptr2;
+	int i;
+	unsigned long size = sizeof(linear);
+
+	if (is_userptr)
+		ptr1 = get_handle_ptr(handle1);
+	else
+		ptr1 = gem_mmap(fd1, handle1, sizeof(linear), PROT_READ | PROT_WRITE);
+
+	ptr2 = gem_mmap(fd2, handle2, sizeof(linear), PROT_READ | PROT_WRITE);
+
+	igt_assert(ptr1);
+	igt_assert(ptr2);
+
+	sigbus_start = (unsigned long)ptr2;
+
+	if (sigbus_cnt == 0)
+		size = 1;
+
+	/* check whether it's still our old object first. */
+	for (i = 0; i < size; i++) {
+		igt_assert(ptr1[i] == counter);
+		igt_assert(ptr2[i] == counter);
+	}
+
+	counter++;
+
+	if (size > 1) {
+		memset(ptr1, counter, size);
+		igt_assert(memcmp(ptr1, ptr2, size) == 0);
+	}
+
+	if (!is_userptr)
+		munmap(ptr1, sizeof(linear));
+	munmap(ptr2, sizeof(linear));
+}
+
+static int export_handle(int fd, uint32_t handle, int *outfd)
+{
+	struct drm_prime_handle args;
+	int ret;
+
+	args.handle = handle;
+	args.flags = DRM_CLOEXEC;
+	args.fd = -1;
+
+	ret = drmIoctl(fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &args);
+	if (ret)
+		ret = errno;
+	*outfd = args.fd;
+
+	return ret;
+}
+
+static void sigbus(int sig, siginfo_t *info, void *param)
+{
+	unsigned long ptr = (unsigned long)info->si_addr;
+	void *addr;
+
+	if (ptr >= sigbus_start &&
+	    ptr <= (sigbus_start + sizeof(linear))) {
+		sigbus_cnt++;
+		addr = mmap((void *)ptr, sizeof(linear), PROT_READ | PROT_WRITE,
+				MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
+		if ((unsigned long)addr == ptr) {
+			memset(addr, counter, sizeof(linear));
+			return;
+		}
+	}
+
+	if (orig_sigbus)
+		orig_sigbus(sig, info, param);
+	assert(0);
+}
+
+static int test_dmabuf(void)
+{
+	int fd1, fd2;
+	uint32_t handle, handle_import1, handle_import2, handle_selfimport;
+	int dma_buf_fd = -1;
+	int ret;
+	struct sigaction sigact, orig_sigact;
+
+	fd1 = drm_open_any();
+	fd2 = drm_open_any();
+
+	handle = create_userptr_bo(fd1, sizeof(linear));
+
+	ret = export_handle(fd1, handle, &dma_buf_fd);
+	if (userptr_flags & LOCAL_I915_USERPTR_UNSYNCHRONIZED) {
+		igt_assert(ret == EINVAL);
+		free_userptr_bo(fd1, handle);
+
+		return 0;
+	} else {
+		igt_assert(ret == 0);
+		igt_assert(dma_buf_fd >= 0);
+	}
+	handle_import1 = prime_fd_to_handle(fd2, dma_buf_fd);
+	check_bo(fd1, handle, 1, fd2, handle_import1);
+
+	/* reimport should give us the same handle so that userspace can check
+	 * whether it has that bo already somewhere. */
+	handle_import2 = prime_fd_to_handle(fd2, dma_buf_fd);
+	igt_assert(handle_import1 == handle_import2);
+
+	/* Same for re-importing on the exporting fd. */
+	handle_selfimport = prime_fd_to_handle(fd1, dma_buf_fd);
+	igt_assert(handle == handle_selfimport);
+
+	/* close dma_buf, check whether nothing disappears. */
+	close(dma_buf_fd);
+	check_bo(fd1, handle, 1, fd2, handle_import1);
+
+	/* destroy userptr object and expect SIGBUS */
+	free_userptr_bo(fd1, handle);
+	sigact.sa_sigaction = sigbus;
+	sigact.sa_flags = SA_SIGINFO;
+	ret = sigaction(SIGBUS, &sigact, &orig_sigact);
+	assert(ret == 0);
+	orig_sigbus = orig_sigact.sa_sigaction;
+	sigbus_cnt = 0;
+	check_bo(fd2, handle_import1, 0, fd2, handle_import1);
+	assert(sigbus_cnt > 0);
+	sigact.sa_sigaction = orig_sigbus;
+	sigact.sa_flags = SA_SIGINFO;
+	ret = sigaction(SIGBUS, &sigact, &orig_sigact);
+	assert(ret == 0);
+
+	gem_close(fd2, handle_import1);
+	close(fd1);
+	close(fd2);
+
+	return 0;
+}
+
+static int test_usage_restrictions(int fd)
+{
+	void *ptr;
+	int ret;
+	uint32_t handle;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE * 2) == 0);
+
+	/* Address not aligned. */
+	ret = gem_userptr(fd, (char *)ptr + 1, PAGE_SIZE, 0, &handle);
+	igt_assert(ret != 0);
+
+	/* Size not rounded to page size. */
+	ret = gem_userptr(fd, ptr, PAGE_SIZE - 1, 0, &handle);
+	igt_assert(ret != 0);
+
+	/* Both wrong. */
+	ret = gem_userptr(fd, (char *)ptr + 1, PAGE_SIZE - 1, 0, &handle);
+	igt_assert(ret != 0);
+
+	/* Read-only not supported. */
+	ret = gem_userptr(fd, (char *)ptr, PAGE_SIZE, 1, &handle);
+	igt_assert(ret != 0);
+
+	free(ptr);
+
+	return 0;
+}
+
+static int test_create_destroy(int fd)
+{
+	void *ptr;
+	int ret;
+	uint32_t handle;
+
+	igt_assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	igt_assert(ret == 0);
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return 0;
+}
+
+static int test_coherency(int fd, int count)
+{
+	uint32_t *memory;
+	uint32_t *cpu, *cpu_val;
+	uint32_t *gpu, *gpu_val;
+	uint32_t start = 0;
+	int i, ret;
+
+	printf("Using 2x%d 1MiB buffers\n", count);
+
+	ret = posix_memalign((void **)&memory, PAGE_SIZE, count*sizeof(linear));
+	if (ret != 0 || memory == NULL) {
+		fprintf(stderr, "Unable to allocate %lld bytes\n",
+			(long long)count*sizeof(linear));
+		return 1;
+	}
+
+	gpu = malloc(sizeof(uint32_t)*count*4);
+	gpu_val = gpu + count;
+	cpu = gpu_val + count;
+	cpu_val = cpu + count;
+
+	for (i = 0; i < count; i++) {
+		gpu[i] = create_bo(fd, start);
+		gpu_val[i] = start;
+		start += WIDTH*HEIGHT;
+	}
+
+	for (i = 0; i < count; i++) {
+		cpu[i] = create_userptr(fd, start, memory+i*WIDTH*HEIGHT);
+		cpu_val[i] = start;
+		start += WIDTH*HEIGHT;
+	}
+
+	printf("Verifying initialisation...\n");
+	for (i = 0; i < count; i++) {
+		check_gpu(fd, gpu[i], gpu_val[i]);
+		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
+	}
+
+	printf("Cyclic blits cpu->gpu, forward...\n");
+	for (i = 0; i < count * 4; i++) {
+		int src = i % count;
+		int dst = (i + 1) % count;
+
+		copy(fd, gpu[dst], cpu[src], 0);
+		gpu_val[dst] = cpu_val[src];
+	}
+	for (i = 0; i < count; i++)
+		check_gpu(fd, gpu[i], gpu_val[i]);
+
+	printf("Cyclic blits gpu->cpu, backward...\n");
+	for (i = 0; i < count * 4; i++) {
+		int src = (i + 1) % count;
+		int dst = i % count;
+
+		copy(fd, cpu[dst], gpu[src], 0);
+		cpu_val[dst] = gpu_val[src];
+	}
+	for (i = 0; i < count; i++) {
+		gem_userptr_sync(fd, cpu[i]);
+		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
+	}
+
+	printf("Random blits...\n");
+	for (i = 0; i < count * 4; i++) {
+		int src = random() % count;
+		int dst = random() % count;
+
+		if (random() & 1) {
+			copy(fd, gpu[dst], cpu[src], 0);
+			gpu_val[dst] = cpu_val[src];
+		} else {
+			copy(fd, cpu[dst], gpu[src], 0);
+			cpu_val[dst] = gpu_val[src];
+		}
+	}
+	for (i = 0; i < count; i++) {
+		check_gpu(fd, gpu[i], gpu_val[i]);
+		gem_close(fd, gpu[i]);
+
+		gem_userptr_sync(fd, cpu[i]);
+		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
+		gem_close(fd, cpu[i]);
+	}
+
+	free(gpu);
+	free(memory);
+
+	return 0;
+}
+
+static struct igt_eviction_test_ops fault_ops = {
+	.create = create_userptr_bo,
+	.close = free_userptr_bo,
+	.copy = blit,
+	.clear = clear,
+};
+
+static int can_swap(void)
+{
+	unsigned long as, ram;
+
+	/* Cannot swap if not enough address space */
+
+	/* FIXME: Improve check criteria. */
+	if (sizeof(void*) < 8)
+		as = 3 * 1024;
+	else
+		as = 256 * 1024; /* Just a big number */
+
+	ram = intel_get_total_ram_mb();
+
+	if ((as - 128) < (ram - 256))
+		return 0;
+
+	return 1;
+}
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+
+static void test_forking_evictions(int fd, int size, int count,
+			     unsigned flags)
+{
+	int trash_count;
+	int num_threads;
+
+	trash_count = intel_get_total_ram_mb() * 11 / 10;
+	/* Use the fact test will spawn a number of child
+	 * processes meaning swapping will be triggered system
+	 * wide even if one process on it's own can't do it.
+	 */
+	num_threads = min(sysconf(_SC_NPROCESSORS_ONLN) * 4, 12);
+	trash_count /= num_threads;
+	if (count > trash_count)
+		count = trash_count;
+
+	forking_evictions(fd, &fault_ops, size, count, trash_count, flags);
+}
+
+static void test_swapping_evictions(int fd, int size, int count)
+{
+	int trash_count;
+
+	igt_skip_on_f(!can_swap(),
+		"Not enough process address space for swapping tests.\n");
+
+	trash_count = intel_get_total_ram_mb() * 11 / 10;
+
+	swapping_evictions(fd, &fault_ops, size, count, trash_count);
+}
+
+static void test_minor_evictions(int fd, int size, int count)
+{
+	minor_evictions(fd, &fault_ops, size, count);
+}
+
+static void test_major_evictions(int fd, int size, int count)
+{
+	major_evictions(fd, &fault_ops, size, count);
+}
+
+static int test_overlap(int fd, int expected)
+{
+	char *ptr;
+	int ret;
+	uint32_t handle, handle2;
+
+	igt_assert(posix_memalign((void *)&ptr, PAGE_SIZE, PAGE_SIZE * 3) == 0);
+
+	ret = gem_userptr(fd, ptr + PAGE_SIZE, PAGE_SIZE, 0, &handle);
+	igt_assert(ret == 0);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle2);
+	igt_assert(ret == 0);
+	gem_close(fd, handle2);
+
+	ret = gem_userptr(fd, ptr + PAGE_SIZE * 2, PAGE_SIZE, 0, &handle2);
+	igt_assert(ret == 0);
+	gem_close(fd, handle2);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE * 2, 0, &handle2);
+	igt_assert(ret == expected);
+	if (ret == 0)
+		gem_close(fd, handle2);
+
+	ret = gem_userptr(fd, ptr + PAGE_SIZE, PAGE_SIZE * 2, 0, &handle2);
+	igt_assert(ret == expected);
+	if (ret == 0)
+		gem_close(fd, handle2);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE * 3, 0, &handle2);
+	igt_assert(ret == expected);
+	if (ret == 0)
+		gem_close(fd, handle2);
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return 0;
+}
+
+static int test_unmap(int fd, int expected)
+{
+	char *ptr, *bo_ptr;
+	const unsigned int num_obj = 3;
+	unsigned int i;
+	uint32_t bo[num_obj + 1];
+	size_t map_size = sizeof(linear) * num_obj + (PAGE_SIZE - 1);
+	int ret;
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+				MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
+
+	for (i = 0; i < num_obj; i++, bo_ptr += sizeof(linear)) {
+		ret = gem_userptr(fd, bo_ptr, sizeof(linear), 0, &bo[i]);
+		igt_assert(ret == 0);
+	}
+
+	bo[num_obj] = create_bo(fd, 0);
+
+	for (i = 0; i < num_obj; i++)
+		copy(fd, bo[num_obj], bo[i], 0);
+
+	ret = munmap(ptr, map_size);
+	assert(ret == 0);
+
+	for (i = 0; i < num_obj; i++)
+		copy(fd, bo[num_obj], bo[i], expected);
+
+	for (i = 0; i < (num_obj + 1); i++)
+		gem_close(fd, bo[i]);
+
+	return 0;
+}
+
+static int test_unmap_after_close(int fd)
+{
+	char *ptr, *bo_ptr;
+	const unsigned int num_obj = 3;
+	unsigned int i;
+	uint32_t bo[num_obj + 1];
+	size_t map_size = sizeof(linear) * num_obj + (PAGE_SIZE - 1);
+	int ret;
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+				MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
+
+	for (i = 0; i < num_obj; i++, bo_ptr += sizeof(linear)) {
+		ret = gem_userptr(fd, bo_ptr, sizeof(linear), 0, &bo[i]);
+		igt_assert(ret == 0);
+	}
+
+	bo[num_obj] = create_bo(fd, 0);
+
+	for (i = 0; i < num_obj; i++)
+		copy(fd, bo[num_obj], bo[i], 0);
+
+	for (i = 0; i < (num_obj + 1); i++)
+		gem_close(fd, bo[i]);
+
+	ret = munmap(ptr, map_size);
+	assert(ret == 0);
+
+	return 0;
+}
+
+static int test_unmap_cycles(int fd, int expected)
+{
+	int i;
+
+	for (i = 0; i < 1000; i++)
+		test_unmap(fd, expected);
+
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	uint64_t aperture_size;
+	unsigned int total_ram;
+	int fd = -1, count = 0, size = 0, ret;
+
+	igt_skip_on_simulation();
+
+	igt_subtest_init(argc, argv);
+
+	igt_fixture {
+		fd = drm_open_any();
+		igt_assert(fd >= 0);
+
+		ret = has_userptr(fd);
+		igt_skip_on_f(ret == 0, "No userptr support - %s (%d)\n",
+			      strerror(errno), ret);
+
+		size = sizeof(linear);
+
+		aperture_size = gem_aperture_size(fd);
+		printf("Aperture size is %lu MiB\n", (long)(aperture_size / (1024*1024)));
+
+		if (argc > 1)
+			count = atoi(argv[1]);
+		if (count == 0)
+			count = 2 * aperture_size / (1024*1024) / 3;
+
+		total_ram = intel_get_total_ram_mb();
+		printf("Total RAM is %u MiB\n", total_ram);
+
+		if (count > total_ram * 3 / 4) {
+			count = intel_get_total_ram_mb() * 3 / 4;
+			printf("Not enough RAM to run test, reducing buffer count.\n");
+		}
+	}
+
+	igt_subtest("input-checking")
+		test_input_checking(fd);
+
+	igt_subtest("usage-restrictions")
+		test_usage_restrictions(fd);
+
+	igt_subtest("invalid-mapping")
+		test_invalid_mapping(fd);
+
+	igt_subtest("forbidden-operations")
+		test_forbidden_ops(fd);
+
+	printf("Testing unsynchronized mappings...\n");
+	gem_userptr_test_unsynchronized();
+
+	igt_subtest("create-destroy-unsync")
+		test_create_destroy(fd);
+
+	igt_subtest("unsync-overlap")
+		test_overlap(fd, 0);
+
+	igt_subtest("unsync-unmap")
+		test_unmap(fd, 0);
+
+	igt_subtest("unsync-unmap-cycles")
+		test_unmap_cycles(fd, 0);
+
+	igt_subtest("unsync-unmap-after-close")
+		test_unmap_after_close(fd);
+
+	igt_subtest("coherency-unsync")
+		test_coherency(fd, count);
+
+	igt_subtest("dmabuf-unsync")
+		test_dmabuf();
+
+	for (unsigned flags = 0; flags < ALL_FORKING_EVICTIONS + 1; flags++) {
+		igt_subtest_f("forked-unsync%s%s%s-%s",
+		    flags & FORKING_EVICTIONS_SWAPPING ? "-swapping" : "",
+		    flags & FORKING_EVICTIONS_DUP_DRMFD ? "-multifd" : "",
+		    flags & FORKING_EVICTIONS_MEMORY_PRESSURE ?
+				"-mempressure" : "",
+		    flags & FORKING_EVICTIONS_INTERRUPTIBLE ?
+				"interruptible" : "normal") {
+			test_forking_evictions(fd, size, count, flags);
+		}
+	}
+
+	igt_subtest("swapping-unsync-normal")
+		test_swapping_evictions(fd, size, count);
+
+	igt_subtest("minor-unsync-normal")
+		test_minor_evictions(fd, size, count);
+
+	igt_subtest("major-unsync-normal") {
+		size = 200 * 1024 * 1024;
+		count = (gem_aperture_size(fd) / size) + 2;
+		test_major_evictions(fd, size, count);
+	}
+
+	igt_fixture {
+		size = sizeof(linear);
+		count = 2 * gem_aperture_size(fd) / (1024*1024) / 3;
+		if (count > total_ram * 3 / 4)
+			count = intel_get_total_ram_mb() * 3 / 4;
+	}
+
+	igt_fork_signal_helper();
+
+	igt_subtest("swapping-unsync-interruptible")
+		test_swapping_evictions(fd, size, count);
+
+	igt_subtest("minor-unsync-interruptible")
+		test_minor_evictions(fd, size, count);
+
+	igt_subtest("major-unsync-interruptible") {
+		size = 200 * 1024 * 1024;
+		count = (gem_aperture_size(fd) / size) + 2;
+		test_major_evictions(fd, size, count);
+	}
+
+	igt_stop_signal_helper();
+
+	printf("Testing synchronized mappings...\n");
+
+	igt_fixture {
+		size = sizeof(linear);
+		count = 2 * gem_aperture_size(fd) / (1024*1024) / 3;
+		if (count > total_ram * 3 / 4)
+			count = intel_get_total_ram_mb() * 3 / 4;
+	}
+
+	gem_userptr_test_synchronized();
+
+	igt_subtest("create-destroy-sync")
+		test_create_destroy(fd);
+
+	igt_subtest("sync-overlap")
+		test_overlap(fd, EINVAL);
+
+	igt_subtest("sync-unmap")
+		test_unmap(fd, EFAULT);
+
+	igt_subtest("sync-unmap-cycles")
+		test_unmap_cycles(fd, EFAULT);
+
+	igt_subtest("sync-unmap-after-close")
+		test_unmap_after_close(fd);
+
+	igt_subtest("coherency-sync")
+		test_coherency(fd, count);
+
+	igt_subtest("dmabuf-sync")
+		test_dmabuf();
+
+	for (unsigned flags = 0; flags < ALL_FORKING_EVICTIONS + 1; flags++) {
+		igt_subtest_f("forked-sync%s%s%s-%s",
+		    flags & FORKING_EVICTIONS_SWAPPING ? "-swapping" : "",
+		    flags & FORKING_EVICTIONS_DUP_DRMFD ? "-multifd" : "",
+		    flags & FORKING_EVICTIONS_MEMORY_PRESSURE ?
+				"-mempressure" : "",
+		    flags & FORKING_EVICTIONS_INTERRUPTIBLE ?
+				"interruptible" : "normal") {
+			test_forking_evictions(fd, size, count, flags);
+		}
+	}
+
+	igt_subtest("swapping-normal-sync")
+		test_swapping_evictions(fd, size, count);
+
+	igt_subtest("minor-normal-sync")
+		test_minor_evictions(fd, size, count);
+
+	igt_subtest("major-normal-sync") {
+		size = 200 * 1024 * 1024;
+		count = (gem_aperture_size(fd) / size) + 2;
+		test_major_evictions(fd, size, count);
+	}
+
+	igt_fixture {
+		size = 1024 * 1024;
+		count = 2 * gem_aperture_size(fd) / (1024*1024) / 3;
+		if (count > total_ram * 3 / 4)
+			count = intel_get_total_ram_mb() * 3 / 4;
+	}
+
+	igt_fork_signal_helper();
+
+	igt_subtest("swapping-sync-interruptible")
+		test_swapping_evictions(fd, size, count);
+
+	igt_subtest("minor-sync-interruptible")
+		test_minor_evictions(fd, size, count);
+
+	igt_subtest("major-sync-interruptible") {
+		size = 200 * 1024 * 1024;
+		count = (gem_aperture_size(fd) / size) + 2;
+		test_major_evictions(fd, size, count);
+	}
+
+	igt_stop_signal_helper();
+
+	igt_subtest("access-control")
+	test_access_control(fd);
+
+	igt_exit();
+
+	return 0;
+}
Signature · 1 line
1.9.1
#11 lore raw

PATCH 2/3 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 a369c8d..84a1d7e 100644
@@ -93,7 +93,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 d9d39db..e89f20a 100644
@@ -118,7 +118,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.9.0

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

cover tests: New userptr test case

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This patch series replaces the old vmap with the new userptr test case and also adds a benchmark for the new feature.

Tested against version 21 of the kernel patch.

Tvrtko Ursulin (3):
tests/gem_userptr_blits: Expanded userptr test cases tests/gem_vmap_blits: Remove obsolete test case tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

 Android.mk                         |    3 +-
 benchmarks/.gitignore              |    1 +
 benchmarks/Android.mk              |   36 ++
 benchmarks/Makefile.am             |    7 +-
 benchmarks/Makefile.sources        |    6 +
 benchmarks/gem_userptr_benchmark.c |  513 +++++++++++++++
 tests/.gitignore                   |    2 +-
 tests/Makefile.sources             |    2 +-
 tests/gem_userptr_blits.c          | 1244 ++++++++++++++++++++++++++++++++++++
 tests/gem_vmap_blits.c             |  344 ----------
 10 files changed, 1804 insertions(+), 354 deletions(-)
 create mode 100644 benchmarks/Android.mk
 create mode 100644 benchmarks/Makefile.sources
 create mode 100644 benchmarks/gem_userptr_benchmark.c
 create mode 100644 tests/gem_userptr_blits.c
 delete mode 100644 tests/gem_vmap_blits.c
Signature · 1 line
1.9.0
#13 lore raw

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

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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

v3:
* Updated copy() for Gen8+.
* Fixed ioctl detection on kernels without MMU_NOTIFIERs.

---
 tests/.gitignore          |    1 +
 tests/Makefile.sources    |    1 +
 tests/gem_userptr_blits.c | 1244 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 1246 insertions(+)
 create mode 100644 tests/gem_userptr_blits.c
tests/.gitignore +1 -0
index 623a621..ff1eff5 100644
@@ -94,6 +94,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 88866ac..240bd99 100644
@@ -119,6 +119,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 +1244 -0

1,244 lines not on this page · raw message

Signature · 6 lines
1.9.0

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

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

Quoted 22 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.

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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

Quoted 5 lines

v3:
* Updated copy() for Gen8+.
* Fixed ioctl detection on kernels without MMU_NOTIFIERs.

A number of the comments I made on patch 3 apply here as well. The sizeof(linear) thing is more prevalent in this test, though it looks like linear is at least used. Other than those comments this looks good to me.

Thanks,
Brad

Quoted 1,289 lines
---
 tests/.gitignore          |    1 +
 tests/Makefile.sources    |    1 +
 tests/gem_userptr_blits.c | 1244 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 1246 insertions(+)
 create mode 100644 tests/gem_userptr_blits.c
tests/.gitignore +1 -0
index 623a621..ff1eff5 100644
@@ -94,6 +94,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 88866ac..240bd99 100644
@@ -119,6 +119,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 +1244 -0
new file mode 100644
index 0000000..1637297
@@ -0,0 +1,1244 @@
+/*
+ * Copyright © 2009-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]>
+ *    Chris Wilson <[email protected]>
+ *    Tvrtko Ursulin <[email protected]>
+ *
+ */
+
+/** @file gem_userptr_blits.c
+ *
+ * This is a test of doing many blits using a mixture of normal system pages
+ * and uncached linear buffers, with a working set larger than the
+ * aperture size.
+ *
+ * The goal is to simply ensure the basics work.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include "drm.h"
+#include "i915_drm.h"
+#include "drmtest.h"
+#include "intel_bufmgr.h"
+#include "intel_batchbuffer.h"
+#include "intel_gpu_tools.h"
+
+#include "eviction_common.c"
+
+#define WIDTH 512
+#define HEIGHT 512
+#define PAGE_SIZE 4096
+
+#define LOCAL_I915_GEM_USERPTR       0x34
+#define LOCAL_IOCTL_I915_GEM_USERPTR DRM_IOWR (DRM_COMMAND_BASE + LOCAL_I915_GEM_USERPTR, struct local_i915_gem_userptr)
+struct local_i915_gem_userptr {
+	uint64_t user_ptr;
+	uint64_t user_size;
+	uint32_t flags;
+#define I915_USERPTR_READ_ONLY (1<<0)
+#define I915_USERPTR_UNSYNCHRONIZED (1<<31)
+	uint32_t handle;
+};
+
+static uint32_t userptr_flags = I915_USERPTR_UNSYNCHRONIZED;
+
+static uint32_t linear[WIDTH*HEIGHT];
+
+static void gem_userptr_test_unsynchronized(void)
+{
+	userptr_flags = I915_USERPTR_UNSYNCHRONIZED;
+}
+
+static void gem_userptr_test_synchronized(void)
+{
+	userptr_flags = 0;
+}
+
+static int gem_userptr(int fd, void *ptr, int size, int read_only, uint32_t *handle)
+{
+	struct local_i915_gem_userptr userptr;
+	int ret;
+
+	userptr.user_ptr = (uintptr_t)ptr;
+	userptr.user_size = size;
+	userptr.flags = userptr_flags;
+	if (read_only)
+		userptr.flags |= I915_USERPTR_READ_ONLY;
+
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	if (ret)
+		ret = errno;
+	igt_skip_on_f(ret == ENODEV &&
+		      (userptr_flags & I915_USERPTR_UNSYNCHRONIZED) == 0 &&
+		      !read_only,
+		      "Skipping, synchronized mappings with no kernel CONFIG_MMU_NOTIFIER?");
+	if (ret == 0)
+		*handle = userptr.handle;
+
+	return ret;
+}
+
+
+static void gem_userptr_sync(int fd, uint32_t handle)
+{
+	gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
+}
+
+static void
+copy(int fd, uint32_t dst, uint32_t src, unsigned int error)
+{
+	uint32_t batch[12];
+	struct drm_i915_gem_relocation_entry reloc[2];
+	struct drm_i915_gem_exec_object2 obj[3];
+	struct drm_i915_gem_execbuffer2 exec;
+	uint32_t handle;
+	int ret, i=0;
+
+	batch[i++] = XY_SRC_COPY_BLT_CMD |
+		  XY_SRC_COPY_BLT_WRITE_ALPHA |
+		  XY_SRC_COPY_BLT_WRITE_RGB;
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i - 1] |= 8;
+	else
+		batch[i - 1] |= 6;
+
+	batch[i++] = (3 << 24) | /* 32 bits */
+		  (0xcc << 16) | /* copy ROP */
+		  WIDTH*4;
+	batch[i++] = 0; /* dst x1,y1 */
+	batch[i++] = (HEIGHT << 16) | WIDTH; /* dst x2,y2 */
+	batch[i++] = 0; /* dst reloc */
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i++] = 0;
+	batch[i++] = 0; /* src x1,y1 */
+	batch[i++] = WIDTH*4;
+	batch[i++] = 0; /* src reloc */
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i++] = 0;
+	batch[i++] = MI_BATCH_BUFFER_END;
+	batch[i++] = MI_NOOP;
+
+	handle = gem_create(fd, 4096);
+	gem_write(fd, handle, 0, batch, sizeof(batch));
+
+	reloc[0].target_handle = dst;
+	reloc[0].delta = 0;
+	reloc[0].offset = 4 * sizeof(batch[0]);
+	reloc[0].presumed_offset = 0;
+	reloc[0].read_domains = I915_GEM_DOMAIN_RENDER;;
+	reloc[0].write_domain = I915_GEM_DOMAIN_RENDER;
+
+	reloc[1].target_handle = src;
+	reloc[1].delta = 0;
+	reloc[1].offset = 7 * sizeof(batch[0]);
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		reloc[1].offset += sizeof(batch[0]);
+	reloc[1].presumed_offset = 0;
+	reloc[1].read_domains = I915_GEM_DOMAIN_RENDER;;
+	reloc[1].write_domain = 0;
+
+	obj[0].handle = dst;
+	obj[0].relocation_count = 0;
+	obj[0].relocs_ptr = 0;
+	obj[0].alignment = 0;
+	obj[0].offset = 0;
+	obj[0].flags = 0;
+	obj[0].rsvd1 = 0;
+	obj[0].rsvd2 = 0;
+
+	obj[1].handle = src;
+	obj[1].relocation_count = 0;
+	obj[1].relocs_ptr = 0;
+	obj[1].alignment = 0;
+	obj[1].offset = 0;
+	obj[1].flags = 0;
+	obj[1].rsvd1 = 0;
+	obj[1].rsvd2 = 0;
+
+	obj[2].handle = handle;
+	obj[2].relocation_count = 2;
+	obj[2].relocs_ptr = (uintptr_t)reloc;
+	obj[2].alignment = 0;
+	obj[2].offset = 0;
+	obj[2].flags = 0;
+	obj[2].rsvd1 = obj[2].rsvd2 = 0;
+
+	exec.buffers_ptr = (uintptr_t)obj;
+	exec.buffer_count = 3;
+	exec.batch_start_offset = 0;
+	exec.batch_len = i * 4;
+	exec.DR1 = exec.DR4 = 0;
+	exec.num_cliprects = 0;
+	exec.cliprects_ptr = 0;
+	exec.flags = HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0;
+	i915_execbuffer2_set_context_id(exec, 0);
+	exec.rsvd2 = 0;
+
+	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
+	if (ret)
+		ret = errno;
+
+	if (error == ~0)
+		igt_assert(ret != 0);
+	else
+		igt_assert(ret == error);
+
+	gem_close(fd, handle);
+}
+
+static void
+blit(int fd, uint32_t dst, uint32_t src, uint32_t *all_bo, int n_bo, int error)
+{
+	uint32_t batch[12];
+	struct drm_i915_gem_relocation_entry reloc[2];
+	struct drm_i915_gem_exec_object2 *obj;
+	struct drm_i915_gem_execbuffer2 exec;
+	uint32_t handle;
+	int n, ret, i=0;
+
+	batch[i++] = XY_SRC_COPY_BLT_CMD |
+		  XY_SRC_COPY_BLT_WRITE_ALPHA |
+		  XY_SRC_COPY_BLT_WRITE_RGB;
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i - 1] |= 8;
+	else
+		batch[i - 1] |= 6;
+	batch[i++] = (3 << 24) | /* 32 bits */
+		  (0xcc << 16) | /* copy ROP */
+		  WIDTH*4;
+	batch[i++] = 0; /* dst x1,y1 */
+	batch[i++] = (HEIGHT << 16) | WIDTH; /* dst x2,y2 */
+	batch[i++] = 0; /* dst reloc */
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i++] = 0;
+	batch[i++] = 0; /* src x1,y1 */
+	batch[i++] = WIDTH*4;
+	batch[i++] = 0; /* src reloc */
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		batch[i++] = 0;
+	batch[i++] = MI_BATCH_BUFFER_END;
+	batch[i++] = MI_NOOP;
+
+	handle = gem_create(fd, 4096);
+	gem_write(fd, handle, 0, batch, sizeof(batch));
+
+	reloc[0].target_handle = dst;
+	reloc[0].delta = 0;
+	reloc[0].offset = 4 * sizeof(batch[0]);
+	reloc[0].presumed_offset = 0;
+	reloc[0].read_domains = I915_GEM_DOMAIN_RENDER;
+	reloc[0].write_domain = I915_GEM_DOMAIN_RENDER;
+
+	reloc[1].target_handle = src;
+	reloc[1].delta = 0;
+	reloc[1].offset = 7 * sizeof(batch[0]);
+	if (intel_gen(intel_get_drm_devid(fd)) >= 8)
+		reloc[1].offset += sizeof(batch[0]);
+	reloc[1].presumed_offset = 0;
+	reloc[1].read_domains = I915_GEM_DOMAIN_RENDER;
+	reloc[1].write_domain = 0;
+
+	obj = calloc(n_bo + 1, sizeof(*obj));
+	for (n = 0; n < n_bo; n++)
+		obj[n].handle = all_bo[n];
+	obj[n].handle = handle;
+	obj[n].relocation_count = 2;
+	obj[n].relocs_ptr = (uintptr_t)reloc;
+
+	exec.buffers_ptr = (uintptr_t)obj;
+	exec.buffer_count = n_bo + 1;
+	exec.batch_start_offset = 0;
+	exec.batch_len = i * 4;
+	exec.DR1 = exec.DR4 = 0;
+	exec.num_cliprects = 0;
+	exec.cliprects_ptr = 0;
+	exec.flags = HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0;
+	i915_execbuffer2_set_context_id(exec, 0);
+	exec.rsvd2 = 0;
+
+	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
+	if (ret)
+		ret = errno;
+
+	igt_assert(ret == error);
+
+	gem_close(fd, handle);
+	free(obj);
+}
+
+static uint32_t
+create_userptr(int fd, uint32_t val, uint32_t *ptr)
+{
+	uint32_t handle;
+	int i, ret;
+
+	ret = gem_userptr(fd, ptr, sizeof(linear), 0, &handle);
+	igt_assert(ret == 0);
+	igt_assert(handle != 0);
+
+	/* Fill the BO with dwords starting at val */
+	for (i = 0; i < WIDTH*HEIGHT; i++)
+		ptr[i] = val++;
+
+	return handle;
+}
+
+static void **handle_ptr_map;
+static unsigned int num_handle_ptr_map;
+
+static void add_handle_ptr(uint32_t handle, void *ptr)
+{
+	if (handle >= num_handle_ptr_map) {
+		handle_ptr_map = realloc(handle_ptr_map,
+					 (handle + 1000) * sizeof(void*));
+		num_handle_ptr_map = handle + 1000;
+	}
+
+	handle_ptr_map[handle] = ptr;
+}
+
+static void *get_handle_ptr(uint32_t handle)
+{
+	return handle_ptr_map[handle];
+}
+
+static void free_handle_ptr(uint32_t handle)
+{
+	igt_assert(handle < num_handle_ptr_map);
+	igt_assert(handle_ptr_map[handle]);
+
+	free(handle_ptr_map[handle]);
+	handle_ptr_map[handle] = NULL;
+}
+
+static uint32_t create_userptr_bo(int fd, int size)
+{
+	void *ptr;
+	uint32_t handle;
+	int ret;
+
+	ret = posix_memalign(&ptr, PAGE_SIZE, size);
+	igt_assert(ret == 0);
+
+	ret = gem_userptr(fd, (uint32_t *)ptr, size, 0, &handle);
+	igt_assert(ret == 0);
+	add_handle_ptr(handle, ptr);
+
+	return handle;
+}
+
+static void clear(int fd, uint32_t handle, int size)
+{
+	void *ptr = get_handle_ptr(handle);
+
+	igt_assert(ptr != NULL);
+
+	memset(ptr, 0, size);
+}
+
+static void free_userptr_bo(int fd, uint32_t handle)
+{
+	gem_close(fd, handle);
+	free_handle_ptr(handle);
+}
+
+static uint32_t
+create_bo(int fd, uint32_t val)
+{
+	uint32_t handle;
+	int i;
+
+	handle = gem_create(fd, sizeof(linear));
+
+	/* Fill the BO with dwords starting at val */
+	for (i = 0; i < WIDTH*HEIGHT; i++)
+		linear[i] = val++;
+	gem_write(fd, handle, 0, linear, sizeof(linear));
+
+	return handle;
+}
+
+static void
+check_cpu(uint32_t *ptr, uint32_t val)
+{
+	int i;
+
+	for (i = 0; i < WIDTH*HEIGHT; i++) {
+		if (ptr[i] != val) {
+			fprintf(stderr, "Expected 0x%08x, found 0x%08x "
+				"at offset 0x%08x\n",
+				val, ptr[i], i * 4);
+			abort();
+		}
+		val++;
+	}
+}
+
+static void
+check_gpu(int fd, uint32_t handle, uint32_t val)
+{
+	gem_read(fd, handle, 0, linear, sizeof(linear));
+	check_cpu(linear, val);
+}
+
+static int has_userptr(int fd)
+{
+	uint32_t handle = 0;
+	void *ptr;
+	uint32_t oldflags;
+	int ret;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+	oldflags = userptr_flags;
+	gem_userptr_test_unsynchronized();
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	userptr_flags = oldflags;
+	if (ret != 0) {
+		free(ptr);
+		return 0;
+	}
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return handle != 0;
+}
+
+static int test_input_checking(int fd)
+{
+	struct local_i915_gem_userptr userptr;
+	int ret;
+
+	/* Invalid flags. */
+	userptr.user_ptr = 0;
+	userptr.user_size = 0;
+	userptr.flags = ~0;
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	igt_assert(ret != 0);
+
+	/* Too big. */
+	userptr.user_ptr = 0;
+	userptr.user_size = ~0;
+	userptr.flags = 0;
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	igt_assert(ret != 0);
+
+	/* Both wrong. */
+	userptr.user_ptr = 0;
+	userptr.user_size = ~0;
+	userptr.flags = ~0;
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	igt_assert(ret != 0);
+
+	return 0;
+}
+
+static int test_access_control(int fd)
+{
+	igt_fork(child, 1) {
+		void *ptr;
+		int ret;
+		uint32_t handle;
+
+		igt_drop_root();
+
+		/* CAP_SYS_ADMIN is needed for UNSYNCHRONIZED mappings. */
+		gem_userptr_test_unsynchronized();
+
+		igt_assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+
+		ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+		if (ret == 0)
+			gem_close(fd, handle);
+		free(ptr);
+		igt_assert(ret == EPERM);
+	}
+
+	igt_waitchildren();
+
+	return 0;
+}
+
+static int test_invalid_mapping(int fd)
+{
+	int ret;
+	uint32_t handle, handle2;
+	void *ptr;
+
+	/* NULL pointer. */
+	ret = gem_userptr(fd, NULL, PAGE_SIZE, 0, &handle);
+	igt_assert(ret == 0);
+	copy(fd, handle, handle, ~0); /* QQQ Precise errno? */
+	gem_close(fd, handle);
+
+	/* GTT mapping */
+	handle = create_bo(fd, 0);
+	ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	if (ptr == NULL)
+		gem_close(fd, handle);
+	assert(ptr != NULL);
+	assert(((unsigned long)ptr & (PAGE_SIZE - 1)) == 0);
+	assert((sizeof(linear) & (PAGE_SIZE - 1)) == 0);
+	ret = gem_userptr(fd, ptr, sizeof(linear), 0, &handle2);
+	igt_assert(ret == 0);
+	copy(fd, handle, handle, ~0); /* QQQ Precise errno? */
+	gem_close(fd, handle2);
+	munmap(ptr, sizeof(linear));
+	gem_close(fd, handle);
+
+	return 0;
+}
+
+static int test_forbidden_ops(int fd)
+{
+	void *ptr;
+	int ret;
+	uint32_t handle;
+	char buf[PAGE_SIZE];
+	struct drm_i915_gem_pread gem_pread;
+	struct drm_i915_gem_pwrite gem_pwrite;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	igt_assert(ret == 0);
+
+	gem_pread.handle = handle;
+	gem_pread.offset = 0;
+	gem_pread.size = PAGE_SIZE;
+	gem_pread.data_ptr = (uintptr_t)buf;
+	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_PREAD, &gem_pread);
+	if (ret == 0) {
+		gem_close(fd, handle);
+		free(ptr);
+	}
+	igt_assert(ret != 0);
+
+	gem_pwrite.handle = handle;
+	gem_pwrite.offset = 0;
+	gem_pwrite.size = PAGE_SIZE;
+	gem_pwrite.data_ptr = (uintptr_t)buf;
+	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_PWRITE, &gem_pwrite);
+	if (ret == 0) {
+		gem_close(fd, handle);
+		free(ptr);
+	}
+	igt_assert(ret != 0);
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return 0;
+}
+
+static char counter;
+
+static void (*orig_sigbus)(int sig, siginfo_t *info, void *param);
+static unsigned long sigbus_start;
+static long sigbus_cnt = -1;
+
+static void
+check_bo(int fd1, uint32_t handle1, int is_userptr, int fd2, uint32_t handle2)
+{
+	char *ptr1, *ptr2;
+	int i;
+	unsigned long size = sizeof(linear);
+
+	if (is_userptr)
+		ptr1 = get_handle_ptr(handle1);
+	else
+		ptr1 = gem_mmap(fd1, handle1, sizeof(linear), PROT_READ | PROT_WRITE);
+
+	ptr2 = gem_mmap(fd2, handle2, sizeof(linear), PROT_READ | PROT_WRITE);
+
+	igt_assert(ptr1);
+	igt_assert(ptr2);
+
+	sigbus_start = (unsigned long)ptr2;
+
+	if (sigbus_cnt == 0)
+		size = 1;
+
+	/* check whether it's still our old object first. */
+	for (i = 0; i < size; i++) {
+		igt_assert(ptr1[i] == counter);
+		igt_assert(ptr2[i] == counter);
+	}
+
+	counter++;
+
+	if (size > 1) {
+		memset(ptr1, counter, size);
+		igt_assert(memcmp(ptr1, ptr2, size) == 0);
+	}
+
+	if (!is_userptr)
+		munmap(ptr1, sizeof(linear));
+	munmap(ptr2, sizeof(linear));
+}
+
+static int export_handle(int fd, uint32_t handle, int *outfd)
+{
+	struct drm_prime_handle args;
+	int ret;
+
+	args.handle = handle;
+	args.flags = DRM_CLOEXEC;
+	args.fd = -1;
+
+	ret = drmIoctl(fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &args);
+	if (ret)
+		ret = errno;
+	*outfd = args.fd;
+
+	return ret;
+}
+
+static void sigbus(int sig, siginfo_t *info, void *param)
+{
+	unsigned long ptr = (unsigned long)info->si_addr;
+	void *addr;
+
+	if (ptr >= sigbus_start &&
+	    ptr <= (sigbus_start + sizeof(linear))) {
+		sigbus_cnt++;
+		addr = mmap((void *)ptr, sizeof(linear), PROT_READ | PROT_WRITE,
+				MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
+		if ((unsigned long)addr == ptr) {
+			memset(addr, counter, sizeof(linear));
+			return;
+		}
+	}
+
+	if (orig_sigbus)
+		orig_sigbus(sig, info, param);
+	assert(0);
+}
+
+static int test_dmabuf(void)
+{
+	int fd1, fd2;
+	uint32_t handle, handle_import1, handle_import2, handle_selfimport;
+	int dma_buf_fd = -1;
+	int ret;
+	struct sigaction sigact, orig_sigact;
+
+	fd1 = drm_open_any();
+	fd2 = drm_open_any();
+
+	handle = create_userptr_bo(fd1, sizeof(linear));
+
+	ret = export_handle(fd1, handle, &dma_buf_fd);
+	if (userptr_flags & I915_USERPTR_UNSYNCHRONIZED) {
+		igt_assert(ret == EINVAL);
+		free_userptr_bo(fd1, handle);
+
+		return 0;
+	} else {
+		igt_assert(ret == 0);
+		igt_assert(dma_buf_fd >= 0);
+	}
+	handle_import1 = prime_fd_to_handle(fd2, dma_buf_fd);
+	check_bo(fd1, handle, 1, fd2, handle_import1);
+
+	/* reimport should give us the same handle so that userspace can check
+	 * whether it has that bo already somewhere. */
+	handle_import2 = prime_fd_to_handle(fd2, dma_buf_fd);
+	igt_assert(handle_import1 == handle_import2);
+
+	/* Same for re-importing on the exporting fd. */
+	handle_selfimport = prime_fd_to_handle(fd1, dma_buf_fd);
+	igt_assert(handle == handle_selfimport);
+
+	/* close dma_buf, check whether nothing disappears. */
+	close(dma_buf_fd);
+	check_bo(fd1, handle, 1, fd2, handle_import1);
+
+	/* destroy userptr object and expect SIGBUS */
+	free_userptr_bo(fd1, handle);
+	sigact.sa_sigaction = sigbus;
+	sigact.sa_flags = SA_SIGINFO;
+	ret = sigaction(SIGBUS, &sigact, &orig_sigact);
+	assert(ret == 0);
+	orig_sigbus = orig_sigact.sa_sigaction;
+	sigbus_cnt = 0;
+	check_bo(fd2, handle_import1, 0, fd2, handle_import1);
+	assert(sigbus_cnt > 0);
+	sigact.sa_sigaction = orig_sigbus;
+	sigact.sa_flags = SA_SIGINFO;
+	ret = sigaction(SIGBUS, &sigact, &orig_sigact);
+	assert(ret == 0);
+
+	gem_close(fd2, handle_import1);
+	close(fd1);
+	close(fd2);
+
+	return 0;
+}
+
+static int test_usage_restrictions(int fd)
+{
+	void *ptr;
+	int ret;
+	uint32_t handle;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE * 2) == 0);
+
+	/* Address not aligned. */
+	ret = gem_userptr(fd, (char *)ptr + 1, PAGE_SIZE, 0, &handle);
+	igt_assert(ret != 0);
+
+	/* Size not rounded to page size. */
+	ret = gem_userptr(fd, ptr, PAGE_SIZE - 1, 0, &handle);
+	igt_assert(ret != 0);
+
+	/* Both wrong. */
+	ret = gem_userptr(fd, (char *)ptr + 1, PAGE_SIZE - 1, 0, &handle);
+	igt_assert(ret != 0);
+
+	/* Read-only not supported. */
+	ret = gem_userptr(fd, (char *)ptr, PAGE_SIZE, 1, &handle);
+	igt_assert(ret != 0);
+
+	free(ptr);
+
+	return 0;
+}
+
+static int test_create_destroy(int fd)
+{
+	void *ptr;
+	int ret;
+	uint32_t handle;
+
+	igt_assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	igt_assert(ret == 0);
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return 0;
+}
+
+static int test_coherency(int fd, int count)
+{
+	uint32_t *memory;
+	uint32_t *cpu, *cpu_val;
+	uint32_t *gpu, *gpu_val;
+	uint32_t start = 0;
+	int i, ret;
+
+	printf("Using 2x%d 1MiB buffers\n", count);
+
+	ret = posix_memalign((void **)&memory, PAGE_SIZE, count*sizeof(linear));
+	if (ret != 0 || memory == NULL) {
+		fprintf(stderr, "Unable to allocate %lld bytes\n",
+			(long long)count*sizeof(linear));
+		return 1;
+	}
+
+	gpu = malloc(sizeof(uint32_t)*count*4);
+	gpu_val = gpu + count;
+	cpu = gpu_val + count;
+	cpu_val = cpu + count;
+
+	for (i = 0; i < count; i++) {
+		gpu[i] = create_bo(fd, start);
+		gpu_val[i] = start;
+		start += WIDTH*HEIGHT;
+	}
+
+	for (i = 0; i < count; i++) {
+		cpu[i] = create_userptr(fd, start, memory+i*WIDTH*HEIGHT);
+		cpu_val[i] = start;
+		start += WIDTH*HEIGHT;
+	}
+
+	printf("Verifying initialisation...\n");
+	for (i = 0; i < count; i++) {
+		check_gpu(fd, gpu[i], gpu_val[i]);
+		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
+	}
+
+	printf("Cyclic blits cpu->gpu, forward...\n");
+	for (i = 0; i < count * 4; i++) {
+		int src = i % count;
+		int dst = (i + 1) % count;
+
+		copy(fd, gpu[dst], cpu[src], 0);
+		gpu_val[dst] = cpu_val[src];
+	}
+	for (i = 0; i < count; i++)
+		check_gpu(fd, gpu[i], gpu_val[i]);
+
+	printf("Cyclic blits gpu->cpu, backward...\n");
+	for (i = 0; i < count * 4; i++) {
+		int src = (i + 1) % count;
+		int dst = i % count;
+
+		copy(fd, cpu[dst], gpu[src], 0);
+		cpu_val[dst] = gpu_val[src];
+	}
+	for (i = 0; i < count; i++) {
+		gem_userptr_sync(fd, cpu[i]);
+		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
+	}
+
+	printf("Random blits...\n");
+	for (i = 0; i < count * 4; i++) {
+		int src = random() % count;
+		int dst = random() % count;
+
+		if (random() & 1) {
+			copy(fd, gpu[dst], cpu[src], 0);
+			gpu_val[dst] = cpu_val[src];
+		} else {
+			copy(fd, cpu[dst], gpu[src], 0);
+			cpu_val[dst] = gpu_val[src];
+		}
+	}
+	for (i = 0; i < count; i++) {
+		check_gpu(fd, gpu[i], gpu_val[i]);
+		gem_close(fd, gpu[i]);
+
+		gem_userptr_sync(fd, cpu[i]);
+		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
+		gem_close(fd, cpu[i]);
+	}
+
+	free(gpu);
+	free(memory);
+
+	return 0;
+}
+
+static struct igt_eviction_test_ops fault_ops = {
+	.create = create_userptr_bo,
+	.close = free_userptr_bo,
+	.copy = blit,
+	.clear = clear,
+};
+
+static int can_swap(void)
+{
+	unsigned long as, ram;
+
+	/* Cannot swap if not enough address space */
+
+	/* FIXME: Improve check criteria. */
+	if (sizeof(void*) < 8)
+		as = 3 * 1024;
+	else
+		as = 256 * 1024; /* Just a big number */
+
+	ram = intel_get_total_ram_mb();
+
+	if ((as - 128) < (ram - 256))
+		return 0;
+
+	return 1;
+}
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+
+static void test_forking_evictions(int fd, int size, int count,
+			     unsigned flags)
+{
+	int trash_count;
+	int num_threads;
+
+	trash_count = intel_get_total_ram_mb() * 11 / 10;
+	/* Use the fact test will spawn a number of child
+	 * processes meaning swapping will be triggered system
+	 * wide even if one process on it's own can't do it.
+	 */
+	num_threads = min(sysconf(_SC_NPROCESSORS_ONLN) * 4, 12);
+	trash_count /= num_threads;
+	if (count > trash_count)
+		count = trash_count;
+
+	forking_evictions(fd, &fault_ops, size, count, trash_count, flags);
+}
+
+static void test_swapping_evictions(int fd, int size, int count)
+{
+	int trash_count;
+
+	igt_skip_on_f(!can_swap(),
+		"Not enough process address space for swapping tests.\n");
+
+	trash_count = intel_get_total_ram_mb() * 11 / 10;
+
+	swapping_evictions(fd, &fault_ops, size, count, trash_count);
+}
+
+static void test_minor_evictions(int fd, int size, int count)
+{
+	minor_evictions(fd, &fault_ops, size, count);
+}
+
+static void test_major_evictions(int fd, int size, int count)
+{
+	major_evictions(fd, &fault_ops, size, count);
+}
+
+static int test_overlap(int fd, int expected)
+{
+	char *ptr;
+	int ret;
+	uint32_t handle, handle2;
+
+	igt_assert(posix_memalign((void *)&ptr, PAGE_SIZE, PAGE_SIZE * 3) == 0);
+
+	ret = gem_userptr(fd, ptr + PAGE_SIZE, PAGE_SIZE, 0, &handle);
+	igt_assert(ret == 0);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle2);
+	igt_assert(ret == 0);
+	gem_close(fd, handle2);
+
+	ret = gem_userptr(fd, ptr + PAGE_SIZE * 2, PAGE_SIZE, 0, &handle2);
+	igt_assert(ret == 0);
+	gem_close(fd, handle2);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE * 2, 0, &handle2);
+	igt_assert(ret == expected);
+	if (ret == 0)
+		gem_close(fd, handle2);
+
+	ret = gem_userptr(fd, ptr + PAGE_SIZE, PAGE_SIZE * 2, 0, &handle2);
+	igt_assert(ret == expected);
+	if (ret == 0)
+		gem_close(fd, handle2);
+
+	ret = gem_userptr(fd, ptr, PAGE_SIZE * 3, 0, &handle2);
+	igt_assert(ret == expected);
+	if (ret == 0)
+		gem_close(fd, handle2);
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return 0;
+}
+
+static int test_unmap(int fd, int expected)
+{
+	char *ptr, *bo_ptr;
+	const unsigned int num_obj = 3;
+	unsigned int i;
+	uint32_t bo[num_obj + 1];
+	size_t map_size = sizeof(linear) * num_obj + (PAGE_SIZE - 1);
+	int ret;
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+				MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)(((unsigned long)ptr + (PAGE_SIZE - 1))
+						& ~(PAGE_SIZE - 1));
+
+	for (i = 0; i < num_obj; i++, bo_ptr += sizeof(linear)) {
+		ret = gem_userptr(fd, bo_ptr, sizeof(linear), 0, &bo[i]);
+		igt_assert(ret == 0);
+	}
+
+	bo[num_obj] = create_bo(fd, 0);
+
+	for (i = 0; i < num_obj; i++)
+		copy(fd, bo[num_obj], bo[i], 0);
+
+	ret = munmap(ptr, map_size);
+	assert(ret == 0);
+
+	for (i = 0; i < num_obj; i++)
+		copy(fd, bo[num_obj], bo[i], expected);
+
+	for (i = 0; i < (num_obj + 1); i++)
+		gem_close(fd, bo[i]);
+
+	return 0;
+}
+
+static int test_unmap_after_close(int fd)
+{
+	char *ptr, *bo_ptr;
+	const unsigned int num_obj = 3;
+	unsigned int i;
+	uint32_t bo[num_obj + 1];
+	size_t map_size = sizeof(linear) * num_obj + (PAGE_SIZE - 1);
+	int ret;
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+				MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)(((unsigned long)ptr + (PAGE_SIZE - 1))
+						& ~(PAGE_SIZE - 1));
+
+	for (i = 0; i < num_obj; i++, bo_ptr += sizeof(linear)) {
+		ret = gem_userptr(fd, bo_ptr, sizeof(linear), 0, &bo[i]);
+		igt_assert(ret == 0);
+	}
+
+	bo[num_obj] = create_bo(fd, 0);
+
+	for (i = 0; i < num_obj; i++)
+		copy(fd, bo[num_obj], bo[i], 0);
+
+	for (i = 0; i < (num_obj + 1); i++)
+		gem_close(fd, bo[i]);
+
+	ret = munmap(ptr, map_size);
+	assert(ret == 0);
+
+	return 0;
+}
+
+static int test_unmap_cycles(int fd, int expected)
+{
+	int i;
+
+	for (i = 0; i < 1000; i++)
+		test_unmap(fd, expected);
+
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	uint64_t aperture_size;
+	unsigned int total_ram;
+	int fd = -1, count = 0, size = 0, ret;
+
+	igt_skip_on_simulation();
+
+	igt_subtest_init(argc, argv);
+
+	igt_fixture {
+		fd = drm_open_any();
+		igt_assert(fd >= 0);
+
+		ret = has_userptr(fd);
+		igt_skip_on_f(ret == 0, "No userptr support - %s (%d)\n",
+			      strerror(errno), ret);
+
+		size = sizeof(linear);
+
+		aperture_size = gem_aperture_size(fd);
+		printf("Aperture size is %lu MiB\n", (long)(aperture_size / (1024*1024)));
+
+		if (argc > 1)
+			count = atoi(argv[1]);
+		if (count == 0)
+			count = 2 * aperture_size / (1024*1024) / 3;
+
+		total_ram = intel_get_total_ram_mb();
+		printf("Total RAM is %u MiB\n", total_ram);
+
+		if (count > total_ram * 3 / 4) {
+			count = intel_get_total_ram_mb() * 3 / 4;
+			printf("Not enough RAM to run test, reducing buffer count.\n");
+		}
+	}
+
+	igt_subtest("input-checking")
+		test_input_checking(fd);
+
+	igt_subtest("usage-restrictions")
+		test_usage_restrictions(fd);
+
+	igt_subtest("invalid-mapping")
+		test_invalid_mapping(fd);
+
+	igt_subtest("forbidden-operations")
+		test_forbidden_ops(fd);
+
+	printf("Testing unsynchronized mappings...\n");
+	gem_userptr_test_unsynchronized();
+
+	igt_subtest("create-destroy-unsync")
+		test_create_destroy(fd);
+
+	igt_subtest("unsync-overlap")
+		test_overlap(fd, 0);
+
+	igt_subtest("unsync-unmap")
+		test_unmap(fd, 0);
+
+	igt_subtest("unsync-unmap-cycles")
+		test_unmap_cycles(fd, 0);
+
+	igt_subtest("unsync-unmap-after-close")
+		test_unmap_after_close(fd);
+
+	igt_subtest("coherency-unsync")
+		test_coherency(fd, count);
+
+	igt_subtest("dmabuf-unsync")
+		test_dmabuf();
+
+	for (unsigned flags = 0; flags < ALL_FORKING_EVICTIONS + 1; flags++) {
+		igt_subtest_f("forked-unsync%s%s%s-%s",
+		    flags & FORKING_EVICTIONS_SWAPPING ? "-swapping" : "",
+		    flags & FORKING_EVICTIONS_DUP_DRMFD ? "-multifd" : "",
+		    flags & FORKING_EVICTIONS_MEMORY_PRESSURE ?
+				"-mempressure" : "",
+		    flags & FORKING_EVICTIONS_INTERRUPTIBLE ?
+				"interruptible" : "normal") {
+			test_forking_evictions(fd, size, count, flags);
+		}
+	}
+
+	igt_subtest("swapping-unsync-normal")
+		test_swapping_evictions(fd, size, count);
+
+	igt_subtest("minor-unsync-normal")
+		test_minor_evictions(fd, size, count);
+
+	igt_subtest("major-unsync-normal") {
+		size = 200 * 1024 * 1024;
+		count = (gem_aperture_size(fd) / size) + 2;
+		test_major_evictions(fd, size, count);
+	}
+
+	igt_fixture {
+		size = sizeof(linear);
+		count = 2 * gem_aperture_size(fd) / (1024*1024) / 3;
+		if (count > total_ram * 3 / 4)
+			count = intel_get_total_ram_mb() * 3 / 4;
+	}
+
+	igt_fork_signal_helper();
+
+	igt_subtest("swapping-unsync-interruptible")
+		test_swapping_evictions(fd, size, count);
+
+	igt_subtest("minor-unsync-interruptible")
+		test_minor_evictions(fd, size, count);
+
+	igt_subtest("major-unsync-interruptible") {
+		size = 200 * 1024 * 1024;
+		count = (gem_aperture_size(fd) / size) + 2;
+		test_major_evictions(fd, size, count);
+	}
+
+	igt_stop_signal_helper();
+
+	printf("Testing synchronized mappings...\n");
+
+	igt_fixture {
+		size = sizeof(linear);
+		count = 2 * gem_aperture_size(fd) / (1024*1024) / 3;
+		if (count > total_ram * 3 / 4)
+			count = intel_get_total_ram_mb() * 3 / 4;
+	}
+
+	gem_userptr_test_synchronized();
+
+	igt_subtest("create-destroy-sync")
+		test_create_destroy(fd);
+
+	igt_subtest("sync-overlap")
+		test_overlap(fd, EINVAL);
+
+	igt_subtest("sync-unmap")
+		test_unmap(fd, EFAULT);
+
+	igt_subtest("sync-unmap-cycles")
+		test_unmap_cycles(fd, EFAULT);
+
+	igt_subtest("sync-unmap-after-close")
+		test_unmap_after_close(fd);
+
+	igt_subtest("coherency-sync")
+		test_coherency(fd, count);
+
+	igt_subtest("dmabuf-sync")
+		test_dmabuf();
+
+	for (unsigned flags = 0; flags < ALL_FORKING_EVICTIONS + 1; flags++) {
+		igt_subtest_f("forked-sync%s%s%s-%s",
+		    flags & FORKING_EVICTIONS_SWAPPING ? "-swapping" : "",
+		    flags & FORKING_EVICTIONS_DUP_DRMFD ? "-multifd" : "",
+		    flags & FORKING_EVICTIONS_MEMORY_PRESSURE ?
+				"-mempressure" : "",
+		    flags & FORKING_EVICTIONS_INTERRUPTIBLE ?
+				"interruptible" : "normal") {
+			test_forking_evictions(fd, size, count, flags);
+		}
+	}
+
+	igt_subtest("swapping-normal-sync")
+		test_swapping_evictions(fd, size, count);
+
+	igt_subtest("minor-normal-sync")
+		test_minor_evictions(fd, size, count);
+
+	igt_subtest("major-normal-sync") {
+		size = 200 * 1024 * 1024;
+		count = (gem_aperture_size(fd) / size) + 2;
+		test_major_evictions(fd, size, count);
+	}
+
+	igt_fixture {
+		size = 1024 * 1024;
+		count = 2 * gem_aperture_size(fd) / (1024*1024) / 3;
+		if (count > total_ram * 3 / 4)
+			count = intel_get_total_ram_mb() * 3 / 4;
+	}
+
+	igt_fork_signal_helper();
+
+	igt_subtest("swapping-sync-interruptible")
+		test_swapping_evictions(fd, size, count);
+
+	igt_subtest("minor-sync-interruptible")
+		test_minor_evictions(fd, size, count);
+
+	igt_subtest("major-sync-interruptible") {
+		size = 200 * 1024 * 1024;
+		count = (gem_aperture_size(fd) / size) + 2;
+		test_major_evictions(fd, size, count);
+	}
+
+	igt_stop_signal_helper();
+
+	igt_subtest("access-control")
+	test_access_control(fd);
+
+	igt_exit();
+
+	return 0;
+}
Signature · 6 lines
1.9.0

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

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

Quoted 27 lines · Bradley D
Quoted 26 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.

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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

v3:
* Updated copy() for Gen8+.
* Fixed ioctl detection on kernels without MMU_NOTIFIERs.

Quoted 6 lines
Quoted 1 line

A number of the comments I made on patch 3 apply here as well. The sizeof(linear) thing is more prevalent in this test, though it looks like linear is at least used. Other than those comments this looks good to me.

Believe it or not that sizeof(linear) "idiom" I inherited from other blitter tests. Personally I don't care one way or another. But since it makes sense to get rid of it for the benchmark part, perhaps I should change it here as well to be consistent. How strongly do you feel strongly about this?

Will see what you reply on the static initializer comment it 3/3, not sure what you meant there.

Thanks,

Tvrtko

#16 lore raw

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

Quoted 36 lines · Tvrtko Ursulin
Quoted 27 lines · Bradley D
Quoted 26 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.

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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

v3:
* Updated copy() for Gen8+.
* Fixed ioctl detection on kernels without MMU_NOTIFIERs.

Quoted 6 lines
Quoted 1 line

A number of the comments I made on patch 3 apply here as well. The sizeof(linear) thing is more prevalent in this test, though it looks like linear is at least used. Other than those comments this looks good to me.

Quoted 5 lines

Believe it or not that sizeof(linear) "idiom" I inherited from other blitter tests. Personally I don't care one way or another. But since it makes sense to get rid of it for the benchmark part, perhaps I should change it here as well to be consistent. How strongly do you feel strongly about this?

I think changing it would be slightly more readable, but if it's consistent with other blit tests then I don't feel too strongly about it. In fact, consistency with the other tests might be the better approach. I'm fine with whichever approach you prefer.

Thanks,
Brad

Quoted 7 lines

Will see what you reply on the static initializer comment it 3/3, not sure what you meant there.

Thanks,

Tvrtko

#17 lore raw

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

Quoted 43 lines · Bradley D
Quoted 36 lines · Tvrtko Ursulin
Quoted 27 lines · Bradley D
Quoted 26 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.

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.

v2:
* Fixed dmabuf test.
* Added test for rejecting read-only.
* Fixed ioctl detection for latest kernel patch.

v3:
* Updated copy() for Gen8+.
* Fixed ioctl detection on kernels without MMU_NOTIFIERs.

Quoted 6 lines
Quoted 1 line

A number of the comments I made on patch 3 apply here as well. The sizeof(linear) thing is more prevalent in this test, though it looks like linear is at least used. Other than those comments this looks good to me.

Quoted 5 lines

Believe it or not that sizeof(linear) "idiom" I inherited from other blitter tests. Personally I don't care one way or another. But since it makes sense to get rid of it for the benchmark part, perhaps I should change it here as well to be consistent. How strongly do you feel strongly about this?

Quoted 4 lines

I think changing it would be slightly more readable, but if it's consistent with other blit tests then I don't feel too strongly about it. In fact, consistency with the other tests might be the better approach. I'm fine with whichever approach you prefer.

Some of the igt tests are so Gross Hacks that justifying ugliness in new tests with consistency is ill-advised ;-)

If you find some spare cycles to clean up existing tests that would be awesome, but I don't mind if they keep being ugly.
-Daniel

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

PATCH 2/3 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 ff1eff5..c600823 100644
@@ -93,7 +93,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 240bd99..610bbf5 100644
@@ -118,7 +118,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.9.0

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

Re: [PATCH 2/3] tests/gem_vmap_blits: Remove obsolete test case

Quoted 5 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

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

Quoted 388 lines
---
 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 ff1eff5..c600823 100644
@@ -93,7 +93,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 240bd99..610bbf5 100644
@@ -118,7 +118,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
deleted file mode 100644
index 48297af..0000000
@@ -1,344 +0,0 @@
-/*
- * Copyright © 2009,2011 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]>
- *    Chris Wilson <[email protected]>
- *
- */
-
-/** @file gem_vmap_blits.c
- *
- * This is a test of doing many blits using a mixture of normal system pages
- * and uncached linear buffers, with a working set larger than the
- * aperture size.
- *
- * The goal is to simply ensure the basics work.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include "drm.h"
-#include "i915_drm.h"
-#include "drmtest.h"
-#include "intel_bufmgr.h"
-#include "intel_batchbuffer.h"
-#include "intel_gpu_tools.h"
-
-#if !defined(I915_PARAM_HAS_VMAP)
-#pragma message("No vmap support in drm, skipping")
-int main(int argc, char **argv)
-{
-	fprintf(stderr, "No vmap support in drm.\n");
-	return 77;
-}
-#else
-
-#define WIDTH 512
-#define HEIGHT 512
-
-static uint32_t linear[WIDTH*HEIGHT];
-
-static uint32_t gem_vmap(int fd, void *ptr, int size, int read_only)
-{
-	struct drm_i915_gem_vmap vmap;
-
-	vmap.user_ptr = (uintptr_t)ptr;
-	vmap.user_size = size;
-	vmap.flags = 0;
-	if (read_only)
-		vmap.flags |= I915_VMAP_READ_ONLY;
-
-	if (drmIoctl(fd, DRM_IOCTL_I915_GEM_VMAP, &vmap))
-		return 0;
-
-	return vmap.handle;
-}
-
-
-static void gem_vmap_sync(int fd, uint32_t handle)
-{
-	gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
-}
-
-static void
-copy(int fd, uint32_t dst, uint32_t src)
-{
-	uint32_t batch[10];
-	struct drm_i915_gem_relocation_entry reloc[2];
-	struct drm_i915_gem_exec_object2 obj[3];
-	struct drm_i915_gem_execbuffer2 exec;
-	uint32_t handle;
-	int ret;
-
-	batch[0] = XY_SRC_COPY_BLT_CMD |
-		  XY_SRC_COPY_BLT_WRITE_ALPHA |
-		  XY_SRC_COPY_BLT_WRITE_RGB | 6;
-	batch[1] = (3 << 24) | /* 32 bits */
-		  (0xcc << 16) | /* copy ROP */
-		  WIDTH*4;
-	batch[2] = 0; /* dst x1,y1 */
-	batch[3] = (HEIGHT << 16) | WIDTH; /* dst x2,y2 */
-	batch[4] = 0; /* dst reloc */
-	batch[5] = 0; /* src x1,y1 */
-	batch[6] = WIDTH*4;
-	batch[7] = 0; /* src reloc */
-	batch[8] = MI_BATCH_BUFFER_END;
-	batch[9] = MI_NOOP;
-
-	handle = gem_create(fd, 4096);
-	gem_write(fd, handle, 0, batch, sizeof(batch));
-
-	reloc[0].target_handle = dst;
-	reloc[0].delta = 0;
-	reloc[0].offset = 4 * sizeof(batch[0]);
-	reloc[0].presumed_offset = 0;
-	reloc[0].read_domains = I915_GEM_DOMAIN_RENDER;;
-	reloc[0].write_domain = I915_GEM_DOMAIN_RENDER;
-
-	reloc[1].target_handle = src;
-	reloc[1].delta = 0;
-	reloc[1].offset = 7 * sizeof(batch[0]);
-	reloc[1].presumed_offset = 0;
-	reloc[1].read_domains = I915_GEM_DOMAIN_RENDER;;
-	reloc[1].write_domain = 0;
-
-	obj[0].handle = dst;
-	obj[0].relocation_count = 0;
-	obj[0].relocs_ptr = 0;
-	obj[0].alignment = 0;
-	obj[0].offset = 0;
-	obj[0].flags = 0;
-	obj[0].rsvd1 = 0;
-	obj[0].rsvd2 = 0;
-
-	obj[1].handle = src;
-	obj[1].relocation_count = 0;
-	obj[1].relocs_ptr = 0;
-	obj[1].alignment = 0;
-	obj[1].offset = 0;
-	obj[1].flags = 0;
-	obj[1].rsvd1 = 0;
-	obj[1].rsvd2 = 0;
-
-	obj[2].handle = handle;
-	obj[2].relocation_count = 2;
-	obj[2].relocs_ptr = (uintptr_t)reloc;
-	obj[2].alignment = 0;
-	obj[2].offset = 0;
-	obj[2].flags = 0;
-	obj[2].rsvd1 = obj[2].rsvd2 = 0;
-
-	exec.buffers_ptr = (uintptr_t)obj;
-	exec.buffer_count = 3;
-	exec.batch_start_offset = 0;
-	exec.batch_len = sizeof(batch);
-	exec.DR1 = exec.DR4 = 0;
-	exec.num_cliprects = 0;
-	exec.cliprects_ptr = 0;
-	exec.flags = HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0;
-	exec.rsvd1 = exec.rsvd2 = 0;
-
-	ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
-	while (ret && errno == EBUSY) {
-		drmCommandNone(fd, DRM_I915_GEM_THROTTLE);
-		ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
-	}
-	igt_assert(ret == 0);
-
-	gem_close(fd, handle);
-}
-
-static uint32_t
-create_vmap(int fd, uint32_t val, uint32_t *ptr)
-{
-	uint32_t handle;
-	int i;
-
-	handle = gem_vmap(fd, ptr, sizeof(linear), 0);
-
-	/* Fill the BO with dwords starting at val */
-	for (i = 0; i < WIDTH*HEIGHT; i++)
-		ptr[i] = val++;
-
-	return handle;
-}
-
-static uint32_t
-create_bo(int fd, uint32_t val)
-{
-	uint32_t handle;
-	int i;
-
-	handle = gem_create(fd, sizeof(linear));
-
-	/* Fill the BO with dwords starting at val */
-	for (i = 0; i < WIDTH*HEIGHT; i++)
-		linear[i] = val++;
-	gem_write(fd, handle, 0, linear, sizeof(linear));
-
-	return handle;
-}
-
-static void
-check_cpu(uint32_t *ptr, uint32_t val)
-{
-	int i;
-
-	for (i = 0; i < WIDTH*HEIGHT; i++) {
-		if (ptr[i] != val) {
-			fprintf(stderr, "Expected 0x%08x, found 0x%08x "
-				"at offset 0x%08x\n",
-				val, ptr[i], i * 4);
-			abort();
-		}
-		val++;
-	}
-}
-
-static void
-check_gpu(int fd, uint32_t handle, uint32_t val)
-{
-	gem_read(fd, handle, 0, linear, sizeof(linear));
-	check_cpu(linear, val);
-}
-
-static int has_vmap(int fd)
-{
-	drm_i915_getparam_t gp;
-	int i;
-
-	gp.param = I915_PARAM_HAS_VMAP;
-	gp.value = &i;
-
-	return drmIoctl(fd, DRM_IOCTL_I915_GETPARAM, &gp) == 0 && i > 0;
-}
-
-int main(int argc, char **argv)
-{
-	uint32_t *memory;
-	uint32_t *cpu, *cpu_val;
-	uint32_t *gpu, *gpu_val;
-	uint32_t start = 0;
-	int i, fd, count;
-
-	igt_simple_init();
-
-	igt_skip_on_simulation();
-
-	fd = drm_open_any();
-
-	if (!has_vmap(fd)) {
-		fprintf(stderr, "No vmap support, ignoring.\n");
-		return 77;
-	}
-
-	count = 0;
-	if (argc > 1)
-		count = atoi(argv[1]);
-	if (count == 0)
-		count = 3 * gem_aperture_size(fd) / (1024*1024) / 4;
-	printf("Using 2x%d 1MiB buffers\n", count);
-
-	memory = malloc(count*sizeof(linear));
-	if (memory == NULL) {
-		fprintf(stderr, "Unable to allocate %lld bytes\n",
-			(long long)count*sizeof(linear));
-		return 1;
-	}
-
-	gpu = malloc(sizeof(uint32_t)*count*4);
-	gpu_val = gpu + count;
-	cpu = gpu_val + count;
-	cpu_val = cpu + count;
-
-	for (i = 0; i < count; i++) {
-		gpu[i] = create_bo(fd, start);
-		gpu_val[i] = start;
-		start += WIDTH*HEIGHT;
-	}
-
-	for (i = 0; i < count; i++) {
-		cpu[i] = create_vmap(fd, start, memory+i*WIDTH*HEIGHT);
-		cpu_val[i] = start;
-		start += WIDTH*HEIGHT;;
-	}
-
-	printf("Verifying initialisation...\n");
-	for (i = 0; i < count; i++) {
-		check_gpu(fd, gpu[i], gpu_val[i]);
-		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
-	}
-
-	printf("Cyclic blits cpu->gpu, forward...\n");
-	for (i = 0; i < count * 4; i++) {
-		int src = i % count;
-		int dst = (i + 1) % count;
-
-		copy(fd, gpu[dst], cpu[src]);
-		gpu_val[dst] = cpu_val[src];
-	}
-	for (i = 0; i < count; i++)
-		check_gpu(fd, gpu[i], gpu_val[i]);
-
-	printf("Cyclic blits gpu->cpu, backward...\n");
-	for (i = 0; i < count * 4; i++) {
-		int src = (i + 1) % count;
-		int dst = i % count;
-
-		copy(fd, cpu[dst], gpu[src]);
-		cpu_val[dst] = gpu_val[src];
-	}
-	for (i = 0; i < count; i++) {
-		gem_vmap_sync(fd, cpu[i]);
-		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
-	}
-
-	printf("Random blits...\n");
-	for (i = 0; i < count * 4; i++) {
-		int src = random() % count;
-		int dst = random() % count;
-
-		if (random() & 1) {
-			copy(fd, gpu[dst], cpu[src]);
-			gpu_val[dst] = cpu_val[src];
-		} else {
-			copy(fd, cpu[dst], gpu[src]);
-			cpu_val[dst] = gpu_val[src];
-		}
-	}
-	for (i = 0; i < count; i++) {
-		check_gpu(fd, gpu[i], gpu_val[i]);
-		gem_vmap_sync(fd, cpu[i]);
-		check_cpu(memory+i*WIDTH*HEIGHT, cpu_val[i]);
-	}
-
-	return 0;
-}
-
-#endif
Signature · 6 lines
1.9.0

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

PATCH 3/3 tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This adds a small benchmark for the new userptr functionality.

Apart from basic surface creation and destruction, also tested is the impact of having userptr surfaces in the process address space. Reason for that is the impact of MMU notifiers on common address space operations like munmap() which is per process.

v2:
* Moved to benchmarks.
* Added pointer read/write tests.
* Changed output to say iterations per second instead of operations per second.
* Multiply result by batch size for multi-create* tests for a more comparable number with create-destroy test.

v3:
* Fixed ioctl detection on kernels without MMU_NOTIFIERs.

---
 Android.mk                         |   3 +-
 benchmarks/.gitignore              |   1 +
 benchmarks/Android.mk              |  36 +++
 benchmarks/Makefile.am             |   7 +-
 benchmarks/Makefile.sources        |   6 +
 benchmarks/gem_userptr_benchmark.c | 513 +++++++++++++++++++++++++++++++++++++
 6 files changed, 558 insertions(+), 8 deletions(-)
 create mode 100644 benchmarks/Android.mk
 create mode 100644 benchmarks/Makefile.sources
 create mode 100644 benchmarks/gem_userptr_benchmark.c
Android.mk +1 -2
index 8aeb2d4..0c969b8 100644
@@ -1,2 +1 @@
-include $(call all-named-subdir-makefiles, lib tests tools)
-
+include $(call all-named-subdir-makefiles, lib tests tools benchmarks)
benchmarks/.gitignore +1 -0
index ddea6f7..09e5bd8 100644
@@ -1,3 +1,4 @@
+gem_userptr_benchmark
 intel_upload_blit_large
 intel_upload_blit_large_gtt
 intel_upload_blit_large_map
benchmarks/Android.mk new file +36 -0
new file mode 100644
index 0000000..5bb8ef5
@@ -0,0 +1,36 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(LOCAL_PATH)/Makefile.sources
+
+#================#
+
+define add_benchmark
+    include $(CLEAR_VARS)
+
+    LOCAL_SRC_FILES := $1.c
+
+    LOCAL_CFLAGS += -DHAVE_STRUCT_SYSINFO_TOTALRAM
+    LOCAL_CFLAGS += -DANDROID -UNDEBUG -include "check-ndebug.h"
+    LOCAL_CFLAGS += -std=c99
+    # FIXME: drop once Bionic correctly annotates "noreturn" on pthread_exit
+    LOCAL_CFLAGS += -Wno-error=return-type
+    # Excessive complaining for established cases. Rely on the Linux version warnings.
+    LOCAL_CFLAGS += -Wno-sign-compare
+
+    LOCAL_MODULE := $1
+    LOCAL_MODULE_TAGS := optional
+
+    LOCAL_STATIC_LIBRARIES := libintel_gpu_tools
+
+    LOCAL_SHARED_LIBRARIES := libpciaccess  \
+                              libdrm        \
+                              libdrm_intel
+
+    include $(BUILD_EXECUTABLE)
+endef
+
+#================#
+
+benchmark_list := $(bin_PROGRAMS)
+
+$(foreach item,$(benchmark_list),$(eval $(call add_benchmark,$(item))))
benchmarks/Makefile.am +1 -6
index e2ad784..d173bf4 100644
@@ -1,9 +1,4 @@
-
-bin_PROGRAMS = 				\
-	intel_upload_blit_large		\
-	intel_upload_blit_large_gtt	\
-	intel_upload_blit_large_map	\
-	intel_upload_blit_small
+include Makefile.sources
 
 AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/lib
 AM_CFLAGS = $(DRM_CFLAGS) $(CWARNFLAGS) $(CAIRO_CFLAGS)
benchmarks/Makefile.sources new file +6 -0
new file mode 100644
index 0000000..fd6c107
@@ -0,0 +1,6 @@
+bin_PROGRAMS =                          \
+        intel_upload_blit_large         \
+        intel_upload_blit_large_gtt     \
+        intel_upload_blit_large_map     \
+        intel_upload_blit_small         \
+        gem_userptr_benchmark
benchmarks/gem_userptr_benchmark.c new file +513 -0

513 lines not on this page · raw message

Signature · 6 lines
1.9.0

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

Re: [PATCH 3/3] tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

Quoted 114 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This adds a small benchmark for the new userptr functionality.

Apart from basic surface creation and destruction, also tested is the impact of having userptr surfaces in the process address space. Reason for that is the impact of MMU notifiers on common address space operations like munmap() which is per process.

v2:
* Moved to benchmarks.
* Added pointer read/write tests.
* Changed output to say iterations per second instead of operations per second.
* Multiply result by batch size for multi-create* tests for a more comparable number with create-destroy test.

v3:
* Fixed ioctl detection on kernels without MMU_NOTIFIERs.

---
 Android.mk                         |   3 +-
 benchmarks/.gitignore              |   1 +
 benchmarks/Android.mk              |  36 +++
 benchmarks/Makefile.am             |   7 +-
 benchmarks/Makefile.sources        |   6 +
 benchmarks/gem_userptr_benchmark.c | 513 +++++++++++++++++++++++++++++++++++++
 6 files changed, 558 insertions(+), 8 deletions(-)
 create mode 100644 benchmarks/Android.mk
 create mode 100644 benchmarks/Makefile.sources
 create mode 100644 benchmarks/gem_userptr_benchmark.c
Android.mk +1 -2
index 8aeb2d4..0c969b8 100644
@@ -1,2 +1 @@
-include $(call all-named-subdir-makefiles, lib tests tools)
-
+include $(call all-named-subdir-makefiles, lib tests tools benchmarks)
benchmarks/.gitignore +1 -0
index ddea6f7..09e5bd8 100644
@@ -1,3 +1,4 @@
+gem_userptr_benchmark
 intel_upload_blit_large
 intel_upload_blit_large_gtt
 intel_upload_blit_large_map
benchmarks/Android.mk new file +36 -0
new file mode 100644
index 0000000..5bb8ef5
@@ -0,0 +1,36 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(LOCAL_PATH)/Makefile.sources
+
+#================#
+
+define add_benchmark
+    include $(CLEAR_VARS)
+
+    LOCAL_SRC_FILES := $1.c
+
+    LOCAL_CFLAGS += -DHAVE_STRUCT_SYSINFO_TOTALRAM
+    LOCAL_CFLAGS += -DANDROID -UNDEBUG -include "check-ndebug.h"
+    LOCAL_CFLAGS += -std=c99
+    # FIXME: drop once Bionic correctly annotates "noreturn" on pthread_exit
+    LOCAL_CFLAGS += -Wno-error=return-type
+    # Excessive complaining for established cases. Rely on the Linux version warnings.
+    LOCAL_CFLAGS += -Wno-sign-compare
+
+    LOCAL_MODULE := $1
+    LOCAL_MODULE_TAGS := optional
+
+    LOCAL_STATIC_LIBRARIES := libintel_gpu_tools
+
+    LOCAL_SHARED_LIBRARIES := libpciaccess  \
+                              libdrm        \
+                              libdrm_intel
+
+    include $(BUILD_EXECUTABLE)
+endef
+
+#================#
+
+benchmark_list := $(bin_PROGRAMS)
+
+$(foreach item,$(benchmark_list),$(eval $(call add_benchmark,$(item))))
benchmarks/Makefile.am +1 -6
index e2ad784..d173bf4 100644
@@ -1,9 +1,4 @@
-
-bin_PROGRAMS = 				\
-	intel_upload_blit_large		\
-	intel_upload_blit_large_gtt	\
-	intel_upload_blit_large_map	\
-	intel_upload_blit_small
+include Makefile.sources
 
 AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/lib
 AM_CFLAGS = $(DRM_CFLAGS) $(CWARNFLAGS) $(CAIRO_CFLAGS)
benchmarks/Makefile.sources new file +0 -0
new file mode 100644
index 0000000..fd6c107

benchmarks/Makefile.sources line 6

Quoted 6 lines
benchmarks/Makefile.sources new file +6 -0
@@ -0,0 +1,6 @@
+bin_PROGRAMS =                          \
+        intel_upload_blit_large         \
+        intel_upload_blit_large_gtt     \
+        intel_upload_blit_large_map     \
+        intel_upload_blit_small         \
+        gem_userptr_benchmark

You might split the makefile cleanup aspect of this into a separate patch, but I'm fine either way.

Quoted 64 lines
benchmarks/gem_userptr_benchmark.c new file +58 -0
new file mode 100644
index 0000000..218f6f1
@@ -0,0 +1,513 @@
+/*
+ * Copyright © 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:
+ *    Tvrtko Ursulin <[email protected]>
+ *
+ */
+
+/** @file gem_userptr_benchmark.c
+ *
+ * Benchmark the userptr code and impact of having userptr surfaces
+ * in process address space on some normal operations.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include "drm.h"
+#include "i915_drm.h"
+#include "drmtest.h"
+#include "intel_bufmgr.h"
+#include "intel_batchbuffer.h"
+#include "intel_gpu_tools.h"
+
+#define WIDTH 128
+#define HEIGHT 128
+#define PAGE_SIZE 4096
+
+#define LOCAL_I915_GEM_USERPTR       0x34
+#define LOCAL_IOCTL_I915_GEM_USERPTR DRM_IOWR (DRM_COMMAND_BASE + LOCAL_I915_GEM_USERPTR, struct local_i915_gem_userptr)
+struct local_i915_gem_userptr {
+	uint64_t user_ptr;

benchmarks/gem_userptr_benchmark.c line 68

Quoted 10 lines
benchmarks/gem_userptr_benchmark.c new file +10 -0
+	uint64_t user_size;
+	uint32_t flags;
+#define I915_USERPTR_READ_ONLY (1<<0)
+#define I915_USERPTR_UNSYNCHRONIZED (1<<31)
+	uint32_t handle;
+};
+
+static uint32_t userptr_flags = I915_USERPTR_UNSYNCHRONIZED;
+
+static uint32_t linear[WIDTH*HEIGHT];

I may have missed it, but I don't think we use this variable except to do sizeof(linear). If that's the case, a constant for the buffer size might make the code more readable.

Quoted 40 lines
benchmarks/gem_userptr_benchmark.c new file +40 -0
+
+static void gem_userptr_test_unsynchronized(void)
+{
+	userptr_flags = I915_USERPTR_UNSYNCHRONIZED;
+}
+
+static void gem_userptr_test_synchronized(void)
+{
+	userptr_flags = 0;
+}
+
+static int gem_userptr(int fd, void *ptr, int size, int read_only, uint32_t *handle)
+{
+	struct local_i915_gem_userptr userptr;
+	int ret;
+
+	userptr.user_ptr = (uintptr_t)ptr;
+	userptr.user_size = size;
+	userptr.flags = userptr_flags;
+	if (read_only)
+		userptr.flags |= I915_USERPTR_READ_ONLY;
+
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	if (ret)
+		ret = errno;
+	igt_skip_on_f(ret == ENODEV &&
+		      (userptr_flags & I915_USERPTR_UNSYNCHRONIZED) == 0,
+		      "Skipping, synchronized mappings with no kernel CONFIG_MMU_NOTIFIER?");
+	if (ret == 0)
+		*handle = userptr.handle;
+
+	return ret;
+}
+
+static uint32_t
+create_userptr(int fd, uint32_t val, uint32_t *ptr)
+{
+	uint32_t handle;
+	int i, ret;
+

benchmarks/gem_userptr_benchmark.c line 118

Quoted 10 lines
benchmarks/gem_userptr_benchmark.c new file +10 -0
+	ret = gem_userptr(fd, ptr, sizeof(linear), 0, &handle);
+	igt_assert(ret == 0);
+	igt_assert(handle != 0);
+
+	/* Fill the BO with dwords starting at val */
+	for (i = 0; i < WIDTH*HEIGHT; i++)
+		ptr[i] = val++;
+
+	return handle;
+}

I don't see that this function is used in this test.

benchmarks/gem_userptr_benchmark.c line 121

Quoted 3 lines
benchmarks/gem_userptr_benchmark.c new file +3 -0
+
+static void **handle_ptr_map;
+static unsigned int num_handle_ptr_map;

I'd prefer that we explicitly initialize at least num_handle_ptr_map.

Quoted 273 lines
benchmarks/gem_userptr_benchmark.c new file +273 -0
+
+static void add_handle_ptr(uint32_t handle, void *ptr)
+{
+	if (handle >= num_handle_ptr_map) {
+		handle_ptr_map = realloc(handle_ptr_map,
+					 (handle + 1000) * sizeof(void*));
+		num_handle_ptr_map = handle + 1000;
+	}
+
+	handle_ptr_map[handle] = ptr;
+}
+
+static void *get_handle_ptr(uint32_t handle)
+{
+	return handle_ptr_map[handle];
+}
+
+static void free_handle_ptr(uint32_t handle)
+{
+	igt_assert(handle < num_handle_ptr_map);
+	igt_assert(handle_ptr_map[handle]);
+
+	free(handle_ptr_map[handle]);
+	handle_ptr_map[handle] = NULL;
+}
+
+static uint32_t create_userptr_bo(int fd, int size)
+{
+	void *ptr;
+	uint32_t handle;
+	int ret;
+
+	ret = posix_memalign(&ptr, PAGE_SIZE, size);
+	igt_assert(ret == 0);
+
+	ret = gem_userptr(fd, (uint32_t *)ptr, size, 0, &handle);
+	igt_assert(ret == 0);
+	add_handle_ptr(handle, ptr);
+
+	return handle;
+}
+
+static void free_userptr_bo(int fd, uint32_t handle)
+{
+	gem_close(fd, handle);
+	free_handle_ptr(handle);
+}
+
+static int has_userptr(int fd)
+{
+	uint32_t handle = 0;
+	void *ptr;
+	uint32_t oldflags;
+	int ret;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+	oldflags = userptr_flags;
+	gem_userptr_test_unsynchronized();
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	userptr_flags = oldflags;
+	if (ret != 0) {
+		free(ptr);
+		return 0;
+	}
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return handle != 0;
+}
+
+static const unsigned int nr_bos[] = {0, 1, 10, 100, 1000};
+static const unsigned int test_duration_sec = 3;
+
+static volatile unsigned int run_test;
+
+static void alarm_handler(int sig)
+{
+	assert(run_test == 1);
+	run_test = 0;
+}
+
+static void start_test(unsigned int duration)
+{
+	run_test = 1;
+	if (duration == 0)
+		duration = test_duration_sec;
+	signal(SIGALRM, alarm_handler);
+	alarm(duration);
+}
+
+static void exchange_ptr(void *array, unsigned i, unsigned j)
+{
+	void **arr, *tmp;
+	arr = (void **)array;
+
+	tmp = arr[i];
+	arr[i] = arr[j];
+	arr[j] = tmp;
+}
+
+static void test_malloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_malloc_realloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++) {
+			ptr[i] = realloc(ptr[i], 2000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_mmap_unmap(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = mmap(NULL, 1000, PROT_READ | PROT_WRITE,
+					MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+			assert(ptr[i] != MAP_FAILED);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			munmap(ptr[i], 1000);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_ptr_read(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	unsigned long i, loops;
+	register unsigned long v;
+
+	loops = sizeof(linear) / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			v = *p++;
+			v = *p++;
+			v = *p++;
+			v = *p++;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * sizeof(linear) / 1000000);
+}
+
+static void test_ptr_write(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	register unsigned long i, loops;
+
+	loops = sizeof(linear) / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * sizeof(linear) / 1000000);
+}
+
+static void test_impact(int fd)
+{
+	unsigned int total = sizeof(nr_bos) / sizeof(nr_bos[0]);
+	unsigned int subtest, i;
+	uint32_t handles[nr_bos[total-1]];
+	void *ptr;
+	char buffer[sizeof(linear)];
+
+	for (subtest = 0; subtest < total; subtest++) {
+		for (i = 0; i < nr_bos[subtest]; i++)
+			handles[i] = create_userptr_bo(fd, sizeof(linear));
+
+		if (nr_bos[subtest] > 0)
+			ptr = get_handle_ptr(handles[0]);
+		else
+			ptr = buffer;
+
+		printf("ptr-read,                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_read(ptr);
+
+		printf("ptr-write                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_write(ptr);
+
+		printf("malloc-free,                %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(0);
+		printf("malloc-free-random          %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(1);
+
+		printf("malloc-realloc-free,        %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(0);
+		printf("malloc-realloc-free-random, %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(1);
+
+		printf("mmap-unmap,                 %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(0);
+		printf("mmap-unmap-random,          %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(1);
+
+		for (i = 0; i < nr_bos[subtest]; i++)
+			free_userptr_bo(fd, handles[i]);
+	}
+}
+
+static void test_single(int fd)
+{
+	char *ptr, *bo_ptr;
+	uint32_t handle = 0;

benchmarks/gem_userptr_benchmark.c line 404

Quoted 10 lines
benchmarks/gem_userptr_benchmark.c new file +10 -0
+	unsigned long iter = 0;
+	int ret;
+	unsigned long map_size = sizeof(linear) + PAGE_SIZE - 1;
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)(((unsigned long)ptr + (PAGE_SIZE - 1))
+					& ~(PAGE_SIZE - 1));

You might add an ALIGN macro in this file or a suitable header. A couple of .c files in lib/ individually define one already.

Brad

Quoted 116 lines
benchmarks/gem_userptr_benchmark.c new file +109 -0
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		ret = gem_userptr(fd, bo_ptr, sizeof(linear), 0, &handle);
+		assert(ret == 0);
+		gem_close(fd, handle);
+		iter++;
+	}
+
+	munmap(ptr, map_size);
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_multiple(int fd, unsigned int batch, int random)
+{
+	char *ptr, *bo_ptr;
+	uint32_t handles[10000];
+	int map[10000];
+	unsigned long iter = 0;
+	int ret;
+	int i;
+	unsigned long map_size = batch * sizeof(linear) + PAGE_SIZE - 1;
+
+	assert(batch < (sizeof(handles) / sizeof(handles[0])));
+	assert(batch < (sizeof(map) / sizeof(map[0])));
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)(((unsigned long)ptr + (PAGE_SIZE - 1))
+				& ~(PAGE_SIZE - 1));
+
+	for (i = 0; i < batch; i++)
+		map[i] = i;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		if (random)
+			igt_permute_array(map, batch, igt_exchange_int);
+		for (i = 0; i < batch; i++) {
+			ret = gem_userptr(fd, bo_ptr + map[i] * sizeof(linear),
+						sizeof(linear),
+						0, &handles[i]);
+			assert(ret == 0);
+		}
+		if (random)
+			igt_permute_array(map, batch, igt_exchange_int);
+		for (i = 0; i < batch; i++)
+			gem_close(fd, handles[map[i]]);
+		iter++;
+	}
+
+	munmap(ptr, map_size);
+
+	printf("%8lu iter/s\n", iter * batch / test_duration_sec);
+}
+
+static void test_userptr(int fd)
+{
+	printf("create-destroy                = ");
+	test_single(fd);
+
+	printf("multi-create-destroy          = ");
+	test_multiple(fd, 100, 0);
+
+	printf("multi-create-destroy-random   = ");
+	test_multiple(fd, 100, 1);
+}
+
+int main(int argc, char **argv)
+{
+	int fd = -1, ret;
+
+	igt_skip_on_simulation();
+
+	igt_subtest_init(argc, argv);
+
+	fd = drm_open_any();
+	igt_assert(fd >= 0);
+
+	ret = has_userptr(fd);
+	igt_skip_on_f(ret == 0, "No userptr support - %s (%d)\n",
+			strerror(errno), ret);
+
+
+	gem_userptr_test_unsynchronized();
+
+	igt_subtest("userptr-unsync")
+		test_userptr(fd);
+
+	igt_subtest("userptr-impact-unsync")
+		test_impact(fd);
+
+	gem_userptr_test_synchronized();
+
+	igt_subtest("userptr-sync")
+		test_userptr(fd);
+
+	igt_subtest("userptr-impact-sync")
+		test_impact(fd);
+
+	igt_exit();
+
+	return 0;
+}
Signature · 6 lines
1.9.0

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

Re: [PATCH 3/3] tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

Quoted 6 lines · Bradley D

Review

Quoted 2 lines · Tvrtko Ursulin
(quoted diff) +2 -0
+	bo_ptr = (char *)(((unsigned long)ptr + (PAGE_SIZE - 1))
+					& ~(PAGE_SIZE - 1));

You might add an ALIGN macro in this file or a suitable header. A couple of .c files in lib/ individually define one already.

lib/drmtest.h (with the gtkdoc for it include) is the current grab-bag for such random useful pieces. We already have an ARRAY_SIZE in there. -Daniel

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

Re: [PATCH 3/3] tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

In reply to Volkin, Bradley D

Hi Brad,

Quoted 116 lines · Bradley D
Quoted 115 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This adds a small benchmark for the new userptr functionality.

Apart from basic surface creation and destruction, also tested is the impact of having userptr surfaces in the process address space. Reason for that is the impact of MMU notifiers on common address space operations like munmap() which is per process.

v2:
* Moved to benchmarks.
* Added pointer read/write tests.
* Changed output to say iterations per second instead of operations per second.
* Multiply result by batch size for multi-create* tests for a more comparable number with create-destroy test.

v3:
* Fixed ioctl detection on kernels without MMU_NOTIFIERs.

---
  Android.mk                         |   3 +-
  benchmarks/.gitignore              |   1 +
  benchmarks/Android.mk              |  36 +++
  benchmarks/Makefile.am             |   7 +-
  benchmarks/Makefile.sources        |   6 +
  benchmarks/gem_userptr_benchmark.c | 513 +++++++++++++++++++++++++++++++++++++
  6 files changed, 558 insertions(+), 8 deletions(-)

create mode 100644 benchmarks/Android.mk create mode 100644 benchmarks/Makefile.sources create mode 100644 benchmarks/gem_userptr_benchmark.c

Android.mk +1 -2
index 8aeb2d4..0c969b8 100644
@@ -1,2 +1 @@
-include $(call all-named-subdir-makefiles, lib tests tools)
-
+include $(call all-named-subdir-makefiles, lib tests tools benchmarks)
benchmarks/.gitignore +1 -0
index ddea6f7..09e5bd8 100644
@@ -1,3 +1,4 @@
+gem_userptr_benchmark
  intel_upload_blit_large
  intel_upload_blit_large_gtt
  intel_upload_blit_large_map
benchmarks/Android.mk new file +36 -0
new file mode 100644
index 0000000..5bb8ef5
@@ -0,0 +1,36 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(LOCAL_PATH)/Makefile.sources
+
+#================#
+
+define add_benchmark
+    include $(CLEAR_VARS)
+
+    LOCAL_SRC_FILES := $1.c
+
+    LOCAL_CFLAGS += -DHAVE_STRUCT_SYSINFO_TOTALRAM
+    LOCAL_CFLAGS += -DANDROID -UNDEBUG -include "check-ndebug.h"
+    LOCAL_CFLAGS += -std=c99
+    # FIXME: drop once Bionic correctly annotates "noreturn" on pthread_exit
+    LOCAL_CFLAGS += -Wno-error=return-type
+    # Excessive complaining for established cases. Rely on the Linux version warnings.
+    LOCAL_CFLAGS += -Wno-sign-compare
+
+    LOCAL_MODULE := $1
+    LOCAL_MODULE_TAGS := optional
+
+    LOCAL_STATIC_LIBRARIES := libintel_gpu_tools
+
+    LOCAL_SHARED_LIBRARIES := libpciaccess  \
+                              libdrm        \
+                              libdrm_intel
+
+    include $(BUILD_EXECUTABLE)
+endef
+
+#================#
+
+benchmark_list := $(bin_PROGRAMS)
+
+$(foreach item,$(benchmark_list),$(eval $(call add_benchmark,$(item))))
benchmarks/Makefile.am +1 -6
index e2ad784..d173bf4 100644
@@ -1,9 +1,4 @@
-
-bin_PROGRAMS = 				\
-	intel_upload_blit_large		\
-	intel_upload_blit_large_gtt	\
-	intel_upload_blit_large_map	\
-	intel_upload_blit_small
+include Makefile.sources
 
  AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/lib
  AM_CFLAGS = $(DRM_CFLAGS) $(CWARNFLAGS) $(CAIRO_CFLAGS)
benchmarks/Makefile.sources new file +1 -0
new file mode 100644
index 0000000..fd6c107
@@ -0,0 +1,6 @@
+bin_PROGRAMS =                          \
Quoted 8 lines

benchmarks/Makefile.sources line 6

Quoted 5 lines
benchmarks/Makefile.sources new file +5 -0
+        intel_upload_blit_large         \
+        intel_upload_blit_large_gtt     \
+        intel_upload_blit_large_map     \
+        intel_upload_blit_small         \
+        gem_userptr_benchmark

You might split the makefile cleanup aspect of this into a separate patch, but I'm fine either way.

Good idea, will try to squeeze that in.

Quoted 70 lines
Quoted 70 lines
benchmarks/gem_userptr_benchmark.c new file +64 -0
new file mode 100644
index 0000000..218f6f1
@@ -0,0 +1,513 @@
+/*
+ * Copyright © 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:
+ *    Tvrtko Ursulin <[email protected]>
+ *
+ */
+
+/** @file gem_userptr_benchmark.c
+ *
+ * Benchmark the userptr code and impact of having userptr surfaces
+ * in process address space on some normal operations.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include "drm.h"
+#include "i915_drm.h"
+#include "drmtest.h"
+#include "intel_bufmgr.h"
+#include "intel_batchbuffer.h"
+#include "intel_gpu_tools.h"
+
+#define WIDTH 128
+#define HEIGHT 128
+#define PAGE_SIZE 4096
+
+#define LOCAL_I915_GEM_USERPTR       0x34
+#define LOCAL_IOCTL_I915_GEM_USERPTR DRM_IOWR (DRM_COMMAND_BASE + LOCAL_I915_GEM_USERPTR, struct local_i915_gem_userptr)
+struct local_i915_gem_userptr {
+	uint64_t user_ptr;
+	uint64_t user_size;
+	uint32_t flags;
+#define I915_USERPTR_READ_ONLY (1<<0)
+#define I915_USERPTR_UNSYNCHRONIZED (1<<31)
+	uint32_t handle;
+};
Quoted 8 lines

benchmarks/gem_userptr_benchmark.c line 68

Quoted 4 lines
benchmarks/gem_userptr_benchmark.c new file +4 -0
+
+static uint32_t userptr_flags = I915_USERPTR_UNSYNCHRONIZED;
+
+static uint32_t linear[WIDTH*HEIGHT];

I may have missed it, but I don't think we use this variable except to do sizeof(linear). If that's the case, a constant for the buffer size might make the code more readable.

You're right, too much copy & paste.

Quoted 44 lines
Quoted 44 lines
benchmarks/gem_userptr_benchmark.c new file +44 -0
+
+static void gem_userptr_test_unsynchronized(void)
+{
+	userptr_flags = I915_USERPTR_UNSYNCHRONIZED;
+}
+
+static void gem_userptr_test_synchronized(void)
+{
+	userptr_flags = 0;
+}
+
+static int gem_userptr(int fd, void *ptr, int size, int read_only, uint32_t *handle)
+{
+	struct local_i915_gem_userptr userptr;
+	int ret;
+
+	userptr.user_ptr = (uintptr_t)ptr;
+	userptr.user_size = size;
+	userptr.flags = userptr_flags;
+	if (read_only)
+		userptr.flags |= I915_USERPTR_READ_ONLY;
+
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	if (ret)
+		ret = errno;
+	igt_skip_on_f(ret == ENODEV &&
+		      (userptr_flags & I915_USERPTR_UNSYNCHRONIZED) == 0,
+		      "Skipping, synchronized mappings with no kernel CONFIG_MMU_NOTIFIER?");
+	if (ret == 0)
+		*handle = userptr.handle;
+
+	return ret;
+}
+
+static uint32_t
+create_userptr(int fd, uint32_t val, uint32_t *ptr)
+{
+	uint32_t handle;
+	int i, ret;
+
+	ret = gem_userptr(fd, ptr, sizeof(linear), 0, &handle);
+	igt_assert(ret == 0);
+	igt_assert(handle != 0);
+
Quoted 8 lines

benchmarks/gem_userptr_benchmark.c line 118

Quoted 6 lines
benchmarks/gem_userptr_benchmark.c new file +6 -0
+	/* Fill the BO with dwords starting at val */
+	for (i = 0; i < WIDTH*HEIGHT; i++)
+		ptr[i] = val++;
+
+	return handle;
+}

I don't see that this function is used in this test.

You are right, artifact of this file starting from gem_userptr_blits.c and then removing stuff. Obviously not enough removed.

Quoted 5 lines

benchmarks/gem_userptr_benchmark.c line 121

Quoted 3 lines
benchmarks/gem_userptr_benchmark.c new file +3 -0
+
+static void **handle_ptr_map;
+static unsigned int num_handle_ptr_map;

I'd prefer that we explicitly initialize at least num_handle_ptr_map.

To zero, why?

Quoted 278 lines
Quoted 278 lines
benchmarks/gem_userptr_benchmark.c new file +278 -0
+
+static void add_handle_ptr(uint32_t handle, void *ptr)
+{
+	if (handle >= num_handle_ptr_map) {
+		handle_ptr_map = realloc(handle_ptr_map,
+					 (handle + 1000) * sizeof(void*));
+		num_handle_ptr_map = handle + 1000;
+	}
+
+	handle_ptr_map[handle] = ptr;
+}
+
+static void *get_handle_ptr(uint32_t handle)
+{
+	return handle_ptr_map[handle];
+}
+
+static void free_handle_ptr(uint32_t handle)
+{
+	igt_assert(handle < num_handle_ptr_map);
+	igt_assert(handle_ptr_map[handle]);
+
+	free(handle_ptr_map[handle]);
+	handle_ptr_map[handle] = NULL;
+}
+
+static uint32_t create_userptr_bo(int fd, int size)
+{
+	void *ptr;
+	uint32_t handle;
+	int ret;
+
+	ret = posix_memalign(&ptr, PAGE_SIZE, size);
+	igt_assert(ret == 0);
+
+	ret = gem_userptr(fd, (uint32_t *)ptr, size, 0, &handle);
+	igt_assert(ret == 0);
+	add_handle_ptr(handle, ptr);
+
+	return handle;
+}
+
+static void free_userptr_bo(int fd, uint32_t handle)
+{
+	gem_close(fd, handle);
+	free_handle_ptr(handle);
+}
+
+static int has_userptr(int fd)
+{
+	uint32_t handle = 0;
+	void *ptr;
+	uint32_t oldflags;
+	int ret;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+	oldflags = userptr_flags;
+	gem_userptr_test_unsynchronized();
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	userptr_flags = oldflags;
+	if (ret != 0) {
+		free(ptr);
+		return 0;
+	}
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return handle != 0;
+}
+
+static const unsigned int nr_bos[] = {0, 1, 10, 100, 1000};
+static const unsigned int test_duration_sec = 3;
+
+static volatile unsigned int run_test;
+
+static void alarm_handler(int sig)
+{
+	assert(run_test == 1);
+	run_test = 0;
+}
+
+static void start_test(unsigned int duration)
+{
+	run_test = 1;
+	if (duration == 0)
+		duration = test_duration_sec;
+	signal(SIGALRM, alarm_handler);
+	alarm(duration);
+}
+
+static void exchange_ptr(void *array, unsigned i, unsigned j)
+{
+	void **arr, *tmp;
+	arr = (void **)array;
+
+	tmp = arr[i];
+	arr[i] = arr[j];
+	arr[j] = tmp;
+}
+
+static void test_malloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_malloc_realloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++) {
+			ptr[i] = realloc(ptr[i], 2000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_mmap_unmap(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = mmap(NULL, 1000, PROT_READ | PROT_WRITE,
+					MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+			assert(ptr[i] != MAP_FAILED);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			munmap(ptr[i], 1000);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_ptr_read(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	unsigned long i, loops;
+	register unsigned long v;
+
+	loops = sizeof(linear) / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			v = *p++;
+			v = *p++;
+			v = *p++;
+			v = *p++;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * sizeof(linear) / 1000000);
+}
+
+static void test_ptr_write(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	register unsigned long i, loops;
+
+	loops = sizeof(linear) / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * sizeof(linear) / 1000000);
+}
+
+static void test_impact(int fd)
+{
+	unsigned int total = sizeof(nr_bos) / sizeof(nr_bos[0]);
+	unsigned int subtest, i;
+	uint32_t handles[nr_bos[total-1]];
+	void *ptr;
+	char buffer[sizeof(linear)];
+
+	for (subtest = 0; subtest < total; subtest++) {
+		for (i = 0; i < nr_bos[subtest]; i++)
+			handles[i] = create_userptr_bo(fd, sizeof(linear));
+
+		if (nr_bos[subtest] > 0)
+			ptr = get_handle_ptr(handles[0]);
+		else
+			ptr = buffer;
+
+		printf("ptr-read,                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_read(ptr);
+
+		printf("ptr-write                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_write(ptr);
+
+		printf("malloc-free,                %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(0);
+		printf("malloc-free-random          %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(1);
+
+		printf("malloc-realloc-free,        %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(0);
+		printf("malloc-realloc-free-random, %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(1);
+
+		printf("mmap-unmap,                 %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(0);
+		printf("mmap-unmap-random,          %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(1);
+
+		for (i = 0; i < nr_bos[subtest]; i++)
+			free_userptr_bo(fd, handles[i]);
+	}
+}
+
+static void test_single(int fd)
+{
+	char *ptr, *bo_ptr;
+	uint32_t handle = 0;
+	unsigned long iter = 0;
+	int ret;
+	unsigned long map_size = sizeof(linear) + PAGE_SIZE - 1;
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
Quoted 8 lines

benchmarks/gem_userptr_benchmark.c line 404

Quoted 5 lines
benchmarks/gem_userptr_benchmark.c new file +5 -0
+			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)(((unsigned long)ptr + (PAGE_SIZE - 1))
+					& ~(PAGE_SIZE - 1));

You might add an ALIGN macro in this file or a suitable header. A couple of .c files in lib/ individually define one already.

OK, will add that in the patch series.

Thanks for the review!

Regards,

Tvrtko

#24 lore raw

Re: [PATCH 3/3] tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

[snip]

Quoted 8 lines · Tvrtko Ursulin
Quoted 5 lines · Bradley D

benchmarks/gem_userptr_benchmark.c line 121

Quoted 2 lines · Tvrtko Ursulin
benchmarks/gem_userptr_benchmark.c new file +2 -0
+static void **handle_ptr_map;
+static unsigned int num_handle_ptr_map;

I'd prefer that we explicitly initialize at least num_handle_ptr_map.

To zero, why?

Partly because I just like explicitly initialized variables and partly because I forgot that static variables are *guaranteed* to be initialized to zero vs just-happen-to-be-zero :)

You can leave it as is or change it, I'm fine either way.

Thanks,
Brad

Quoted 296 lines
Quoted 279 lines
Quoted 279 lines
benchmarks/gem_userptr_benchmark.c new file +278 -0
+
+static void add_handle_ptr(uint32_t handle, void *ptr)
+{
+	if (handle >= num_handle_ptr_map) {
+		handle_ptr_map = realloc(handle_ptr_map,
+					 (handle + 1000) * sizeof(void*));
+		num_handle_ptr_map = handle + 1000;
+	}
+
+	handle_ptr_map[handle] = ptr;
+}
+
+static void *get_handle_ptr(uint32_t handle)
+{
+	return handle_ptr_map[handle];
+}
+
+static void free_handle_ptr(uint32_t handle)
+{
+	igt_assert(handle < num_handle_ptr_map);
+	igt_assert(handle_ptr_map[handle]);
+
+	free(handle_ptr_map[handle]);
+	handle_ptr_map[handle] = NULL;
+}
+
+static uint32_t create_userptr_bo(int fd, int size)
+{
+	void *ptr;
+	uint32_t handle;
+	int ret;
+
+	ret = posix_memalign(&ptr, PAGE_SIZE, size);
+	igt_assert(ret == 0);
+
+	ret = gem_userptr(fd, (uint32_t *)ptr, size, 0, &handle);
+	igt_assert(ret == 0);
+	add_handle_ptr(handle, ptr);
+
+	return handle;
+}
+
+static void free_userptr_bo(int fd, uint32_t handle)
+{
+	gem_close(fd, handle);
+	free_handle_ptr(handle);
+}
+
+static int has_userptr(int fd)
+{
+	uint32_t handle = 0;
+	void *ptr;
+	uint32_t oldflags;
+	int ret;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+	oldflags = userptr_flags;
+	gem_userptr_test_unsynchronized();
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	userptr_flags = oldflags;
+	if (ret != 0) {
+		free(ptr);
+		return 0;
+	}
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return handle != 0;
+}
+
+static const unsigned int nr_bos[] = {0, 1, 10, 100, 1000};
+static const unsigned int test_duration_sec = 3;
+
+static volatile unsigned int run_test;
+
+static void alarm_handler(int sig)
+{
+	assert(run_test == 1);
+	run_test = 0;
+}
+
+static void start_test(unsigned int duration)
+{
+	run_test = 1;
+	if (duration == 0)
+		duration = test_duration_sec;
+	signal(SIGALRM, alarm_handler);
+	alarm(duration);
+}
+
+static void exchange_ptr(void *array, unsigned i, unsigned j)
+{
+	void **arr, *tmp;
+	arr = (void **)array;
+
+	tmp = arr[i];
+	arr[i] = arr[j];
+	arr[j] = tmp;
+}
+
+static void test_malloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_malloc_realloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++) {
+			ptr[i] = realloc(ptr[i], 2000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_mmap_unmap(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = mmap(NULL, 1000, PROT_READ | PROT_WRITE,
+					MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+			assert(ptr[i] != MAP_FAILED);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			munmap(ptr[i], 1000);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_ptr_read(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	unsigned long i, loops;
+	register unsigned long v;
+
+	loops = sizeof(linear) / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			v = *p++;
+			v = *p++;
+			v = *p++;
+			v = *p++;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * sizeof(linear) / 1000000);
+}
+
+static void test_ptr_write(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	register unsigned long i, loops;
+
+	loops = sizeof(linear) / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * sizeof(linear) / 1000000);
+}
+
+static void test_impact(int fd)
+{
+	unsigned int total = sizeof(nr_bos) / sizeof(nr_bos[0]);
+	unsigned int subtest, i;
+	uint32_t handles[nr_bos[total-1]];
+	void *ptr;
+	char buffer[sizeof(linear)];
+
+	for (subtest = 0; subtest < total; subtest++) {
+		for (i = 0; i < nr_bos[subtest]; i++)
+			handles[i] = create_userptr_bo(fd, sizeof(linear));
+
+		if (nr_bos[subtest] > 0)
+			ptr = get_handle_ptr(handles[0]);
+		else
+			ptr = buffer;
+
+		printf("ptr-read,                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_read(ptr);
+
+		printf("ptr-write                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_write(ptr);
+
+		printf("malloc-free,                %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(0);
+		printf("malloc-free-random          %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(1);
+
+		printf("malloc-realloc-free,        %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(0);
+		printf("malloc-realloc-free-random, %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(1);
+
+		printf("mmap-unmap,                 %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(0);
+		printf("mmap-unmap-random,          %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(1);
+
+		for (i = 0; i < nr_bos[subtest]; i++)
+			free_userptr_bo(fd, handles[i]);
+	}
+}
+
+static void test_single(int fd)
+{
+	char *ptr, *bo_ptr;
+	uint32_t handle = 0;
+	unsigned long iter = 0;
+	int ret;
+	unsigned long map_size = sizeof(linear) + PAGE_SIZE - 1;
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
Quoted 8 lines

benchmarks/gem_userptr_benchmark.c line 404

Quoted 5 lines
benchmarks/gem_userptr_benchmark.c new file +5 -0
+			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)(((unsigned long)ptr + (PAGE_SIZE - 1))
+					& ~(PAGE_SIZE - 1));

You might add an ALIGN macro in this file or a suitable header. A couple of .c files in lib/ individually define one already.

OK, will add that in the patch series.

Thanks for the review!

Regards,

Tvrtko

#25 lore raw

PATCH 3/3 tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This adds a small benchmark for the new userptr functionality.

Apart from basic surface creation and destruction, also tested is the impact of having userptr surfaces in the process address space. Reason for that is the impact of MMU notifiers on common address space operations like munmap() which is per process.

v2:
* Moved to benchmarks.
* Added pointer read/write tests.
* Changed output to say iterations per second instead of operations per second.
* Multiply result by batch size for multi-create* tests for a more comparable number with create-destroy test.

---
 Android.mk                         |   3 +-
 benchmarks/.gitignore              |   1 +
 benchmarks/Android.mk              |  36 +++
 benchmarks/Makefile.am             |   7 +-
 benchmarks/Makefile.sources        |   6 +
 benchmarks/gem_userptr_benchmark.c | 513 +++++++++++++++++++++++++++++++++++++
 6 files changed, 558 insertions(+), 8 deletions(-)
 create mode 100644 benchmarks/Android.mk
 create mode 100644 benchmarks/Makefile.sources
 create mode 100644 benchmarks/gem_userptr_benchmark.c
Android.mk +1 -2
index 8aeb2d4..0c969b8 100644
@@ -1,2 +1 @@
-include $(call all-named-subdir-makefiles, lib tests tools)
-
+include $(call all-named-subdir-makefiles, lib tests tools benchmarks)
benchmarks/.gitignore +1 -0
index ddea6f7..09e5bd8 100644
@@ -1,3 +1,4 @@
+gem_userptr_benchmark
 intel_upload_blit_large
 intel_upload_blit_large_gtt
 intel_upload_blit_large_map
benchmarks/Android.mk new file +36 -0
new file mode 100644
index 0000000..5bb8ef5
@@ -0,0 +1,36 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(LOCAL_PATH)/Makefile.sources
+
+#================#
+
+define add_benchmark
+    include $(CLEAR_VARS)
+
+    LOCAL_SRC_FILES := $1.c
+
+    LOCAL_CFLAGS += -DHAVE_STRUCT_SYSINFO_TOTALRAM
+    LOCAL_CFLAGS += -DANDROID -UNDEBUG -include "check-ndebug.h"
+    LOCAL_CFLAGS += -std=c99
+    # FIXME: drop once Bionic correctly annotates "noreturn" on pthread_exit
+    LOCAL_CFLAGS += -Wno-error=return-type
+    # Excessive complaining for established cases. Rely on the Linux version warnings.
+    LOCAL_CFLAGS += -Wno-sign-compare
+
+    LOCAL_MODULE := $1
+    LOCAL_MODULE_TAGS := optional
+
+    LOCAL_STATIC_LIBRARIES := libintel_gpu_tools
+
+    LOCAL_SHARED_LIBRARIES := libpciaccess  \
+                              libdrm        \
+                              libdrm_intel
+
+    include $(BUILD_EXECUTABLE)
+endef
+
+#================#
+
+benchmark_list := $(bin_PROGRAMS)
+
+$(foreach item,$(benchmark_list),$(eval $(call add_benchmark,$(item))))
benchmarks/Makefile.am +1 -6
index e2ad784..d173bf4 100644
@@ -1,9 +1,4 @@
-
-bin_PROGRAMS = 				\
-	intel_upload_blit_large		\
-	intel_upload_blit_large_gtt	\
-	intel_upload_blit_large_map	\
-	intel_upload_blit_small
+include Makefile.sources
 
 AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/lib
 AM_CFLAGS = $(DRM_CFLAGS) $(CWARNFLAGS) $(CAIRO_CFLAGS)
benchmarks/Makefile.sources new file +6 -0
new file mode 100644
index 0000000..fd6c107
@@ -0,0 +1,6 @@
+bin_PROGRAMS =                          \
+        intel_upload_blit_large         \
+        intel_upload_blit_large_gtt     \
+        intel_upload_blit_large_map     \
+        intel_upload_blit_small         \
+        gem_userptr_benchmark
benchmarks/gem_userptr_benchmark.c new file +513 -0

513 lines not on this page · raw message

Signature · 6 lines
1.9.0

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

PATCH 3/3 tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This adds a small benchmark for the new userptr functionality.

Apart from basic surface creation and destruction, also tested is the impact of having userptr surfaces in the process address space. Reason for that is the impact of MMU notifiers on common address space operations like munmap() which is per process.

v2:
* Moved to benchmarks.
* Added pointer read/write tests.
* Changed output to say iterations per second instead of operations per second.
* Multiply result by batch size for multi-create* tests for a more comparable number with create-destroy test.

v3:
* Use ALIGN macro.
* Catchup with big lib/ reorganization.
* Removed unused code and one global variable.
* Fixed up some warnings.

v4:
* Fixed feature test, does not matter here but makes it consistent with gem_userptr_blits and clearer.

Cc Chris Wilson <[email protected]>
Cc Brad Volkin <[email protected]>
---
 benchmarks/.gitignore              |   1 +
 benchmarks/Makefile.sources        |   3 +-
 benchmarks/gem_userptr_benchmark.c | 498 +++++++++++++++++++++++++++++++++++++
 3 files changed, 501 insertions(+), 1 deletion(-)
 create mode 100644 benchmarks/gem_userptr_benchmark.c
benchmarks/.gitignore +1 -0
index ddea6f7..09e5bd8 100644
@@ -1,3 +1,4 @@
+gem_userptr_benchmark
 intel_upload_blit_large
 intel_upload_blit_large_gtt
 intel_upload_blit_large_map
benchmarks/Makefile.sources +2 -1
index f9da579..60bdae2 100644
@@ -2,4 +2,5 @@ bin_PROGRAMS =                          \
 	intel_upload_blit_large         \
 	intel_upload_blit_large_gtt     \
 	intel_upload_blit_large_map     \
-	intel_upload_blit_small
+	intel_upload_blit_small		\
+	gem_userptr_benchmark
benchmarks/gem_userptr_benchmark.c new file +498 -0

498 lines not on this page · raw message

Signature · 6 lines
1.9.1

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Reviewed-by on v1 3/3
#27 lore raw

Re: [PATCH 3/3] tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact

Quoted 564 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

This adds a small benchmark for the new userptr functionality.

Apart from basic surface creation and destruction, also tested is the impact of having userptr surfaces in the process address space. Reason for that is the impact of MMU notifiers on common address space operations like munmap() which is per process.

v2:
* Moved to benchmarks.
* Added pointer read/write tests.
* Changed output to say iterations per second instead of operations per second.
* Multiply result by batch size for multi-create* tests for a more comparable number with create-destroy test.

v3:
* Use ALIGN macro.
* Catchup with big lib/ reorganization.
* Removed unused code and one global variable.
* Fixed up some warnings.

v4:
* Fixed feature test, does not matter here but makes it consistent with gem_userptr_blits and clearer.

Cc Chris Wilson <[email protected]>
Cc Brad Volkin <[email protected]>
---
 benchmarks/.gitignore              |   1 +
 benchmarks/Makefile.sources        |   3 +-
 benchmarks/gem_userptr_benchmark.c | 498 +++++++++++++++++++++++++++++++++++++
 3 files changed, 501 insertions(+), 1 deletion(-)
 create mode 100644 benchmarks/gem_userptr_benchmark.c
benchmarks/.gitignore +1 -0
index ddea6f7..09e5bd8 100644
@@ -1,3 +1,4 @@
+gem_userptr_benchmark
 intel_upload_blit_large
 intel_upload_blit_large_gtt
 intel_upload_blit_large_map
benchmarks/Makefile.sources +2 -1
index f9da579..60bdae2 100644
@@ -2,4 +2,5 @@ bin_PROGRAMS =                          \
 	intel_upload_blit_large         \
 	intel_upload_blit_large_gtt     \
 	intel_upload_blit_large_map     \
-	intel_upload_blit_small
+	intel_upload_blit_small		\
+	gem_userptr_benchmark
benchmarks/gem_userptr_benchmark.c new file +498 -0
new file mode 100644
index 0000000..9ad6e4a
@@ -0,0 +1,498 @@
+/*
+ * Copyright © 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:
+ *    Tvrtko Ursulin <[email protected]>
+ *
+ */
+
+/** @file gem_userptr_benchmark.c
+ *
+ * Benchmark the userptr code and impact of having userptr surfaces
+ * in process address space on some normal operations.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include "drm.h"
+#include "i915_drm.h"
+#include "drmtest.h"
+#include "intel_bufmgr.h"
+#include "intel_batchbuffer.h"
+#include "intel_chipset.h"
+#include "ioctl_wrappers.h"
+#include "igt_aux.h"
+
+#ifndef PAGE_SIZE
+  #define PAGE_SIZE 4096
+#endif
+
+#define LOCAL_I915_GEM_USERPTR       0x34
+#define LOCAL_IOCTL_I915_GEM_USERPTR DRM_IOWR (DRM_COMMAND_BASE + LOCAL_I915_GEM_USERPTR, struct local_i915_gem_userptr)
+struct local_i915_gem_userptr {
+	uint64_t user_ptr;
+	uint64_t user_size;
+	uint32_t flags;
+#define LOCAL_I915_USERPTR_READ_ONLY (1<<0)
+#define LOCAL_I915_USERPTR_UNSYNCHRONIZED (1<<31)
+	uint32_t handle;
+};
+
+static uint32_t userptr_flags = LOCAL_I915_USERPTR_UNSYNCHRONIZED;
+
+#define BO_SIZE (65536)
+
+static void gem_userptr_test_unsynchronized(void)
+{
+	userptr_flags = LOCAL_I915_USERPTR_UNSYNCHRONIZED;
+}
+
+static void gem_userptr_test_synchronized(void)
+{
+	userptr_flags = 0;
+}
+
+static int gem_userptr(int fd, void *ptr, int size, int read_only, uint32_t *handle)
+{
+	struct local_i915_gem_userptr userptr;
+	int ret;
+
+	userptr.user_ptr = (uintptr_t)ptr;
+	userptr.user_size = size;
+	userptr.flags = userptr_flags;
+	if (read_only)
+		userptr.flags |= LOCAL_I915_USERPTR_READ_ONLY;
+
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+	if (ret)
+		ret = errno;
+	igt_skip_on_f(ret == ENODEV &&
+		      (userptr_flags & LOCAL_I915_USERPTR_UNSYNCHRONIZED) == 0 &&
+		      !read_only,
+		      "Skipping, synchronized mappings with no kernel CONFIG_MMU_NOTIFIER?");
+	if (ret == 0)
+		*handle = userptr.handle;
+
+	return ret;
+}
+
+static void **handle_ptr_map;
+static unsigned int num_handle_ptr_map;
+
+static void add_handle_ptr(uint32_t handle, void *ptr)
+{
+	if (handle >= num_handle_ptr_map) {
+		handle_ptr_map = realloc(handle_ptr_map,
+					 (handle + 1000) * sizeof(void*));
+		num_handle_ptr_map = handle + 1000;
+	}
+
+	handle_ptr_map[handle] = ptr;
+}
+
+static void *get_handle_ptr(uint32_t handle)
+{
+	return handle_ptr_map[handle];
+}
+
+static void free_handle_ptr(uint32_t handle)
+{
+	igt_assert(handle < num_handle_ptr_map);
+	igt_assert(handle_ptr_map[handle]);
+
+	free(handle_ptr_map[handle]);
+	handle_ptr_map[handle] = NULL;
+}
+
+static uint32_t create_userptr_bo(int fd, int size)
+{
+	void *ptr;
+	uint32_t handle;
+	int ret;
+
+	ret = posix_memalign(&ptr, PAGE_SIZE, size);
+	igt_assert(ret == 0);
+
+	ret = gem_userptr(fd, (uint32_t *)ptr, size, 0, &handle);
+	igt_assert(ret == 0);
+	add_handle_ptr(handle, ptr);
+
+	return handle;
+}
+
+static void free_userptr_bo(int fd, uint32_t handle)
+{
+	gem_close(fd, handle);
+	free_handle_ptr(handle);
+}
+
+static int has_userptr(int fd)
+{
+	uint32_t handle = 0;
+	void *ptr;
+	uint32_t oldflags;
+	int ret;
+
+	assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
+	oldflags = userptr_flags;
+	gem_userptr_test_unsynchronized();
+	ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
+	userptr_flags = oldflags;
+	if (ret != 0) {
+		free(ptr);
+		return 0;
+	}
+
+	gem_close(fd, handle);
+	free(ptr);
+
+	return handle != 0;
+}
+
+static const unsigned int nr_bos[] = {0, 1, 10, 100, 1000};
+static const unsigned int test_duration_sec = 3;
+
+static volatile unsigned int run_test;
+
+static void alarm_handler(int sig)
+{
+	assert(run_test == 1);
+	run_test = 0;
+}
+
+static void start_test(unsigned int duration)
+{
+	run_test = 1;
+	if (duration == 0)
+		duration = test_duration_sec;
+	signal(SIGALRM, alarm_handler);
+	alarm(duration);
+}
+
+static void exchange_ptr(void *array, unsigned i, unsigned j)
+{
+	void **arr, *tmp;
+	arr = (void **)array;
+
+	tmp = arr[i];
+	arr[i] = arr[j];
+	arr[j] = tmp;
+}
+
+static void test_malloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_malloc_realloc_free(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = malloc(1000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++) {
+			ptr[i] = realloc(ptr[i], 2000);
+			assert(ptr[i]);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			free(ptr[i]);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_mmap_unmap(int random)
+{
+	unsigned long iter = 0;
+	unsigned int i, tot = 1000;
+	void *ptr[tot];
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		for (i = 0; i < tot; i++) {
+			ptr[i] = mmap(NULL, 1000, PROT_READ | PROT_WRITE,
+					MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+			assert(ptr[i] != MAP_FAILED);
+		}
+		if (random)
+			igt_permute_array(ptr, tot, exchange_ptr);
+		for (i = 0; i < tot; i++)
+			munmap(ptr[i], 1000);
+		iter++;
+	}
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_ptr_read(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	unsigned long i, loops;
+	register unsigned long v;
+
+	loops = BO_SIZE / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			v = *p++;
+			v = *p++;
+			v = *p++;
+			v = *p++;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * BO_SIZE / 1000000);
+}
+
+static void test_ptr_write(void *ptr)
+{
+	unsigned long iter = 0;
+	volatile unsigned long *p;
+	register unsigned long i, loops;
+
+	loops = BO_SIZE / sizeof(unsigned long) / 4;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		p = (unsigned long *)ptr;
+		for (i = 0; i < loops; i++) {
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+			*p++ = i;
+		}
+		iter++;
+	}
+
+	printf("%8lu MB/s\n", iter / test_duration_sec * BO_SIZE / 1000000);
+}
+
+static void test_impact(int fd)
+{
+	unsigned int total = sizeof(nr_bos) / sizeof(nr_bos[0]);
+	unsigned int subtest, i;
+	uint32_t handles[nr_bos[total-1]];
+	void *ptr;
+	char buffer[BO_SIZE];
+
+	for (subtest = 0; subtest < total; subtest++) {
+		for (i = 0; i < nr_bos[subtest]; i++)
+			handles[i] = create_userptr_bo(fd, BO_SIZE);
+
+		if (nr_bos[subtest] > 0)
+			ptr = get_handle_ptr(handles[0]);
+		else
+			ptr = buffer;
+
+		printf("ptr-read,                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_read(ptr);
+
+		printf("ptr-write                   %5u bos = ", nr_bos[subtest]);
+		test_ptr_write(ptr);
+
+		printf("malloc-free,                %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(0);
+		printf("malloc-free-random          %5u bos = ", nr_bos[subtest]);
+		test_malloc_free(1);
+
+		printf("malloc-realloc-free,        %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(0);
+		printf("malloc-realloc-free-random, %5u bos = ", nr_bos[subtest]);
+		test_malloc_realloc_free(1);
+
+		printf("mmap-unmap,                 %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(0);
+		printf("mmap-unmap-random,          %5u bos = ", nr_bos[subtest]);
+		test_mmap_unmap(1);
+
+		for (i = 0; i < nr_bos[subtest]; i++)
+			free_userptr_bo(fd, handles[i]);
+	}
+}
+
+static void test_single(int fd)
+{
+	char *ptr, *bo_ptr;
+	uint32_t handle = 0;
+	unsigned long iter = 0;
+	int ret;
+	unsigned long map_size = BO_SIZE + PAGE_SIZE - 1;
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		ret = gem_userptr(fd, bo_ptr, BO_SIZE, 0, &handle);
+		assert(ret == 0);
+		gem_close(fd, handle);
+		iter++;
+	}
+
+	munmap(ptr, map_size);
+
+	printf("%8lu iter/s\n", iter / test_duration_sec);
+}
+
+static void test_multiple(int fd, unsigned int batch, int random)
+{
+	char *ptr, *bo_ptr;
+	uint32_t handles[10000];
+	int map[10000];
+	unsigned long iter = 0;
+	int ret;
+	int i;
+	unsigned long map_size = batch * BO_SIZE + PAGE_SIZE - 1;
+
+	assert(batch < (sizeof(handles) / sizeof(handles[0])));
+	assert(batch < (sizeof(map) / sizeof(map[0])));
+
+	ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
+			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
+
+	for (i = 0; i < batch; i++)
+		map[i] = i;
+
+	start_test(test_duration_sec);
+
+	while (run_test) {
+		if (random)
+			igt_permute_array(map, batch, igt_exchange_int);
+		for (i = 0; i < batch; i++) {
+			ret = gem_userptr(fd, bo_ptr + map[i] * BO_SIZE,
+						BO_SIZE,
+						0, &handles[i]);
+			assert(ret == 0);
+		}
+		if (random)
+			igt_permute_array(map, batch, igt_exchange_int);
+		for (i = 0; i < batch; i++)
+			gem_close(fd, handles[map[i]]);
+		iter++;
+	}
+
+	munmap(ptr, map_size);
+
+	printf("%8lu iter/s\n", iter * batch / test_duration_sec);
+}
+
+static void test_userptr(int fd)
+{
+	printf("create-destroy                = ");
+	test_single(fd);
+
+	printf("multi-create-destroy          = ");
+	test_multiple(fd, 100, 0);
+
+	printf("multi-create-destroy-random   = ");
+	test_multiple(fd, 100, 1);
+}
+
+int main(int argc, char **argv)
+{
+	int fd = -1, ret;
+
+	igt_skip_on_simulation();
+
+	igt_subtest_init(argc, argv);
+
+	fd = drm_open_any();
+	igt_assert(fd >= 0);
+
+	ret = has_userptr(fd);
+	igt_skip_on_f(ret == 0, "No userptr support - %s (%d)\n",
+			strerror(errno), ret);
+
+
+	gem_userptr_test_unsynchronized();
+
+	igt_subtest("userptr-unsync")
+		test_userptr(fd);
+
+	igt_subtest("userptr-impact-unsync")
+		test_impact(fd);
+
+	gem_userptr_test_synchronized();
+
+	igt_subtest("userptr-sync")
+		test_userptr(fd);
+
+	igt_subtest("userptr-impact-sync")
+		test_impact(fd);
+
+	igt_exit();
+
+	return 0;
+}
Signature · 1 line
1.9.1