[PATCH i-g-t v2 1/2] tests/intel/xe_pmu: Add engine activity test for all functions
Umesh Nerlige Ramappa
umesh.nerlige.ramappa at intel.com
Wed Mar 19 22:22:00 UTC 2025
On Wed, Mar 12, 2025 at 11:54:30AM +0530, Riana Tauro wrote:
>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)
>
>Signed-off-by: Riana Tauro <riana.tauro at intel.com>
>---
> tests/intel/xe_pmu.c | 130 +++++++++++++++++++++++++++++++++++++++----
> 1 file changed, 120 insertions(+), 10 deletions(-)
>
>diff --git a/tests/intel/xe_pmu.c b/tests/intel/xe_pmu.c
>index 66edf24ad..a95ee1777 100644
>--- a/tests/intel/xe_pmu.c
>+++ b/tests/intel/xe_pmu.c
>@@ -14,18 +14,22 @@
>
> #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 */
>+#define TOTAL_EXEC_QUANTUM 128 /* in ms */
> /* flag masks */
> #define TEST_LOAD BIT(0)
> #define TEST_TRAILING_IDLE BIT(1)
>
> const double tolerance = 0.1;
>+char xe_device[NAME_MAX];
These globals should be static.
Optionally, for easier reviews, it's better to split the patch in two -
(1) make xe_device global (2) Add the engine activity test.
With just the static change, this is
Reviewed-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa at intel.com>
Thanks,
Umesh
>
> #define test_each_engine(test, fd, hwe) \
> igt_subtest_with_dynamic(test) \
>@@ -92,7 +96,7 @@ static unsigned long read_idle_residency(int fd, int gt)
> return residency;
> }
>
>-static uint64_t add_format_config(const char *xe_device, const char *format, uint64_t val)
>+static uint64_t add_format_config(const char *format, uint64_t val)
> {
> int ret;
> uint32_t shift;
>@@ -105,26 +109,30 @@ static uint64_t add_format_config(const char *xe_device, const char *format, uin
> return config;
> }
>
>-static uint64_t get_event_config(int xe, unsigned int gt, struct drm_xe_engine_class_instance *eci,
>+static uint64_t get_event_config(unsigned int gt, struct drm_xe_engine_class_instance *eci,
> const char *event)
> {
>- char xe_device[100];
> uint64_t pmu_config = 0;
> int ret;
>
>- xe_perf_device(xe, xe_device, sizeof(xe_device));
> ret = perf_event_config(xe_device, event, &pmu_config);
> igt_assert(ret >= 0);
>- pmu_config |= add_format_config(xe_device, "gt", gt);
>+ pmu_config |= add_format_config("gt", gt);
>
> if (eci) {
>- pmu_config |= add_format_config(xe_device, "engine_class", eci->engine_class);
>- pmu_config |= add_format_config(xe_device, "engine_instance", eci->engine_instance);
>+ pmu_config |= add_format_config("engine_class", eci->engine_class);
>+ pmu_config |= add_format_config("engine_instance", eci->engine_instance);
> }
>
> 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
>@@ -144,10 +152,10 @@ static void engine_activity(int fd, struct drm_xe_engine_class_instance *eci, un
> uint32_t vm;
> int pmu_fd[2];
>
>- config = get_event_config(fd, eci->gt_id, eci, "engine-active-ticks");
>+ config = get_event_config(eci->gt_id, eci, "engine-active-ticks");
> pmu_fd[0] = open_group(fd, config, -1);
>
>- config = get_event_config(fd, eci->gt_id, eci, "engine-total-ticks");
>+ config = get_event_config(eci->gt_id, eci, "engine-total-ticks");
> pmu_fd[1] = open_group(fd, config, pmu_fd[0]);
>
> vm = xe_vm_create(fd, 0, 0);
>@@ -188,6 +196,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
>@@ -202,7 +277,7 @@ static void test_gt_c6_idle(int xe, unsigned int gt)
> uint64_t val;
>
> /* Get the PMU config for the gt-c6 event */
>- pmu_config = get_event_config(xe, gt, NULL, "gt-c6-residency");
>+ pmu_config = get_event_config(gt, NULL, "gt-c6-residency");
>
> pmu_fd = open_pmu(xe, pmu_config);
>
>@@ -226,13 +301,34 @@ 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;
>+
>+ igt_sriov_enable_vfs(fd, 2);
>+ num_vfs = igt_sriov_get_enabled_vfs(fd);
>+ igt_require(num_vfs);
>+
>+ /* 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 ? TOTAL_EXEC_QUANTUM / 4 :
>+ TOTAL_EXEC_QUANTUM / 2);
>+ }
>+
>+ return num_vfs;
>+}
>+
> igt_main
> {
> int fd, gt;
>+ unsigned int num_fns;
> struct drm_xe_engine_class_instance *eci;
>
> igt_fixture {
> fd = drm_open_driver(DRIVER_XE);
>+ xe_perf_device(fd, xe_device, sizeof(xe_device));
> }
>
> igt_describe("Validate PMU gt-c6 residency counters when idle");
>@@ -254,6 +350,20 @@ igt_main
> test_each_engine("engine-activity-load", fd, eci)
> engine_activity(fd, eci, TEST_LOAD);
>
>+ igt_subtest_group {
>+ igt_fixture {
>+ igt_require(igt_sriov_is_pf(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);
>+ }
>+
> igt_fixture {
> close(fd);
> }
>--
>2.47.1
>
More information about the igt-dev
mailing list