[PATCH] benchmark: Measure allocation time for objects

[Dandamudi, Priyanka]

LGTM,
Reviewed-by: Priyanka Dandamudi <priyanka.dandamudi at intel.com>

> -----Original Message-----
> From: Gurram, Pravalika <pravalika.gurram at intel.com>
> Sent: 24 April 2025 02:47 PM
> To: igt-dev at lists.freedesktop.org
> Cc: Dandamudi, Priyanka <priyanka.dandamudi at intel.com>; Gurram,
> Pravalika <pravalika.gurram at intel.com>
> Subject: [PATCH] benchmark: Measure allocation time for objects
> 
> A basic measurement, how fast can we create and populate an object with
> backing storage
> 
> v2: remove the headers and unused variable which are not required
> [Priyanka]
>     use SPDX [kamil]
> v3: Move sync and exec functions inside busy condition. [Priyanka]
> v4: Move other variables inside busy condition. [Priyanka]
> 
> Signed-off-by: Pravalika Gurram <pravalika.gurram at intel.com>
> ---
>  benchmarks/meson.build |   1 +
>  benchmarks/xe_create.c | 157
> +++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 158 insertions(+)
>  create mode 100644 benchmarks/xe_create.c
> 
> diff --git a/benchmarks/meson.build b/benchmarks/meson.build index
> 2c9a88fd3..0e41eed06 100644
> --- a/benchmarks/meson.build
> +++ b/benchmarks/meson.build
> @@ -21,6 +21,7 @@ benchmark_progs = [
>  	'kms_vblank',
>  	'prime_lookup',
>  	'vgem_mmap',
> +        'xe_create',
>  ]
> 
>  benchmarksdir = join_paths(libexecdir, 'benchmarks') diff --git
> a/benchmarks/xe_create.c b/benchmarks/xe_create.c new file mode 100644
> index 000000000..9a739b19b
> --- /dev/null
> +++ b/benchmarks/xe_create.c
> @@ -0,0 +1,157 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2025 Intel Corporation
> + */
> +
> +#include "igt.h"
> +#include "igt_syncobj.h"
> +#include "xe/xe_ioctl.h"
> +#include "xe/xe_query.h"
> +
> +
> +#define OBJECT_SIZE (1<<23)
> +
> +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 test_exec(int fd, int busy) {
> +	uint32_t vm, bo;
> +	uint64_t bo_size = xe_bb_size(fd, SZ_4K);
> +	int err;
> +
> +	vm = xe_vm_create(fd, 0, 0);
> +	bo = xe_bo_create(fd, vm, bo_size, system_memory(fd), 0);
> +
> +	if (busy) {
> +		uint32_t *batch, exec_queue_id;
> +		uint64_t addr = 0x1a0000;
> +		struct drm_xe_sync sync = {
> +			.type = DRM_XE_SYNC_TYPE_SYNCOBJ,
> +			.flags = DRM_XE_SYNC_FLAG_SIGNAL,
> +			.handle = syncobj_create(fd, 0),
> +		};
> +		struct drm_xe_exec exec = {
> +			.num_syncs = 1,
> +			.syncs = to_user_pointer(&sync),
> +			.address = addr,
> +			.num_batch_buffer = 1,
> +		};
> +
> +		batch = xe_bo_map(fd, bo, bo_size);
> +		*batch = MI_BATCH_BUFFER_END;
> +		munmap(batch, bo_size);
> +		xe_vm_bind_sync(fd, vm, bo, 0, addr, bo_size);
> +
> +		err = __xe_exec_queue_create(fd, vm, 1, 1, &xe_engine(fd, 0)-
> >instance, 0,
> +					    &exec_queue_id);
> +		igt_assert_f(!err, "Failed to create exec queue (%d)\n", err);
> +
> +		exec.exec_queue_id = exec_queue_id;
> +		err = __xe_exec(fd, &exec);
> +		igt_assert_f(!err, "Failed to execute batch (%d)\n", err);
> +
> +		err = syncobj_wait(fd, &sync.handle, 1, INT64_MAX, 0, NULL);
> +		igt_assert_f(err, "Timeout while waiting for syncobj signal
> (%d)\n",
> +err);
> +
> +		xe_exec_queue_destroy(fd, exec_queue_id);
> +		syncobj_destroy(fd, sync.handle);
> +	}
> +
> +	gem_close(fd, bo);
> +	xe_vm_destroy(fd, vm);
> +}
> +
> +int main(int argc, char **argv)
> +{
> +	int fd = drm_open_driver(DRIVER_XE);
> +	int size = 0;
> +	int busy = 0;
> +	int reps = 13;
> +	int ncpus = 1;
> +	int c, n, s;
> +
> +	while ((c = getopt(argc, argv, "s:b:r:f")) != -1) {
> +		switch (c) {
> +		case 's':
> +			size = atoi(optarg);
> +			break;
> +
> +		case 'r':
> +			reps = atoi(optarg);
> +			if (reps < 1)
> +				reps = 1;
> +			break;
> +
> +		case 'f':
> +			ncpus = sysconf(_SC_NPROCESSORS_ONLN);
> +			break;
> +
> +		case 'b':
> +			busy = true;
> +			break;
> +
> +		default:
> +			break;
> +		}
> +	}
> +
> +	if (size == 0) {
> +		for (s = 4096; s <=  OBJECT_SIZE; s <<= 1) {
> +			igt_stats_t stats;
> +
> +			igt_stats_init_with_size(&stats, reps);
> +			for (n = 0; n < reps; n++) {
> +				struct timespec start, end;
> +				uint64_t count = 0;
> +
> +				clock_gettime(CLOCK_MONOTONIC, &start);
> +				do {
> +					for (c = 0; c < 1000; c++)
> +						test_exec(fd, busy);
> +
> +					count += c;
> +					clock_gettime(CLOCK_MONOTONIC,
> &end);
> +				} while (end.tv_sec - start.tv_sec < 2);
> +
> +				igt_stats_push_float(&stats, count /
> elapsed(&start, &end));
> +			}
> +			printf("%f\n", igt_stats_get_trimean(&stats));
> +			igt_stats_fini(&stats);
> +		}
> +	} else {
> +		double *shared;
> +
> +		shared = mmap(0, 4096, PROT_WRITE, MAP_SHARED |
> MAP_ANON, -1, 0);
> +		for (n = 0; n < reps; n++) {
> +			memset(shared, 0, 4096);
> +
> +			igt_fork(child, ncpus) {
> +				struct timespec start, end;
> +				uint64_t count = 0;
> +
> +				clock_gettime(CLOCK_MONOTONIC, &start);
> +				do {
> +					for (c = 0; c < 1000; c++)
> +						test_exec(fd, busy);
> +
> +					count += c;
> +					clock_gettime(CLOCK_MONOTONIC,
> &end);
> +				} while (end.tv_sec - start.tv_sec < 2);
> +
> +				shared[child] = count / elapsed(&start, &end);
> +			}
> +			igt_waitchildren();
> +
> +			for (int child = 0; child < ncpus; child++)
> +				shared[ncpus] += shared[child];
> +
> +			printf("%7.3f\n", shared[ncpus]);
> +		}
> +	}
> +
> +	return 0;
> +}
> --
> 2.34.1