Re: [PATCH i-g-t v3 2/3] tests/intel/xe_pmu: Add engine activity test for all functions

["Bernatowicz, Marcin" <marcin.bernatowicz@linux.intel.com>]

On 3/21/2025 12:09 PM, Riana Tauro wrote:
> Provision and enable 2 VFs with execution quantum and scheduling policy
> set. Add a test that runs workload on all functions simultaneously and
> validates that all engines are equally and fully loaded for the
> entire execution quantum of the function
> 
> v2: add a different function for function config
>      add function details to log
>      move pmu_fd to struct
>      enable and provision VF's (Umesh)
> 
> v3: split patches
>      move exec_quantum to variables
>      skip test if vfs are already provisioned
>      fix assert (Umesh)
> 
> Signed-off-by: Riana Tauro <riana.tauro@intel.com>
> ---
>   tests/intel/xe_pmu.c | 129 +++++++++++++++++++++++++++++++++++++++++++
>   1 file changed, 129 insertions(+)
> 
> diff --git a/tests/intel/xe_pmu.c b/tests/intel/xe_pmu.c
> index f0959abe2..9a1f9b39e 100644
> --- a/tests/intel/xe_pmu.c
> +++ b/tests/intel/xe_pmu.c
> @@ -14,11 +14,13 @@
>   
>   #include "igt.h"
>   #include "igt_perf.h"
> +#include "igt_sriov_device.h"
>   #include "igt_sysfs.h"
>   
>   #include "xe/xe_gt.h"
>   #include "xe/xe_ioctl.h"
>   #include "xe/xe_spin.h"
> +#include "xe/xe_sriov_provisioning.h"
>   
>   #define SLEEP_DURATION 2 /* in seconds */
>   /* flag masks */
> @@ -124,6 +126,12 @@ static uint64_t get_event_config(unsigned int gt, struct drm_xe_engine_class_ins
>   	return pmu_config;
>   }
>   
> +static uint64_t get_event_config_fn(unsigned int gt, int function,
> +				    struct drm_xe_engine_class_instance *eci, const char *event)
> +{
> +	return get_event_config(gt, eci, event) | add_format_config("function", function);
> +}
> +
>   /**
>    * SUBTEST: engine-activity-idle
>    * Description: Test to validate engine activity shows no load when idle
> @@ -187,6 +195,73 @@ static void engine_activity(int fd, struct drm_xe_engine_class_instance *eci, un
>   		igt_assert(!engine_active_ticks);
>   }
>   
> +/**
> + * SUBTEST: all-fn-engine-activity-load
> + * Description: Test to validate engine activity by running load on all functions simultaneously
> + */
> +static void engine_activity_all_fn(int fd, struct drm_xe_engine_class_instance *eci, int num_fns)
> +{
> +	uint64_t config, engine_active_ticks, engine_total_ticks;
> +	uint64_t after[2 * num_fns], before[2 * num_fns];
> +	struct pmu_function {
> +		struct xe_cork *cork;
> +		uint32_t vm;
> +		uint64_t pmu_fd[2];
> +		int fd;
> +	} fn[num_fns];
> +	int i;
> +
> +	fn[0].pmu_fd[0] = -1;
> +	for (i = 0; i < num_fns; i++) {
> +		config = get_event_config_fn(eci->gt_id, i, eci, "engine-active-ticks");
> +		fn[i].pmu_fd[0] = open_group(fd, config, fn[0].pmu_fd[0]);
> +
> +		config = get_event_config_fn(eci->gt_id, i, eci, "engine-total-ticks");
> +		fn[i].pmu_fd[1] = open_group(fd, config, fn[0].pmu_fd[0]);
> +
> +		if (i > 0)
> +			fn[i].fd = igt_sriov_open_vf_drm_device(fd, i);
> +		else
> +			fn[i].fd = fd;
> +
> +		igt_assert_fd(fn[i].fd);
> +
> +		fn[i].vm = xe_vm_create(fn[i].fd, 0, 0);
> +		fn[i].cork = xe_cork_create_opts(fn[i].fd, eci, fn[i].vm, 1, 1);
> +		xe_cork_sync_start(fn[i].fd, fn[i].cork);
> +	}
> +
> +	pmu_read_multi(fn[0].pmu_fd[0], 2 * num_fns, before);
> +	usleep(SLEEP_DURATION * USEC_PER_SEC);
> +	pmu_read_multi(fn[0].pmu_fd[0], 2 * num_fns, after);
> +
> +	for (i = 0; i < num_fns; i++) {
> +		int idx = i * 2;
> +
> +		xe_cork_sync_end(fn[i].fd, fn[i].cork);
> +		engine_active_ticks = after[idx] - before[idx];
> +		engine_total_ticks = after[idx + 1] - before[idx + 1];
> +
> +		igt_debug("[%d] Engine active ticks: after %ld, before %ld delta %ld\n", i,
> +			  after[idx], before[idx], engine_active_ticks);
> +		igt_debug("[%d] Engine total ticks: after %ld, before %ld delta %ld\n", i,
> +			  after[idx + 1], before[idx + 1], engine_total_ticks);
> +
> +		if (fn[i].cork)
> +			xe_cork_destroy(fn[i].fd, fn[i].cork);
> +
> +		xe_vm_destroy(fn[i].fd, fn[i].vm);
> +
> +		close(fn[i].pmu_fd[0]);
> +		close(fn[i].pmu_fd[1]);
> +
> +		if (i > 0)
> +			close(fn[i].fd);
> +
> +		assert_within_epsilon(engine_active_ticks, engine_total_ticks, tolerance);
> +	}
> +}
> +
>   /**
>    * SUBTEST: gt-c6-idle
>    * Description: Basic residency test to validate idle residency
> @@ -225,6 +300,33 @@ static void test_gt_c6_idle(int xe, unsigned int gt)
>   	close(pmu_fd);
>   }
>   
> +static unsigned int enable_and_provision_vfs(int fd)
> +{
> +	unsigned int gt, num_vfs;
> +	int pf_exec_quantum = 64, vf_exec_quantum = 32, vf;

Are those arbirtrary exec_quantum values ?

> +
> +	/* Enable VF's */
> +	igt_sriov_disable_driver_autoprobe(fd);
> +	igt_sriov_enable_vfs(fd, 2);

Perhaps we want to skip if sriov_totalvfs < 2 ?

> +	num_vfs = igt_sriov_get_enabled_vfs(fd);
> +	igt_require(num_vfs == 2);
> +
> +	/* Set 32ms for VF execution quantum and 64ms for PF execution quantum */
> +	xe_for_each_gt(fd, gt) {
> +		xe_sriov_set_sched_if_idle(fd, gt, 0);
> +		for (int fn = 0; fn <= num_vfs; fn++)
> +			xe_sriov_set_exec_quantum_ms(fd, fn, gt, fn ? vf_exec_quantum :
> +						     pf_exec_quantum);
> +	}
> +
> +	/* probe VFs */
> +	igt_sriov_enable_driver_autoprobe(fd);
> +	for (vf = 1; vf <= num_vfs; vf++)
> +		igt_sriov_bind_vf_drm_driver(fd, vf);
> +
> +	return num_vfs;
> +}
> +
>   igt_main
>   {
>   	int fd, gt;
> @@ -254,6 +356,33 @@ igt_main
>   	test_each_engine("engine-activity-load", fd, eci)
>   		engine_activity(fd, eci, TEST_LOAD);
>   
> +	igt_subtest_group {
> +		bool autoprobe;
> +		unsigned int num_fns;
> +
> +		igt_fixture {
> +			igt_require(igt_sriov_is_pf(fd));
> +			igt_require(igt_sriov_get_enabled_vfs(fd) == 0);
> +			autoprobe = igt_sriov_is_driver_autoprobe_enabled(fd);
> +			num_fns = enable_and_provision_vfs(fd) + 1;

The drawback of enabling VFs inside this fixture is that it executes for 
each subtest outside the subtest group (e.g., engine-activity-load 
above). It might be worth creating a dedicated test with sriov in its 
name and considering not limiting it to just two VFs.

> +		}
> +
> +		igt_describe("Validate engine activity on all functions");
> +		test_each_engine("all-fn-engine-activity-load", fd, eci)
> +			engine_activity_all_fn(fd, eci, num_fns);
> +
> +		igt_fixture {
> +			igt_sriov_disable_vfs(fd);
> +			/* abort to avoid execution of next tests with enabled VFs */
> +			igt_abort_on_f(igt_sriov_get_enabled_vfs(fd) > 0,
> +				       "Failed to disable VF(s)");
> +			autoprobe ? igt_sriov_enable_driver_autoprobe(fd) :
> +				    igt_sriov_disable_driver_autoprobe(fd);
> +			igt_abort_on_f(autoprobe != igt_sriov_is_driver_autoprobe_enabled(fd),
> +				       "Failed to restore sriov_drivers_autoprobe value\n");
> +		}
> +	}
> +
>   	igt_fixture {
>   		close(fd);
>   	}