[PATCH i-g-t v3 2/3] tests/intel/xe_pmu: Add engine activity test for all functions
K V P, Satyanarayana
satyanarayana.k.v.p at intel.com
Mon Mar 24 05:43:24 UTC 2025
> -----Original Message-----
> From: Tauro, Riana <riana.tauro at intel.com>
> Sent: Friday, March 21, 2025 4:40 PM
> To: igt-dev at lists.freedesktop.org
> Cc: Tauro, Riana <riana.tauro at intel.com>; Gupta, Anshuman
> <anshuman.gupta at intel.com>; Nerlige Ramappa, Umesh
> <umesh.nerlige.ramappa at intel.com>; De Marchi, Lucas
> <lucas.demarchi at intel.com>; Wajdeczko, Michal
> <Michal.Wajdeczko at intel.com>; K V P, Satyanarayana
> <satyanarayana.k.v.p at intel.com>
> Subject: [PATCH i-g-t v3 2/3] tests/intel/xe_pmu: Add engine activity test for
> all functions
>
> 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 at 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;
> +
> + /* Enable VF's */
> + igt_sriov_disable_driver_autoprobe(fd);
> + igt_sriov_enable_vfs(fd, 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;
> + }
> +
> + 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);
> }
> --
LGTM.
Reviewed-by: Satyanarayana K V P <satyanarayana.k.v.p at intel.com>
> 2.47.1
More information about the igt-dev
mailing list