tests: New userptr test case
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
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
@@ -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
@@ -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
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_everythingand 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.Signed-off-by Tvrtko Ursulin <[email protected]>---
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
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_everythingand 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.Signed-off-by Tvrtko Ursulin <[email protected]>---
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 thiscopy()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
PATCH 1/3 tests/gem_userptr_blits: Expanded userptr test cases
In reply to Tvrtko UrsulinFrom: 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
@@ -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
@@ -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
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
@@ -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
@@ -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
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 forlib/reorganization.Signed-off-by Tvrtko Ursulin <[email protected]>--- 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.ctests/.gitignore +0
-1@@ -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_switchtests/Makefile.sources +0
-1@@ -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@@ -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
PATCH 3/3 tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact
In reply to Tvrtko UrsulinFrom: 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
@@ -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
@@ -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
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 biglib/reorganization.
* Removed unused code and one global variable.
* Fixed up some warnings.Signed-off-by Tvrtko Ursulin <[email protected]>Cc Chris Wilson <[email protected]>--- 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.cbenchmarks/.gitignore +1
-0@@ -1,3 +1,4 @@ +gem_userptr_benchmark intel_upload_blit_large intel_upload_blit_large_gtt intel_upload_blit_large_mapbenchmarks/Makefile.sources +2
-1@@ -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_benchmarkbenchmarks/gem_userptr_benchmark.c new file +89
-0@@ -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; + registerunsigned 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; + registerunsigned 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
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_onlywill always be 0 in this test though, so probably not an issue.
Quoted 1 line
Reviewed-by Brad Volkin <[email protected]>
Good catch! It does not matter in the benchmark but I've sent a respin for consistency and clarity.
Thanks,
Tvrtko
Re: [PATCH 1/3] tests/gem_userptr_blits: Expanded userptr test cases
In reply to Tvrtko UrsulinQuoted 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_everythingand 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 biglib/reorganization.
* Fixed up some warnings.Signed-off-by Tvrtko Ursulin <[email protected]>--- 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.ctests/.gitignore +1
-0@@ -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_blitstests/Makefile.sources +1
-0@@ -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@@ -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
PATCH 2/3 tests/gem_vmap_blits: Remove obsolete test case
In reply to Tvrtko UrsulinFrom: 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
@@ -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
@@ -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
cover tests: New userptr test case
In reply to Tvrtko UrsulinFrom: 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
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
@@ -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
@@ -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
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_everythingand 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:
* Updatedcopy()for Gen8+.
* Fixed ioctl detection on kernels withoutMMU_NOTIFIERs.Signed-off-by Tvrtko Ursulin <[email protected]>
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.ctests/.gitignore +1
-0@@ -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_blitstests/Makefile.sources +1
-0@@ -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@@ -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
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_everythingand 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:
* Updatedcopy()for Gen8+.
* Fixed ioctl detection on kernels withoutMMU_NOTIFIERs.
Quoted 6 lines
Quoted 1 line
Signed-off-by Tvrtko Ursulin <[email protected]>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
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_everythingand 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:
* Updatedcopy()for Gen8+.
* Fixed ioctl detection on kernels withoutMMU_NOTIFIERs.Quoted 6 lines
Quoted 1 line
Signed-off-by Tvrtko Ursulin <[email protected]>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
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_everythingand 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:
* Updatedcopy()for Gen8+.
* Fixed ioctl detection on kernels withoutMMU_NOTIFIERs.Quoted 6 lines
Quoted 1 line
Signed-off-by Tvrtko Ursulin <[email protected]>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
PATCH 2/3 tests/gem_vmap_blits: Remove obsolete test case
In reply to Tvrtko UrsulinFrom: 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
@@ -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
@@ -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
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.
Signed-off-by Tvrtko Ursulin <[email protected]>
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.ctests/.gitignore +0
-1@@ -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_switchtests/Makefile.sources +0
-1@@ -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@@ -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
PATCH 3/3 tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact
In reply to Tvrtko UrsulinFrom: 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
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 withoutMMU_NOTIFIERs.Signed-off-by Tvrtko Ursulin <[email protected]>Cc Chris Wilson <[email protected]>--- 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.cAndroid.mk +1
-2@@ -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@@ -1,3 +1,4 @@ +gem_userptr_benchmark intel_upload_blit_large intel_upload_blit_large_gtt intel_upload_blit_large_mapbenchmarks/Android.mk new file +36
-0@@ -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@@ -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
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@@ -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; + registerunsigned 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; + registerunsigned 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
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
Re: [PATCH 3/3] tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact
In reply to Volkin, Bradley DHi 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 withoutMMU_NOTIFIERs.Signed-off-by Tvrtko Ursulin <[email protected]>Cc Chris Wilson <[email protected]>--- 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.mkcreate mode 100644 benchmarks/Makefile.sources create mode 100644benchmarks/gem_userptr_benchmark.cAndroid.mk +1
-2@@ -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@@ -1,3 +1,4 @@ +gem_userptr_benchmark intel_upload_blit_large intel_upload_blit_large_gtt intel_upload_blit_large_mapbenchmarks/Android.mk new file +36
-0@@ -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@@ -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@@ -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_benchmarkYou 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@@ -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; + registerunsigned 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; + registerunsigned 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
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; + registerunsigned 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; + registerunsigned 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
PATCH 3/3 tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact
In reply to Tvrtko UrsulinFrom: 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
PATCH 3/3 tests/gem_userptr_benchmark: Benchmarking userptr surfaces and impact
In reply to Tvrtko UrsulinFrom: 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.
--- 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
@@ -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
@@ -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
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 biglib/reorganization.
* Removed unused code and one global variable.
* Fixed up some warnings.v4:
* Fixed feature test, does not matter here but makes it consistent withgem_userptr_blitsand clearer.Signed-off-by Tvrtko Ursulin <[email protected]>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.cbenchmarks/.gitignore +1
-0@@ -1,3 +1,4 @@ +gem_userptr_benchmark intel_upload_blit_large intel_upload_blit_large_gtt intel_upload_blit_large_mapbenchmarks/Makefile.sources +2
-1@@ -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_benchmarkbenchmarks/gem_userptr_benchmark.c new file +498
-0@@ -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; + registerunsigned 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; + registerunsigned 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