ntel-gpu-tools/tests/gem_ctx_thrash.c

/*
 * 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.
 *
 */

#include "igt.h"
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/resource.h>


IGT_TEST_DESCRIPTION("Fill the Gobal GTT with context objects and VMs\n");

#define OBJECT_SIZE (1024 * 1024)
#define NUM_THREADS 8

static int fd;
static unsigned devid;
static igt_render_copyfunc_t render_copy;

static dri_bo **all_bo;
static int num_bo;
static int bo_per_ctx;

static drm_intel_context **all_ctx;
static int num_ctx;
static int ctx_per_thread;

static void xchg_ptr(void *array, unsigned i, unsigned j)
{
	void **A = array;
	igt_swap(A[i], A[j]);
}

static void xchg_int(void *array, unsigned i, unsigned j)
{
	int *A = array;
	igt_swap(A[i], A[j]);
}

static int reopen(int _fd)
{
	struct stat st;
	char name[128];

	igt_assert(fstat(_fd, &st) == 0);

	sprintf(name, "/dev/dri/card%u", (unsigned)(st.st_rdev & 0x7f));
	return open(name, O_RDWR);
}

static void *thread(void *bufmgr)
{
	struct intel_batchbuffer *batch;
	dri_bo **bo;
	drm_intel_context **ctx;
	int c, b;

	batch = intel_batchbuffer_alloc(bufmgr, devid);

	bo = malloc(num_bo * sizeof(dri_bo *));
	igt_assert(bo);
	memcpy(bo, all_bo, num_bo * sizeof(dri_bo *));

	ctx = malloc(num_ctx * sizeof(drm_intel_context *));
	igt_assert(ctx);
	memcpy(ctx, all_ctx, num_ctx * sizeof(drm_intel_context *));
	igt_permute_array(ctx, num_ctx, xchg_ptr);

	for (c = 0; c < ctx_per_thread; c++) {
		igt_permute_array(bo, num_bo, xchg_ptr);
		for (b = 0; b < bo_per_ctx; b++) {
			struct igt_buf src, dst;

			src.bo = bo[b % num_bo];
			src.stride = 64;
			src.size = OBJECT_SIZE;
			src.tiling = I915_TILING_NONE;

			dst.bo = bo[(b+1) % num_bo];
			dst.stride = 64;
			dst.size = OBJECT_SIZE;
			dst.tiling = I915_TILING_NONE;

			render_copy(batch, ctx[c % num_ctx],
				    &src, 0, 0, 16, 16, &dst, 0, 0);
		}
	}

	free(ctx);
	free(bo);
	intel_batchbuffer_free(batch);

	return NULL;
}

static int uses_ppgtt(int _fd)
{
	struct drm_i915_getparam gp;
	int val = 0;

	memset(&gp, 0, sizeof(gp));
	gp.param = 18; /* HAS_ALIASING_PPGTT */
	gp.value = &val;

	if (drmIoctl(_fd, DRM_IOCTL_I915_GETPARAM, &gp))
		return 0;

	errno = 0;
	return val;
}

static void
processes(void)
{
	int *all_fds;
	uint64_t aperture;
	struct rlimit rlim;
	int ppgtt_mode;
	int ctx_size;
	int obj_size;
	int n;

	igt_skip_on_simulation();

	fd = drm_open_driver_render(DRIVER_INTEL);
	devid = intel_get_drm_devid(fd);
	aperture = gem_aperture_size(fd);

	ppgtt_mode = uses_ppgtt(fd);
	igt_require(ppgtt_mode);

	render_copy = igt_get_render_copyfunc(devid);
	igt_require_f(render_copy, "no render-copy function\n");

	if (ppgtt_mode > 1)
		ctx_size = aperture >> 10; /* Assume full-ppgtt of maximum size */
	else
		ctx_size = 64 << 10; /* Most gen require at least 64k for ctx */
	num_ctx = 3 * (aperture / ctx_size) / 2;
	igt_info("Creating %d contexts (assuming of size %d)\n",
		 num_ctx, ctx_size);
	intel_require_memory(num_ctx, ctx_size, CHECK_RAM | CHECK_SWAP);

	/* tweak rlimits to allow us to create this many files */
	igt_assert(getrlimit(RLIMIT_NOFILE, &rlim) == 0);
	if (rlim.rlim_cur < ALIGN(num_ctx + 1024, 1024)) {
		rlim.rlim_cur = ALIGN(num_ctx + 1024, 1024);
		if (rlim.rlim_cur > rlim.rlim_max)
			rlim.rlim_max = rlim.rlim_cur;
		igt_assert(setrlimit(RLIMIT_NOFILE, &rlim) == 0);
	}

	all_fds = malloc(num_ctx * sizeof(int));
	igt_assert(all_fds);
	for (n = 0; n < num_ctx; n++) {
		all_fds[n] = reopen(fd);
		if (all_fds[n] == -1) {
			int err = errno;
			for (int i = n; i--; )
				close(all_fds[i]);
			free(all_fds);
			errno = err;
			igt_assert_f(0, "failed to create context %d/%d\n", n, num_ctx);
		}
	}

	num_bo = 2 * num_ctx;
	obj_size = (2 * aperture / num_bo + 4095) & -4096;
	igt_info("Creating %d surfaces (of size %d)\n", num_bo, obj_size);
	intel_require_memory(num_bo, obj_size, CHECK_RAM);

	igt_fork(child, NUM_THREADS) {
		drm_intel_bufmgr *bufmgr;
		struct intel_batchbuffer *batch;
		int c;

		igt_permute_array(all_fds, num_ctx, xchg_int);

		for (c = 0; c < num_ctx; c++) {
			struct igt_buf src, dst;

			bufmgr = drm_intel_bufmgr_gem_init(all_fds[c], 4096);
			igt_assert(bufmgr);
			batch = intel_batchbuffer_alloc(bufmgr, devid);

			src.bo = drm_intel_bo_alloc(bufmgr, "", obj_size, 0);
			igt_assert(src.bo);
			src.stride = 64;
			src.size = obj_size;
			src.tiling = I915_TILING_NONE;

			dst.bo = drm_intel_bo_alloc(bufmgr, "", obj_size, 0);
			igt_assert(dst.bo);
			dst.stride = 64;
			dst.size = obj_size;
			dst.tiling = I915_TILING_NONE;

			render_copy(batch, NULL,
				    &src, 0, 0, 16, 16, &dst, 0, 0);

			intel_batchbuffer_free(batch);
			drm_intel_bo_unreference(src.bo);
			drm_intel_bo_unreference(dst.bo);
			drm_intel_bufmgr_destroy(bufmgr);
		}
	}
	igt_waitchildren();

	for (n = 0; n < num_ctx; n++)
		close(all_fds[n]);
	free(all_fds);
	close(fd);
}

static void
threads(void)
{
	pthread_t threads[NUM_THREADS];
	drm_intel_bufmgr *bufmgr;
	uint64_t aperture;
	int ppgtt_mode;
	int ctx_size;
	int n;

	igt_skip_on_simulation();

	fd = drm_open_driver_render(DRIVER_INTEL);
	devid = intel_get_drm_devid(fd);
	aperture = gem_aperture_size(fd);

	ppgtt_mode = uses_ppgtt(fd);
	igt_require(ppgtt_mode);

	render_copy = igt_get_render_copyfunc(devid);
	igt_require_f(render_copy, "no render-copy function\n");

	bufmgr = drm_intel_bufmgr_gem_init(fd, 4096);
	igt_assert(bufmgr);
	drm_intel_bufmgr_gem_enable_reuse(bufmgr);

	if (ppgtt_mode > 1)
		ctx_size = aperture >> 10; /* Assume full-ppgtt of maximum size */
	else
		ctx_size = 64 << 10; /* Most gen require at least 64k for ctx */
	num_ctx = 3 * (aperture / ctx_size) / 2;
	igt_info("Creating %d contexts (assuming of size %d)\n",
		 num_ctx, ctx_size);
	intel_require_memory(num_ctx, ctx_size, CHECK_RAM | CHECK_SWAP);
	all_ctx = malloc(num_ctx * sizeof(drm_intel_context *));
	igt_assert(all_ctx);
	for (n = 0; n < num_ctx; n++) {
		all_ctx[n] = drm_intel_gem_context_create(bufmgr);
		igt_assert(all_ctx[n]);
	}

	num_bo = 3 * (aperture / OBJECT_SIZE) / 2;
	igt_info("Creating %d surfaces (of size %d)\n", num_bo, OBJECT_SIZE);
	intel_require_memory(num_bo, OBJECT_SIZE, CHECK_RAM);
	all_bo = malloc(num_bo * sizeof(dri_bo *));
	igt_assert(all_bo);
	for (n = 0; n < num_bo; n++) {
		all_bo[n] = drm_intel_bo_alloc(bufmgr, "", OBJECT_SIZE, 0);
		igt_assert(all_bo[n]);
	}

	ctx_per_thread = 3 * num_ctx / NUM_THREADS / 2;
	bo_per_ctx = 3 * num_bo / NUM_THREADS / 2;

	for (n = 0; n < NUM_THREADS; n++)
		pthread_create(&threads[n], NULL, thread, bufmgr);

	for (n = 0; n < NUM_THREADS; n++)
		pthread_join(threads[n], NULL);

	drm_intel_bufmgr_destroy(bufmgr);
	close(fd);
}

igt_main
{
	igt_subtest("processes")
		processes();

	igt_subtest("threads")
		threads();
}