[PATCH v2 24/33] drm/xe: Add defrag profiling tracepoints
From: Matthew Brost
Date: Fri Jul 10 2026 - 18:00:20 EST
Add two tracepoints to profile the page defragmentation worker:
- xe_bo_defrag_worker: emitted on worker entry and exit with the
current defrag list count and the bytes processed in the run.
- xe_bo_defrag_one: emitted per BO with the run budget, the prealloc
fill ratio (got/want) and the lock-held, lock-wait and prealloc
durations, plus the bytes consumed and the result.
These break down the cost of a defrag attempt into its locked vs
unlocked phases, making it possible to confirm that the expensive
beneficial-order allocation and cpu cache mode change happen outside
the BO dma-resv lock and that the residual lock-held time is copy-bound
(with the tail dominated by lock-wait behind active rendering).
Cc: Carlos Santa <carlos.santa@xxxxxxxxx>
Cc: Ryan Neph <ryanneph@xxxxxxxxxx>
Cc: Christian Koenig <christian.koenig@xxxxxxx>
Cc: Huang Rui <ray.huang@xxxxxxx>
Cc: Matthew Auld <matthew.auld@xxxxxxxxx>
Cc: Maarten Lankhorst <maarten.lankhorst@xxxxxxxxxxxxxxx>
Cc: Maxime Ripard <mripard@xxxxxxxxxx>
Cc: Thomas Zimmermann <tzimmermann@xxxxxxx>
Cc: David Airlie <airlied@xxxxxxxxx>
Cc: Simona Vetter <simona@xxxxxxxx>
Cc: dri-devel@xxxxxxxxxxxxxxxxxxxxx
Cc: linux-kernel@xxxxxxxxxxxxxxx
Cc: Thomas Hellström <thomas.hellstrom@xxxxxxxxxxxxxxx>
Assisted-by: GitHub_Copilot:claude-opus-4.8
Signed-off-by: Matthew Brost <matthew.brost@xxxxxxxxx>
---
drivers/gpu/drm/xe/xe_bo.c | 18 +++++++++-
drivers/gpu/drm/xe/xe_trace_bo.h | 59 ++++++++++++++++++++++++++++++++
2 files changed, 76 insertions(+), 1 deletion(-)
diff --git a/drivers/gpu/drm/xe/xe_bo.c b/drivers/gpu/drm/xe/xe_bo.c
index 2f014fc9f988..a01004265349 100644
--- a/drivers/gpu/drm/xe/xe_bo.c
+++ b/drivers/gpu/drm/xe/xe_bo.c
@@ -1254,7 +1254,9 @@ static int xe_bo_defrag_one(struct xe_device *xe, struct xe_bo *bo,
struct ttm_placement placement;
struct ttm_place place;
enum ttm_caching tt_caching;
- unsigned int order, want = 0;
+ unsigned int order, want = 0, got = 0;
+ u64 lock_ns = 0, prealloc_ns = 0, lockwait_ns = 0;
+ ktime_t t0;
int ret = 0;
*consumed = 0;
@@ -1284,6 +1286,7 @@ static int xe_bo_defrag_one(struct xe_device *xe, struct xe_bo *bo,
/* Phase 2: preallocate outside the lock; */
if (want) {
+ t0 = ktime_get();
ret = ttm_pool_prealloc_fill(pool, tt_caching, &pp, want);
if (ret || !pp.count) {
ret = ret ?: -ENOMEM;
@@ -1291,12 +1294,16 @@ static int xe_bo_defrag_one(struct xe_device *xe, struct xe_bo *bo,
XE_GT_STATS_ID_DEFRAG_FAILED_COUNT, 1);
goto out_err;
}
+ prealloc_ns = ktime_to_ns(ktime_sub(ktime_get(), t0));
}
/*
* Phase 3: re-take the lock, re-check, and validate using the prealloc.
*/
+ t0 = ktime_get();
xe_bo_lock(bo, false);
+ lockwait_ns = ktime_to_ns(ktime_sub(ktime_get(), t0));
+ t0 = ktime_get();
if (!xe_bo_needs_defrag(bo)) {
xe_bo_defrag_remove(bo);
@@ -1350,9 +1357,13 @@ static int xe_bo_defrag_one(struct xe_device *xe, struct xe_bo *bo,
unlock:
xe_bo_unlock(bo);
+ lock_ns = ktime_to_ns(ktime_sub(ktime_get(), t0));
+ got = pp.used;
out_err:
ttm_pool_prealloc_fini(pool, &pp);
out:
+ trace_xe_bo_defrag_one(bo, budget, want, got, lock_ns, prealloc_ns,
+ lockwait_ns, *consumed, ret);
return ret;
}
@@ -1373,6 +1384,9 @@ static void xe_bo_defrag_worker(struct work_struct *w)
return;
}
+ trace_xe_bo_defrag_worker(xe, 0, atomic_read(&xe->mem.defrag.count),
+ true);
+
/*
* Process at most XE_BO_DEFRAG_SIZE_LIMIT bytes of newly (re)allocated
* backing per run rather than draining the whole list in one go. Only
@@ -1479,6 +1493,8 @@ static void xe_bo_defrag_worker(struct work_struct *w)
xe_pm_runtime_put(xe);
drm_dev_exit(idx);
+ trace_xe_bo_defrag_worker(xe, defrag_bytes,
+ atomic_read(&xe->mem.defrag.count), false);
}
static int xe_bo_move(struct ttm_buffer_object *ttm_bo, bool evict,
diff --git a/drivers/gpu/drm/xe/xe_trace_bo.h b/drivers/gpu/drm/xe/xe_trace_bo.h
index 86323cf3be2c..a169a322464b 100644
--- a/drivers/gpu/drm/xe/xe_trace_bo.h
+++ b/drivers/gpu/drm/xe/xe_trace_bo.h
@@ -85,6 +85,65 @@ TRACE_EVENT(xe_bo_move,
__get_str(new_placement_name), __get_str(device_id))
);
+TRACE_EVENT(xe_bo_defrag_worker,
+ TP_PROTO(struct xe_device *xe, u64 defrag_bytes, int count,
+ bool enter),
+ TP_ARGS(xe, defrag_bytes, count, enter),
+ TP_STRUCT__entry(
+ __string(dev, dev_name(xe->drm.dev))
+ __field(u64, defrag_bytes)
+ __field(int, count)
+ __field(bool, enter)
+ ),
+ TP_fast_assign(
+ __assign_str(dev);
+ __entry->defrag_bytes = defrag_bytes;
+ __entry->count = count;
+ __entry->enter = enter;
+ ),
+ TP_printk("dev=%s %s defrag_bytes=%llu count=%d",
+ __get_str(dev), __entry->enter ? "enter" : "exit",
+ __entry->defrag_bytes, __entry->count)
+);
+
+TRACE_EVENT(xe_bo_defrag_one,
+ TP_PROTO(struct xe_bo *bo, u64 budget, unsigned int prealloc_want,
+ unsigned int prealloc_got, u64 lock_ns, u64 prealloc_ns,
+ u64 lockwait_ns, u64 consumed, int ret),
+ TP_ARGS(bo, budget, prealloc_want, prealloc_got, lock_ns,
+ prealloc_ns, lockwait_ns, consumed, ret),
+ TP_STRUCT__entry(
+ __string(dev, __dev_name_bo(bo))
+ __field(size_t, size)
+ __field(u64, budget)
+ __field(unsigned int, prealloc_want)
+ __field(unsigned int, prealloc_got)
+ __field(u64, lock_ns)
+ __field(u64, prealloc_ns)
+ __field(u64, lockwait_ns)
+ __field(u64, consumed)
+ __field(int, ret)
+ ),
+ TP_fast_assign(
+ __assign_str(dev);
+ __entry->size = xe_bo_size(bo);
+ __entry->budget = budget;
+ __entry->prealloc_want = prealloc_want;
+ __entry->prealloc_got = prealloc_got;
+ __entry->lock_ns = lock_ns;
+ __entry->prealloc_ns = prealloc_ns;
+ __entry->lockwait_ns = lockwait_ns;
+ __entry->consumed = consumed;
+ __entry->ret = ret;
+ ),
+ TP_printk("dev=%s size=%zu budget=%llu prealloc=%u/%u lock_us=%llu lockwait_us=%llu prealloc_us=%llu consumed=%llu ret=%d",
+ __get_str(dev), __entry->size, __entry->budget,
+ __entry->prealloc_got, __entry->prealloc_want,
+ __entry->lock_ns / 1000, __entry->lockwait_ns / 1000,
+ __entry->prealloc_ns / 1000, __entry->consumed,
+ __entry->ret)
+);
+
DECLARE_EVENT_CLASS(xe_vma,
TP_PROTO(struct xe_vma *vma),
TP_ARGS(vma),
--
2.34.1