On Wed, Apr 23, 2014 at 05:38:35PM +0100, Tvrtko Ursulin wrote:
> From: Tvrtko Ursulin <tvrtko.ursu...@intel.com>
>
> 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.
>
> Signed-off-by: Tvrtko Ursulin <tvrtko.ursu...@intel.com>
> Cc: Chris Wilson <ch...@chris-wilson.co.uk>
> ---
> 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
>
> diff --git a/benchmarks/.gitignore b/benchmarks/.gitignore
> index ddea6f7..09e5bd8 100644
> --- a/benchmarks/.gitignore
> +++ b/benchmarks/.gitignore
> @@ -1,3 +1,4 @@
> +gem_userptr_benchmark
> intel_upload_blit_large
> intel_upload_blit_large_gtt
> intel_upload_blit_large_map
> diff --git a/benchmarks/Makefile.sources b/benchmarks/Makefile.sources
> index f9da579..60bdae2 100644
> --- a/benchmarks/Makefile.sources
> +++ b/benchmarks/Makefile.sources
> @@ -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
> diff --git a/benchmarks/gem_userptr_benchmark.c
> b/benchmarks/gem_userptr_benchmark.c
> new file mode 100644
> index 0000000..a51201c
> --- /dev/null
> +++ b/benchmarks/gem_userptr_benchmark.c
> @@ -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 <tvrtko.ursu...@intel.com>
> + *
> + */
> +
> +/** @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,
> + "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.
Reviewed-by: Brad Volkin <bradley.d.vol...@intel.com>
> + if (ret == 0)
> + *handle = userptr.handle;
> +
> + return ret;
> +}
> +
> +static void **handle_ptr_map;
> +static unsigned int num_handle_ptr_map;
> +
> +static void add_handle_ptr(uint32_t handle, void *ptr)
> +{
> + if (handle >= num_handle_ptr_map) {
> + handle_ptr_map = realloc(handle_ptr_map,
> + (handle + 1000) * sizeof(void*));
> + num_handle_ptr_map = handle + 1000;
> + }
> +
> + handle_ptr_map[handle] = ptr;
> +}
> +
> +static void *get_handle_ptr(uint32_t handle)
> +{
> + return handle_ptr_map[handle];
> +}
> +
> +static void free_handle_ptr(uint32_t handle)
> +{
> + igt_assert(handle < num_handle_ptr_map);
> + igt_assert(handle_ptr_map[handle]);
> +
> + free(handle_ptr_map[handle]);
> + handle_ptr_map[handle] = NULL;
> +}
> +
> +static uint32_t create_userptr_bo(int fd, int size)
> +{
> + void *ptr;
> + uint32_t handle;
> + int ret;
> +
> + ret = posix_memalign(&ptr, PAGE_SIZE, size);
> + igt_assert(ret == 0);
> +
> + ret = gem_userptr(fd, (uint32_t *)ptr, size, 0, &handle);
> + igt_assert(ret == 0);
> + add_handle_ptr(handle, ptr);
> +
> + return handle;
> +}
> +
> +static void free_userptr_bo(int fd, uint32_t handle)
> +{
> + gem_close(fd, handle);
> + free_handle_ptr(handle);
> +}
> +
> +static int has_userptr(int fd)
> +{
> + uint32_t handle = 0;
> + void *ptr;
> + uint32_t oldflags;
> + int ret;
> +
> + assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
> + oldflags = userptr_flags;
> + gem_userptr_test_unsynchronized();
> + ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
> + userptr_flags = oldflags;
> + if (ret != 0) {
> + free(ptr);
> + return 0;
> + }
> +
> + gem_close(fd, handle);
> + free(ptr);
> +
> + return handle != 0;
> +}
> +
> +static const unsigned int nr_bos[] = {0, 1, 10, 100, 1000};
> +static const unsigned int test_duration_sec = 3;
> +
> +static volatile unsigned int run_test;
> +
> +static void alarm_handler(int sig)
> +{
> + assert(run_test == 1);
> + run_test = 0;
> +}
> +
> +static void start_test(unsigned int duration)
> +{
> + run_test = 1;
> + if (duration == 0)
> + duration = test_duration_sec;
> + signal(SIGALRM, alarm_handler);
> + alarm(duration);
> +}
> +
> +static void exchange_ptr(void *array, unsigned i, unsigned j)
> +{
> + void **arr, *tmp;
> + arr = (void **)array;
> +
> + tmp = arr[i];
> + arr[i] = arr[j];
> + arr[j] = tmp;
> +}
> +
> +static void test_malloc_free(int random)
> +{
> + unsigned long iter = 0;
> + unsigned int i, tot = 1000;
> + void *ptr[tot];
> +
> + start_test(test_duration_sec);
> +
> + while (run_test) {
> + for (i = 0; i < tot; i++) {
> + ptr[i] = malloc(1000);
> + assert(ptr[i]);
> + }
> + if (random)
> + igt_permute_array(ptr, tot, exchange_ptr);
> + for (i = 0; i < tot; i++)
> + free(ptr[i]);
> + iter++;
> + }
> +
> + printf("%8lu iter/s\n", iter / test_duration_sec);
> +}
> +
> +static void test_malloc_realloc_free(int random)
> +{
> + unsigned long iter = 0;
> + unsigned int i, tot = 1000;
> + void *ptr[tot];
> +
> + start_test(test_duration_sec);
> +
> + while (run_test) {
> + for (i = 0; i < tot; i++) {
> + ptr[i] = malloc(1000);
> + assert(ptr[i]);
> + }
> + if (random)
> + igt_permute_array(ptr, tot, exchange_ptr);
> + for (i = 0; i < tot; i++) {
> + ptr[i] = realloc(ptr[i], 2000);
> + assert(ptr[i]);
> + }
> + if (random)
> + igt_permute_array(ptr, tot, exchange_ptr);
> + for (i = 0; i < tot; i++)
> + free(ptr[i]);
> + iter++;
> + }
> +
> + printf("%8lu iter/s\n", iter / test_duration_sec);
> +}
> +
> +static void test_mmap_unmap(int random)
> +{
> + unsigned long iter = 0;
> + unsigned int i, tot = 1000;
> + void *ptr[tot];
> +
> + start_test(test_duration_sec);
> +
> + while (run_test) {
> + for (i = 0; i < tot; i++) {
> + ptr[i] = mmap(NULL, 1000, PROT_READ | PROT_WRITE,
> + MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
> + assert(ptr[i] != MAP_FAILED);
> + }
> + if (random)
> + igt_permute_array(ptr, tot, exchange_ptr);
> + for (i = 0; i < tot; i++)
> + munmap(ptr[i], 1000);
> + iter++;
> + }
> +
> + printf("%8lu iter/s\n", iter / test_duration_sec);
> +}
> +
> +static void test_ptr_read(void *ptr)
> +{
> + unsigned long iter = 0;
> + volatile unsigned long *p;
> + unsigned long i, loops;
> + register unsigned long v;
> +
> + loops = BO_SIZE / sizeof(unsigned long) / 4;
> +
> + start_test(test_duration_sec);
> +
> + while (run_test) {
> + p = (unsigned long *)ptr;
> + for (i = 0; i < loops; i++) {
> + v = *p++;
> + v = *p++;
> + v = *p++;
> + v = *p++;
> + }
> + iter++;
> + }
> +
> + printf("%8lu MB/s\n", iter / test_duration_sec * BO_SIZE / 1000000);
> +}
> +
> +static void test_ptr_write(void *ptr)
> +{
> + unsigned long iter = 0;
> + volatile unsigned long *p;
> + register unsigned long i, loops;
> +
> + loops = BO_SIZE / sizeof(unsigned long) / 4;
> +
> + start_test(test_duration_sec);
> +
> + while (run_test) {
> + p = (unsigned long *)ptr;
> + for (i = 0; i < loops; i++) {
> + *p++ = i;
> + *p++ = i;
> + *p++ = i;
> + *p++ = i;
> + }
> + iter++;
> + }
> +
> + printf("%8lu MB/s\n", iter / test_duration_sec * BO_SIZE / 1000000);
> +}
> +
> +static void test_impact(int fd)
> +{
> + unsigned int total = sizeof(nr_bos) / sizeof(nr_bos[0]);
> + unsigned int subtest, i;
> + uint32_t handles[nr_bos[total-1]];
> + void *ptr;
> + char buffer[BO_SIZE];
> +
> + for (subtest = 0; subtest < total; subtest++) {
> + for (i = 0; i < nr_bos[subtest]; i++)
> + handles[i] = create_userptr_bo(fd, BO_SIZE);
> +
> + if (nr_bos[subtest] > 0)
> + ptr = get_handle_ptr(handles[0]);
> + else
> + ptr = buffer;
> +
> + printf("ptr-read, %5u bos = ",
> nr_bos[subtest]);
> + test_ptr_read(ptr);
> +
> + printf("ptr-write %5u bos = ",
> nr_bos[subtest]);
> + test_ptr_write(ptr);
> +
> + printf("malloc-free, %5u bos = ",
> nr_bos[subtest]);
> + test_malloc_free(0);
> + printf("malloc-free-random %5u bos = ",
> nr_bos[subtest]);
> + test_malloc_free(1);
> +
> + printf("malloc-realloc-free, %5u bos = ",
> nr_bos[subtest]);
> + test_malloc_realloc_free(0);
> + printf("malloc-realloc-free-random, %5u bos = ",
> nr_bos[subtest]);
> + test_malloc_realloc_free(1);
> +
> + printf("mmap-unmap, %5u bos = ",
> nr_bos[subtest]);
> + test_mmap_unmap(0);
> + printf("mmap-unmap-random, %5u bos = ",
> nr_bos[subtest]);
> + test_mmap_unmap(1);
> +
> + for (i = 0; i < nr_bos[subtest]; i++)
> + free_userptr_bo(fd, handles[i]);
> + }
> +}
> +
> +static void test_single(int fd)
> +{
> + char *ptr, *bo_ptr;
> + uint32_t handle = 0;
> + unsigned long iter = 0;
> + int ret;
> + unsigned long map_size = BO_SIZE + PAGE_SIZE - 1;
> +
> + ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
> + MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
> + assert(ptr != MAP_FAILED);
> +
> + bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
> +
> + start_test(test_duration_sec);
> +
> + while (run_test) {
> + ret = gem_userptr(fd, bo_ptr, BO_SIZE, 0, &handle);
> + assert(ret == 0);
> + gem_close(fd, handle);
> + iter++;
> + }
> +
> + munmap(ptr, map_size);
> +
> + printf("%8lu iter/s\n", iter / test_duration_sec);
> +}
> +
> +static void test_multiple(int fd, unsigned int batch, int random)
> +{
> + char *ptr, *bo_ptr;
> + uint32_t handles[10000];
> + int map[10000];
> + unsigned long iter = 0;
> + int ret;
> + int i;
> + unsigned long map_size = batch * BO_SIZE + PAGE_SIZE - 1;
> +
> + assert(batch < (sizeof(handles) / sizeof(handles[0])));
> + assert(batch < (sizeof(map) / sizeof(map[0])));
> +
> + ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
> + MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
> + assert(ptr != MAP_FAILED);
> +
> + bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
> +
> + for (i = 0; i < batch; i++)
> + map[i] = i;
> +
> + start_test(test_duration_sec);
> +
> + while (run_test) {
> + if (random)
> + igt_permute_array(map, batch, igt_exchange_int);
> + for (i = 0; i < batch; i++) {
> + ret = gem_userptr(fd, bo_ptr + map[i] * BO_SIZE,
> + BO_SIZE,
> + 0, &handles[i]);
> + assert(ret == 0);
> + }
> + if (random)
> + igt_permute_array(map, batch, igt_exchange_int);
> + for (i = 0; i < batch; i++)
> + gem_close(fd, handles[map[i]]);
> + iter++;
> + }
> +
> + munmap(ptr, map_size);
> +
> + printf("%8lu iter/s\n", iter * batch / test_duration_sec);
> +}
> +
> +static void test_userptr(int fd)
> +{
> + printf("create-destroy = ");
> + test_single(fd);
> +
> + printf("multi-create-destroy = ");
> + test_multiple(fd, 100, 0);
> +
> + printf("multi-create-destroy-random = ");
> + test_multiple(fd, 100, 1);
> +}
> +
> +int main(int argc, char **argv)
> +{
> + int fd = -1, ret;
> +
> + igt_skip_on_simulation();
> +
> + igt_subtest_init(argc, argv);
> +
> + fd = drm_open_any();
> + igt_assert(fd >= 0);
> +
> + ret = has_userptr(fd);
> + igt_skip_on_f(ret == 0, "No userptr support - %s (%d)\n",
> + strerror(errno), ret);
> +
> +
> + gem_userptr_test_unsynchronized();
> +
> + igt_subtest("userptr-unsync")
> + test_userptr(fd);
> +
> + igt_subtest("userptr-impact-unsync")
> + test_impact(fd);
> +
> + gem_userptr_test_synchronized();
> +
> + igt_subtest("userptr-sync")
> + test_userptr(fd);
> +
> + igt_subtest("userptr-impact-sync")
> + test_impact(fd);
> +
> + igt_exit();
> +
> + return 0;
> +}
> --
> 1.9.1
>
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
