[PATCH v2] drm/xe: GPU frequency tracing support
S Sebinraj
s.sebinraj at intel.com
Mon Aug 11 08:34:14 UTC 2025
A periodic GPU frequency monitoring and tracing program for the
Xe driver. The implementation provides periodic sampling of
GPU frequency through the Linux ftrace infrastructure.
Key features:
- Periodic GPU frequency sampling with configurable intervals
- Immediate frequency change reporting via tracepoints
- Integration with Linux ftrace subsystem under 'power' events
- Per-GT (Graphics Technology) monitoring support
- Dedicated workqueue for non-blocking frequency sampling
- Configurable via CONFIG_DRM_XE_GPUFREQTRACER kernel option
- The monitoring interval can be configured at runtime via the sysfs
(default 5sec).
The sysfs entry is at:
/sys/module/xe/parameters/gpufreq_monitoring_interval_ms
The tracepoint is exposed at:
/sys/kernel/debug/tracing/events/power/gpu_frequency
Format: {unsigned int state, unsigned int gpu_id}
- state: GPU frequency in KHz
- gpu_id: GPU clock domain identifier
This enables userspace tools and system monitoring applications to track
GPU frequency changes for power management analysis, performance tuning,
and debugging purposes.
Signed-off-by: S Sebinraj <s.sebinraj at intel.com>
---
drivers/gpu/drm/xe/Kconfig | 22 ++
drivers/gpu/drm/xe/Makefile | 3 +
drivers/gpu/drm/xe/xe_device.c | 7 +
drivers/gpu/drm/xe/xe_device_types.h | 4 +
drivers/gpu/drm/xe/xe_gpufreqtracer.c | 292 ++++++++++++++++++++
drivers/gpu/drm/xe/xe_gpufreqtracer.h | 30 ++
drivers/gpu/drm/xe/xe_gpufreqtracer_trace.h | 48 ++++
drivers/gpu/drm/xe/xe_module.c | 12 +
drivers/gpu/drm/xe/xe_module.h | 3 +
9 files changed, 421 insertions(+)
create mode 100644 drivers/gpu/drm/xe/xe_gpufreqtracer.c
create mode 100644 drivers/gpu/drm/xe/xe_gpufreqtracer.h
create mode 100644 drivers/gpu/drm/xe/xe_gpufreqtracer_trace.h
diff --git a/drivers/gpu/drm/xe/Kconfig b/drivers/gpu/drm/xe/Kconfig
index 714d5702dfd7..d9d07ec69875 100644
--- a/drivers/gpu/drm/xe/Kconfig
+++ b/drivers/gpu/drm/xe/Kconfig
@@ -129,6 +129,28 @@ config DRM_XE_FORCE_PROBE
Use "!*" to block the probe of the driver for all known devices.
+config DRM_XE_GPUFREQTRACER
+ bool "Enable XE GPU frequency tracing"
+ depends on DRM_XE && FTRACE
+ default n
+ help
+ Enable GPU frequency tracing support for Intel XE driver.
+ This adds an ftrace tracepoint that reports GPU frequency changes
+ at periodic boundaries (default 5 secs, configurable via the
+ gpufreq_monitoring_interval_ms module parameter) and
+ on direct frequency change events.
+
+ The monitoring interval can be configured at runtime via the sysfs module parameter:
+ /sys/module/xe/parameters/gpufreq_monitoring_interval_ms
+
+ The tracepoint will be available at:
+ /sys/kernel/debug/tracing/events/power/gpu_frequency
+
+ Format: {unsigned int state, unsigned int gpu_id}
+ Where state is the frequency in KHz and gpu_id is the GPU clock domain.
+
+ If unsure, say N.
+
menu "drm/Xe Debugging"
depends on DRM_XE
depends on EXPERT
diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile
index 8e0c3412a757..61d46cc4dc25 100644
--- a/drivers/gpu/drm/xe/Makefile
+++ b/drivers/gpu/drm/xe/Makefile
@@ -170,6 +170,9 @@ xe-$(CONFIG_PCI_IOV) += \
xe_sriov_pf.o \
xe_sriov_pf_service.o
+# GPU frequency tracer
+xe-$(CONFIG_DRM_XE_GPUFREQTRACER) += xe_gpufreqtracer.o
+
# include helpers for tests even when XE is built-in
ifdef CONFIG_DRM_XE_KUNIT_TEST
xe-y += tests/xe_kunit_helpers.o
diff --git a/drivers/gpu/drm/xe/xe_device.c b/drivers/gpu/drm/xe/xe_device.c
index 57edbc63da6f..88198ceb519b 100644
--- a/drivers/gpu/drm/xe/xe_device.c
+++ b/drivers/gpu/drm/xe/xe_device.c
@@ -34,6 +34,7 @@
#include "xe_exec_queue.h"
#include "xe_force_wake.h"
#include "xe_ggtt.h"
+#include "xe_gpufreqtracer.h"
#include "xe_gsc_proxy.h"
#include "xe_gt.h"
#include "xe_gt_mcr.h"
@@ -896,6 +897,12 @@ int xe_device_probe(struct xe_device *xe)
if (err)
return err;
+#if IS_ENABLED(CONFIG_DRM_XE_GPUFREQTRACER)
+ err = xe_gpufreqtracer_init(xe);
+ if (err)
+ return err;
+#endif
+
err = xe_oa_init(xe);
if (err)
return err;
diff --git a/drivers/gpu/drm/xe/xe_device_types.h b/drivers/gpu/drm/xe/xe_device_types.h
index 01e8fa0d2f9f..0634dbbbdc3f 100644
--- a/drivers/gpu/drm/xe/xe_device_types.h
+++ b/drivers/gpu/drm/xe/xe_device_types.h
@@ -35,6 +35,7 @@ struct dram_info;
struct intel_display;
struct intel_dg_nvm_dev;
struct xe_ggtt;
+struct xe_gpufreqtracer_data;
struct xe_i2c;
struct xe_pat_ops;
struct xe_pxp;
@@ -529,6 +530,9 @@ struct xe_device {
/** @oa: oa observation subsystem */
struct xe_oa oa;
+ /** @gpufreqtracer_data: GPU frequency tracer data */
+ struct xe_gpufreqtracer_data *gpufreqtracer_data;
+
/** @pxp: Encapsulate Protected Xe Path support */
struct xe_pxp *pxp;
diff --git a/drivers/gpu/drm/xe/xe_gpufreqtracer.c b/drivers/gpu/drm/xe/xe_gpufreqtracer.c
new file mode 100644
index 000000000000..07eedfb79e93
--- /dev/null
+++ b/drivers/gpu/drm/xe/xe_gpufreqtracer.c
@@ -0,0 +1,292 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright © 2025 Intel Corporation
+ */
+
+#include "xe_gpufreqtracer.h"
+
+#include <linux/workqueue.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/container_of.h>
+#include <linux/gfp.h>
+#include <linux/atomic.h>
+#include <drm/drm_managed.h>
+
+#include "xe_device.h"
+#include "xe_gt.h"
+#include "xe_gt_types.h"
+#include "xe_guc_pc.h"
+#include "xe_module.h"
+
+/* GPU frequency monitoring interval constants (in milliseconds) */
+#define XE_GPUFREQ_MONITORING_MIN_INTERVAL_MS 100
+#define XE_GPUFREQ_MONITORING_MAX_INTERVAL_MS 10000
+#define XE_GPUFREQ_MONITORING_DEFAULT_INTERVAL_MS 5000
+
+#define CREATE_TRACE_POINTS
+#include "xe_gpufreqtracer_trace.h"
+
+/**
+ * struct xe_gpufreqtracer_gt_data - Per-GT frequency monitoring data
+ * @gt: Reference to the GT
+ * @delayed_work: Delayed work for periodic monitoring
+ * @last_frequency: Last reported frequency to avoid duplicate reports
+ * @monitoring_active: Whether monitoring is currently active
+ */
+struct xe_gpufreqtracer_gt_data {
+ struct xe_gt *gt;
+ struct delayed_work delayed_work;
+ atomic_t last_frequency;
+ atomic_t monitoring_active;
+};
+
+/**
+ * struct xe_gpufreqtracer_data - Per-device frequency tracer data
+ * @xe: Reference to the XE device
+ * @gt_data: Array of per-GT monitoring data
+ */
+struct xe_gpufreqtracer_data {
+ struct xe_device *xe;
+ struct xe_gpufreqtracer_gt_data *gt_data;
+};
+
+
+/**
+ * xe_gpufreqtracer_sample_work - Worker function to sample GPU frequency.
+ * @work: Pointer to the delayed_work_struct representing the scheduled work.
+ *
+ * This function is executed in a workqueue context to periodically sample
+ * the GPU frequency and perform any necessary tracing or logging operations.
+ * It reschedules itself for the next sampling interval.
+ */
+static void xe_gpufreqtracer_sample_work(struct work_struct *work)
+{
+ struct xe_gpufreqtracer_gt_data *gt_data =
+ container_of(work, struct xe_gpufreqtracer_gt_data, delayed_work.work);
+ struct xe_gt *gt = gt_data->gt;
+ struct xe_guc_pc *pc = >->uc.guc.pc;
+ u32 current_freq, last_freq;
+
+ if (!atomic_read(>_data->monitoring_active)) {
+ drm_warn(>_to_xe(gt)->drm, "monitoring not active for GT%u, exiting",
+ gt->info.id);
+ return;
+ }
+
+ current_freq = xe_guc_pc_get_act_freq(pc) * 1000; /* Convert MHz to KHz */
+ last_freq = atomic_read(>_data->last_frequency);
+
+ /* Only report if frequency has changed or this is the first sample */
+ if (current_freq != last_freq) {
+ drm_dbg(>_to_xe(gt)->drm, "GT%u frequency changed, tracing %u KHz",
+ gt->info.id, current_freq);
+ trace_gpu_frequency(current_freq, gt->info.id);
+ atomic_set(>_data->last_frequency, current_freq);
+ }
+
+ /* Reschedule for the next sampling interval if monitoring is still active */
+ if (atomic_read(>_data->monitoring_active)) {
+ schedule_delayed_work(>_data->delayed_work,
+ msecs_to_jiffies(xe_modparam.gpufreq_monitoring_interval_ms));
+ }
+}
+
+/**
+ * xe_gpufreqtracer_start_monitoring - Start periodic frequency monitoring
+ * @gt: The GT instance
+ *
+ * Starts periodic sampling of GPU frequency for the specified GT using the global
+ * monitoring interval from module parameters.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int xe_gpufreqtracer_start_monitoring(struct xe_gt *gt)
+{
+ struct xe_gpufreqtracer_data *tracer_data = gt_to_xe(gt)->gpufreqtracer_data;
+ struct xe_gpufreqtracer_gt_data *gt_data;
+
+ if (!tracer_data) {
+ drm_warn(>_to_xe(gt)->drm, "no tracer data for GT%u, not supported", gt->info.id);
+ return -EOPNOTSUPP;
+ }
+
+ if (gt->info.id >= gt_to_xe(gt)->info.gt_count) {
+ drm_err(>_to_xe(gt)->drm, "invalid GT ID %u, max supported is %u",
+ gt->info.id, gt_to_xe(gt)->info.gt_count - 1);
+ return -EINVAL;
+ }
+
+ gt_data = &tracer_data->gt_data[gt->info.id];
+
+ if (atomic_read(>_data->monitoring_active)) {
+ drm_warn(>_to_xe(gt)->drm, "monitoring already active for GT%u", gt->info.id);
+ return -EALREADY;
+ }
+
+ atomic_set(>_data->monitoring_active, 1);
+ atomic_set(>_data->last_frequency, 0);
+
+ /* Start the delayed work using global interval */
+ schedule_delayed_work(>_data->delayed_work,
+ msecs_to_jiffies(xe_modparam.gpufreq_monitoring_interval_ms));
+
+ drm_dbg(>_to_xe(gt)->drm, "monitoring started for GT%u with interval %u ms",
+ gt->info.id, xe_modparam.gpufreq_monitoring_interval_ms);
+
+ return 0;
+}
+
+/**
+ * xe_gpufreqtracer_stop_monitoring - Stop periodic frequency monitoring
+ * @gt: The GT instance
+ *
+ * Stops periodic sampling of GPU frequency for the specified GT.
+ */
+static void xe_gpufreqtracer_stop_monitoring(struct xe_gt *gt)
+{
+ struct xe_gpufreqtracer_data *tracer_data = gt_to_xe(gt)->gpufreqtracer_data;
+ struct xe_gpufreqtracer_gt_data *gt_data;
+
+ if (!tracer_data || gt->info.id >= gt_to_xe(gt)->info.gt_count) {
+ drm_err(>_to_xe(gt)->drm, "invalid tracer data or GT ID %u for stop request",
+ gt->info.id);
+ return;
+ }
+
+ gt_data = &tracer_data->gt_data[gt->info.id];
+
+ if (!atomic_read(>_data->monitoring_active)) {
+ drm_warn(>_to_xe(gt)->drm, "monitoring not active for GT%u, nothing to stop",
+ gt->info.id);
+ return;
+ }
+
+ atomic_set(>_data->monitoring_active, 0);
+
+ cancel_delayed_work_sync(>_data->delayed_work);
+}
+
+/**
+ * xe_gpufreqtracer_validate_params - Validate GPU frequency monitoring parameters
+ *
+ * Validates and corrects the GPU frequency monitoring interval parameter.
+ * If the parameter is out of range, it will be reset to the default value.
+ */
+static void xe_gpufreqtracer_validate_params(void)
+{
+ if (xe_modparam.gpufreq_monitoring_interval_ms < XE_GPUFREQ_MONITORING_MIN_INTERVAL_MS ||
+ xe_modparam.gpufreq_monitoring_interval_ms > XE_GPUFREQ_MONITORING_MAX_INTERVAL_MS) {
+ pr_warn("xe: gpufreq_monitoring_interval_ms %u out of range [%u, %u], using default %u ms\n",
+ xe_modparam.gpufreq_monitoring_interval_ms,
+ XE_GPUFREQ_MONITORING_MIN_INTERVAL_MS,
+ XE_GPUFREQ_MONITORING_MAX_INTERVAL_MS,
+ XE_GPUFREQ_MONITORING_DEFAULT_INTERVAL_MS);
+ xe_modparam.gpufreq_monitoring_interval_ms = XE_GPUFREQ_MONITORING_DEFAULT_INTERVAL_MS;
+ }
+}
+
+/**
+ * xe_gpufreqtracer_cleanup_action - DRM managed cleanup action
+ * @drm: DRM device
+ * @ptr: Pointer to xe_device
+ *
+ * Cleanup function called automatically by DRM managed resource system.
+ */
+static void xe_gpufreqtracer_cleanup_action(struct drm_device *drm, void *ptr)
+{
+ struct xe_device *xe = ptr;
+ struct xe_gpufreqtracer_data *tracer_data = xe->gpufreqtracer_data;
+ struct xe_gt *gt;
+ u8 tile_id;
+
+ if (!tracer_data) {
+ drm_warn(drm, "no tracer data found, nothing to cleanup");
+ return;
+ }
+
+ /* Stop all monitoring */
+ for_each_gt(gt, xe, tile_id) {
+ drm_dbg(drm, "stopping monitoring for GT%u", gt->info.id);
+ xe_gpufreqtracer_stop_monitoring(gt);
+ }
+
+ /* Memory is automatically freed by drmm - just clear the pointer */
+ xe->gpufreqtracer_data = NULL;
+}
+
+/**
+ * xe_gpufreqtracer_init - Initialize GPU frequency tracer for a device
+ * @xe: The XE device
+ *
+ * Sets up the frequency tracer infrastructure for all GTs in the device.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+int xe_gpufreqtracer_init(struct xe_device *xe)
+{
+ struct xe_gpufreqtracer_data *tracer_data;
+ struct xe_gt *gt;
+ u8 tile_id;
+ int ret = 0;
+
+ /* Validate module parameters first */
+ xe_gpufreqtracer_validate_params();
+
+ tracer_data = drmm_kzalloc(&xe->drm, sizeof(*tracer_data), GFP_KERNEL);
+ if (!tracer_data)
+ return -ENOMEM;
+
+ tracer_data->xe = xe;
+
+ /* Allocate GT data array based on actual GT count */
+ tracer_data->gt_data = drmm_kcalloc(&xe->drm, xe->info.gt_count,
+ sizeof(*tracer_data->gt_data),
+ GFP_KERNEL);
+ if (!tracer_data->gt_data) {
+ ret = -ENOMEM;
+ goto err_free_tracer;
+ }
+
+ /* Initialize per-GT data */
+ for_each_gt(gt, xe, tile_id) {
+ struct xe_gpufreqtracer_gt_data *gt_data =
+ &tracer_data->gt_data[gt->info.id];
+
+ drm_dbg(&xe->drm, "initializing GT%u (tile %u)", gt->info.id, tile_id);
+
+ gt_data->gt = gt;
+ atomic_set(>_data->monitoring_active, 0);
+ atomic_set(>_data->last_frequency, 0);
+
+ INIT_DELAYED_WORK(>_data->delayed_work, xe_gpufreqtracer_sample_work);
+
+ drm_dbg(&xe->drm, "GT%u initialized with global interval=%u ms",
+ gt->info.id, xe_modparam.gpufreq_monitoring_interval_ms);
+ }
+
+ xe->gpufreqtracer_data = tracer_data;
+
+ /* Start periodic monitoring on all GTs using global module parameter */
+ for_each_gt(gt, xe, tile_id) {
+ ret = xe_gpufreqtracer_start_monitoring(gt);
+ if (ret) {
+ drm_err(&xe->drm, "xe_gpufreqtracer: failed to start monitoring for GT%u, err=%d\n",
+ gt->info.id, ret);
+ }
+ }
+
+ /* Register cleanup action for proper work cancellation */
+ ret = drmm_add_action(&xe->drm, xe_gpufreqtracer_cleanup_action, xe);
+ if (ret)
+ return ret;
+
+ return 0;
+
+err_free_tracer:
+ drm_err(&xe->drm, "initialization failed, freeing tracer data");
+ return ret;
+}
diff --git a/drivers/gpu/drm/xe/xe_gpufreqtracer.h b/drivers/gpu/drm/xe/xe_gpufreqtracer.h
new file mode 100644
index 000000000000..561abe27b6e2
--- /dev/null
+++ b/drivers/gpu/drm/xe/xe_gpufreqtracer.h
@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright © 2025 Intel Corporation
+ */
+
+#ifndef _XE_GPUFREQTRACER_H_
+#define _XE_GPUFREQTRACER_H_
+
+#include <linux/types.h>
+
+struct xe_device;
+struct xe_gt;
+
+#ifdef CONFIG_DRM_XE_GPUFREQTRACER
+
+/*
+ * Initialize the GPU frequency tracer for a device
+ */
+int xe_gpufreqtracer_init(struct xe_device *xe);
+
+#else /* CONFIG_DRM_XE_GPUFREQTRACER */
+
+static inline int xe_gpufreqtracer_init(struct xe_device *xe)
+{
+ return 0;
+}
+
+#endif /* CONFIG_DRM_XE_GPUFREQTRACER */
+
+#endif /* _XE_GPUFREQTRACER_H_ */
diff --git a/drivers/gpu/drm/xe/xe_gpufreqtracer_trace.h b/drivers/gpu/drm/xe/xe_gpufreqtracer_trace.h
new file mode 100644
index 000000000000..5664db62e3fb
--- /dev/null
+++ b/drivers/gpu/drm/xe/xe_gpufreqtracer_trace.h
@@ -0,0 +1,48 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright © 2025 Intel Corporation
+ */
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM power
+
+#if !defined(_XE_GPUFREQTRACER_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _XE_GPUFREQTRACER_TRACE_H
+
+#include <linux/tracepoint.h>
+
+/*
+ * Tracepoint for GPU frequency changes
+ * This tracepoint is exposed at /sys/kernel/debug/tracing/events/power/gpu_frequency
+ *
+ * location: /d/events/power/gpu_frequency
+ * format: {unsigned int state, unsigned int gpu_id}
+ * where state holds the frequency(in Khz) and the gpu_id holds the GPU clock domain.
+ */
+
+TRACE_EVENT(gpu_frequency,
+ TP_PROTO(unsigned int state, unsigned int gpu_id),
+
+ TP_ARGS(state, gpu_id),
+
+ TP_STRUCT__entry(
+ __field(unsigned int, state)
+ __field(unsigned int, gpu_id)
+ ),
+
+ TP_fast_assign(
+ __entry->state = state;
+ __entry->gpu_id = gpu_id;
+ ),
+
+ TP_printk("state=%u gpu_id=%u", __entry->state, __entry->gpu_id)
+);
+
+#endif /* _XE_GPUFREQTRACER_TRACE_H */
+
+/* This part must be outside protection */
+#undef TRACE_INCLUDE_PATH
+#undef TRACE_INCLUDE_FILE
+#define TRACE_INCLUDE_PATH .
+#define TRACE_INCLUDE_FILE xe_gpufreqtracer_trace
+#include <trace/define_trace.h>
diff --git a/drivers/gpu/drm/xe/xe_module.c b/drivers/gpu/drm/xe/xe_module.c
index d08338fc3bc1..f5d4f8bca61f 100644
--- a/drivers/gpu/drm/xe/xe_module.c
+++ b/drivers/gpu/drm/xe/xe_module.c
@@ -31,6 +31,7 @@
#define DEFAULT_MAX_VFS_STR "unlimited"
#define DEFAULT_WEDGED_MODE 1
#define DEFAULT_SVM_NOTIFIER_SIZE 512
+#define DEFAULT_GPUFREQ_MONITORING_INTERVAL_MS 5000
struct xe_modparam xe_modparam = {
.probe_display = DEFAULT_PROBE_DISPLAY,
@@ -41,6 +42,9 @@ struct xe_modparam xe_modparam = {
#endif
.wedged_mode = DEFAULT_WEDGED_MODE,
.svm_notifier_size = DEFAULT_SVM_NOTIFIER_SIZE,
+#ifdef CONFIG_DRM_XE_GPUFREQTRACER
+ .gpufreq_monitoring_interval_ms = DEFAULT_GPUFREQ_MONITORING_INTERVAL_MS,
+#endif
/* the rest are 0 by default */
};
@@ -93,6 +97,14 @@ MODULE_PARM_DESC(wedged_mode,
"Module's default policy for the wedged mode (0=never, 1=upon-critical-errors, 2=upon-any-hang "
"[default=" __stringify(DEFAULT_WEDGED_MODE) "])");
+#ifdef CONFIG_DRM_XE_GPUFREQTRACER
+module_param_named(gpufreq_monitoring_interval_ms,
+ xe_modparam.gpufreq_monitoring_interval_ms, uint, 0644);
+MODULE_PARM_DESC(gpufreq_monitoring_interval_ms,
+ "GPU frequency monitoring interval in milliseconds (100-10000, default: "
+ __stringify(DEFAULT_GPUFREQ_MONITORING_INTERVAL_MS) ")");
+#endif
+
static int xe_check_nomodeset(void)
{
if (drm_firmware_drivers_only())
diff --git a/drivers/gpu/drm/xe/xe_module.h b/drivers/gpu/drm/xe/xe_module.h
index 5a3bfea8b7b4..fd60de38d24d 100644
--- a/drivers/gpu/drm/xe/xe_module.h
+++ b/drivers/gpu/drm/xe/xe_module.h
@@ -23,6 +23,9 @@ struct xe_modparam {
#endif
int wedged_mode;
u32 svm_notifier_size;
+#ifdef CONFIG_DRM_XE_GPUFREQTRACER
+ u32 gpufreq_monitoring_interval_ms;
+#endif
};
extern struct xe_modparam xe_modparam;
--
2.34.1
More information about the Intel-xe
mailing list