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

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Wed, Mar 19, 2014 at 04:13:06AM -0700, Tvrtko Ursulin wrote:
> From: Tvrtko Ursulin <tvrtko.ursulin@xxxxxxxxx>
> 
> 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.
> 
> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@xxxxxxxxx>
> Cc: Chris Wilson <chris@xxxxxxxxxxxxxxxxxx>
> ---
>  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
> 
> diff --git a/Android.mk b/Android.mk
> index 8aeb2d4..0c969b8 100644
> --- a/Android.mk
> +++ b/Android.mk
> @@ -1,2 +1 @@
> -include $(call all-named-subdir-makefiles, lib tests tools)
> -
> +include $(call all-named-subdir-makefiles, lib tests tools benchmarks)
> 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/Android.mk b/benchmarks/Android.mk
> new file mode 100644
> index 0000000..5bb8ef5
> --- /dev/null
> +++ b/benchmarks/Android.mk
> @@ -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))))
> diff --git a/benchmarks/Makefile.am b/benchmarks/Makefile.am
> index e2ad784..d173bf4 100644
> --- a/benchmarks/Makefile.am
> +++ b/benchmarks/Makefile.am
> @@ -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)
> diff --git a/benchmarks/Makefile.sources b/benchmarks/Makefile.sources
> new file mode 100644
> index 0000000..fd6c107
> --- /dev/null
> +++ b/benchmarks/Makefile.sources
> @@ -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.

> diff --git a/benchmarks/gem_userptr_benchmark.c b/benchmarks/gem_userptr_benchmark.c
> new file mode 100644
> index 0000000..218f6f1
> --- /dev/null
> +++ b/benchmarks/gem_userptr_benchmark.c
> @@ -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 <tvrtko.ursulin@xxxxxxxxx>
> + *
> + */
> +
> +/** @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;
> +};
> +
> +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.

> +
> +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);
> +
> +	/* 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.

> +
> +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.

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

> +
> +	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;
> +}
> -- 
> 1.9.0
> 
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
> http://lists.freedesktop.org/mailman/listinfo/intel-gfx
_______________________________________________
Intel-gfx mailing list
Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/intel-gfx





[Index of Archives]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]
  Powered by Linux