diff options
Diffstat (limited to 'tests/i915/gem_ctx_create.c')
-rw-r--r-- | tests/i915/gem_ctx_create.c | 388 |
1 files changed, 388 insertions, 0 deletions
diff --git a/tests/i915/gem_ctx_create.c b/tests/i915/gem_ctx_create.c new file mode 100644 index 00000000..a664070d --- /dev/null +++ b/tests/i915/gem_ctx_create.c @@ -0,0 +1,388 @@ +/* + * Copyright © 2012 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: + * Ben Widawsky <ben@bwidawsk.net> + * + */ + +#include "igt.h" + +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <time.h> + +#include "igt_rand.h" + +#define LOCAL_I915_EXEC_BSD_SHIFT (13) +#define LOCAL_I915_EXEC_BSD_MASK (3 << LOCAL_I915_EXEC_BSD_SHIFT) + +#define ENGINE_FLAGS (I915_EXEC_RING_MASK | LOCAL_I915_EXEC_BSD_MASK) + +static unsigned all_engines[16]; +static unsigned all_nengine; + +static unsigned ppgtt_engines[16]; +static unsigned ppgtt_nengine; + +static int __gem_context_create_local(int fd, struct drm_i915_gem_context_create *arg) +{ + int ret = 0; + if (drmIoctl(fd, DRM_IOCTL_I915_GEM_CONTEXT_CREATE, arg)) + ret = -errno; + return ret; +} + +static double elapsed(const struct timespec *start, + const struct timespec *end) +{ + return (end->tv_sec - start->tv_sec) + 1e-9*(end->tv_nsec - start->tv_nsec); +} + +static void files(int core, int timeout, const int ncpus) +{ + const uint32_t bbe = MI_BATCH_BUFFER_END; + struct drm_i915_gem_execbuffer2 execbuf; + struct drm_i915_gem_exec_object2 obj; + uint32_t batch, name; + + batch = gem_create(core, 4096); + gem_write(core, batch, 0, &bbe, sizeof(bbe)); + name = gem_flink(core, batch); + + memset(&obj, 0, sizeof(obj)); + memset(&execbuf, 0, sizeof(execbuf)); + execbuf.buffers_ptr = to_user_pointer(&obj); + execbuf.buffer_count = 1; + + igt_fork(child, ncpus) { + struct timespec start, end; + unsigned count = 0; + + clock_gettime(CLOCK_MONOTONIC, &start); + do { + do { + int fd = drm_open_driver(DRIVER_INTEL); + obj.handle = gem_open(fd, name); + execbuf.flags &= ~ENGINE_FLAGS; + execbuf.flags |= ppgtt_engines[count % ppgtt_nengine]; + gem_execbuf(fd, &execbuf); + close(fd); + } while (++count & 1023); + clock_gettime(CLOCK_MONOTONIC, &end); + } while (elapsed(&start, &end) < timeout); + + gem_sync(core, batch); + clock_gettime(CLOCK_MONOTONIC, &end); + igt_info("[%d] File creation + execution: %.3f us\n", + child, elapsed(&start, &end) / count *1e6); + } + igt_waitchildren(); + + gem_close(core, batch); +} + +static void active(int fd, unsigned engine, int timeout, int ncpus) +{ + const uint32_t bbe = MI_BATCH_BUFFER_END; + struct drm_i915_gem_execbuffer2 execbuf; + struct drm_i915_gem_exec_object2 obj; + unsigned int nengine, engines[16]; + unsigned *shared; + + if (engine == ALL_ENGINES) { + igt_require(all_nengine); + nengine = all_nengine; + memcpy(engines, all_engines, sizeof(engines[0])*nengine); + } else { + gem_require_ring(fd, engine); + nengine = 1; + engines[0] = engine; + } + + shared = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0); + igt_assert(shared != MAP_FAILED); + + memset(&obj, 0, sizeof(obj)); + obj.handle = gem_create(fd, 4096); + gem_write(fd, obj.handle, 0, &bbe, sizeof(bbe)); + + memset(&execbuf, 0, sizeof(execbuf)); + execbuf.buffers_ptr = to_user_pointer(&obj); + execbuf.buffer_count = 1; + + if (ncpus < 0) { + igt_fork(child, ppgtt_nengine) { + unsigned long count = 0; + + if (ppgtt_engines[child] == engine) + continue; + + execbuf.flags = ppgtt_engines[child]; + + while (!*(volatile unsigned *)shared) { + obj.handle = gem_create(fd, 4096 << 10); + gem_write(fd, obj.handle, 0, &bbe, sizeof(bbe)); + + gem_execbuf(fd, &execbuf); + gem_close(fd, obj.handle); + count++; + } + + igt_debug("hog[%d]: cycles=%lu\n", child, count); + } + ncpus = -ncpus; + } + + igt_fork(child, ncpus) { + struct timespec start, end; + unsigned count = 0; + + clock_gettime(CLOCK_MONOTONIC, &start); + do { + do { + execbuf.rsvd1 = gem_context_create(fd); + for (unsigned n = 0; n < nengine; n++) { + execbuf.flags = engines[n]; + gem_execbuf(fd, &execbuf); + } + gem_context_destroy(fd, execbuf.rsvd1); + } while (++count & 1023); + clock_gettime(CLOCK_MONOTONIC, &end); + } while (elapsed(&start, &end) < timeout); + + gem_sync(fd, obj.handle); + clock_gettime(CLOCK_MONOTONIC, &end); + igt_info("[%d] Context creation + execution: %.3f us\n", + child, elapsed(&start, &end) / count *1e6); + + shared[0] = 1; + } + igt_waitchildren(); + + gem_close(fd, obj.handle); + munmap(shared, 4096); +} + +static void xchg_u32(void *array, unsigned i, unsigned j) +{ + uint32_t *a = array, tmp; + + tmp = a[i]; + a[i] = a[j]; + a[j] = tmp; +} + +static unsigned __context_size(int fd) +{ + switch (intel_gen(intel_get_drm_devid(fd))) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: return 17 << 12; + case 8: return 20 << 12; + case 9: return 22 << 12; + default: return 32 << 12; + } +} + +static unsigned context_size(int fd) +{ + uint64_t size; + + size = __context_size(fd); + if (ppgtt_nengine > 1) { + size += 4 << 12; /* ringbuffer as well */ + size *= ppgtt_nengine; + } + + return size; +} + +static uint64_t total_avail_mem(unsigned mode) +{ + uint64_t total = intel_get_avail_ram_mb(); + if (mode & CHECK_SWAP) + total += intel_get_total_swap_mb(); + return total << 20; +} + +static void maximum(int fd, int ncpus, unsigned mode) +{ + const uint32_t bbe = MI_BATCH_BUFFER_END; + struct drm_i915_gem_execbuffer2 execbuf; + struct drm_i915_gem_exec_object2 obj[2]; + uint64_t avail_mem = total_avail_mem(mode); + unsigned ctx_size = context_size(fd); + uint32_t *contexts = NULL; + unsigned long count = 0; + uint32_t ctx_id; + + do { + int err; + + if ((count & -count) == count) { + int sz = count ? 2*count : 1; + contexts = realloc(contexts, + sz*sizeof(*contexts)); + igt_assert(contexts); + } + + err = -ENOMEM; + if (avail_mem > (count + 1) * ctx_size) + err = __gem_context_create(fd, &ctx_id); + if (err) { + igt_info("Created %lu contexts, before failing with '%s' [%d]\n", + count, strerror(-err), -err); + break; + } + + contexts[count++] = ctx_id; + } while (1); + igt_require(count); + + memset(obj, 0, sizeof(obj)); + obj[1].handle = gem_create(fd, 4096); + gem_write(fd, obj[1].handle, 0, &bbe, sizeof(bbe)); + + memset(&execbuf, 0, sizeof(execbuf)); + execbuf.buffers_ptr = to_user_pointer(obj); + execbuf.buffer_count = 2; + + igt_fork(child, ncpus) { + struct timespec start, end; + + hars_petruska_f54_1_random_perturb(child); + obj[0].handle = gem_create(fd, 4096); + + clock_gettime(CLOCK_MONOTONIC, &start); + for (int repeat = 0; repeat < 3; repeat++) { + igt_permute_array(contexts, count, xchg_u32); + igt_permute_array(all_engines, all_nengine, xchg_u32); + + for (unsigned long i = 0; i < count; i++) { + execbuf.rsvd1 = contexts[i]; + for (unsigned long j = 0; j < all_nengine; j++) { + execbuf.flags = all_engines[j]; + gem_execbuf(fd, &execbuf); + } + } + } + gem_sync(fd, obj[0].handle); + clock_gettime(CLOCK_MONOTONIC, &end); + gem_close(fd, obj[0].handle); + + igt_info("[%d] Context execution: %.3f us\n", child, + elapsed(&start, &end) / (3 * count * all_nengine) * 1e6); + } + igt_waitchildren(); + + gem_close(fd, obj[1].handle); + + for (unsigned long i = 0; i < count; i++) + gem_context_destroy(fd, contexts[i]); + free(contexts); +} + +igt_main +{ + const int ncpus = sysconf(_SC_NPROCESSORS_ONLN); + struct drm_i915_gem_context_create create; + int fd = -1; + + igt_fixture { + unsigned engine; + + fd = drm_open_driver(DRIVER_INTEL); + igt_require_gem(fd); + gem_require_contexts(fd); + + for_each_physical_engine(fd, engine) + all_engines[all_nengine++] = engine; + igt_require(all_nengine); + + if (gem_uses_full_ppgtt(fd)) { + ppgtt_nengine = all_nengine; + memcpy(ppgtt_engines, + all_engines, + all_nengine * sizeof(all_engines[0])); + } else + ppgtt_engines[ppgtt_nengine++] = 0; + + igt_fork_hang_detector(fd); + } + + igt_subtest("basic") { + memset(&create, 0, sizeof(create)); + create.ctx_id = rand(); + create.pad = 0; + igt_assert_eq(__gem_context_create_local(fd, &create), 0); + igt_assert(create.ctx_id != 0); + gem_context_destroy(fd, create.ctx_id); + } + + igt_subtest("invalid-pad") { + memset(&create, 0, sizeof(create)); + create.ctx_id = rand(); + create.pad = 1; + igt_assert_eq(__gem_context_create_local(fd, &create), -EINVAL); + } + + igt_subtest("maximum-mem") + maximum(fd, ncpus, CHECK_RAM); + igt_subtest("maximum-swap") + maximum(fd, ncpus, CHECK_RAM | CHECK_SWAP); + + igt_subtest("basic-files") + files(fd, 5, 1); + igt_subtest("files") + files(fd, 150, 1); + igt_subtest("forked-files") + files(fd, 150, ncpus); + + igt_subtest("active-all") + active(fd, ALL_ENGINES, 120, 1); + igt_subtest("forked-active-all") + active(fd, ALL_ENGINES, 120, ncpus); + + for (const struct intel_execution_engine *e = intel_execution_engines; + e->name; e++) { + igt_subtest_f("active-%s", e->name) + active(fd, e->exec_id | e->flags, 20, 1); + igt_subtest_f("forked-active-%s", e->name) + active(fd, e->exec_id | e->flags, 20, ncpus); + if (e->exec_id) { + igt_subtest_f("hog-%s", e->name) + active(fd, e->exec_id | e->flags, 20, -1); + } + } + + igt_fixture { + igt_stop_hang_detector(); + close(fd); + } +} |